agrupado por columnas múltiples en una consulta F#3.0

f#-3.0

Question

Simplemente probando F # 3.0 y golpear un poco de una pared cuando se trata de agrupar por múltiples columnas. Lo obvio para intentar era

query {
    for d in context.table do
    groupBy (d.col1,d.col2) into g
    select (g.Key)
}

Pero obtengo un "Solo los constructores y los inicializadores sin parámetros son compatibles con LINQ to Entities". excepción.

Parece que no puedo encontrar un ejemplo en msdn

http://msdn.microsoft.com/en-us/library/hh225374(v=vs.110).aspx

http://msdn.microsoft.com/en-us/library/hh361035(v=vs.110).aspx

Y me doy cuenta de que mi pregunta es similar a " Entity Framework and Anonymous Types in F # ", pero parece ser powerpack / F # 2.x centrado y espero que F # 3.0 tenga una respuesta elegante ... ¿Alguna idea?

ACTUALIZAR:

Me encontré con el atributo CLIMutable al leer la publicación de Brian en:

http://blogs.msdn.com/b/fsharpteam/archive/2012/07/19/more-about-fsharp-3.0-language-features.aspx

Yo era bastante optimista, así que lo intenté

[<CLIMutable>]
type MyRecord = { Column1 : int; Column2 : int }

query {
    for d in context.table do
    groupBy {Column1 = col1; Column2 = col2} into g
    select (g.Key)
}

Desafortunadamente recibo la misma excepción exacta.

Answer 1

Al usar groupBy, necesita seleccionar una función de agregación (por ejemplo, count, sum, avg ...).

Answer 2

Primero debe recordar que una consulta se traduce en SQL real en algún momento. Parece que linq no admite el uso de varias claves de grupo como Tuple<> . Por lo tanto, cualquier transformación en Tuple<> debe realizarse después de que se haya completado la llamada a la base de datos.

En segundo lugar, debe poder lograr múltiples agrupaciones de teclas realizando múltiples agrupaciones detrás de las otras en las claves respectivas:

query {
    for d1 in context.table do
    groupBy d1.col1 into g1
    for d2 in g1 do
    groupBy d2.col2 into g2
    select g2
}

Por favor, ten piedad de mí si la sintaxis no es 100% ya que F # no es mi lengua materna :) Sin embargo, el concepto debería funcionar bien.

Answer 3

query {  
    for d in context.table do  
    groupBy (new {d.col1, d.col2}) into g  
    select (g.Key) 
}

Answer 4

open Microsoft.FSharp.Linq.RuntimeHelpers
open System.Linq

query {
    for d in context.table do
    let t = MutableTuple<_,_>(Item1=d.col1,Item2=d.col2)
    groupValBy d t into g
    select (g.Key,g.Count())
    } 

Answer 5

Veo esto en el primero de sus enlaces, creo que es lo que quiere:

query {
    for student in db.Student do
    groupValBy student.Name student.Age into g
    select (g, g.Key, g.Count())
}

Answer 6

El siguiente es un ejemplo de columnas múltiples que se usan para agrupar en c # y convertir a f # (la administración excesivamente paranoica me ha hecho cambiar el nombre de todo, pero creo que he sido coherente):

(TheDatabase fue generado por SqlMetal, GetSummedValuesResult es un tipo de registro F #)

do#

public static class Reports
{
    public static IReadOnlyList<GetSummedValuesResult> GetSummedValues(TheDatabase db, DateTime startDate, DateTime? endDate)
    {
        var query =
            from sv in db.SomeValues

            where (sv.ADate >= startDate && sv.ADate <= (endDate ?? startDate))

            group sv by new { sv.ADate, sv.Owner.Name } into grouping

            select new GetSummedValuesResult(
                grouping.Key.ADate,
                grouping.Key.Name,
                grouping.Sum(g => g.Value)
            );

        return query.ToList();
    }
}

F#

type Reports() =
    static member GetSummedValues (db:TheDatabase) startDate (endDate:Nullable<DateTime>) =
        let endDate = if endDate.HasValue then endDate.Value else startDate

        let q = query {
            for sv in db.SomeValues do
            where (sv.ADate >= startDate && sv.ADate <= endDate)

            let key = AnonymousObject<_,_>(sv.ADate, sv.Owner.Name)
            groupValBy sv key into grouping

            select {
                ADate        = grouping.Key.Item1;
                AName        = grouping.Key.Item2;
                SummedValues = grouping.Sum (fun (g:TheDatabaseSchema.SomeValues) -> g.Value)
            }
        }

        List(q) :> IReadOnlyList<GetSummedValuesResult>

Entonces, lo que hay que usar es Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject

Tenga en cuenta que no debe usar el módulo Seq para las funciones de agregación.

SummedValues  = grouping |> Seq.sumBy (fun g -> g.SomeValues)

Aunque esto FUNCIONARÁ, hace la agregación en el lado del cliente, en lugar de formular el SQL apropiado.

Answer 7

//in F# 3.0
open Microsoft.FSharp.Linq.RuntimeHelpers
open Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter
open System.Linq

//[<CLIMutable>]
//type MyRecord = { Column1 : int; Column2 : int }
// require constructor in F#
// groupBy is not valid

type T(column1 : int, column2 : int)
    member val Colum1=colum1 with get,set
    membre val Colum2=colum2 with get,set

query {
    for d in context.table do
    groupValBy d (NewAnonymousObjectHelper(T(d.Colum1,d.Colume2))) into g
    select (g.Key)
    }