Wie erstellt man eine Multi-Mapping-Abfrage in Dapper mit drei Ebenen Tiefe Mapping?

Question

Ich bin versuchen, eine Abfrage zu tun, die die folgenden korrekt abbildet:

public class A 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public int BId {get; set; } 
    public List<B> { get; set; } 
} 

public class B 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public int CId { get; set; } 
    public int DId { get; set; } 
    public C C { get; set; } 
    public D D { get; set; } 
} 

public class C 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

public class D 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

Wie schreibe ich eine Abfrage, die mit einer Liste von Unternehmen B mit C und D gefüllt korrekt Einheit A abbildet?

Answer 1

Sie möchten hier zwei Abfragen durchführen, um die Eins-zu-Viele-Natur von B auf A zu erfassen. Außerdem werden Ihre Bs wahrscheinlich einen Verweis auf A in der Abfrage benötigen.

var query1 = conn.Query<A>(select * from dbo.A) 

var query2 = conn.Query<B,C,D,B>("select * from dbo.B...join C...join 

D",(b,c,d)=>{ 



    b.C = c; 
     b.D = d; 

return b; 

     } 

Jetzt musst du sie miteinander verbinden. Ich benutze Linq Joins und Erweiterungen, um eine Menge davon zu automatisieren, aber das Wesentliche ist, Schleife über jeden 'A' und finden Sie die passenden 'B's von Abfrage 2. Wörterbücher und Listen möglicherweise schneller als' Where 'auch, so Sie kann eine Erweiterung schreiben, die die darunter liegende Schleife optimiert.

foreach(var a in query1){ 
a.Bs = query2.Where(w=>w.AId.Equals(a.Id)); 
} 

Beachten Sie, dass Reisen in die db reduzieren QueryMultiple durch die Verwendung mehrerer Cord-Sets zurück (sollte Ihr db-Unterstützung, die).

Answer 2

Sie könnten wahrscheinlich in einer Hin- und Rückfahrt zur db mit Drapper (auf Dapper gebaut) erreichen.

Vorausgesetzt Sie haben eine Reihe von SQL-Abfragen, die mehrere Ergebnisse zurückgeben:

select * from [TableA]; 
select * from [TableB]; 
select * from [TableC]; 
select * from [TableD] 

... mit jedem Ergebnis zu den anderen in irgendeiner Form Kennung/Fremdschlüssel halten, könnten Sie wahrscheinlich ein Repository wie aufbauen derjenige unter:

public class Repository : IRepository 
{ 
    // IDbCommander is a Drapper construct. 
    private readonly IDbCommander _commander; 

    public Repository(IDbCommander commander) 
    { 
     _commander = commander; 
    } 

    public IEnumerable<A> RetrieveAll() 
    { 
     // execute the multiple queries and 
     // pass control to a mapping function. 
     return _commander.Query(Map.Results); 
    } 

    private static class Map 
    { 
     internal static Func<IEnumerable<A>, 
          IEnumerable<B>, 
          IEnumerable<C>, 
          IEnumerable<C>, 
          IEnumerable<A>> Results = (collectionA, collectionB, collectionC, collectionD) => 
     { 
      // map C and D to B based on their Id's 
      collectionB.C = collectionC.SingleOrDefault(c => c.Id == b.Id); 
      collectionB.D = collectionD.SingleOrDefault(d => d.Id == b.Id); 

      // now map B to A. 
      collectionA.B = collectionB.Where(b => b.Id == a.Id).ToList(); 
      return collectionA; 
     } 
    } 
} 

Beispiel aus dem Speicher eingegeben so Syntax ein wenig aus sein könnte, aber Sie den Kern erhalten.

Ich stimme mit BlackjacetMack überein, dass Sie eher eine Art von Seitenumbruch in den Ergebnissen haben sollten (auch in Drapper unterstützt).