open System

open System.Linq

open System.Collections

open System.Collections.Generic

open Microsoft.FSharp

open Microsoft.FSharp.Core

open Microsoft.FSharp.Core.Operators

open Microsoft.FSharp.Collections

open Microsoft.FSharp.Quotations

open Microsoft.FSharp.Linq.RuntimeHelpers

#nowarn "64"

type QuerySource<'T, 'Q> (source: seq<'T>) =

member __.Source = source

// This helps the somewhat complicated type inference for AverageByNullable and SumByNullable, by making both type in a '+' the same

let inline plus (x:'T) (y:'T) = Checked.(+) x y

let inline checkNonNull argName arg =

match box arg with

| null -> nullArg argName

| _ -> ()

let checkThenBySource (source: seq<'T>) =

match source with

| :? System.Linq.IOrderedEnumerable<'T> as source -> source

| _ -> invalidArg "source" (SR.GetString(SR.thenByError))

module ForwardDeclarations =

type IQueryMethods =

abstract Execute : Expr<'T> -> 'U

abstract EliminateNestedQueries : Expr -> Expr

let mutable Query =

{

new IQueryMethods with

member this.Execute(_) = failwith "IQueryMethods.Execute should never be called"

member this.EliminateNestedQueries(_) = failwith "IQueryMethods.EliminateNestedQueries should never be called"

}

type QueryBuilder() =

member __.For (source:QuerySource<'T,'Q>, body: 'T -> QuerySource<'Result,'Q2>) : QuerySource<'Result,'Q> = QuerySource (Seq.collect (fun x -> (body x).Source) source.Source)

member __.Zero () = QuerySource Seq.empty

member __.Yield value = QuerySource (Seq.singleton value)

member __.YieldFrom (computation: QuerySource<'T,'Q>) : QuerySource<'T,'Q> = computation

member __.Quote (q:Quotations.Expr<'T>) = q

member __.Source (source: IQueryable<'T>) = QuerySource source

member __.Source (source: IEnumerable<'T>) : QuerySource<'T,System.Collections.IEnumerable> = QuerySource source

member __.Contains(source:QuerySource<'T,'Q>,key) = Enumerable.Contains(source.Source, key)

member __.Select(source:QuerySource<'T,'Q>,projection) : QuerySource<'U,'Q>= QuerySource (Seq.map projection source.Source)

member __.Where(source:QuerySource<'T,'Q>,predicate) : QuerySource<'T,'Q> = QuerySource (Enumerable.Where (source.Source, Func<_,_>(predicate)) )

member __.Last (source:QuerySource<'T,'Q>) = Enumerable.Last source.Source

member __.LastOrDefault (source:QuerySource<'T,'Q>) = Enumerable.LastOrDefault source.Source

member __.ExactlyOne (source:QuerySource<'T,'Q>) = Enumerable.Single source.Source

member __.ExactlyOneOrDefault (source:QuerySource<'T,'Q>) = Enumerable.SingleOrDefault source.Source

member __.Count (source:QuerySource<'T,'Q>) = Enumerable.Count source.Source

member __.Distinct (source : QuerySource<'T,'Q> when 'T : equality) : QuerySource<'T,'Q> = QuerySource (Enumerable.Distinct source.Source)

member __.Exists(source: QuerySource<'T,'Q>,predicate) = Enumerable.Any (source.Source, Func<_,_>(predicate))

member __.All (source: QuerySource<'T,'Q>,predicate) = Enumerable.All (source.Source, Func<_,_>(predicate))

member __.Head (source: QuerySource<'T,'Q>) = Enumerable.First source.Source

member __.Nth (source: QuerySource<'T,'Q>, index) = Enumerable.ElementAt (source.Source, index)

//let reduceBy projection reduction source = source |> Seq.map projection |> Seq.reduce reduction

member __.Skip (source: QuerySource<'T,'Q>,count) : QuerySource<'T,'Q> = QuerySource (Enumerable.Skip (source.Source, count))

member __.SkipWhile (source: QuerySource<'T,'Q>,predicate) : QuerySource<'T,'Q> = QuerySource (Enumerable.SkipWhile (source.Source, Func<_,_>(predicate)))

member __.Take (source: QuerySource<'T,'Q>,count) : QuerySource<'T,'Q> = QuerySource (Enumerable.Take (source.Source, count))

member __.TakeWhile (source: QuerySource<'T,'Q>,predicate) : QuerySource<'T,'Q> = QuerySource (Enumerable.TakeWhile (source.Source, Func<_,_>(predicate)))

member __.Find (source: QuerySource<'T,'Q>,predicate) = Enumerable.First (source.Source, Func<_,_>(predicate))

member __.HeadOrDefault (source:QuerySource<'T,'Q>) = Enumerable.FirstOrDefault source.Source

member __.MinBy<'T,'Q,'Key when 'Key : equality and 'Key : comparison> (source:QuerySource<'T,'Q>, valueSelector : 'T -> 'Key) =

Enumerable.Min(source.Source, Func<'T,'Key>(valueSelector))

member __.MaxBy<'T,'Q,'Key when 'Key : equality and 'Key : comparison> (source:QuerySource<'T,'Q>, valueSelector : 'T -> 'Key) =

Enumerable.Max(source.Source, Func<'T,'Key>(valueSelector))

member __.MinByNullable<'T,'Q,'Key when 'Key : equality and 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType> (source:QuerySource<'T,'Q>, valueSelector : 'T -> Nullable<'Key>) =

Enumerable.Min(source.Source, Func<'T, Nullable<'Key>>(valueSelector))

member __.MaxByNullable<'T,'Q,'Key when 'Key : equality and 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType> (source:QuerySource<'T,'Q>, valueSelector : 'T -> Nullable<'Key>) =

Enumerable.Max(source.Source, Func<'T, Nullable<'Key>>(valueSelector))

member inline __.SumByNullable<'T, 'Q, ^Value

when ^Value :> ValueType

and ^Value : struct

and ^Value : (new : unit -> ^Value)

and ^Value : (static member ( + ) : ^Value * ^Value -> ^Value)

and ^Value : (static member Zero : ^Value)

and default ^Value : int>

(source: QuerySource<'T,'Q>, valueSelector : 'T -> Nullable< ^Value >) : Nullable< ^Value > =

let source = source.Source

checkNonNull "source" source

use e = source.GetEnumerator()

let mutable acc : ^Value = LanguagePrimitives.GenericZero< (^Value) >

while e.MoveNext() do

let v : Nullable< ^Value > = valueSelector e.Current

if v.HasValue then

acc <- plus acc (v.Value : ^Value)

Nullable acc

member inline __.AverageByNullable< 'T, 'Q, ^Value

when ^Value :> ValueType

and ^Value : struct

and ^Value : (new : unit -> ^Value)

and ^Value : (static member ( + ) : ^Value * ^Value -> ^Value)

and ^Value : (static member DivideByInt : ^Value * int -> ^Value)

and ^Value : (static member Zero : ^Value)

and default ^Value : float >

(source: QuerySource<'T,'Q>, projection: 'T -> Nullable< ^Value >) : Nullable< ^Value > =

let source = source.Source

checkNonNull "source" source

use e = source.GetEnumerator()

let mutable acc = LanguagePrimitives.GenericZero< (^Value) >

let mutable count = 0

while e.MoveNext() do

let v = projection e.Current

if v.HasValue then

acc <- plus acc v.Value

count <- count + 1

if count = 0 then Nullable() else Nullable(LanguagePrimitives.DivideByInt< (^Value) > acc count)

member inline __.AverageBy< 'T, 'Q, ^Value

when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value)

and ^Value : (static member DivideByInt : ^Value * int -> ^Value)

and ^Value : (static member Zero : ^Value)

and default ^Value : float >

(source: QuerySource<'T,'Q>, projection: 'T -> ^Value) : ^Value =

let source = source.Source

checkNonNull "source" source

use e = source.GetEnumerator()

let mutable acc = LanguagePrimitives.GenericZero< (^U) >

let mutable count = 0

while e.MoveNext() do

acc <- plus acc (projection e.Current)

count <- count + 1

if count = 0 then

invalidOp "source"

LanguagePrimitives.DivideByInt< (^U) > acc count

member inline __.SumBy< 'T, 'Q, ^Value

when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value)

and ^Value : (static member Zero : ^Value)

and default ^Value : int >

(source:QuerySource<'T,'Q>, projection : ('T -> ^Value)) : ^Value =

Seq.sumBy projection source.Source

member __.GroupBy (source: QuerySource<'T,'Q>, keySelector : _ -> 'Key) : QuerySource<_,'Q> when 'Key : equality =

QuerySource (Enumerable.GroupBy(source.Source, Func<_,_>(keySelector)))

member __.SortBy (source: QuerySource<'T,'Q>, keySelector : 'T -> 'Key) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.OrderBy(source.Source, Func<_,_>(keySelector)))

member __.SortByDescending (source: QuerySource<'T,'Q>, keySelector : 'T -> 'Key) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.OrderByDescending(source.Source, Func<_,_>(keySelector)))

member __.ThenBy (source: QuerySource<'T,'Q>, keySelector : 'T -> 'Key) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.ThenBy(checkThenBySource source.Source, Func<_,_>(keySelector)))

member __.ThenByDescending (source: QuerySource<'T,'Q>, keySelector : 'T -> 'Key) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.ThenByDescending(checkThenBySource source.Source, Func<_,_>(keySelector)))

member __.SortByNullable (source: QuerySource<'T,'Q>, keySelector : 'T -> Nullable<'Key>) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.OrderBy(source.Source, Func<_,_>(keySelector)))

member __.SortByNullableDescending (source: QuerySource<'T,'Q>, keySelector : 'T -> Nullable<'Key>) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.OrderByDescending(source.Source, Func<_,_>(keySelector)))

member __.ThenByNullable (source: QuerySource<'T,'Q>, keySelector : 'T -> Nullable<'Key>) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.ThenBy(checkThenBySource source.Source, Func<_,_>(keySelector)))

member __.ThenByNullableDescending (source: QuerySource<'T,'Q>, keySelector : 'T -> Nullable<'Key>) : QuerySource<'T,'Q> when 'Key : equality and 'Key : comparison =

QuerySource (Enumerable.ThenByDescending(checkThenBySource source.Source, Func<_,_>(keySelector)))

member __.GroupValBy<'T,'Key,'Result, 'Q when 'Key : equality > (source:QuerySource<'T,'Q>, resultSelector: 'T -> 'Result, keySelector: 'T -> 'Key) : QuerySource<IGrouping<'Key,'Result>,'Q> =

QuerySource (Enumerable.GroupBy(source.Source, Func<'T,'Key>(keySelector), Func<'T,'Result>(resultSelector)))

#if SUPPORT_ZIP_IN_QUERIES

member __.Zip (firstSource, secondSource, elementSelector) =

Enumerable.Zip(firstSource, secondSource, Func<_,_,_>(elementSelector) )

member __.Join (outerSource: QuerySource<_,'Q>, innerSource: QuerySource<_,'Q>, outerKeySelector, innerKeySelector, resultSelector) : QuerySource<_,'Q> =

QuerySource (Enumerable.Join(outerSource.Source, innerSource.Source, Func<_,_>(outerKeySelector), Func<_,_>(innerKeySelector), Func<_,_,_>(resultSelector)))

member __.GroupJoin (outerSource: QuerySource<_,'Q>, innerSource: QuerySource<_,'Q>, outerKeySelector, innerKeySelector, resultSelector: _ -> seq<_> -> _) : QuerySource<_,'Q> =

QuerySource (Enumerable.GroupJoin(outerSource.Source, innerSource.Source, Func<_,_>(outerKeySelector), Func<_,_>(innerKeySelector), Func<_,_,_>(fun x g -> resultSelector x g)))

member __.LeftOuterJoin (outerSource:QuerySource<_,'Q>, innerSource: QuerySource<_,'Q>, outerKeySelector, innerKeySelector, resultSelector: _ -> seq<_> -> _) : QuerySource<_,'Q> =

QuerySource (Enumerable.GroupJoin(outerSource.Source, innerSource.Source, Func<_,_>(outerKeySelector), Func<_,_>(innerKeySelector), Func<_,_,_>(fun x g -> resultSelector x (g.DefaultIfEmpty()))))

member __.RunQueryAsValue (q:Quotations.Expr<'T>) : 'T = ForwardDeclarations.Query.Execute q

member __.RunQueryAsEnumerable (q:Quotations.Expr<QuerySource<'T,IEnumerable>>) : IEnumerable<'T> =

let queryAfterEliminatingNestedQueries = ForwardDeclarations.Query.EliminateNestedQueries q

let queryAfterCleanup = Microsoft.FSharp.Linq.RuntimeHelpers.Adapters.CleanupLeaf queryAfterEliminatingNestedQueries

(LeafExpressionConverter.EvaluateQuotation queryAfterCleanup :?> QuerySource<'T,IEnumerable>).Source

member __.RunQueryAsQueryable (q:Quotations.Expr<QuerySource<'T,IQueryable>>) : IQueryable<'T> = ForwardDeclarations.Query.Execute q

member this.Run q = this.RunQueryAsQueryable q

open Microsoft.FSharp.Core

[<AutoOpen>]

module LowPriority =

type Microsoft.FSharp.Linq.QueryBuilder with

[<CompiledName("RunQueryAsValue")>]

member this.Run (q: Microsoft.FSharp.Quotations.Expr<'T>) = this.RunQueryAsValue q

[<AutoOpen>]

module HighPriority =

type Microsoft.FSharp.Linq.QueryBuilder with

[<CompiledName("RunQueryAsEnumerable")>]

member this.Run (q: Microsoft.FSharp.Quotations.Expr<Microsoft.FSharp.Linq.QuerySource<'T,System.Collections.IEnumerable>>) = this.RunQueryAsEnumerable q

open System

open System.Linq

open System.Collections

open System.Collections.Generic

open System.Linq.Expressions

open System.Reflection

open Microsoft.FSharp

open Microsoft.FSharp.Core

open Microsoft.FSharp.Core.Operators

open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators

open Microsoft.FSharp.Collections

open Microsoft.FSharp.Reflection

open Microsoft.FSharp.Linq

open Microsoft.FSharp.Linq.RuntimeHelpers.Adapters

open Microsoft.FSharp.Linq.RuntimeHelpers

open Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter

open Microsoft.FSharp.Quotations

open Microsoft.FSharp.Quotations.Patterns

open Microsoft.FSharp.Quotations.DerivedPatterns

open Microsoft.FSharp.Linq.QueryRunExtensions

#if FX_RESHAPED_REFLECTION

open PrimReflectionAdapters

open ReflectionAdapters

let ConvVar (v: Var) =

Expression.Parameter(v.Type, v.Name)

let asExpr x = (x :> Expression)

let (|Getter|_|) (prop: PropertyInfo) =

match prop.GetGetMethod(true) with

| null -> None

| v -> Some v

// Match 'f x'

let (|SpecificCall1|_|) q =

let (|CallQ|_|) = (|SpecificCallToMethod|_|) q

function

| CallQ (Some builderObj, tyargs, [arg1]) -> Some(builderObj, tyargs, arg1)

| _ -> None

// Match 'f x y' or 'f (x,y)'

let (|SpecificCall2|_|) q =

let (|CallQ|_|) = (|SpecificCallToMethod|_|) q

function

| CallQ (Some builderObj, tyargs, [arg1;arg2]) -> Some(builderObj, tyargs, arg1, arg2)

| _ -> None

// Match 'f x y z' or 'f (x,y,z)'

let (|SpecificCall3|_|) q =

let (|CallQ|_|) = (|SpecificCallToMethod|_|) q

function

| CallQ (Some builderObj, tyargs, [arg1;arg2;arg3]) -> Some(builderObj, tyargs, arg1, arg2, arg3)

| _ -> None

/// (fun (x,y) -> z) is represented as 'fun p -> let x = p#0 let y = p#1' etc.

/// This reverses this encoding, but does not de-tuple the input variable into multiple variables.

let (|LambdaNoDetupling|_|) (lam: Expr) =

/// Strip off the 'let' bindings for an LambdaNoDetupling

let rec stripSuccessiveProjLets (p:Var) n expr =

match expr with

| Let(v1,(TupleGet(Var pA,m) as e1),rest)

when p = pA && m = n->

let restvs,b = stripSuccessiveProjLets p (n+1) rest

(v1,e1)::restvs, b

| _ -> ([],expr)

match lam with

| Lambda(v,body) ->

let projs,b = stripSuccessiveProjLets v 0 body

Some(v, projs, b)

| _ -> None

let restoreTupleProjections projs b = List.foldBack (fun (v,e) acc -> Expr.Let (v,e,acc)) projs b

let (|LambdasNoDetupling|_|) (inpExpr: Expr) =

let rec loop rvs rprojs e =

match e with

| LambdaNoDetupling(v,projs,body) -> loop (v::rvs) (projs::rprojs) body

| _ ->

match rvs with

| [] -> None

| _ -> Some(List.rev rvs,restoreTupleProjections (List.concat (List.rev rprojs)) e)

loop [] [] inpExpr

let GetGenericMethodDefinition (methInfo:MethodInfo) =

if methInfo.IsGenericMethod then methInfo.GetGenericMethodDefinition() else methInfo

let CallGenericStaticMethod (methHandle:System.RuntimeMethodHandle) =

let methInfo = methHandle |> System.Reflection.MethodInfo.GetMethodFromHandle :?> MethodInfo

fun (tyargs: Type list, args: obj list) ->

let methInfo = if methInfo.IsGenericMethod then methInfo.MakeGenericMethod(Array.ofList tyargs) else methInfo

try

methInfo.Invoke(null, Array.ofList args)

with :? System.Reflection.TargetInvocationException as exn ->

raise exn.InnerException

let CallGenericInstanceMethod (methHandle:System.RuntimeMethodHandle) =

let methInfo = methHandle |> System.Reflection.MethodInfo.GetMethodFromHandle :?> MethodInfo

fun (objExpr:obj, tyargs: Type list, args: obj list) ->

let methInfo = if methInfo.IsGenericMethod then methInfo.MakeGenericMethod(Array.ofList tyargs) else methInfo

try

methInfo.Invoke(objExpr, Array.ofList args)

with :? System.Reflection.TargetInvocationException as exn ->

raise exn.InnerException

let BindGenericStaticMethod (methInfo:MethodInfo) tyargs =

if methInfo.IsGenericMethod then

methInfo.GetGenericMethodDefinition().MakeGenericMethod(Array.ofList tyargs)

else

methInfo

let MakeGenericStaticMethod (methHandle:System.RuntimeMethodHandle) =

let methInfo = methHandle |> System.Reflection.MethodInfo.GetMethodFromHandle :?> MethodInfo

(fun (tyargs: Type list, args: Expr list) -> Expr.Call(BindGenericStaticMethod methInfo tyargs, args))

let MakeGenericInstanceMethod (methHandle:System.RuntimeMethodHandle) =

let methInfo = methHandle |> System.Reflection.MethodInfo.GetMethodFromHandle :?> MethodInfo

(fun (obj:Expr, tyargs: Type list, args: Expr list) -> Expr.Call(obj, BindGenericStaticMethod methInfo tyargs, args))

let ImplicitExpressionConversionHelperMethodInfo =

methodhandleof (fun e -> LeafExpressionConverter.ImplicitExpressionConversionHelper e)

|> System.Reflection.MethodInfo.GetMethodFromHandle

:?> MethodInfo

let MakeImplicitExpressionConversion (x:Expr) = Expr.Call(ImplicitExpressionConversionHelperMethodInfo.MakeGenericMethod [| x.Type |], [ x ])

let NT = typedefof<System.Nullable<int>>

let FT1 = typedefof<System.Func<_,_>>

let FT2 = typedefof<System.Func<_,_,_>>

let boolTy = typeof<bool>

let MakeNullableTy ty = NT.MakeGenericType [| ty |]

let MakeQueryFuncTy (dty, rty) = FT1.MakeGenericType [| dty; rty |]

let MakeQueryFunc2Ty (dty1, dty2, rty) = FT2.MakeGenericType [| dty1; dty2; rty |]

let IEnumerableTypeDef = typedefof<IEnumerable<_>>

let IQueryableTypeDef = typedefof<IQueryable<_>>

let QuerySourceTypeDef = typedefof<QuerySource<_,_>>

let MakeIEnumerableTy dty= IEnumerableTypeDef.MakeGenericType [| dty|]

let MakeIQueryableTy dty= IQueryableTypeDef.MakeGenericType [| dty|]

let IsQuerySourceTy (ty: System.Type) = ty.IsGenericType && ty.GetGenericTypeDefinition() = QuerySourceTypeDef

let IsIQueryableTy (ty: System.Type) = ty.IsGenericType && ty.GetGenericTypeDefinition() = IQueryableTypeDef

let IsIEnumerableTy (ty: System.Type) = ty.IsGenericType && ty.GetGenericTypeDefinition() = IEnumerableTypeDef

// Check a tag type on QuerySource is IQueryable

let qTyIsIQueryable (ty : System.Type) = not (ty.Equals(typeof<IEnumerable>))

let FuncExprToDelegateExpr (srcTy, targetTy, v, body) =

Expr.NewDelegate(Linq.Expressions.Expression.GetFuncType [| srcTy; targetTy |], [v], body)

/// Project F# function expressions to Linq LambdaExpression nodes

let FuncExprToLinqFunc2Expression (srcTy, targetTy, v, body) =

FuncExprToDelegateExpr(srcTy, targetTy, v, body) |> LeafExpressionConverter.QuotationToExpression

let FuncExprToLinqFunc2 (srcTy, targetTy, v, body) =

FuncExprToDelegateExpr(srcTy, targetTy, v, body) |> LeafExpressionConverter.EvaluateQuotation

let MakersCallers F = CallGenericStaticMethod F, MakeGenericStaticMethod F

let MakersCallersInstance F = CallGenericInstanceMethod F, MakeGenericInstanceMethod F

let MakersCallers2 FQ FE = MakersCallers FQ, MakersCallers FE

let MakeOrCallContainsOrElementAt FQ FE =

let (CQ, MQ), (CE, ME) = MakersCallers2 FQ FE

let Make (isIQ, srcItemTy:Type, src:Expr, key:Expr) =

if isIQ then

//let key = MakeImplicitExpressionConversion key

MQ ([srcItemTy], [src; key])

else

ME ([srcItemTy], [src; key])

let Call (isIQ, srcItemTy, src:obj, key:Expr) =

let key = key |> LeafExpressionConverter.EvaluateQuotation

let C = if isIQ then CQ else CE

C ([srcItemTy], [src;box key])

Make, Call

let MakeContains, CallContains =

let FQ = methodhandleof (fun (x,y) -> System.Linq.Queryable.Contains(x,y))

let FE = methodhandleof (fun (x,y) -> Enumerable.Contains(x, y))

MakeOrCallContainsOrElementAt FQ FE

let MakeElementAt, CallElementAt =

let FQ = methodhandleof (fun (x,y) -> System.Linq.Queryable.ElementAt(x,y))

let FE = methodhandleof (fun (x,y) -> Enumerable.ElementAt(x,y))

MakeOrCallContainsOrElementAt FQ FE

let MakeOrCallMinByOrMaxBy FQ FE =

let (CQ, MQ), (CE, ME) = MakersCallers2 FQ FE

let Make (isIQ, src:Expr, v:Var, valSelector:Expr) =

let srcItemTy = v.Type

let keyElemTy = valSelector.Type

let valSelector = FuncExprToDelegateExpr (srcItemTy, keyElemTy, v, valSelector)

if isIQ then

let valSelector = MakeImplicitExpressionConversion valSelector

MQ ([srcItemTy;keyElemTy], [src;valSelector])

else

ME ([srcItemTy;keyElemTy], [src;valSelector])

let Call (isIQ, srcItemTy:Type,_keyItemTy:Type, src:obj, keyElemTy:Type, v:Var, res:Expr) =

if isIQ then

let selector = FuncExprToLinqFunc2Expression (srcItemTy, keyElemTy, v, res)

CQ ([srcItemTy;keyElemTy], [src;box selector])

else

let selector = FuncExprToLinqFunc2 (srcItemTy, keyElemTy, v, res)

CE ([srcItemTy;keyElemTy], [src;selector])

Make, Call

let (MakeMinBy: bool * Expr * Var * Expr -> Expr), (CallMinBy : bool * Type * Type * obj * Type * Var * Expr -> obj) =

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.Min(x,y))

let FE = methodhandleof (fun (x,y:Func<_,'Result>) -> Enumerable.Min(x,y))

MakeOrCallMinByOrMaxBy FQ FE

let MakeMaxBy, CallMaxBy =

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.Max(x, y))

let FE = methodhandleof (fun (x,y: Func<_,'Result>) -> Enumerable.Max(x, y))

MakeOrCallMinByOrMaxBy FQ FE

let MakeMinByNullable, CallMinByNullable =

// Note there is no separate LINQ overload for Min on nullables - the one implementation just magically skips nullable elements

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.Min(x, y))

let FE = methodhandleof (fun (x,y:Func<_,'Result>) -> Enumerable.Min(x, y))

MakeOrCallMinByOrMaxBy FQ FE

let MakeMaxByNullable, CallMaxByNullable =

// Note there is no separate LINQ overload for Max on nullables - the one implementation just magically skips nullable elements

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.Max(x,y))

let FE = methodhandleof (fun (x,y:Func<_,'Result>) -> Enumerable.Max(x,y))

MakeOrCallMinByOrMaxBy FQ FE

let MakeOrCallAnyOrAllOrFirstFind FQ FE =

let (CQ, MQ), (CE, ME) = MakersCallers2 FQ FE

let Make (isIQ, src:Expr, v:Var, predicate:Expr) =

let srcItemTy= v.Type

let predicate = FuncExprToDelegateExpr (srcItemTy, boolTy, v, predicate)

if isIQ then

let predicate = MakeImplicitExpressionConversion predicate

MQ ([srcItemTy], [src; predicate])

else

ME ([srcItemTy], [src; predicate])

let Call (isIQ, srcItemTy:Type, src:obj, v:Var, res:Expr) =

if isIQ then

let selector = FuncExprToLinqFunc2Expression (srcItemTy, boolTy, v, res)

CQ ([srcItemTy], [src;box selector])

else

let selector = FuncExprToLinqFunc2 (srcItemTy, boolTy, v, res)

CE ([srcItemTy], [src;selector])

Make, Call

let MakeAny, CallAny =

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.Any(x,y))

let FE = methodhandleof (fun (x,y:Func<_,_>) -> Enumerable.Any(x,y))

MakeOrCallAnyOrAllOrFirstFind FQ FE

let MakeAll, CallAll =

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.All(x,y))

let FE = methodhandleof (fun (x,y:Func<_,_>) -> Enumerable.All(x,y))

MakeOrCallAnyOrAllOrFirstFind FQ FE

let MakeFirstFind, CallFirstFind =

let FQ = methodhandleof (fun (x,y:Expression<Func<_,_>>) -> System.Linq.Queryable.First(x,y))

let FE = methodhandleof (fun (x,y:Func<_,_>) -> Enumerable.First(x,y))

MakeOrCallAnyOrAllOrFirstFind FQ FE

let MakeOrCallAverageByOrSumByGeneric (isNullable,fq_double, fq_single, fq_decimal, fq_int32, fq_int64, fe_double, fe_single, fe_decimal, fe_int32, fe_int64, FE) =

let (cq_double, mq_double), (ce_double, me_double) = MakersCallers2 fq_double fe_double

let (cq_single, mq_single), (ce_single, me_single) = MakersCallers2 fq_single fe_single

let (cq_decimal, mq_decimal), (ce_decimal, me_decimal) = MakersCallers2 fq_decimal fe_decimal

let (cq_int32, mq_int32), (ce_int32, me_int32) = MakersCallers2 fq_int32 fe_int32

let (cq_int64, mq_int64), (ce_int64, me_int64) = MakersCallers2 fq_int64 fe_int64

// The F# implementation is an instance method on QueryBuilder

let (CE, ME) = MakersCallersInstance FE

let failDueToUnsupportedInputTypeInSumByOrAverageBy() = invalidOp (SR.GetString(SR.failDueToUnsupportedInputTypeInSumByOrAverageBy))

let Make (qb:Expr,isIQ, src:Expr, v:Var, res:Expr) =

let srcItemTy = v.Type

let resTy = res.Type

let resTyNoNullable =

if isNullable then

assert resTy.IsGenericType;

assert (resTy.GetGenericTypeDefinition() = typedefof<Nullable<int>>);

resTy.GetGenericArguments().[0]

else

resTy

let selector = FuncExprToDelegateExpr (srcItemTy, resTy, v, res)

if isIQ then

let selector = MakeImplicitExpressionConversion selector

let maker =

match resTyNoNullable with

| ty when ty = typeof<double> -> mq_double

| ty when ty = typeof<single> -> mq_single

| ty when ty = typeof<decimal> -> mq_decimal

| ty when ty = typeof<int32> -> mq_int32

| ty when ty = typeof<int64> -> mq_int64

| _ -> failDueToUnsupportedInputTypeInSumByOrAverageBy()

maker ([srcItemTy], [src;selector])

else

// Try to dynamically invoke a LINQ method if one exists, since these may be optimized over arrays etc.

match resTyNoNullable with

| ty when ty = typeof<double> -> me_double ([srcItemTy], [src;selector])

| ty when ty = typeof<single> -> me_single ([srcItemTy], [src;selector])

| ty when ty = typeof<decimal> -> me_decimal ([srcItemTy], [src;selector])

| ty when ty = typeof<int32> -> me_int32 ([srcItemTy], [src;selector])

| ty when ty = typeof<int64> -> me_int64 ([srcItemTy], [src;selector])

| _ ->

// The F# implementation needs a QuerySource as a parameter.

let qTy = typeof<IEnumerable>

let ctor = typedefof<QuerySource<_,_>>.MakeGenericType([|srcItemTy;qTy|]).GetConstructors().[0]

let src = Expr.NewObject(ctor, [src])

// The F# implementation needs an FSharpFunc as a parameter.

let selector = Expr.Lambda(v, res)

ME (qb, [srcItemTy;qTy;resTyNoNullable], [src;selector])

let Call (qb:obj,isIQ, srcItemTy:Type, resTyNoNullable:Type, src:obj, resTy:Type, v:Var, res:Expr) =

if isIQ then

let selector = FuncExprToLinqFunc2Expression (srcItemTy, resTy, v, res)

let caller =

match resTyNoNullable with

| ty when ty = typeof<double> -> cq_double

| ty when ty = typeof<single> -> cq_single

| ty when ty = typeof<decimal> -> cq_decimal

| ty when ty = typeof<int32> -> cq_int32

| ty when ty = typeof<int64> -> cq_int64

| _ -> failDueToUnsupportedInputTypeInSumByOrAverageBy()

caller ([srcItemTy], [src;box selector]) : obj

else

// Try to dynamically invoke a LINQ method if one exists, since these may be optimized over arrays etc.

let linqMethOpt =

match resTyNoNullable with

| ty when ty = typeof<double> -> Some ce_double

| ty when ty = typeof<single> -> Some ce_single

| ty when ty = typeof<decimal> -> Some ce_decimal

| ty when ty = typeof<int32> -> Some ce_int32

| ty when ty = typeof<int64> -> Some ce_int64

| _ -> None

match linqMethOpt with

| Some ce ->

// A LINQ method needs a Delegate as a parameter

let selector = FuncExprToLinqFunc2 (srcItemTy, resTy, v, res)

ce ([srcItemTy], [src;selector])

| None ->

// The F# implementation needs a QuerySource as a parameter.

let qTy = typeof<IEnumerable>

let ctor = typedefof<QuerySource<_,_>>.MakeGenericType([|srcItemTy;qTy|]).GetConstructors().[0]

let srcE =

try

ctor.Invoke [|src|]

with :? System.Reflection.TargetInvocationException as exn ->

raise exn.InnerException

// The F# implementation needs an FSharpFunc as a parameter.

let selectorE = Expr.Lambda (v, res) |> LeafExpressionConverter.EvaluateQuotation

CE (qb, [srcItemTy;qTy;resTy], [srcE;selectorE])

Make, Call

let MakeAverageBy, CallAverageBy =

let FQ_double = methodhandleof (fun (x,y:Expression<Func<_,double>>) -> System.Linq.Queryable.Average(x,y))

let FQ_single = methodhandleof (fun (x,y:Expression<Func<_,single>>) -> System.Linq.Queryable.Average(x,y))

let FQ_decimal = methodhandleof (fun (x,y:Expression<Func<_,decimal>>) -> System.Linq.Queryable.Average(x,y))

let FQ_int32 = methodhandleof (fun (x,y:Expression<Func<_,int32>>) -> System.Linq.Queryable.Average(x,y))

let FQ_int64 = methodhandleof (fun (x,y:Expression<Func<_,int64>>) -> System.Linq.Queryable.Average(x,y))

let FE_double = methodhandleof (fun (x,y:Func<_,double>) -> Enumerable.Average(x,y))

let FE_single = methodhandleof (fun (x,y:Func<_,single>) -> Enumerable.Average(x,y))

let FE_decimal = methodhandleof (fun (x,y:Func<_,decimal>) -> Enumerable.Average(x,y))

let FE_int32 = methodhandleof (fun (x,y:Func<_,int32>) -> Enumerable.Average(x,y))

let FE_int64 = methodhandleof (fun (x,y:Func<_,int64>) -> Enumerable.Average(x,y))

let FE = methodhandleof (fun (query:QueryBuilder,arg1:QuerySource<_,_>,arg2:_->double) -> query.AverageBy(arg1,arg2))

MakeOrCallAverageByOrSumByGeneric (false,FQ_double, FQ_single, FQ_decimal, FQ_int32, FQ_int64, FE_double, FE_single, FE_decimal, FE_int32, FE_int64, FE)

let MakeAverageByNullable, CallAverageByNullable =

let FQ_double = methodhandleof (fun (x,y:Expression<Func<_,Nullable<double>>>) -> System.Linq.Queryable.Average(x,y))

let FQ_single = methodhandleof (fun (x,y:Expression<Func<_,Nullable<single>>>) -> System.Linq.Queryable.Average(x,y))

let FQ_decimal = methodhandleof (fun (x,y:Expression<Func<_,Nullable<decimal>>>) -> System.Linq.Queryable.Average(x,y))

let FQ_int32 = methodhandleof (fun (x,y:Expression<Func<_,Nullable<int32>>>) -> System.Linq.Queryable.Average(x,y))

let FQ_int64 = methodhandleof (fun (x,y:Expression<Func<_,Nullable<int64>>>) -> System.Linq.Queryable.Average(x,y))

let FE_double = methodhandleof (fun (x,y:Func<_,Nullable<double>>) -> Enumerable.Average(x,y))

let FE_single = methodhandleof (fun (x,y:Func<_,Nullable<single>>) -> Enumerable.Average(x,y))

let FE_decimal = methodhandleof (fun (x,y:Func<_,Nullable<decimal>>) -> Enumerable.Average(x,y))

let FE_int32 = methodhandleof (fun (x,y:Func<_,Nullable<int32>>) -> Enumerable.Average(x,y))

let FE_int64 = methodhandleof (fun (x,y:Func<_,Nullable<int64>>) -> Enumerable.Average(x,y))

let FE = methodhandleof (fun (query:QueryBuilder, arg1:QuerySource<_,_>, arg2:_->Nullable<double>) -> query.AverageByNullable(arg1,arg2))

MakeOrCallAverageByOrSumByGeneric (true,FQ_double, FQ_single, FQ_decimal, FQ_int32, FQ_int64, FE_double, FE_single, FE_decimal, FE_int32, FE_int64, FE)

let MakeSumBy, CallSumBy =

let FQ_double = methodhandleof (fun (x,y:Expression<Func<_,double>>) -> System.Linq.Queryable.Sum(x,y))

let FQ_single = methodhandleof (fun (x,y:Expression<Func<_,single>>) -> System.Linq.Queryable.Sum(x,y))

let FQ_decimal = methodhandleof (fun (x,y:Expression<Func<_,decimal>>) -> System.Linq.Queryable.Sum(x,y))

let FQ_int32 = methodhandleof (fun (x,y:Expression<Func<_,int32>>) -> System.Linq.Queryable.Sum(x,y))

let FQ_int64 = methodhandleof (fun (x,y:Expression<Func<_,int64>>) -> System.Linq.Queryable.Sum(x,y))

let FE_double = methodhandleof (fun (x,y:Func<_,double>) -> Enumerable.Sum(x,y))