//---------------------------------------------------------------------
// <copyright file="EdmFunctions.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner  [....]
// @backupOwner [....]
//---------------------------------------------------------------------

namespace System.Data.Common.CommandTrees.ExpressionBuilder
{
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Metadata.Edm;
    using System.Diagnostics;

    /// <summary>
    /// Provides an API to construct <see cref="DbExpression"/>s that invoke canonical EDM functions, and allows that API to be accessed as extension methods on the expression type itself.
    /// </summary>
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
    public 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<EdmFunction> functions = new List<EdmFunction>(
                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(Strings.Cqt_Function_CanonicalFunction_AmbiguousMatch(functionName));
                }
            }

            if (foundFunction == null)
            {
                throw EntityUtil.Argument(Strings.Cqt_Function_CanonicalFunction_NotFound(functionName));
            }

            return foundFunction;
        }

        internal 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

        #region Aggregate functions - Average, Count, LongCount, Max, Min, Sum, StDev, StDevP, Var, VarP

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Avg' function over the
        /// specified collection. The result type of the expression is the same as the element type of the collection.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection from which the average value should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the average value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Avg' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Average(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Avg", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Count' function over the
        /// specified collection. The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection over which the count value should be computed.</param>
        /// <returns>A new DbFunctionExpression that produces the count value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Count' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Count(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Count", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'BigCount' function over the
        /// specified collection. The result type of the expression is Edm.Int64.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection over which the count value should be computed.</param>
        /// <returns>A new DbFunctionExpression that produces the count value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'BigCount' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression LongCount(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("BigCount", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Max' function over the
        /// specified collection. The result type of the expression is the same as the element type of the collection.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection from which the maximum value should be retrieved</param>
        /// <returns>A new DbFunctionExpression that produces the maximum value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Max' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Max(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Max", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Min' function over the
        /// specified collection. The result type of the expression is the same as the element type of the collection.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection from which the minimum value should be retrieved</param>
        /// <returns>A new DbFunctionExpression that produces the minimum value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Min' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Min(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Min", collection);
        }
                
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Sum' function over the
        /// specified collection. The result type of the expression is the same as the element type of the collection.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection from which the sum should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the sum.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Sum' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Sum(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Sum", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'StDev' function over the
        /// non-null members of the specified collection. The result type of the expression is Edm.Double.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection for which the standard deviation should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the standard deviation value over non-null members of the collection.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'StDev' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        [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);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'StDevP' function over the
        /// population of the specified collection. The result type of the expression is Edm.Double.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection for which the standard deviation should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the standard deviation value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'StDevP' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        [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);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Var' function over the
        /// non-null members of the specified collection. The result type of the expression is Edm.Double.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection for which the statistical variance should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the statistical variance value for the non-null members of the collection.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Var' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        public static DbFunctionExpression Var(this DbExpression collection)
        {
            EntityUtil.CheckArgumentNull(collection, "collection");
            return InvokeCanonicalFunction("Var", collection);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'VarP' function over the
        /// population of the specified collection. The result type of the expression Edm.Double.
        /// </summary>
        /// <param name="collection">An expression that specifies the collection for which the statistical variance should be computed</param>
        /// <returns>A new DbFunctionExpression that produces the statistical variance value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'VarP' function accepts an argument with the result type of <paramref name="collection"/>.</exception>
        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

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Concat' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// string.
        /// </summary>
        /// <param name="string1">An expression that specifies the string that should appear first in the concatenated result string.</param>
        /// <param name="string2">An expression that specifies the string that should appear second in the concatenated result string.</param>
        /// <returns>A new DbFunctionExpression that produces the concatenated string.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="string1"/> or <paramref name="string2"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Concat' function accepts arguments with the result types of <paramref name="string1"/> and <paramref name="string2"/>.</exception>
        public static DbFunctionExpression Concat(this DbExpression string1, DbExpression string2)
        {
            EntityUtil.CheckArgumentNull(string1, "string1");
            EntityUtil.CheckArgumentNull(string2, "string2");
            return InvokeCanonicalFunction("Concat", string1, string2);
        }

        // 

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Contains' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// Boolean.
        /// </summary>
        /// <param name="searchedString">An expression that specifies the string to search for any occurence of <paramref name="searchedForString"/>.</param>
        /// <param name="searchedForString">An expression that specifies the string to search for in <paramref name="searchedString"/>.</param>
        /// <returns>A new DbFunctionExpression that returns a Boolean value indicating whether or not <paramref name="searchedForString"/> occurs within <paramref name="searchedString"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="searchedString"/> or <paramref name="searchedForString"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Contains' function accepts arguments with the result types of <paramref name="searchedString"/> and <paramref name="searchedForString"/>.</exception>
        public static DbExpression Contains(this DbExpression searchedString, DbExpression searchedForString)
        {
            EntityUtil.CheckArgumentNull(searchedString, "searchedString");
            EntityUtil.CheckArgumentNull(searchedForString, "searchedForString");
            return InvokeCanonicalFunction("Contains", searchedString, searchedForString);
        }
                
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'EndsWith' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// Boolean.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string to check for the specified <param name="suffix">.</param>
        /// <param name="suffix">An expression that specifies the suffix for which <paramref name="stringArgument"/> should be checked.</param>
        /// <returns>A new DbFunctionExpression that indicates whether <paramref name="stringArgument"/> ends with <paramref name="suffix"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> or <paramref name="suffix"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'EndsWith' function accepts arguments with the result types of <paramref name="stringArgument"/> and <paramref name="suffix"/>.</exception>
        public static DbFunctionExpression EndsWith(this DbExpression stringArgument, DbExpression suffix)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            EntityUtil.CheckArgumentNull(suffix, "suffix");
            return InvokeCanonicalFunction("EndsWith", stringArgument, suffix);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'IndexOf' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// Edm.Int32.
        /// </summary>
        /// <remarks>The index returned by IndexOf is <b>1-based</b>.</remarks>
        /// <param name="searchString">An expression that specifies the string to search for <paramref name="stringToFind"/>.</param>
        /// <param name="stringToFind">An expression that specifies the string to locate within <paramref name="searchString"/> should be checked.</param>
        /// <returns>A new DbFunctionExpression that returns the first index of <paramref name="stringToFind"/> in <paramref name="searchString"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="searchString"/> or <paramref name="stringToFind"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'IndexOf' function accepts arguments with the result types of <paramref name="searchString"/> and <paramref name="stringToFind"/>.</exception>
        public static DbFunctionExpression IndexOf(this DbExpression searchString, DbExpression stringToFind)
        {
            EntityUtil.CheckArgumentNull(searchString, "searchString");
            EntityUtil.CheckArgumentNull(stringToFind, "stringToFind");
            return InvokeCanonicalFunction("IndexOf", stringToFind, searchString);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Left' function with the
        /// specified arguments, which must have a string and integer numeric result type. The result type of the expression is
        /// string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string from which to extract the leftmost substring.</param>
        /// <param name="length">An expression that specifies the length of the leftmost substring to extract from <paramref name="stringArgument"/>.</param>
        /// <returns>A new DbFunctionExpression that returns the the leftmost substring of length <paramref name="length"/> from <paramref name="stringArgument"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> or <paramref name="length"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Left' function accepts arguments with the result types of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression Left(this DbExpression stringArgument, DbExpression length)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            EntityUtil.CheckArgumentNull(length, "length");
            return InvokeCanonicalFunction("Left", stringArgument, length);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Length' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string for which the length should be computed.</param>
        /// <returns>A new DbFunctionExpression that returns the the length of <paramref name="stringArgument"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Length' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression Length(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("Length", stringArgument);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Replace' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string in which to perform the replacement operation</param>
        /// <param name="toReplace">An expression that specifies the string to replace</param>
        /// <param name="replacement">An expression that specifies the replacement string</param>
        /// <returns>A new DbFunctionExpression than returns a new string based on <paramref name="stringArgument"/> where every occurence of <paramref name="toReplace"/> is replaced by <paramref name="replacement"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/>, <paramref name="toReplace"/> or <paramref name="replacement"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Length' function accepts arguments with the result types of <paramref name="stringArgument"/>, <paramref name="toReplace"/> and <paramref name="replacement"/>.</exception>
        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);
        }
                
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Reverse' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string to reverse.</param>
        /// <returns>A new DbFunctionExpression that produces the reversed value of <paramref name="stringArgument"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Reverse' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression Reverse(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("Reverse", stringArgument);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Right' function with the
        /// specified arguments, which must have a string and integer numeric result type. The result type of the expression is
        /// string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string from which to extract the rightmost substring.</param>
        /// <param name="length">An expression that specifies the length of the rightmost substring to extract from <paramref name="stringArgument"/>.</param>
        /// <returns>A new DbFunctionExpression that returns the the rightmost substring of length <paramref name="length"/> from <paramref name="stringArgument"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> or <paramref name="length"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Right' function accepts arguments with the result types of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression Right(this DbExpression stringArgument, DbExpression length)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            EntityUtil.CheckArgumentNull(length, "length");
            return InvokeCanonicalFunction("Right", stringArgument, length);
        }
                
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'StartsWith' function with the
        /// specified arguments, which must each have a string result type. The result type of the expression is
        /// Boolean.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string to check for the specified <param name="prefix">.</param>
        /// <param name="suffix">An expression that specifies the prefix for which <paramref name="stringArgument"/> should be checked.</param>
        /// <returns>A new DbFunctionExpression that indicates whether <paramref name="stringArgument"/> starts with <paramref name="prefix"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> or <paramref name="prefix"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'StartsWith' function accepts arguments with the result types of <paramref name="stringArgument"/> and <paramref name="prefix"/>.</exception>
        public static DbFunctionExpression StartsWith(this DbExpression stringArgument, DbExpression prefix)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            EntityUtil.CheckArgumentNull(prefix, "prefix");
            return InvokeCanonicalFunction("StartsWith", stringArgument, prefix);
        }

        // 

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Substring' function with the
        /// specified arguments, which must have a string and integer numeric result types. The result type of the
        /// expression is string.
        /// </summary>
        /// <remarks>Substring requires that the index specified by <paramref name="start"/> be <b>1-based</b>.</remarks>
        /// <param name="stringArgument">An expression that specifies the string from which to extract the substring.</param>
        /// <param name="start">An expression that specifies the starting index from which the substring should be taken.</param>
        /// <param name="length">An expression that specifies the length of the substring.</param>
        /// <returns>A new DbFunctionExpression that returns the substring of length <paramref name="length"/> from <paramref name="stringArgument"/> starting at <paramref name="start"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/>, <paramref name="start"/> or <paramref name="length"/>is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Substring' function accepts arguments with the result types of <paramref name="stringArgument"/>, <paramref name="start"/> and <paramref name="length"/>.</exception>
        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);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'ToLower' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string that should be converted to lower case.</param>
        /// <returns>A new DbFunctionExpression that returns value of <paramref name="stringArgument"/> converted to lower case.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'ToLower' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression ToLower(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("ToLower", stringArgument);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'ToUpper' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string that should be converted to upper case.</param>
        /// <returns>A new DbFunctionExpression that returns value of <paramref name="stringArgument"/> converted to upper case.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'ToUpper' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression ToUpper(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("ToUpper", stringArgument);
        }
                        
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Trim' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string from which leading and trailing space should be removed.</param>
        /// <returns>A new DbFunctionExpression that returns value of <paramref name="stringArgument"/> with leading and trailing space removed.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Trim' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression Trim(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("Trim", stringArgument);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'RTrim' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string from which trailing space should be removed.</param>
        /// <returns>A new DbFunctionExpression that returns value of <paramref name="stringArgument"/> with trailing space removed.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'RTrim' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        public static DbFunctionExpression TrimEnd(this DbExpression stringArgument)
        {
            EntityUtil.CheckArgumentNull(stringArgument, "stringArgument");
            return InvokeCanonicalFunction("RTrim", stringArgument);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'LTrim' function with the
        /// specified argument, which must have a string result type. The result type of the expression is
        /// also string.
        /// </summary>
        /// <param name="stringArgument">An expression that specifies the string from which leading space should be removed.</param>
        /// <returns>A new DbFunctionExpression that returns value of <paramref name="stringArgument"/> with leading space removed.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="stringArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'LTrim' function accepts an argument with the result type of <paramref name="stringArgument"/>.</exception>
        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
        
        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Year' function with the
        /// specified argument, which must have a DateTime or DateTimeOffset result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value from which the year should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer year value from <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Year' function accepts an argument with the result type of <paramref name="dateValue"/>.</exception>
        public static DbFunctionExpression Year(this DbExpression dateValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            return InvokeCanonicalFunction("Year", dateValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Month' function with the
        /// specified argument, which must have a DateTime or DateTimeOffset result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value from which the month should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer month value from <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Month' function accepts an argument with the result type of <paramref name="dateValue"/>.</exception>
        public static DbFunctionExpression Month(this DbExpression dateValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            return InvokeCanonicalFunction("Month", dateValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Day' function with the
        /// specified argument, which must have a DateTime or DateTimeOffset result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value from which the day should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer day value from <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Day' function accepts an argument with the result type of <paramref name="dateValue"/>.</exception>
        public static DbFunctionExpression Day(this DbExpression dateValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            return InvokeCanonicalFunction("Day", dateValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DayOfYear' function with the
        /// specified argument, which must have a DateTime or DateTimeOffset result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value from which the day within the year should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer day of year value from <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DayOfYear' function accepts an argument with the result type of <paramref name="dateValue"/>.</exception>
        public static DbFunctionExpression DayOfYear(this DbExpression dateValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            return InvokeCanonicalFunction("DayOfYear", dateValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Hour' function with the
        /// specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value from which the hour should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer hour value from <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Hour' function accepts an argument with the result type of <paramref name="timeValue"/>.</exception>
        public static DbFunctionExpression Hour(this DbExpression timeValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            return InvokeCanonicalFunction("Hour", timeValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Minute' function with the
        /// specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value from which the minute should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer minute value from <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Minute' function accepts an argument with the result type of <paramref name="timeValue"/>.</exception>
        public static DbFunctionExpression Minute(this DbExpression timeValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            return InvokeCanonicalFunction("Minute", timeValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Second' function with the
        /// specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value from which the second should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer second value from <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Second' function accepts an argument with the result type of <paramref name="timeValue"/>.</exception>
        public static DbFunctionExpression Second(this DbExpression timeValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            return InvokeCanonicalFunction("Second", timeValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Millisecond' function with the
        /// specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of
        /// the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value from which the millisecond should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the integer millisecond value from <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Millisecond' function accepts an argument with the result type of <paramref name="timeValue"/>.</exception>
        public static DbFunctionExpression Millisecond(this DbExpression timeValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            return InvokeCanonicalFunction("Millisecond", timeValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'GetTotalOffsetMinutes' function with the
        /// specified argument, which must have a DateTimeOffset result type. The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateTimeOffsetArgument">An expression that specifies the DateTimeOffset value from which the minute offset from GMT should be retrieved.</param>
        /// <returns>A new DbFunctionExpression that returns the number of minutes <paramref name="dateTimeOffsetArgument"/> is offset from GMT.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateTimeOffsetArgument"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'GetTotalOffsetMinutes' function accepts an argument with the result type of <paramref name="dateTimeOffsetArgument"/>.</exception>
        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

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CurrentDateTime' function.
        /// </summary>
        /// <returns>A new DbFunctionExpression that returns the current date and time as an Edm.DateTime instance.</returns>
        public static DbFunctionExpression CurrentDateTime()
        {
            return InvokeCanonicalFunction("CurrentDateTime");
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CurrentDateTimeOffset' function.
        /// </summary>
        /// <returns>A new DbFunctionExpression that returns the current date and time as an Edm.DateTimeOffset instance.</returns>
        public static DbFunctionExpression CurrentDateTimeOffset()
        {
            return InvokeCanonicalFunction("CurrentDateTimeOffset");
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CurrentUtcDateTime' function.
        /// </summary>
        /// <returns>A new DbFunctionExpression that returns the current UTC date and time as an Edm.DateTime instance.</returns>
        public static DbFunctionExpression CurrentUtcDateTime()
        {
            return InvokeCanonicalFunction("CurrentUtcDateTime");
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'TruncateTime' function with the
        /// specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the
        /// expression is the same as the result type of <paramref name="dateValue"/>.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value for which the time portion should be truncated.</param>
        /// <returns>A new DbFunctionExpression that returns the value of <paramref name="dateValue"/> with time set to zero.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'TruncateTime' function accepts an argument with the result type of <paramref name="dateValue"/>.</exception>
        public static DbFunctionExpression TruncateTime(this DbExpression dateValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            return InvokeCanonicalFunction("TruncateTime", dateValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CreateDateTime' function with the
        /// specified arguments. <paramref name="second"/> must have a result type of Edm.Double, while all other arguments
        /// must have a result type of Edm.Int32. The result type of the expression is Edm.DateTime.
        /// </summary>
        /// <param name="year">An expression that provides the year value for the new DateTime instance.</param>
        /// <param name="month">An expression that provides the month value for the new DateTime instance.</param>
        /// <param name="day">An expression that provides the day value for the new DateTime instance.</param>
        /// <param name="hour">An expression that provides the hour value for the new DateTime instance.</param>
        /// <param name="minute">An expression that provides the minute value for the new DateTime instance.</param>
        /// <param name="second">An expression that provides the second value for the new DateTime instance.</param>
        /// <returns>A new DbFunctionExpression that returns a new DateTime based on the specified values.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="year"/>, <paramref name="month"/>, <paramref name="day"/>, <paramref name="hour"/>, <paramref name="minute"/>, or <paramref name="second"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'CreateDateTime' function accepts arguments with the result types of <paramref name="year"/>, <paramref name="month"/>, <paramref name="day"/>, <paramref name="hour"/>, <paramref name="minute"/>, and <paramref name="second"/>.</exception>
        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);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CreateDateTimeOffset' function with the
        /// specified arguments. <paramref name="second"/> must have a result type of Edm.Double, while all other arguments
        /// must have a result type of Edm.Int32. The result type of the expression is Edm.DateTimeOffset.
        /// </summary>
        /// <param name="year">An expression that provides the year value for the new DateTimeOffset instance.</param>
        /// <param name="month">An expression that provides the month value for the new DateTimeOffset instance.</param>
        /// <param name="day">An expression that provides the day value for the new DateTimeOffset instance.</param>
        /// <param name="hour">An expression that provides the hour value for the new DateTimeOffset instance.</param>
        /// <param name="minute">An expression that provides the minute value for the new DateTimeOffset instance.</param>
        /// <param name="second">An expression that provides the second value for the new DateTimeOffset instance.</param>
        /// <param name="timeZoneOffset">An expression that provides the number of minutes in the time zone offset value for the new DateTimeOffset instance.</param>
        /// <returns>A new DbFunctionExpression that returns a new DateTimeOffset based on the specified values.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="year"/>, <paramref name="month"/>, <paramref name="day"/>, <paramref name="hour"/>, <paramref name="minute"/>, <paramref name="second"/> or <paramref name="timeZoneOffset"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'CreateDateTimeOffset' function accepts arguments with the result types of <paramref name="year"/>, <paramref name="month"/>, <paramref name="day"/>, <paramref name="hour"/>, <paramref name="minute"/>, <paramref name="second"/> and <paramref name="timeZoneOffset"/>.</exception>
        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);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'CreateTime' function with the
        /// specified arguments. <paramref name="second"/> must have a result type of Edm.Double, while all other arguments
        /// must have a result type of Edm.Int32. The result type of the expression is Edm.Time.
        /// </summary>
        /// <param name="hour">An expression that provides the hour value for the new DateTime instance.</param>
        /// <param name="minute">An expression that provides the minute value for the new DateTime instance.</param>
        /// <param name="second">An expression that provides the second value for the new DateTime instance.</param>
        /// <returns>A new DbFunctionExpression that returns a new Time based on the specified values.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="hour"/>, <paramref name="minute"/>, or <paramref name="second"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'CreateTime' function accepts arguments with the result types of <paramref name="hour"/>, <paramref name="minute"/>, and <paramref name="second"/>.</exception>
        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

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddYears' function with the
        /// specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="dateValue"/>.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of years to add to <paramref name="dateValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of years specified by <paramref name="addValue"/> to the value specified by <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddYears' function accepts arguments with the result types of <paramref name="dateValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddYears(this DbExpression dateValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddYears", dateValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddMonths' function with the
        /// specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="dateValue"/>.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of months to add to <paramref name="dateValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of months specified by <paramref name="addValue"/> to the value specified by <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddMonths' function accepts arguments with the result types of <paramref name="dateValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddMonths(this DbExpression dateValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddMonths", dateValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddDays' function with the
        /// specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="dateValue"/>.
        /// </summary>
        /// <param name="dateValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of days to add to <paramref name="dateValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of days specified by <paramref name="addValue"/> to the value specified by <paramref name="dateValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddDays' function accepts arguments with the result types of <paramref name="dateValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddDays(this DbExpression dateValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(dateValue, "dateValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddDays", dateValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddHours' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of hours to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of hours specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddHours' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddHours(this DbExpression timeValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddHours", timeValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddMinutes' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of minutes to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of minutes specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddMinutes' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddMinutes(this DbExpression timeValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddMinutes", timeValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddSeconds' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of seconds to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of seconds specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddSeconds' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddSeconds(this DbExpression timeValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddSeconds", timeValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddMilliseconds' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of milliseconds to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of milliseconds specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddMilliseconds' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddMilliseconds(this DbExpression timeValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddMilliseconds", timeValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddMicroseconds' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of microseconds to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of microseconds specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddMicroseconds' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        public static DbFunctionExpression AddMicroseconds(this DbExpression timeValue, DbExpression addValue)
        {
            EntityUtil.CheckArgumentNull(timeValue, "timeValue");
            EntityUtil.CheckArgumentNull(addValue, "addValue");
            return InvokeCanonicalFunction("AddMicroseconds", timeValue, addValue);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'AddNanoseconds' function with the
        /// specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="timeValue"/>.
        /// </summary>
        /// <param name="timeValue">An expression that specifies the value to which <paramref name="addValue"/>should be added.</param>
        /// <param name="addValue">An expression that specifies the number of nanoseconds to add to <paramref name="timeValue"/>.</param>
        /// <returns>A new DbFunctionExpression that adds the number of nanoseconds specified by <paramref name="addValue"/> to the value specified by <paramref name="timeValue"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue"/> or <paramref name="addValue"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'AddNanoseconds' function accepts arguments with the result types of <paramref name="timeValue"/> and <paramref name="addValue"/>.</exception>
        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

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffYears' function with the
        /// specified arguments, which must each have a DateTime or DateTimeOffset result type. The result type of
        /// <paramref name="dateValue1"/> must match the result type of <paramref name="dateValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue1">An expression that specifies the first DateTime or DateTimeOffset value.</param>
        /// <param name="dateValue2">An expression that specifies the DateTime or DateTimeOffset for which the year difference from <paramref name="dateValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the year difference between <param name="dateValue1"> and <param name="dateValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue1"/> or <paramref name="dateValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffYears' function accepts arguments with the result types of <paramref name="dateValue1"/> and <paramref name="dateValue2"/>.</exception>
        public static DbFunctionExpression DiffYears(this DbExpression dateValue1, DbExpression dateValue2)
        {
            EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
            EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
            return InvokeCanonicalFunction("DiffYears", dateValue1, dateValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffMonths' function with the
        /// specified arguments, which must each have a DateTime or DateTimeOffset result type. The result type of
        /// <paramref name="dateValue1"/> must match the result type of <paramref name="dateValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue1">An expression that specifies the first DateTime or DateTimeOffset value.</param>
        /// <param name="dateValue2">An expression that specifies the DateTime or DateTimeOffset for which the month difference from <paramref name="dateValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the month difference between <param name="dateValue1"> and <param name="dateValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue1"/> or <paramref name="dateValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffMonths' function accepts arguments with the result types of <paramref name="dateValue1"/> and <paramref name="dateValue2"/>.</exception>
        public static DbFunctionExpression DiffMonths(this DbExpression dateValue1, DbExpression dateValue2)
        {
            EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
            EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
            return InvokeCanonicalFunction("DiffMonths", dateValue1, dateValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffDays' function with the
        /// specified arguments, which must each have a DateTime or DateTimeOffset result type. The result type of
        /// <paramref name="dateValue1"/> must match the result type of <paramref name="dateValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="dateValue1">An expression that specifies the first DateTime or DateTimeOffset value.</param>
        /// <param name="dateValue2">An expression that specifies the DateTime or DateTimeOffset for which the day difference from <paramref name="dateValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the day difference between <param name="dateValue1"> and <param name="dateValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="dateValue1"/> or <paramref name="dateValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffDays' function accepts arguments with the result types of <paramref name="dateValue1"/> and <paramref name="dateValue2"/>.</exception>
        public static DbFunctionExpression DiffDays(this DbExpression dateValue1, DbExpression dateValue2)
        {
            EntityUtil.CheckArgumentNull(dateValue1, "dateValue1");
            EntityUtil.CheckArgumentNull(dateValue2, "dateValue2");
            return InvokeCanonicalFunction("DiffDays", dateValue1, dateValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffHours' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the hour difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the hour difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffHours' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        public static DbFunctionExpression DiffHours(this DbExpression timeValue1, DbExpression timeValue2)
        {
            EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
            EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
            return InvokeCanonicalFunction("DiffHours", timeValue1, timeValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffMinutes' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the minute difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the minute difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffMinutes' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        public static DbFunctionExpression DiffMinutes(this DbExpression timeValue1, DbExpression timeValue2)
        {
            EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
            EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
            return InvokeCanonicalFunction("DiffMinutes", timeValue1, timeValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffSeconds' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the second difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the second difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffSeconds' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        public static DbFunctionExpression DiffSeconds(this DbExpression timeValue1, DbExpression timeValue2)
        {
            EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
            EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
            return InvokeCanonicalFunction("DiffSeconds", timeValue1, timeValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffMilliseconds' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the millisecond difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the millisecond difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffMilliseconds' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        public static DbFunctionExpression DiffMilliseconds(this DbExpression timeValue1, DbExpression timeValue2)
        {
            EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
            EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
            return InvokeCanonicalFunction("DiffMilliseconds", timeValue1, timeValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffMicroseconds' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the microsecond difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the microsecond difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffMicroseconds' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        public static DbFunctionExpression DiffMicroseconds(this DbExpression timeValue1, DbExpression timeValue2)
        {
            EntityUtil.CheckArgumentNull(timeValue1, "timeValue1");
            EntityUtil.CheckArgumentNull(timeValue2, "timeValue2");
            return InvokeCanonicalFunction("DiffMicroseconds", timeValue1, timeValue2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'DiffNanoseconds' function with the
        /// specified arguments, which must each have a DateTime, DateTimeOffset or Time result type. The result type of
        /// <paramref name="timeValue1"/> must match the result type of <paramref name="timeValue2"/>. 
        /// The result type of the expression is Edm.Int32.
        /// </summary>
        /// <param name="timeValue1">An expression that specifies the first DateTime, DateTimeOffset or Time value.</param>
        /// <param name="timeValue2">An expression that specifies the DateTime, DateTimeOffset or Time for which the nanosecond difference from <paramref name="timeValue1"/> should be calculated.</param>
        /// <returns>A new DbFunctionExpression that returns the nanosecond difference between <param name="timeValue1"> and <param name="timeValue2">.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="timeValue1"/> or <paramref name="timeValue2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'DiffNanoseconds' function accepts arguments with the result types of <paramref name="timeValue1"/> and <paramref name="timeValue2"/>.</exception>
        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

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Round' function with the
        /// specified argument, which must each have a single, double or decimal result type. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value to round.</param>
        /// <returns>A new DbFunctionExpression that rounds the specified argument to the nearest integer value.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Round' function accepts an argument with the result type of <paramref name="value"/>.</exception>
        public static DbFunctionExpression Round(this DbExpression value)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            return InvokeCanonicalFunction("Round", value);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Round' function with the
        /// specified arguments, which must have a single, double or decimal, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value to round.</param>
        /// <param name="digits">An expression that specifies the number of digits of precision to use when rounding.</param>
        /// <returns>A new DbFunctionExpression that rounds the specified argument to the nearest integer value, with precision as specified by <paramref name="digits"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> or <paramref name="digits"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Round' function accepts arguments with the result types of <paramref name="value"/> and <paramref name="digits"/>.</exception>
        public static DbFunctionExpression Round(this DbExpression value, DbExpression digits)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            EntityUtil.CheckArgumentNull(digits, "digits");
            return InvokeCanonicalFunction("Round", value, digits);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Floor' function with the
        /// specified argument, which must each have a single, double or decimal result type. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value.</param>
        /// <returns>A new DbFunctionExpression that returns the largest integer value not greater than <paramref name="value"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Floor' function accepts an argument with the result type of <paramref name="value"/>.</exception>
        public static DbFunctionExpression Floor(this DbExpression value)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            return InvokeCanonicalFunction("Floor", value);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Ceiling' function with the
        /// specified argument, which must each have a single, double or decimal result type. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value.</param>
        /// <returns>A new DbFunctionExpression that returns the smallest integer value not less than than <paramref name="value"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Ceiling' function accepts an argument with the result type of <paramref name="value"/>.</exception>
        public static DbFunctionExpression Ceiling(this DbExpression value)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            return InvokeCanonicalFunction("Ceiling", value);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Abs' function with the
        /// specified argument, which must each have a numeric result type. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value.</param>
        /// <returns>A new DbFunctionExpression that returns the absolute value of <paramref name="value"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Abs' function accepts an argument with the result type of <paramref name="value"/>.</exception>
        public static DbFunctionExpression Abs(this DbExpression value)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            return InvokeCanonicalFunction("Abs", value);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Truncate' function with the
        /// specified arguments, which must have a single, double or decimal, and integer result types. The result
        /// type of the expression is the same as the result type of <paramref name="value"/>.
        /// </summary>
        /// <param name="value">An expression that specifies the numeric value to truncate.</param>
        /// <param name="digits">An expression that specifies the number of digits of precision to use when truncating.</param>
        /// <returns>A new DbFunctionExpression that truncates the specified argument to the nearest integer value, with precision as specified by <paramref name="digits"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> <paramref name="digits"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Truncate' function accepts arguments with the result types of <paramref name="value"/> and <paramref name="digits"/>.</exception>
        public static DbFunctionExpression Truncate(this DbExpression value, DbExpression digits)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            EntityUtil.CheckArgumentNull(digits, "digits");
            return InvokeCanonicalFunction("Truncate", value, digits);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'Power' function with the
        /// specified arguments, which must have numeric result types. The result type of the expression is
        /// the same as the result type of <paramref name="baseArgument"/>.
        /// </summary>
        /// <param name="baseArgument">An expression that specifies the numeric value to raise to the given power.</param>
        /// <param name="exponent">An expression that specifies the power to which <paramref name="baseArgument"/> should be raised.</param>
        /// <returns>A new DbFunctionExpression that returns the value of <paramref name="baseArgument"/> raised to the power specified by <paramref name="exponent"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="baseArgument"/> <paramref name="exponent"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'Power' function accepts arguments with the result types of <paramref name="baseArgument"/> and <paramref name="exponent"/>.</exception>
        public static DbFunctionExpression Power(this DbExpression baseArgument, DbExpression exponent)
        {
            EntityUtil.CheckArgumentNull(baseArgument, "baseArgument");
            EntityUtil.CheckArgumentNull(exponent, "exponent");
            return InvokeCanonicalFunction("Power", baseArgument, exponent);
        }

        #endregion

        #region Bitwise functions - And, Or, Not, Xor

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'BitwiseAnd' function with the
        /// specified arguments, which must have the same integer numeric result type. The result type of the
        /// expression is this same type.
        /// </summary>
        /// <param name="value">An expression that specifies the first operand.</param>
        /// <param name="value2">An expression that specifies the second operand.</param>
        /// <returns>A new DbFunctionExpression that returns the value produced by performing the bitwise AND of <paramref name="value1"/> and <paramref name="value2"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value1"/> <paramref name="value2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'BitwiseAnd' function accepts arguments with the result types of <paramref name="value1"/> and <paramref name="value2"/>.</exception>
        public static DbFunctionExpression BitwiseAnd(this DbExpression value1, DbExpression value2)
        {
            EntityUtil.CheckArgumentNull(value1, "value1");
            EntityUtil.CheckArgumentNull(value2, "value2");
            return InvokeCanonicalFunction("BitwiseAnd", value1, value2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'BitwiseOr' function with the
        /// specified arguments, which must have the same integer numeric result type. The result type of the
        /// expression is this same type.
        /// </summary>
        /// <param name="value1">An expression that specifies the first operand.</param>
        /// <param name="value2">An expression that specifies the second operand.</param>
        /// <returns>A new DbFunctionExpression that returns the value produced by performing the bitwise OR of <paramref name="value1"/> and <paramref name="value2"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value1"/> <paramref name="value2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'BitwiseOr' function accepts arguments with the result types of <paramref name="value1"/> and <paramref name="value2"/>.</exception>
        public static DbFunctionExpression BitwiseOr(this DbExpression value1, DbExpression value2)
        {
            EntityUtil.CheckArgumentNull(value1, "value1");
            EntityUtil.CheckArgumentNull(value2, "value2");
            return InvokeCanonicalFunction("BitwiseOr", value1, value2);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'BitwiseNot' function with the
        /// specified argument, which must have an integer numeric result type. The result type of the expression 
        /// is this same type.
        /// </summary>
        /// <param name="value">An expression that specifies the first operand.</param>
        /// <returns>A new DbFunctionExpression that returns the value produced by performing the bitwise NOT of <paramref name="value"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'BitwiseNot' function accepts an argument with the result type of <paramref name="value"/>.</exception>
        public static DbFunctionExpression BitwiseNot(this DbExpression value)
        {
            EntityUtil.CheckArgumentNull(value, "value");
            return InvokeCanonicalFunction("BitwiseNot", value);
        }

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'BitwiseXor' function with the
        /// specified arguments, which must have the same integer numeric result type. The result type of the
        /// expression is this same type.
        /// </summary>
        /// <param name="value1">An expression that specifies the first operand.</param>
        /// <param name="value2">An expression that specifies the second operand.</param>
        /// <returns>A new DbFunctionExpression that returns the value produced by performing the bitwise XOR (exclusive OR) of <paramref name="value1"/> and <paramref name="value2"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value1"/> <paramref name="value2"/> is null.</exception>
        /// <exception cref="ArgumentException">No overload of the canonical 'BitwiseXor' function accepts arguments with the result types of <paramref name="value1"/> and <paramref name="value2"/>.</exception>
        public static DbFunctionExpression BitwiseXor(this DbExpression value1, DbExpression value2)
        {
            EntityUtil.CheckArgumentNull(value1, "value1");
            EntityUtil.CheckArgumentNull(value2, "value2");
            return InvokeCanonicalFunction("BitwiseXor", value1, value2);
        }

        #endregion

        #region GUID Generation - NewGuid

        /// <summary>
        /// Creates a <see cref="DbFunctionExpression"/> that invokes the canonical 'NewGuid' function.
        /// </summary>
        /// <returns>A new DbFunctionExpression that returns a new GUID value.</returns>
        public static DbFunctionExpression NewGuid()
        {
            return InvokeCanonicalFunction("NewGuid");
        }

        #endregion
    }
}