Wie übersetze ich komplexe SQL-Abfragen mit mehreren Joins, Counts und Left Joins in LINQ?

Konvertieren Sie komplexe Multi-Table-Join-, Count- und Left-Join-SQL-Abfragen in LINQ

Wenn Ihre vorhandenen SQL-Abfragen komplexe Joins, Zählungen und Left-Joins umfassen, müssen Sie diese in äquivalente LINQ-Ausdrücke konvertieren. Lassen Sie uns den Prozess aufschlüsseln und auf die spezifischen Herausforderungen eingehen.

Verstehen Sie die Konvertierungsregeln

Die Konvertierung von SQL in LINQ erfordert das Verständnis der spezifischen Konvertierungsregeln. Zu den wichtigsten Grundsätzen gehören:

• Separate Unterabfragen können in separate Variablen umgewandelt werden, während Unterabfragen, die auf externe Spalten verweisen, Klammern erfordern.
• Join-Klauseln können durch die Kombination von Tabellenaliasen und Gleichheitsbedingungen ausgedrückt werden.
• Linke Verknüpfungen werden mithilfe von Navigationseigenschaften und der Methode DefaultIfEmpty() implementiert.
• Aggregationsfunktionen und -zählungen können mithilfe von LINQ-Aggregaten implementiert werden (z. B. Count(), Distinct().Count()).

Konvertierung von SQL-Abfragen

Anhand der bereitgestellten SQL-Abfrage definieren wir zunächst die Unterabfrage zur Berechnung der Anzahl:

var subrq = from r in Table_R
            group r by r.Id into rg
            select new { Id = rg.Key, cnt = rg.Count() };

Nun zur Hauptabfrage:

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

Dieser LINQ-Ausdruck führt die erforderlichen Verknüpfungs-, Gruppen- und Zählvorgänge aus.

Konvertierung von Lambda-Ausdrücken

Für die Konvertierung von Lambda-Ausdrücken können wir die Methoden GroupJoin() und SelectMany() verwenden, um Links-Joins zu verarbeiten:

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

Dieser Ausdruck im Lambda-Stil erfüllt die gleiche Aufgabe wie das Abfrageverständnis.

Das obige ist der detaillierte Inhalt vonWie übersetze ich komplexe SQL-Abfragen mit mehreren Joins, Counts und Left Joins in LINQ?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!