Nieco bardziej zaawansowane mapowanie niż w moimpoprzednie pytanie :)

Tabele:

<code>create table [Primary] (
    Id int not null,
    CustomerId int not null,
    CustomerName varchar(60) not null,
    Date datetime default getdate(),
    constraint PK_Primary primary key (Id)
)

create table Secondary(
    PrimaryId int not null,
    Id int not null,
    Date datetime default getdate(),
    constraint PK_Secondary primary key (PrimaryId, Id),
    constraint FK_Secondary_Primary foreign key (PrimaryId) references [Primary] (Id)
)

create table Tertiary(
    PrimaryId int not null,
    SecondaryId int not null,
    Id int not null,
    Date datetime default getdate(),
    constraint PK_Tertiary primary key (PrimaryId, SecondaryId, Id),
    constraint FK_Tertiary_Secondary foreign key (PrimaryId, SecondaryId) references Secondary (PrimaryId, Id)
)
</code>

Klasy:

<code>public class Primary
{
    public int Id { get; set; }
    public Customer Customer { get; set; }
    public DateTime Date { get; set; }
    public List<Secondary> Secondaries { get; set; }
}

public class Secondary
{
    public int Id { get; set; }
    public DateTime Date { get; set; }
    public List<Tertiary> Tertiarys { get; set; }
}

public class Tertiary
{
    public int Id { get; set; }
    public DateTime Date { get; set; }
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}
</code>

Czy można użyć jednego wyboru, aby wypełnić je wszystkie? Coś takiego:

<code>const string sqlStatement = @"
    select 
        p.Id, p.CustomerId, p.CustomerName, p.Date,
        s.Id, s.Date,
        t.Id, t.Date
    from 
        [Primary] p left join Secondary s on (p.Id = s.PrimaryId)
        left join Tertiary t on (s.PrimaryId = t.PrimaryId and s.Id = t.SecondaryId)
    order by 
        p.Id, s.Id, t.Id
";
</code>

I wtedy:

<code>IEnumerable<Primary> primaries = connection.Query<Primary, Customer, Secondary, Tertiary, Primary>(
    sqlStatement,
    ... here comes dragons ...
    );
</code>

Edit1 - Mógłbym to zrobić za pomocą dwóch zagnieżdżonych pętli (foreach secondaries -> foreach tertiaries) i wykonać zapytanie dla każdego elementu, ale po prostu zastanawiam się, czy można to zrobić za pomocą pojedynczego wywołania bazy danych.

Edit2 - być może odpowiednia byłaby tutaj metoda QueryMultiple, ale jeśli dobrze rozumiem, potrzebowałbym wielu instrukcji wyboru. W moim prawdziwym przykładzie zaznaczenie ma więcej niż 20 warunków (w klauzuli gdzie), gdzie parametr wyszukiwania może mieć wartość null, więc nie chciałbym powtarzać wszystkich tych, w których stwierdzenia we wszystkich zapytaniach ...