Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / ExpressionBuilder / EdmFunctions.cs / 1305376 / EdmFunctions.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Data.Common.Utils;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees.Internal;
using System.Data.Common.CommandTrees.ExpressionBuilder.Internal;
using System.Reflection;
namespace System.Data.Common.CommandTrees.ExpressionBuilder
{
///
/// Provides an API to construct
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
#if PUBLIC_DBEXPRESSIONBUILDER
public
#endif
static class EdmFunctions
{
#region Private Implementation
private static EdmFunction ResolveCanonicalFunction(string functionName, TypeUsage[] argumentTypes)
{
Debug.Assert(!string.IsNullOrEmpty(functionName), "Function name must not be null");
List functions = new List(
System.Linq.Enumerable.Where(
EdmProviderManifest.Instance.GetStoreFunctions(),
func => string.Equals(func.Name, functionName, StringComparison.Ordinal))
);
EdmFunction foundFunction = null;
bool ambiguous = false;
if (functions.Count > 0)
{
foundFunction = EntitySql.FunctionOverloadResolver.ResolveFunctionOverloads(functions, argumentTypes, false, out ambiguous);
if (ambiguous)
{
throw EntityUtil.Argument(Entity.Strings.Cqt_Function_CanonicalFunction_AmbiguousMatch(functionName));
}
}
if (foundFunction == null)
{
throw EntityUtil.Argument(Entity.Strings.Cqt_Function_CanonicalFunction_NotFound(functionName));
}
return foundFunction;
}
private static DbFunctionExpression InvokeCanonicalFunction(string functionName, params DbExpression[] arguments)
{
TypeUsage[] argumentTypes = new TypeUsage[arguments.Length];
for (int idx = 0; idx < arguments.Length; idx++)
{
Debug.Assert(arguments[idx] != null, "Ensure arguments are non-null before calling InvokeCanonicalFunction");
argumentTypes[idx] = arguments[idx].ResultType;
}
EdmFunction foundFunction = ResolveCanonicalFunction(functionName, argumentTypes);
return DbExpressionBuilder.Invoke(foundFunction, arguments);
}
#endregion
#if PUBLIC_DBEXPRESSIONBUILDER
#region Aggregate functions - Average, Count, LongCount, Max, Min, Sum, StDev, StDevP, Var, VarP
///
/// Creates a
/// An expression that specifies the collection from which the average value should be computed
/// A new DbFunctionExpression that produces the average value.
/// No overload of the canonical 'Avg' function accepts an argument with the result type of
public static DbFunctionExpression Average(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Avg", collection);
}
///
/// Creates a
/// An expression that specifies the collection over which the count value should be computed.
/// A new DbFunctionExpression that produces the count value.
/// No overload of the canonical 'Count' function accepts an argument with the result type of
public static DbFunctionExpression Count(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Count", collection);
}
///
/// Creates a
/// An expression that specifies the collection over which the count value should be computed.
/// A new DbFunctionExpression that produces the count value.
/// No overload of the canonical 'BigCount' function accepts an argument with the result type of
public static DbFunctionExpression LongCount(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("BigCount", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the maximum value should be retrieved
/// A new DbFunctionExpression that produces the maximum value.
/// No overload of the canonical 'Max' function accepts an argument with the result type of
public static DbFunctionExpression Max(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Max", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the minimum value should be retrieved
/// A new DbFunctionExpression that produces the minimum value.
/// No overload of the canonical 'Min' function accepts an argument with the result type of
public static DbFunctionExpression Min(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Min", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the sum should be computed
/// A new DbFunctionExpression that produces the sum.
/// No overload of the canonical 'Sum' function accepts an argument with the result type of
public static DbFunctionExpression Sum(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Sum", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the standard deviation should be computed
/// A new DbFunctionExpression that produces the standard deviation value over non-null members of the collection.
/// No overload of the canonical 'StDev' function accepts an argument with the result type of
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "St")]
public static DbFunctionExpression StDev(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("StDev", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the standard deviation should be computed
/// A new DbFunctionExpression that produces the standard deviation value.
/// No overload of the canonical 'StDevP' function accepts an argument with the result type of
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "St")]
public static DbFunctionExpression StDevP(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("StDevP", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the statistical variance should be computed
/// A new DbFunctionExpression that produces the statistical variance value for the non-null members of the collection.
/// No overload of the canonical 'Var' function accepts an argument with the result type of
public static DbFunctionExpression Var(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Var", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the statistical variance should be computed
/// A new DbFunctionExpression that produces the statistical variance value.
/// No overload of the canonical 'VarP' function accepts an argument with the result type of
public static DbFunctionExpression VarP(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("VarP", collection);
}
#endregion
#region String functions - Concat, Contains, EndsWith, IndexOf, Left, Length, LTrim, Replace, Reverse, Right, RTrim, StartsWith, Substring, ToUpper, ToLower, Trim
///
/// Creates a
/// An expression that specifies the string that should appear first in the concatenated result string.
/// An expression that specifies the string that should appear second in the concatenated result string.
/// A new DbFunctionExpression that produces the concatenated string.
/// No overload of the canonical 'Concat' function accepts arguments with the result types of
public static DbFunctionExpression Concat(this DbExpression string1, DbExpression string2)
{
EntityUtil.CheckArgumentNull(string1, "string1");
EntityUtil.CheckArgumentNull(string2, "string2");
return InvokeCanonicalFunction("Concat", string1, string2);
}
//
///
/// Creates a
/// An expression that specifies the string to search for any occurence of A new DbFunctionExpression that returns a Boolean value indicating whether or not
/// No overload of the canonical 'Contains' function accepts arguments with the result types of
public static DbExpression Contains(this DbExpression searchedString, DbExpression searchedForString)
{
EntityUtil.CheckArgumentNull(searchedString, "searchedString");
EntityUtil.CheckArgumentNull(searchedForString, "searchedForString");
return InvokeCanonicalFunction("Contains", searchedString, searchedForString);
}
///
/// Creates a
/// An expression that specifies the string to check for the specified .
/// An expression that specifies the suffix for which A new DbFunctionExpression that indicates whether
/// No overload of the canonical 'EndsWith' function accepts arguments with the result types of
public static DbFunctionExpression EndsWith(this DbExpression stringArgument, DbExpression suffix)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(suffix, "suffix");
return InvokeCanonicalFunction("EndsWith", stringArgument, suffix);
}
///
/// Creates a
/// The index returned by IndexOf is 1-based.
/// An expression that specifies the string to search for A new DbFunctionExpression that returns the first index of
/// No overload of the canonical 'IndexOf' function accepts arguments with the result types of
public static DbFunctionExpression IndexOf(this DbExpression searchString, DbExpression stringToFind)
{
EntityUtil.CheckArgumentNull(searchString, "searchString");
EntityUtil.CheckArgumentNull(stringToFind, "stringToFind");
return InvokeCanonicalFunction("IndexOf", stringToFind, searchString);
}
///
/// Creates a
/// An expression that specifies the string from which to extract the leftmost substring.
/// An expression that specifies the length of the leftmost substring to extract from A new DbFunctionExpression that returns the the leftmost substring of length
/// No overload of the canonical 'Left' function accepts arguments with the result types of
public static DbFunctionExpression Left(this DbExpression stringArgument, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Left", stringArgument, length);
}
///
/// Creates a
/// An expression that specifies the string for which the length should be computed.
/// A new DbFunctionExpression that returns the the length of
/// No overload of the canonical 'Length' function accepts an argument with the result type of
public static DbFunctionExpression Length(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Length", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string in which to perform the replacement operation
/// An expression that specifies the string to replace
/// An expression that specifies the replacement string
/// A new DbFunctionExpression than returns a new string based on
/// No overload of the canonical 'Length' function accepts arguments with the result types of
public static DbFunctionExpression Replace(this DbExpression stringArgument, DbExpression toReplace, DbExpression replacement)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(toReplace, "toReplace");
EntityUtil.CheckArgumentNull(replacement, "replacement");
return InvokeCanonicalFunction("Replace", stringArgument, toReplace, replacement);
}
///
/// Creates a
/// An expression that specifies the string to reverse.
/// A new DbFunctionExpression that produces the reversed value of
/// No overload of the canonical 'Reverse' function accepts an argument with the result type of
public static DbFunctionExpression Reverse(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Reverse", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which to extract the rightmost substring.
/// An expression that specifies the length of the rightmost substring to extract from A new DbFunctionExpression that returns the the rightmost substring of length
/// No overload of the canonical 'Right' function accepts arguments with the result types of
public static DbFunctionExpression Right(this DbExpression stringArgument, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Right", stringArgument, length);
}
///
/// Creates a
/// An expression that specifies the string to check for the specified .
/// An expression that specifies the prefix for which A new DbFunctionExpression that indicates whether
/// No overload of the canonical 'StartsWith' function accepts arguments with the result types of
public static DbFunctionExpression StartsWith(this DbExpression stringArgument, DbExpression prefix)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(prefix, "prefix");
return InvokeCanonicalFunction("StartsWith", stringArgument, prefix);
}
//
///
/// Creates a
/// Substring requires that the index specified by
/// An expression that specifies the string from which to extract the substring.
/// An expression that specifies the starting index from which the substring should be taken.
/// An expression that specifies the length of the substring.
/// A new DbFunctionExpression that returns the substring of length
/// No overload of the canonical 'Substring' function accepts arguments with the result types of
public static DbFunctionExpression Substring(this DbExpression stringArgument, DbExpression start, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(start, "start");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Substring", stringArgument, start, length);
}
///
/// Creates a
/// An expression that specifies the string that should be converted to lower case.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'ToLower' function accepts an argument with the result type of
public static DbFunctionExpression ToLower(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("ToLower", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string that should be converted to upper case.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'ToUpper' function accepts an argument with the result type of
public static DbFunctionExpression ToUpper(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("ToUpper", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which leading and trailing space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'Trim' function accepts an argument with the result type of
public static DbFunctionExpression Trim(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Trim", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which trailing space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'RTrim' function accepts an argument with the result type of
public static DbFunctionExpression TrimEnd(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("RTrim", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which leading space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'LTrim' function accepts an argument with the result type of
public static DbFunctionExpression TrimStart(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("LTrim", stringArgument);
}
#endregion
#region Date/Time member access methods - Year, Month, Day, DayOfYear, Hour, Minute, Second, Millisecond, GetTotalOffsetMinutes
///
/// Creates a
/// An expression that specifies the value from which the year should be retrieved.
/// A new DbFunctionExpression that returns the integer year value from
/// No overload of the canonical 'Year' function accepts an argument with the result type of
public static DbFunctionExpression Year(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Year", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the month should be retrieved.
/// A new DbFunctionExpression that returns the integer month value from
/// No overload of the canonical 'Month' function accepts an argument with the result type of
public static DbFunctionExpression Month(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Month", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the day should be retrieved.
/// A new DbFunctionExpression that returns the integer day value from
/// No overload of the canonical 'Day' function accepts an argument with the result type of
public static DbFunctionExpression Day(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Day", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the day within the year should be retrieved.
/// A new DbFunctionExpression that returns the integer day of year value from
/// No overload of the canonical 'DayOfYear' function accepts an argument with the result type of
public static DbFunctionExpression DayOfYear(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("DayOfYear", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the hour should be retrieved.
/// A new DbFunctionExpression that returns the integer hour value from
/// No overload of the canonical 'Hour' function accepts an argument with the result type of
public static DbFunctionExpression Hour(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Hour", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the minute should be retrieved.
/// A new DbFunctionExpression that returns the integer minute value from
/// No overload of the canonical 'Minute' function accepts an argument with the result type of
public static DbFunctionExpression Minute(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Minute", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the second should be retrieved.
/// A new DbFunctionExpression that returns the integer second value from
/// No overload of the canonical 'Second' function accepts an argument with the result type of
public static DbFunctionExpression Second(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Second", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the millisecond should be retrieved.
/// A new DbFunctionExpression that returns the integer millisecond value from
/// No overload of the canonical 'Millisecond' function accepts an argument with the result type of
public static DbFunctionExpression Millisecond(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Millisecond", timeValue);
}
///
/// Creates a
/// An expression that specifies the DateTimeOffset value from which the minute offset from GMT should be retrieved.
/// A new DbFunctionExpression that returns the number of minutes
/// No overload of the canonical 'GetTotalOffsetMinutes' function accepts an argument with the result type of
public static DbFunctionExpression GetTotalOffsetMinutes(this DbExpression dateTimeOffsetArgument)
{
EntityUtil.CheckArgumentNull(dateTimeOffsetArgument, "dateTimeOffsetArgument");
return InvokeCanonicalFunction("GetTotalOffsetMinutes", dateTimeOffsetArgument);
}
#endregion
#region Date/Time creation methods - CurrentDateTime, CurrentDateTimeOffset, CurrentUtcDateTime, CreateDateTime, CreateDateTimeOffset, CreateTime, TruncateTime
///
/// Creates a
/// A new DbFunctionExpression that returns the current date and time as an Edm.DateTime instance.
public static DbFunctionExpression CurrentDateTime()
{
return InvokeCanonicalFunction("CurrentDateTime");
}
///
/// Creates a
/// A new DbFunctionExpression that returns the current date and time as an Edm.DateTimeOffset instance.
public static DbFunctionExpression CurrentDateTimeOffset()
{
return InvokeCanonicalFunction("CurrentDateTimeOffset");
}
///
/// Creates a
/// A new DbFunctionExpression that returns the current UTC date and time as an Edm.DateTime instance.
public static DbFunctionExpression CurrentUtcDateTime()
{
return InvokeCanonicalFunction("CurrentUtcDateTime");
}
///
/// Creates a
/// An expression that specifies the value for which the time component should be truncated.
/// A new DbFunctionExpression that returns the value of
/// No overload of the canonical 'TruncateTime' function accepts an argument with the result type of
public static DbFunctionExpression TruncateTime(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("TruncateTime", dateValue);
}
///
/// Creates a
/// An expression that provides the year component value for the new DateTime instance.
/// An expression that provides the month component value for the new DateTime instance.
/// An expression that provides the day component value for the new DateTime instance.
/// An expression that provides the hour component value for the new DateTime instance.
/// An expression that provides the minute component value for the new DateTime instance.
/// An expression that provides the second component value for the new DateTime instance.
/// A new DbFunctionExpression that returns a new DateTime based on the specified component values.
/// No overload of the canonical 'CreateDateTime' function accepts arguments with the result types of
public static DbFunctionExpression CreateDateTime(DbExpression year, DbExpression month, DbExpression day, DbExpression hour, DbExpression minute, DbExpression second)
{
EntityUtil.CheckArgumentNull(year, "year");
EntityUtil.CheckArgumentNull(month, "month");
EntityUtil.CheckArgumentNull(day, "day");
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
return InvokeCanonicalFunction("CreateDateTime", year, month, day, hour, minute, second);
}
///
/// Creates a
/// An expression that provides the year component value for the new DateTimeOffset instance.
/// An expression that provides the month component value for the new DateTimeOffset instance.
/// An expression that provides the day component value for the new DateTimeOffset instance.
/// An expression that provides the hour component value for the new DateTimeOffset instance.
/// An expression that provides the minute component value for the new DateTimeOffset instance.
/// An expression that provides the second component value for the new DateTimeOffset instance.
/// An expression that provides the number of minutes in the time zone offset component value for the new DateTimeOffset instance.
/// A new DbFunctionExpression that returns a new DateTimeOffset based on the specified component values.
/// No overload of the canonical 'CreateDateTimeOffset' function accepts arguments with the result types of
public static DbFunctionExpression CreateDateTimeOffset(DbExpression year, DbExpression month, DbExpression day, DbExpression hour, DbExpression minute, DbExpression second, DbExpression timeZoneOffset)
{
EntityUtil.CheckArgumentNull(year, "year");
EntityUtil.CheckArgumentNull(month, "month");
EntityUtil.CheckArgumentNull(day, "day");
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
EntityUtil.CheckArgumentNull(timeZoneOffset, "timeZoneOffset");
return InvokeCanonicalFunction("CreateDateTimeOffset", year, month, day, hour, minute, second, timeZoneOffset);
}
///
/// Creates a
/// An expression that provides the hour component value for the new DateTime instance.
/// An expression that provides the minute component value for the new DateTime instance.
/// An expression that provides the second component value for the new DateTime instance.
/// A new DbFunctionExpression that returns a new Time based on the specified component values.
/// No overload of the canonical 'CreateTime' function accepts arguments with the result types of
public static DbFunctionExpression CreateTime(DbExpression hour, DbExpression minute, DbExpression second)
{
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
return InvokeCanonicalFunction("CreateTime", hour, minute, second);
}
#endregion
#region Date/Time addition - AddYears, AddMonths, AddDays, AddHours, AddMinutes, AddSeconds, AddMilliseconds, AddMicroseconds, AddNanoseconds
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of years specified by
/// No overload of the canonical 'AddYears' function accepts arguments with the result types of
public static DbFunctionExpression AddYears(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddYears", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of months specified by
/// No overload of the canonical 'AddMonths' function accepts arguments with the result types of
public static DbFunctionExpression AddMonths(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMonths", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of days specified by
/// No overload of the canonical 'AddDays' function accepts arguments with the result types of
public static DbFunctionExpression AddDays(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddDays", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of hours specified by
/// No overload of the canonical 'AddHours' function accepts arguments with the result types of
public static DbFunctionExpression AddHours(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddHours", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of minutes specified by
/// No overload of the canonical 'AddMinutes' function accepts arguments with the result types of
public static DbFunctionExpression AddMinutes(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMinutes", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of seconds specified by
/// No overload of the canonical 'AddSeconds' function accepts arguments with the result types of
public static DbFunctionExpression AddSeconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddSeconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of milliseconds specified by
/// No overload of the canonical 'AddMilliseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddMilliseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMilliseconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of microseconds specified by
/// No overload of the canonical 'AddMicroseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddMicroseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMicroseconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of nanoseconds specified by
/// No overload of the canonical 'AddNanoseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddNanoseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddNanoseconds", timeValue, addValue);
}
#endregion
#region Date/Time difference - DiffYears, DiffMonths, DiffDays, DiffHours, DiffMinutes, DiffSeconds, DiffMilliseconds, DiffMicroseconds, DiffNanoseconds
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the year difference from A new DbFunctionExpression that returns the year difference between and .
/// No overload of the canonical 'DiffYears' function accepts arguments with the result types of
public static DbFunctionExpression DiffYears(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffYears", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the month difference from A new DbFunctionExpression that returns the month difference between and .
/// No overload of the canonical 'DiffMonths' function accepts arguments with the result types of
public static DbFunctionExpression DiffMonths(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffMonths", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the day difference from A new DbFunctionExpression that returns the day difference between and .
/// No overload of the canonical 'DiffDays' function accepts arguments with the result types of
public static DbFunctionExpression DiffDays(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffDays", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the hour difference from A new DbFunctionExpression that returns the hour difference between and .
/// No overload of the canonical 'DiffHours' function accepts arguments with the result types of
public static DbFunctionExpression DiffHours(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffHours", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the minute difference from A new DbFunctionExpression that returns the minute difference between and .
/// No overload of the canonical 'DiffMinutes' function accepts arguments with the result types of
public static DbFunctionExpression DiffMinutes(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMinutes", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the second difference from A new DbFunctionExpression that returns the second difference between and .
/// No overload of the canonical 'DiffSeconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffSeconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffSeconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the millisecond difference from A new DbFunctionExpression that returns the millisecond difference between and .
/// No overload of the canonical 'DiffMilliseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffMilliseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMilliseconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the microsecond difference from A new DbFunctionExpression that returns the microsecond difference between and .
/// No overload of the canonical 'DiffMicroseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffMicroseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMicroseconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the nanosecond difference from A new DbFunctionExpression that returns the nanosecond difference between and .
/// No overload of the canonical 'DiffNanoseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffNanoseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffNanoseconds", timeValue1, timeValue2);
}
#endregion
#region Math functions - Floor, Ceiling, Round, Truncate, Abs, Power
///
/// Creates a
/// An expression that specifies the numeric value to round.
/// A new DbFunctionExpression that rounds the specified argument to the nearest integer value.
/// No overload of the canonical 'Round' function accepts an argument with the result type of
public static DbFunctionExpression Round(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Round", value);
}
///
/// Creates a
/// An expression that specifies the numeric value to round.
/// An expression that specifies the number of digits of precision to use when rounding.
/// A new DbFunctionExpression that rounds the specified argument to the nearest integer value, with precision as specified by
/// No overload of the canonical 'Round' function accepts arguments with the result types of
public static DbFunctionExpression Round(this DbExpression value, DbExpression digits)
{
EntityUtil.CheckArgumentNull(value, "value");
EntityUtil.CheckArgumentNull(digits, "digits");
return InvokeCanonicalFunction("Round", value, digits);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the largest integer value not greater than
/// No overload of the canonical 'Floor' function accepts an argument with the result type of
public static DbFunctionExpression Floor(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Floor", value);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the smallest integer value not less than than
/// No overload of the canonical 'Ceiling' function accepts an argument with the result type of
public static DbFunctionExpression Ceiling(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Ceiling", value);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the absolute value of
/// No overload of the canonical 'Abs' function accepts an argument with the result type of
public static DbFunctionExpression Abs(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Abs", value);
}
///
/// Creates a
/// An expression that specifies the numeric value to truncate.
/// An expression that specifies the number of digits of precision to use when truncating.
/// A new DbFunctionExpression that truncates the specified argument to the nearest integer value, with precision as specified by
/// No overload of the canonical 'Truncate' function accepts arguments with the result types of
public static DbFunctionExpression Truncate(this DbExpression value, DbExpression digits)
{
EntityUtil.CheckArgumentNull(value, "value");
EntityUtil.CheckArgumentNull(digits, "digits");
return InvokeCanonicalFunction("Truncate", value, digits);
}
#endregion
#endif
///
/// Creates a
/// An expression that specifies the numeric value to raise to the given power.
/// An expression that specifies the power to which A new DbFunctionExpression that returns the value of
/// No overload of the canonical 'Power' function accepts arguments with the result types of
public static DbFunctionExpression Power(this DbExpression baseArgument, DbExpression exponent)
{
EntityUtil.CheckArgumentNull(baseArgument, "baseArgument");
EntityUtil.CheckArgumentNull(exponent, "exponent");
return InvokeCanonicalFunction("Power", baseArgument, exponent);
}
#if PUBLIC_DBEXPRESSIONBUILDER
#region Bitwise functions - And, Or, Not, Xor
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise AND of
/// No overload of the canonical 'BitwiseAnd' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseAnd(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseAnd", value1, value2);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise OR of
/// No overload of the canonical 'BitwiseOr' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseOr(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseOr", value1, value2);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise NOT of
/// No overload of the canonical 'BitwiseNot' function accepts an argument with the result type of
public static DbFunctionExpression BitwiseNot(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("BitwiseNot", value);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise XOR (exclusive OR) of
/// No overload of the canonical 'BitwiseXor' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseXor(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseXor", value1, value2);
}
#endregion
#endif
#region GUID Generation - NewGuid
///
/// Creates a
/// A new DbFunctionExpression that returns a new GUID value.
public static DbFunctionExpression NewGuid()
{
return InvokeCanonicalFunction("NewGuid");
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Data.Common.Utils;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees.Internal;
using System.Data.Common.CommandTrees.ExpressionBuilder.Internal;
using System.Reflection;
namespace System.Data.Common.CommandTrees.ExpressionBuilder
{
///
/// Provides an API to construct
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
#if PUBLIC_DBEXPRESSIONBUILDER
public
#endif
static class EdmFunctions
{
#region Private Implementation
private static EdmFunction ResolveCanonicalFunction(string functionName, TypeUsage[] argumentTypes)
{
Debug.Assert(!string.IsNullOrEmpty(functionName), "Function name must not be null");
List functions = new List(
System.Linq.Enumerable.Where(
EdmProviderManifest.Instance.GetStoreFunctions(),
func => string.Equals(func.Name, functionName, StringComparison.Ordinal))
);
EdmFunction foundFunction = null;
bool ambiguous = false;
if (functions.Count > 0)
{
foundFunction = EntitySql.FunctionOverloadResolver.ResolveFunctionOverloads(functions, argumentTypes, false, out ambiguous);
if (ambiguous)
{
throw EntityUtil.Argument(Entity.Strings.Cqt_Function_CanonicalFunction_AmbiguousMatch(functionName));
}
}
if (foundFunction == null)
{
throw EntityUtil.Argument(Entity.Strings.Cqt_Function_CanonicalFunction_NotFound(functionName));
}
return foundFunction;
}
private static DbFunctionExpression InvokeCanonicalFunction(string functionName, params DbExpression[] arguments)
{
TypeUsage[] argumentTypes = new TypeUsage[arguments.Length];
for (int idx = 0; idx < arguments.Length; idx++)
{
Debug.Assert(arguments[idx] != null, "Ensure arguments are non-null before calling InvokeCanonicalFunction");
argumentTypes[idx] = arguments[idx].ResultType;
}
EdmFunction foundFunction = ResolveCanonicalFunction(functionName, argumentTypes);
return DbExpressionBuilder.Invoke(foundFunction, arguments);
}
#endregion
#if PUBLIC_DBEXPRESSIONBUILDER
#region Aggregate functions - Average, Count, LongCount, Max, Min, Sum, StDev, StDevP, Var, VarP
///
/// Creates a
/// An expression that specifies the collection from which the average value should be computed
/// A new DbFunctionExpression that produces the average value.
/// No overload of the canonical 'Avg' function accepts an argument with the result type of
public static DbFunctionExpression Average(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Avg", collection);
}
///
/// Creates a
/// An expression that specifies the collection over which the count value should be computed.
/// A new DbFunctionExpression that produces the count value.
/// No overload of the canonical 'Count' function accepts an argument with the result type of
public static DbFunctionExpression Count(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Count", collection);
}
///
/// Creates a
/// An expression that specifies the collection over which the count value should be computed.
/// A new DbFunctionExpression that produces the count value.
/// No overload of the canonical 'BigCount' function accepts an argument with the result type of
public static DbFunctionExpression LongCount(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("BigCount", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the maximum value should be retrieved
/// A new DbFunctionExpression that produces the maximum value.
/// No overload of the canonical 'Max' function accepts an argument with the result type of
public static DbFunctionExpression Max(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Max", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the minimum value should be retrieved
/// A new DbFunctionExpression that produces the minimum value.
/// No overload of the canonical 'Min' function accepts an argument with the result type of
public static DbFunctionExpression Min(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Min", collection);
}
///
/// Creates a
/// An expression that specifies the collection from which the sum should be computed
/// A new DbFunctionExpression that produces the sum.
/// No overload of the canonical 'Sum' function accepts an argument with the result type of
public static DbFunctionExpression Sum(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Sum", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the standard deviation should be computed
/// A new DbFunctionExpression that produces the standard deviation value over non-null members of the collection.
/// No overload of the canonical 'StDev' function accepts an argument with the result type of
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "St")]
public static DbFunctionExpression StDev(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("StDev", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the standard deviation should be computed
/// A new DbFunctionExpression that produces the standard deviation value.
/// No overload of the canonical 'StDevP' function accepts an argument with the result type of
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "St")]
public static DbFunctionExpression StDevP(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("StDevP", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the statistical variance should be computed
/// A new DbFunctionExpression that produces the statistical variance value for the non-null members of the collection.
/// No overload of the canonical 'Var' function accepts an argument with the result type of
public static DbFunctionExpression Var(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("Var", collection);
}
///
/// Creates a
/// An expression that specifies the collection for which the statistical variance should be computed
/// A new DbFunctionExpression that produces the statistical variance value.
/// No overload of the canonical 'VarP' function accepts an argument with the result type of
public static DbFunctionExpression VarP(this DbExpression collection)
{
EntityUtil.CheckArgumentNull(collection, "collection");
return InvokeCanonicalFunction("VarP", collection);
}
#endregion
#region String functions - Concat, Contains, EndsWith, IndexOf, Left, Length, LTrim, Replace, Reverse, Right, RTrim, StartsWith, Substring, ToUpper, ToLower, Trim
///
/// Creates a
/// An expression that specifies the string that should appear first in the concatenated result string.
/// An expression that specifies the string that should appear second in the concatenated result string.
/// A new DbFunctionExpression that produces the concatenated string.
/// No overload of the canonical 'Concat' function accepts arguments with the result types of
public static DbFunctionExpression Concat(this DbExpression string1, DbExpression string2)
{
EntityUtil.CheckArgumentNull(string1, "string1");
EntityUtil.CheckArgumentNull(string2, "string2");
return InvokeCanonicalFunction("Concat", string1, string2);
}
//
///
/// Creates a
/// An expression that specifies the string to search for any occurence of A new DbFunctionExpression that returns a Boolean value indicating whether or not
/// No overload of the canonical 'Contains' function accepts arguments with the result types of
public static DbExpression Contains(this DbExpression searchedString, DbExpression searchedForString)
{
EntityUtil.CheckArgumentNull(searchedString, "searchedString");
EntityUtil.CheckArgumentNull(searchedForString, "searchedForString");
return InvokeCanonicalFunction("Contains", searchedString, searchedForString);
}
///
/// Creates a
/// An expression that specifies the string to check for the specified .
/// An expression that specifies the suffix for which A new DbFunctionExpression that indicates whether
/// No overload of the canonical 'EndsWith' function accepts arguments with the result types of
public static DbFunctionExpression EndsWith(this DbExpression stringArgument, DbExpression suffix)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(suffix, "suffix");
return InvokeCanonicalFunction("EndsWith", stringArgument, suffix);
}
///
/// Creates a
/// The index returned by IndexOf is 1-based.
/// An expression that specifies the string to search for A new DbFunctionExpression that returns the first index of
/// No overload of the canonical 'IndexOf' function accepts arguments with the result types of
public static DbFunctionExpression IndexOf(this DbExpression searchString, DbExpression stringToFind)
{
EntityUtil.CheckArgumentNull(searchString, "searchString");
EntityUtil.CheckArgumentNull(stringToFind, "stringToFind");
return InvokeCanonicalFunction("IndexOf", stringToFind, searchString);
}
///
/// Creates a
/// An expression that specifies the string from which to extract the leftmost substring.
/// An expression that specifies the length of the leftmost substring to extract from A new DbFunctionExpression that returns the the leftmost substring of length
/// No overload of the canonical 'Left' function accepts arguments with the result types of
public static DbFunctionExpression Left(this DbExpression stringArgument, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Left", stringArgument, length);
}
///
/// Creates a
/// An expression that specifies the string for which the length should be computed.
/// A new DbFunctionExpression that returns the the length of
/// No overload of the canonical 'Length' function accepts an argument with the result type of
public static DbFunctionExpression Length(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Length", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string in which to perform the replacement operation
/// An expression that specifies the string to replace
/// An expression that specifies the replacement string
/// A new DbFunctionExpression than returns a new string based on
/// No overload of the canonical 'Length' function accepts arguments with the result types of
public static DbFunctionExpression Replace(this DbExpression stringArgument, DbExpression toReplace, DbExpression replacement)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(toReplace, "toReplace");
EntityUtil.CheckArgumentNull(replacement, "replacement");
return InvokeCanonicalFunction("Replace", stringArgument, toReplace, replacement);
}
///
/// Creates a
/// An expression that specifies the string to reverse.
/// A new DbFunctionExpression that produces the reversed value of
/// No overload of the canonical 'Reverse' function accepts an argument with the result type of
public static DbFunctionExpression Reverse(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Reverse", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which to extract the rightmost substring.
/// An expression that specifies the length of the rightmost substring to extract from A new DbFunctionExpression that returns the the rightmost substring of length
/// No overload of the canonical 'Right' function accepts arguments with the result types of
public static DbFunctionExpression Right(this DbExpression stringArgument, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Right", stringArgument, length);
}
///
/// Creates a
/// An expression that specifies the string to check for the specified .
/// An expression that specifies the prefix for which A new DbFunctionExpression that indicates whether
/// No overload of the canonical 'StartsWith' function accepts arguments with the result types of
public static DbFunctionExpression StartsWith(this DbExpression stringArgument, DbExpression prefix)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(prefix, "prefix");
return InvokeCanonicalFunction("StartsWith", stringArgument, prefix);
}
//
///
/// Creates a
/// Substring requires that the index specified by
/// An expression that specifies the string from which to extract the substring.
/// An expression that specifies the starting index from which the substring should be taken.
/// An expression that specifies the length of the substring.
/// A new DbFunctionExpression that returns the substring of length
/// No overload of the canonical 'Substring' function accepts arguments with the result types of
public static DbFunctionExpression Substring(this DbExpression stringArgument, DbExpression start, DbExpression length)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
EntityUtil.CheckArgumentNull(start, "start");
EntityUtil.CheckArgumentNull(length, "length");
return InvokeCanonicalFunction("Substring", stringArgument, start, length);
}
///
/// Creates a
/// An expression that specifies the string that should be converted to lower case.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'ToLower' function accepts an argument with the result type of
public static DbFunctionExpression ToLower(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("ToLower", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string that should be converted to upper case.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'ToUpper' function accepts an argument with the result type of
public static DbFunctionExpression ToUpper(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("ToUpper", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which leading and trailing space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'Trim' function accepts an argument with the result type of
public static DbFunctionExpression Trim(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("Trim", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which trailing space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'RTrim' function accepts an argument with the result type of
public static DbFunctionExpression TrimEnd(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("RTrim", stringArgument);
}
///
/// Creates a
/// An expression that specifies the string from which leading space should be removed.
/// A new DbFunctionExpression that returns value of
/// No overload of the canonical 'LTrim' function accepts an argument with the result type of
public static DbFunctionExpression TrimStart(this DbExpression stringArgument)
{
EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
return InvokeCanonicalFunction("LTrim", stringArgument);
}
#endregion
#region Date/Time member access methods - Year, Month, Day, DayOfYear, Hour, Minute, Second, Millisecond, GetTotalOffsetMinutes
///
/// Creates a
/// An expression that specifies the value from which the year should be retrieved.
/// A new DbFunctionExpression that returns the integer year value from
/// No overload of the canonical 'Year' function accepts an argument with the result type of
public static DbFunctionExpression Year(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Year", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the month should be retrieved.
/// A new DbFunctionExpression that returns the integer month value from
/// No overload of the canonical 'Month' function accepts an argument with the result type of
public static DbFunctionExpression Month(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Month", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the day should be retrieved.
/// A new DbFunctionExpression that returns the integer day value from
/// No overload of the canonical 'Day' function accepts an argument with the result type of
public static DbFunctionExpression Day(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("Day", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the day within the year should be retrieved.
/// A new DbFunctionExpression that returns the integer day of year value from
/// No overload of the canonical 'DayOfYear' function accepts an argument with the result type of
public static DbFunctionExpression DayOfYear(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("DayOfYear", dateValue);
}
///
/// Creates a
/// An expression that specifies the value from which the hour should be retrieved.
/// A new DbFunctionExpression that returns the integer hour value from
/// No overload of the canonical 'Hour' function accepts an argument with the result type of
public static DbFunctionExpression Hour(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Hour", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the minute should be retrieved.
/// A new DbFunctionExpression that returns the integer minute value from
/// No overload of the canonical 'Minute' function accepts an argument with the result type of
public static DbFunctionExpression Minute(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Minute", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the second should be retrieved.
/// A new DbFunctionExpression that returns the integer second value from
/// No overload of the canonical 'Second' function accepts an argument with the result type of
public static DbFunctionExpression Second(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Second", timeValue);
}
///
/// Creates a
/// An expression that specifies the value from which the millisecond should be retrieved.
/// A new DbFunctionExpression that returns the integer millisecond value from
/// No overload of the canonical 'Millisecond' function accepts an argument with the result type of
public static DbFunctionExpression Millisecond(this DbExpression timeValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
return InvokeCanonicalFunction("Millisecond", timeValue);
}
///
/// Creates a
/// An expression that specifies the DateTimeOffset value from which the minute offset from GMT should be retrieved.
/// A new DbFunctionExpression that returns the number of minutes
/// No overload of the canonical 'GetTotalOffsetMinutes' function accepts an argument with the result type of
public static DbFunctionExpression GetTotalOffsetMinutes(this DbExpression dateTimeOffsetArgument)
{
EntityUtil.CheckArgumentNull(dateTimeOffsetArgument, "dateTimeOffsetArgument");
return InvokeCanonicalFunction("GetTotalOffsetMinutes", dateTimeOffsetArgument);
}
#endregion
#region Date/Time creation methods - CurrentDateTime, CurrentDateTimeOffset, CurrentUtcDateTime, CreateDateTime, CreateDateTimeOffset, CreateTime, TruncateTime
///
/// Creates a
/// A new DbFunctionExpression that returns the current date and time as an Edm.DateTime instance.
public static DbFunctionExpression CurrentDateTime()
{
return InvokeCanonicalFunction("CurrentDateTime");
}
///
/// Creates a
/// A new DbFunctionExpression that returns the current date and time as an Edm.DateTimeOffset instance.
public static DbFunctionExpression CurrentDateTimeOffset()
{
return InvokeCanonicalFunction("CurrentDateTimeOffset");
}
///
/// Creates a
/// A new DbFunctionExpression that returns the current UTC date and time as an Edm.DateTime instance.
public static DbFunctionExpression CurrentUtcDateTime()
{
return InvokeCanonicalFunction("CurrentUtcDateTime");
}
///
/// Creates a
/// An expression that specifies the value for which the time component should be truncated.
/// A new DbFunctionExpression that returns the value of
/// No overload of the canonical 'TruncateTime' function accepts an argument with the result type of
public static DbFunctionExpression TruncateTime(this DbExpression dateValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
return InvokeCanonicalFunction("TruncateTime", dateValue);
}
///
/// Creates a
/// An expression that provides the year component value for the new DateTime instance.
/// An expression that provides the month component value for the new DateTime instance.
/// An expression that provides the day component value for the new DateTime instance.
/// An expression that provides the hour component value for the new DateTime instance.
/// An expression that provides the minute component value for the new DateTime instance.
/// An expression that provides the second component value for the new DateTime instance.
/// A new DbFunctionExpression that returns a new DateTime based on the specified component values.
/// No overload of the canonical 'CreateDateTime' function accepts arguments with the result types of
public static DbFunctionExpression CreateDateTime(DbExpression year, DbExpression month, DbExpression day, DbExpression hour, DbExpression minute, DbExpression second)
{
EntityUtil.CheckArgumentNull(year, "year");
EntityUtil.CheckArgumentNull(month, "month");
EntityUtil.CheckArgumentNull(day, "day");
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
return InvokeCanonicalFunction("CreateDateTime", year, month, day, hour, minute, second);
}
///
/// Creates a
/// An expression that provides the year component value for the new DateTimeOffset instance.
/// An expression that provides the month component value for the new DateTimeOffset instance.
/// An expression that provides the day component value for the new DateTimeOffset instance.
/// An expression that provides the hour component value for the new DateTimeOffset instance.
/// An expression that provides the minute component value for the new DateTimeOffset instance.
/// An expression that provides the second component value for the new DateTimeOffset instance.
/// An expression that provides the number of minutes in the time zone offset component value for the new DateTimeOffset instance.
/// A new DbFunctionExpression that returns a new DateTimeOffset based on the specified component values.
/// No overload of the canonical 'CreateDateTimeOffset' function accepts arguments with the result types of
public static DbFunctionExpression CreateDateTimeOffset(DbExpression year, DbExpression month, DbExpression day, DbExpression hour, DbExpression minute, DbExpression second, DbExpression timeZoneOffset)
{
EntityUtil.CheckArgumentNull(year, "year");
EntityUtil.CheckArgumentNull(month, "month");
EntityUtil.CheckArgumentNull(day, "day");
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
EntityUtil.CheckArgumentNull(timeZoneOffset, "timeZoneOffset");
return InvokeCanonicalFunction("CreateDateTimeOffset", year, month, day, hour, minute, second, timeZoneOffset);
}
///
/// Creates a
/// An expression that provides the hour component value for the new DateTime instance.
/// An expression that provides the minute component value for the new DateTime instance.
/// An expression that provides the second component value for the new DateTime instance.
/// A new DbFunctionExpression that returns a new Time based on the specified component values.
/// No overload of the canonical 'CreateTime' function accepts arguments with the result types of
public static DbFunctionExpression CreateTime(DbExpression hour, DbExpression minute, DbExpression second)
{
EntityUtil.CheckArgumentNull(hour, "hour");
EntityUtil.CheckArgumentNull(minute, "minute");
EntityUtil.CheckArgumentNull(second, "second");
return InvokeCanonicalFunction("CreateTime", hour, minute, second);
}
#endregion
#region Date/Time addition - AddYears, AddMonths, AddDays, AddHours, AddMinutes, AddSeconds, AddMilliseconds, AddMicroseconds, AddNanoseconds
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of years specified by
/// No overload of the canonical 'AddYears' function accepts arguments with the result types of
public static DbFunctionExpression AddYears(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddYears", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of months specified by
/// No overload of the canonical 'AddMonths' function accepts arguments with the result types of
public static DbFunctionExpression AddMonths(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMonths", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of days specified by
/// No overload of the canonical 'AddDays' function accepts arguments with the result types of
public static DbFunctionExpression AddDays(this DbExpression dateValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(dateValue, "dateValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddDays", dateValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of hours specified by
/// No overload of the canonical 'AddHours' function accepts arguments with the result types of
public static DbFunctionExpression AddHours(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddHours", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of minutes specified by
/// No overload of the canonical 'AddMinutes' function accepts arguments with the result types of
public static DbFunctionExpression AddMinutes(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMinutes", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of seconds specified by
/// No overload of the canonical 'AddSeconds' function accepts arguments with the result types of
public static DbFunctionExpression AddSeconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddSeconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of milliseconds specified by
/// No overload of the canonical 'AddMilliseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddMilliseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMilliseconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of microseconds specified by
/// No overload of the canonical 'AddMicroseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddMicroseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddMicroseconds", timeValue, addValue);
}
///
/// Creates a
/// An expression that specifies the value to which A new DbFunctionExpression that adds the number of nanoseconds specified by
/// No overload of the canonical 'AddNanoseconds' function accepts arguments with the result types of
public static DbFunctionExpression AddNanoseconds(this DbExpression timeValue, DbExpression addValue)
{
EntityUtil.CheckArgumentNull(timeValue, "timeValue");
EntityUtil.CheckArgumentNull(addValue, "addValue");
return InvokeCanonicalFunction("AddNanoseconds", timeValue, addValue);
}
#endregion
#region Date/Time difference - DiffYears, DiffMonths, DiffDays, DiffHours, DiffMinutes, DiffSeconds, DiffMilliseconds, DiffMicroseconds, DiffNanoseconds
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the year difference from A new DbFunctionExpression that returns the year difference between and .
/// No overload of the canonical 'DiffYears' function accepts arguments with the result types of
public static DbFunctionExpression DiffYears(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffYears", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the month difference from A new DbFunctionExpression that returns the month difference between and .
/// No overload of the canonical 'DiffMonths' function accepts arguments with the result types of
public static DbFunctionExpression DiffMonths(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffMonths", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime or DateTimeOffset value.
/// An expression that specifies the DateTime or DateTimeOffset for which the day difference from A new DbFunctionExpression that returns the day difference between and .
/// No overload of the canonical 'DiffDays' function accepts arguments with the result types of
public static DbFunctionExpression DiffDays(this DbExpression dateValue1, DbExpression dateValue2)
{
EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
return InvokeCanonicalFunction("DiffDays", dateValue1, dateValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the hour difference from A new DbFunctionExpression that returns the hour difference between and .
/// No overload of the canonical 'DiffHours' function accepts arguments with the result types of
public static DbFunctionExpression DiffHours(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffHours", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the minute difference from A new DbFunctionExpression that returns the minute difference between and .
/// No overload of the canonical 'DiffMinutes' function accepts arguments with the result types of
public static DbFunctionExpression DiffMinutes(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMinutes", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the second difference from A new DbFunctionExpression that returns the second difference between and .
/// No overload of the canonical 'DiffSeconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffSeconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffSeconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the millisecond difference from A new DbFunctionExpression that returns the millisecond difference between and .
/// No overload of the canonical 'DiffMilliseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffMilliseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMilliseconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the microsecond difference from A new DbFunctionExpression that returns the microsecond difference between and .
/// No overload of the canonical 'DiffMicroseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffMicroseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffMicroseconds", timeValue1, timeValue2);
}
///
/// Creates a
/// An expression that specifies the first DateTime, DateTimeOffset or Time value.
/// An expression that specifies the DateTime, DateTimeOffset or Time for which the nanosecond difference from A new DbFunctionExpression that returns the nanosecond difference between and .
/// No overload of the canonical 'DiffNanoseconds' function accepts arguments with the result types of
public static DbFunctionExpression DiffNanoseconds(this DbExpression timeValue1, DbExpression timeValue2)
{
EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
return InvokeCanonicalFunction("DiffNanoseconds", timeValue1, timeValue2);
}
#endregion
#region Math functions - Floor, Ceiling, Round, Truncate, Abs, Power
///
/// Creates a
/// An expression that specifies the numeric value to round.
/// A new DbFunctionExpression that rounds the specified argument to the nearest integer value.
/// No overload of the canonical 'Round' function accepts an argument with the result type of
public static DbFunctionExpression Round(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Round", value);
}
///
/// Creates a
/// An expression that specifies the numeric value to round.
/// An expression that specifies the number of digits of precision to use when rounding.
/// A new DbFunctionExpression that rounds the specified argument to the nearest integer value, with precision as specified by
/// No overload of the canonical 'Round' function accepts arguments with the result types of
public static DbFunctionExpression Round(this DbExpression value, DbExpression digits)
{
EntityUtil.CheckArgumentNull(value, "value");
EntityUtil.CheckArgumentNull(digits, "digits");
return InvokeCanonicalFunction("Round", value, digits);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the largest integer value not greater than
/// No overload of the canonical 'Floor' function accepts an argument with the result type of
public static DbFunctionExpression Floor(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Floor", value);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the smallest integer value not less than than
/// No overload of the canonical 'Ceiling' function accepts an argument with the result type of
public static DbFunctionExpression Ceiling(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Ceiling", value);
}
///
/// Creates a
/// An expression that specifies the numeric value.
/// A new DbFunctionExpression that returns the absolute value of
/// No overload of the canonical 'Abs' function accepts an argument with the result type of
public static DbFunctionExpression Abs(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("Abs", value);
}
///
/// Creates a
/// An expression that specifies the numeric value to truncate.
/// An expression that specifies the number of digits of precision to use when truncating.
/// A new DbFunctionExpression that truncates the specified argument to the nearest integer value, with precision as specified by
/// No overload of the canonical 'Truncate' function accepts arguments with the result types of
public static DbFunctionExpression Truncate(this DbExpression value, DbExpression digits)
{
EntityUtil.CheckArgumentNull(value, "value");
EntityUtil.CheckArgumentNull(digits, "digits");
return InvokeCanonicalFunction("Truncate", value, digits);
}
#endregion
#endif
///
/// Creates a
/// An expression that specifies the numeric value to raise to the given power.
/// An expression that specifies the power to which A new DbFunctionExpression that returns the value of
/// No overload of the canonical 'Power' function accepts arguments with the result types of
public static DbFunctionExpression Power(this DbExpression baseArgument, DbExpression exponent)
{
EntityUtil.CheckArgumentNull(baseArgument, "baseArgument");
EntityUtil.CheckArgumentNull(exponent, "exponent");
return InvokeCanonicalFunction("Power", baseArgument, exponent);
}
#if PUBLIC_DBEXPRESSIONBUILDER
#region Bitwise functions - And, Or, Not, Xor
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise AND of
/// No overload of the canonical 'BitwiseAnd' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseAnd(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseAnd", value1, value2);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise OR of
/// No overload of the canonical 'BitwiseOr' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseOr(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseOr", value1, value2);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise NOT of
/// No overload of the canonical 'BitwiseNot' function accepts an argument with the result type of
public static DbFunctionExpression BitwiseNot(this DbExpression value)
{
EntityUtil.CheckArgumentNull(value, "value");
return InvokeCanonicalFunction("BitwiseNot", value);
}
///
/// Creates a
/// An expression that specifies the first operand.
/// An expression that specifies the second operand.
/// A new DbFunctionExpression that returns the value produced by performing the bitwise XOR (exclusive OR) of
/// No overload of the canonical 'BitwiseXor' function accepts arguments with the result types of
public static DbFunctionExpression BitwiseXor(this DbExpression value1, DbExpression value2)
{
EntityUtil.CheckArgumentNull(value1, "value1");
EntityUtil.CheckArgumentNull(value2, "value2");
return InvokeCanonicalFunction("BitwiseXor", value1, value2);
}
#endregion
#endif
#region GUID Generation - NewGuid
///
/// Creates a
/// A new DbFunctionExpression that returns a new GUID value.
public static DbFunctionExpression NewGuid()
{
return InvokeCanonicalFunction("NewGuid");
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CancellationState.cs
- ObjRef.cs
- DoubleAnimationClockResource.cs
- SqlBulkCopyColumnMapping.cs
- ScrollItemPattern.cs
- SocketAddress.cs
- MaterialCollection.cs
- FieldNameLookup.cs
- StreamWriter.cs
- XmlIgnoreAttribute.cs
- Tracer.cs
- FlatButtonAppearance.cs
- CombinedGeometry.cs
- SchemaAttDef.cs
- StandardCommands.cs
- Duration.cs
- cookie.cs
- ApplicationDirectoryMembershipCondition.cs
- PersonalizationStateQuery.cs
- ReadOnlyDictionary.cs
- SmiEventSink.cs
- HMACMD5.cs
- GetParentChain.cs
- PeoplePickerWrapper.cs
- ComponentCache.cs
- GeometryCollection.cs
- TakeQueryOptionExpression.cs
- NetworkCredential.cs
- TabControlAutomationPeer.cs
- DoWorkEventArgs.cs
- TableDetailsCollection.cs
- ColorMatrix.cs
- CopyOfAction.cs
- SchemaComplexType.cs
- ProgressChangedEventArgs.cs
- Label.cs
- TimelineClockCollection.cs
- ListViewItem.cs
- ListControl.cs
- SqlServer2KCompatibilityCheck.cs
- FormattedText.cs
- RemotingConfiguration.cs
- DBDataPermissionAttribute.cs
- ISFClipboardData.cs
- DataGridCaption.cs
- WeakReadOnlyCollection.cs
- DesignTimeParseData.cs
- PageStatePersister.cs
- dataprotectionpermission.cs
- BitStream.cs
- FlowDocumentReaderAutomationPeer.cs
- FormsAuthenticationCredentials.cs
- Window.cs
- AddToCollection.cs
- EdmComplexTypeAttribute.cs
- CustomErrorsSectionWrapper.cs
- WebBrowser.cs
- CodeMethodReturnStatement.cs
- MainMenu.cs
- ProxyAttribute.cs
- FileAuthorizationModule.cs
- XmlReturnReader.cs
- TrackingMemoryStreamFactory.cs
- ExtensionQuery.cs
- FrugalList.cs
- EpmSyndicationContentSerializer.cs
- SystemWebSectionGroup.cs
- MappingException.cs
- DisplayNameAttribute.cs
- ServiceObjectContainer.cs
- FileUpload.cs
- VirtualDirectoryMapping.cs
- Missing.cs
- GenericTypeParameterBuilder.cs
- DataObject.cs
- ApplicationId.cs
- BrowserCapabilitiesFactory.cs
- SelectedGridItemChangedEvent.cs
- DataAccessor.cs
- SafeBitVector32.cs
- SafeCoTaskMem.cs
- PolyBezierSegment.cs
- AsyncResult.cs
- ValidationEventArgs.cs
- WindowsFont.cs
- AddInSegmentDirectoryNotFoundException.cs
- DbQueryCommandTree.cs
- FontStyles.cs
- UnknownBitmapDecoder.cs
- NullableDecimalAverageAggregationOperator.cs
- CompressedStack.cs
- BooleanSwitch.cs
- ApplicationSecurityManager.cs
- NoClickablePointException.cs
- UmAlQuraCalendar.cs
- TextElementEnumerator.cs
- HttpHandlerAction.cs
- QueryResponse.cs
- StyleHelper.cs
- SoapAttributeOverrides.cs