Comment traduire des requêtes SQL complexes avec plusieurs jointures, comptes et jointures gauche dans Linq?

Convertir les requêtes SQL complexes de jointure multi-table, de comptage et de jointure gauche en LINQ

Lorsque vos requêtes SQL existantes impliquent des jointures, des décomptes et des jointures gauches complexes, vous devez les convertir en expressions LINQ équivalentes. Décomposons le processus et abordons les défis spécifiques rencontrés.

Comprendre les règles de conversion

La conversion de SQL en LINQ nécessite de comprendre les règles de conversion spécifiques impliquées. Voici quelques principes clés :

• Les sous-requêtes distinctes peuvent être converties en variables distinctes, tandis que les sous-requêtes faisant référence à des colonnes externes nécessitent des parenthèses.
• Les clauses de jointure peuvent être exprimées en combinant des alias de table et des conditions d'égalité.
• Les jointures gauches sont implémentées à l'aide des propriétés de navigation et de la méthode DefaultIfEmpty().
• Les fonctions et les décomptes d'agrégation peuvent être implémentés à l'aide d'agrégats LINQ (par exemple, Count(), Distinct().Count()).

Conversion des requêtes SQL

Considérant la requête SQL fournie, nous définissons d'abord la sous-requête permettant de calculer le décompte :

<code class="language-csharp">var subrq = from r in Table_R
            group r by r.Id into rg
            select new { Id = rg.Key, cnt = rg.Count() };</code>

Maintenant, pour la requête principale :

<code class="language-csharp">var ansq = (from c in Table_C
            join v in Table_V on c.Id equals v.Id
            join r in subrq on c.Id equals r.Id into rj
            from r in rj.DefaultIfEmpty()
            where c.IdUser == "1234"
            group new { c, v, r } by new { c.Id, c.Title, r.cnt } into cvrg
            select new {
                cvrg.Key.Title,
                Nb_V2 = cvrg.Count(),
                Nb_V1 = cvrg.Select(cvr => cvr.v.IdUser).Distinct().Count(),
                Nb_R = (int?)cvrg.Key.cnt
            }).Distinct();</code>

Cette expression LINQ effectue les opérations de jointure, de groupe et de comptage nécessaires.

Conversion d'expressions Lambda

Pour la conversion des expressions lambda, nous pouvons utiliser les méthodes GroupJoin() et SelectMany() pour gérer les jointures gauches :

<code class="language-csharp">var subr2 = Table_R.GroupBy(r => r.Id).Select(rg => new { Id = rg.Key, cnt = rg.Count() });
var ans2 = Table_C.Where(c => c.IdUser == "1234")
                  .Join(Table_V, c => c.Id, v => v.Id, (c, v) => new { c, v })
                  .GroupJoin(subr, cv => cv.c.Id, r => r.Id, (cv, rj) => new { cv.c, cv.v, rj })
                  .SelectMany(cvrj => cvrj.rj.DefaultIfEmpty(), (cvrj, r) => new { cvrj.c, cvrj.v, r })
                  .GroupBy(cvr => new { cvr.c.Id, cvr.c.Title, cvr.r.cnt })
                  .Select(cvrg => new { cvrg.Key.Title, Nb_V2 = cvrg.Count(), Nb_V1 = cvrg.Select(cvr => cvr.v.IdUser).Distinct().Count(), Nb_R = (int?)cvrg.Key.cnt });</code>

Cette expression de style lambda accomplit la même tâche que la compréhension des requêtes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!