Lambda expresion - aplikacja Maraton

Lambda Expression - narzędzie przydatne do zabawy z danymi i nie tylko.
Przykłady będę prezentował na podstawie bazy maratonu rowerowego i aplikacji  LinqPad 5, Github - skrypty.
Uwaga
Funkcja Dump() jest używana w LinqPad do wyświetlenia wyniku na ekran.

1. Pobranie wszystkich kolumn i wierszy "*" - tego znaku nie powinno się używać, jak nie wiemy ile wiersz y i kolumn jest w tabeli lepiej dodać TOP 10 (np 10 może być 1)
Sql:
select top 10 * from kartoteka2
C#:
var result = Kartoteka2s
             .OrderBy(x => x.Kart_id)
             .Take(10);








Wszystkie kolumny gdzie plec_id = 2
Sql:
select * from kartoteka2
where
       plec_id = 2
C#:
var result = Kartoteka2s
             .Where(x => x.Plec_id == 2);


Kolumny, które nas interesują gdzie plec_id = 2
Sql:
select 
      kart_imie as 'Imie', 
      kart_nazwisko as 'Nazwisko',
      plec_id as 'Plec' 
from kartoteka2
where
       plec_id = 2
C#:
var result = Kartoteka2s
             .Where(x => x.Plec_id == 2)
             .Select(x => new
             {
                    Imie = x.Kart_imie,
                    Nazwisko = x.Kart_nazwisko,
                    plec_id = x.Plec_id


             });
2. Połączenie tabeli "kartotek2" z  tabelą "plec", kolumny wyświtlone to imie, nazwisko, pleć warunek gdzie plec_id = 2 


Sql:
select K2.kart_imie as 'Imie'
       , K2.kart_nazwisko as 'Nazwisko'
       ,P.plec_opis as 'Plec'
from kartoteka2 K2
inner join plec P on P.plec_id = K2.plec_id
where
       K2.plec_id = 2
C#:
var result = Kartoteka2s
             .Join(Plecs,
             x => x.Plec_id,
             y => y.Plec_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = y.Plec_id,
                    Plec_opis = y.Plec_opis
             })
                    .Where(x => x.Plec_id == 2)
             .Select(x => new
             {
                    Imie = x.Kart_imie,
                    Nazwisko = x.Kart_nazwisko,
                    Plec = x.Plec_opis
             });
3. Dołączenie do powyższych wyników tabeli "Dystans"


Sql:

select K2.kart_imie as 'Imie'
       , K2.kart_nazwisko as 'Nazwisko'
       ,P.plec_opis as 'Plec'
       ,D.dys_wartosc as 'Dystans'
from kartoteka2 K2
inner join plec P on P.plec_id = K2.plec_id
inner join dystans D on D.dys_id = K2.dys_id
where
       K2.plec_id = 2
C#:

var result = Kartoteka2s
             .Join(Plecs,
             x => x.Plec_id,
             y => y.Plec_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = y.Plec_id,
                    Plec_opis = y.Plec_opis,
                    Dys_id = x.Dys_id
             })
             .Join(Dystans,
             x => x.Dys_id,
             y => y.Dys_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = x.Plec_id,
                    Plec_opis = x.Plec_opis,
                    Dystans = y.Dys_wartosc
             })
             .Where(x => x.Plec_id == 2)
             .Select(x => new
             {
                    Imie = x.Kart_imie,
                    Nazwisko = x.Kart_nazwisko,
                    Plec = x.Plec_opis,
                    Dystans = x.Dystans


             });








Dołączenie do tabeli "Dystans" tabeli "Dystans_info" i połączenie z resztą tabel
Sql:


select K2.kart_imie as 'Imie'
       , K2.kart_nazwisko as 'Nazwisko'
       ,P.plec_opis as 'Plec'
       ,D.dys_wartosc as 'Dystans'
       ,DI.info_start_date as 'Data_startu'
from kartoteka2 K2
inner join plec P on P.plec_id = K2.plec_id
inner join dystans D on D.dys_id = K2.dys_id
inner join dystans_info DI on DI.info_id = D.info_id
where
       K2.plec_id = 2
C#:


var result = Kartoteka2s
             .Join(Plecs,
             x => x.Plec_id,
             y => y.Plec_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = y.Plec_id,
                    Plec_opis = y.Plec_opis,
                    Dys_id = x.Dys_id
             })
             .Join(Dystans,
             x => x.Dys_id,
             y => y.Dys_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = x.Plec_id,
                    Plec_opis = x.Plec_opis,
                    Dystans = y.Dys_wartosc,
                    Info_id = y.Info_id
             })
             .Join(Dystans_info,
             x => x.Info_id,
             y => y.Info_id,
             (x,y) => new
             {
                    Kart_imie = x.Kart_imie,
                    Kart_nazwisko = x.Kart_nazwisko,
                    Plec_id = x.Plec_id,
                    Plec_opis = x.Plec_opis,
                    Dystans = x.Dystans,
                    Data_startu = y.Info_start_date
             })
             .Where(x => x.Plec_id == 2)
             .Select(x => new
             {
                    Imie = x.Kart_imie,
                    Nazwisko = x.Kart_nazwisko,
                    Plec = x.Plec_opis,
                    Dystans = x.Dystans,
                    Data_startu = x.Data_startu
             });


4. Grupowanie powyższych wyników, ilość zawodników na danym dystansie
W tym wypadku nie powtarzałem już join-ów, był by za duży chaos, w przypadku lambda na bazie resultatu z poprzedniego punktu zostało stworzone grupowanie


Sql:
with source as
(
select K2.kart_imie as 'Imie'
       , K2.kart_nazwisko as 'Nazwisko'
       ,P.plec_opis as 'Plec'
       ,D.dys_wartosc as 'Dystans'
       ,DI.info_start_date as 'Data_startu'
from kartoteka2 K2
inner join plec P on P.plec_id = K2.plec_id
inner join dystans D on D.dys_id = K2.dys_id
inner join dystans_info DI on DI.info_id = D.info_id
)
select count(Nazwisko) as 'ilosc_zawodnikow', Dystans from source
group by Dystans


C#:

var result2 = result
             .GroupBy(x => x.Dystans)
             .Select(x => new
             {
                    Ilosc_zawodnikow = x.Count(),
                    Dystans = x.Key


             });
5. Na podstawie grupowania (poprzednie zapytanie) wyświetlić ilość zawodników większą niż 20 na danym dystansie. 
W przypadku Sql-a skrócone zostało zapytanie o CTE (with source as ( ... ) ), źródłem dla kolejnego zapytania jest source
Sql:

select count(Nazwisko) as 'ilosc_zawodnikow', Dystans from source
group by Dystans
having
       count(Nazwisko) > 20
C#
var result2 = result
.GroupBy(x => x.Dystans)
             .Select(x => new
             {
                    Ilosc_zawodnikow = x.Count(),
                    Dystans = x.Key
             })
.Where(x => x.Ilosc_zawodnikow > 20);


6. Left Join "kartoteka2" i "dystans"
 var result = Kartoteka2s

       .GroupJoin(Dystans,
       kartoteka => kartotek.Dys_id,
       dystans => dystans.Dys_id,
       (x,y) => new {Kartoteka2s = x, Dystans = y})
       .SelectMany(x => x.Dystans.DefaultIfEmpty(),
       (x,y) => new {Kartoteka2s = x.Kartoteka2s, Dystans = y});