groupby de plusieurs colonnes dans une requête F# 3.0

Question

Je suis en train d'essayer F# 3.0 et je me heurte à un mur lorsqu'il s'agit de regrouper par plusieurs colonnes. La chose évidente à essayer était

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

Mais je reçois une exception "Only parameterless constructors and initializers are supported in LINQ to Entities".

Je n'arrive pas à trouver un exemple sur 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

Et je réalise que ma question est similaire à " Entity Framework et types anonymes en F# "mais il semble que ce problème soit lié à powerpack/F#2.x et j'espère que F# 3.0 a une réponse élégante... Des idées ?

UPDATE :

J'ai découvert l'attribut CLIMutable en lisant le billet de Brian sur le site :

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

J'étais plutôt optimiste alors j'ai essayé

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

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

Malheureusement, j'obtiens exactement la même exception.

Answer 1

Voici un exemple de colonnes multiples utilisées pour le regroupement en c# et converties en f# (une gestion trop paranoïaque m'a fait tout renommer, mais je pense avoir été cohérent) :

(TheDatabase a été généré par SqlMetal, GetSummedValuesResult est un type d'enregistrement F#)

c#

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>

Donc la chose à utiliser est Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject

Notez que vous ne devez pas utiliser le module Seq pour les fonctions d'agrégation !

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

Bien que cette méthode puisse fonctionner, elle effectue l'agrégation du côté client, plutôt que de formuler le SQL approprié.

Answer 2

Je vois ceci dans le premier de vos liens, je pense que c'est ce que vous voulez :

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

Answer 3

Tout d'abord, il faut se rappeler qu'une requête est traduite en termes réels. SQL à un moment donné. Il semble que linq ne prenne pas en charge l'utilisation de plusieurs clés de groupe en tant qu'élément d'information. Tuple<> . Par conséquent, toute transformation en Tuple<> doit être fait après que l'appel à la base de données soit terminé.

Deuxièmement, vous devriez être en mesure de réaliser regroupement de plusieurs clés en effectuant plusieurs regroupements les uns derrière les autres sur les touches respectives :

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

Je vous prie d'avoir pitié de moi si la syntaxe n'est pas à 100 % car F# n'est pas ma langue maternelle :) Le concept devrait cependant fonctionner parfaitement.

Answer 4

Lorsque vous utilisez groupBy, vous devez sélectionner une fonction d'agrégation (par exemple, count, sum, avg...).

Answer 5

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())
    }