Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00202 004726 12219027 na godz. na dobę w sumie
SQL. Jak osiągnąć mistrzostwo w konstruowaniu zapytań - książka
SQL. Jak osiągnąć mistrzostwo w konstruowaniu zapytań - książka
Autor: Liczba stron: 288
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1283-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> bazy danych >> sql - programowanie
Porównaj ceny (książka, ebook (-25%), audiobook).

Zaprzyjaźnij się z SQL-em!

SQL, podstawowy język służący do komunikowania się z bazami danych, na pierwszy rzut oka nie wydaje się zbyt trudny. Ma przejrzystą składnię i sporo pomocnych funkcji, a ponadto jest elastyczny. Jest tylko jeden warunek: żeby sprawnie, szybko wyszukiwać i wyświetlać informacje z bazy danych, musimy go dobrze opanować. Nie chodzi tu tylko o samą konstrukcję zapytań, a raczej o sensowne wyłuskiwanie żądanej informacji spośród tysięcy innych, być może całkiem podobnych. Chodzi o to, by być przygotowanym na nietypowe sytuacje, umieć skonstruować skomplikowane zapytanie z wieloma warunkami i odpowiednio je doprecyzować.

W tej książce znajdziesz setki ćwiczeń i zadań do samodzielnego wykonania. Wszystkie one mają jeden cel: przygotować Cię do wszechstronnej komunikacji z bazą danych i nauczyć Cię wysyłania nawet najbardziej złożonych zapytań. W każdym rozdziale znalazło się nieco teorii i mnóstwo praktyki, a zadania w kolejnych rozdziałach wymagają wiedzy z poprzednich, co pozwala na ciągłe utrwalanie całej zdobytej wiedzy. Jeśli chcesz rzetelnie i od podszewki poznać bogactwo SQL-a, ta książka z pewnością Ci w tym pomoże!

Zacznij rozmawiać z własną bazą danych!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Michał Mrowiec Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/sqljak Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Kody źródłowe wybranych przykładów dostępne są pod adresem: ftp://ftp.helion.pl/przyklady/sqljak.zip ISBN: 978-83-283-1283-8 Copyright © Helion 2015 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:264)ci Wst(cid:246)p .............................................................................................. 5 Podzi(cid:266)kowania .................................................................................................................. 5 Rozdzia(cid:228) 1. Klauzula SELECT .............................................................................. 7 (cid:251)wiczenia ......................................................................................................................... 8 Zadania do samodzielnego wykonania ........................................................................... 46 Rozwi(cid:261)zania zada(cid:276) ......................................................................................................... 56 Rozdzia(cid:228) 2. Funkcje wbudowane ....................................................................... 61 (cid:251)wiczenia ....................................................................................................................... 61 Zadania do samodzielnego wykonania ........................................................................... 79 Rozwi(cid:261)zania zada(cid:276) ......................................................................................................... 86 Rozdzia(cid:228) 3. Z(cid:228)(cid:241)czenia ....................................................................................... 91 Rodzaje z(cid:225)(cid:261)cze(cid:276) .............................................................................................................. 91 Z(cid:225)(cid:261)czenie wewn(cid:266)trzne INNER JOIN .............................................................................. 92 Z(cid:225)(cid:261)czenie zewn(cid:266)trzne lewostronne LEFT OUTER JOIN ............................................... 93 Z(cid:225)(cid:261)czenie zewn(cid:266)trzne prawostronne RIGHT OUTER JOIN .......................................... 93 Pe(cid:225)ne z(cid:225)(cid:261)czenie zewn(cid:266)trzne FULL OUTER JOIN .......................................................... 94 Z(cid:225)(cid:261)czenie krzy(cid:298)owe CROSS JOIN ................................................................................. 95 (cid:251)wiczenia ....................................................................................................................... 96 Zadania do samodzielnego wykonania ......................................................................... 121 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 128 Rozdzia(cid:228) 4. Funkcje agreguj(cid:241)ce ...................................................................... 133 (cid:251)wiczenia ..................................................................................................................... 133 Zadania do samodzielnego wykonania ......................................................................... 158 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 166 Rozdzia(cid:228) 5. Operacje na zbiorach .................................................................... 173 Operator UNION ALL ................................................................................................. 173 Operator EXCEPT ........................................................................................................ 174 Operator INTERSECT ................................................................................................. 175 (cid:251)wiczenia ..................................................................................................................... 176 Zadania do samodzielnego wykonania ......................................................................... 187 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 190 Poleć książkęKup książkę 4 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Rozdzia(cid:228) 6. Podzapytania ............................................................................... 193 (cid:251)wiczenia ..................................................................................................................... 193 Zadania do samodzielnego wykonania ......................................................................... 212 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 217 Rozdzia(cid:228) 7. CASE, CAST i CONVERT ............................................................... 223 CASE ............................................................................................................................ 223 CAST i CONVERT ...................................................................................................... 224 (cid:251)wiczenia ..................................................................................................................... 225 Zadania do samodzielnego wykonania ......................................................................... 231 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 233 Rozdzia(cid:228) 8. Zadania ....................................................................................... 235 Tabela Reader ............................................................................................................... 235 Tabela Genre ................................................................................................................ 236 Tabela Book ................................................................................................................. 237 Tabela BookCopy ......................................................................................................... 237 Tabela BookRating ....................................................................................................... 238 Tabela Employee .......................................................................................................... 239 Tabela Loan .................................................................................................................. 239 Tabela Parameter .......................................................................................................... 240 Zadania do samodzielnego wykonania ......................................................................... 241 Rozwi(cid:261)zania zada(cid:276) ....................................................................................................... 266 Skorowidz ................................................................................... 287 Poleć książkęKup książkę Rozdzia(cid:228) 4. Funkcje agreguj(cid:241)ce Funkcje agreguj(cid:261)ce s(cid:261) to funkcje, które jako parametr przyjmuj(cid:261) zbiór warto(cid:286)ci i zwra- caj(cid:261) w wyniku pojedyncz(cid:261) warto(cid:286)(cid:252). Ten parametr podajemy zazwyczaj w postaci na- zwy kolumny, a obliczenia s(cid:261) wykonywane na wszystkich warto(cid:286)ciach wyst(cid:266)puj(cid:261)cych w tej kolumnie. W tym rozdziale omówimy nast(cid:266)puj(cid:261)ce funkcje agreguj(cid:261)ce: (cid:141) COUNT — zlicza liczb(cid:266) wierszy, (cid:141) SUM — oblicza sum(cid:266) warto(cid:286)ci, (cid:141) MIN — znajduje najni(cid:298)sz(cid:261) warto(cid:286)(cid:252), (cid:141) MAX — znajduje najwy(cid:298)sz(cid:261) warto(cid:286)(cid:252), (cid:141) AVG — oblicza (cid:286)redni(cid:261) warto(cid:286)(cid:252). (cid:231)wiczenia (cid:251)wiczenia b(cid:266)d(cid:261) wykonywane na tych samych tabelach Employee, Department i City, co (cid:252)wiczenia z rozdzia(cid:225)u 3. (cid:231)wiczenie 4.1 Policz wszystkich pracowników. Oczekiwany wynik Rysunek 4.1. Oczekiwany wynik (cid:252)wiczenia 4.1 Poleć książkęKup książkę 134 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Rozwi(cid:241)zanie Aby policzy(cid:252) wszystkich pracowników, skorzystamy z funkcji agreguj(cid:261)cej COUNT, któr(cid:261) wywo(cid:225)amy z u(cid:298)yciem parametru *: SELECT COUNT(*) as LiczbaPracowników FROM Employee Funkcja COUNT wywo(cid:225)ana z u(cid:298)yciem parametru * zlicza wszystkie wiersze w danej tabeli. Je(cid:286)li natomiast jako parametr podamy nazw(cid:266) kolumny, zostan(cid:261) zliczone wszystkie war- to(cid:286)ci w tej kolumnie, które nie s(cid:261) warto(cid:286)ciami NULL. Jako przyk(cid:225)ad we(cid:296)my tabel(cid:266) 4.1 o nazwie S(cid:239)ownik. Tabela 4.1. S(cid:225)ownik Id 1 3 4 5 Nazwa AAA BBB NULL CCC Dla zapytania: SELECT COUNT(*) FROM S(cid:273)ownik otrzymamy wynik 4 —zosta(cid:225)y zliczone wszystkie wiersze. Dla zapytania: SELECT COUNT(Nazwa) FROM S(cid:273)ownik otrzymamy wynik 3 — zosta(cid:225)y zliczone te wiersze, które w kolumnie Nazwa maj(cid:261) warto- (cid:286)ci inne ni(cid:298) NULL. (cid:231)wiczenie 4.2 Policz wszystkich pracowników, którzy nie maj(cid:261) drugiego imienia. Oczekiwany wynik Rysunek 4.2. Oczekiwany wynik (cid:252)wiczenia 4.2 Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 135 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) pracowników, którzy nie maj(cid:261) drugiego imienia, nale(cid:298)y wy(cid:286)wietli(cid:252) te wszystkie wiersze z tabeli Employee, których warto(cid:286)(cid:252) w kolumnie SecondName jest warto- (cid:286)ci(cid:261) NULL. Nast(cid:266)pnie nale(cid:298)y — za pomoc(cid:261) funkcji agreguj(cid:261)cej COUNT — policzy(cid:252) liczb(cid:266) zwróconych wierszy: SELECT COUNT(*) as LiczbaPracownikow FROM Employee WHERE SecondName IS NOT NULL To zadanie mo(cid:298)na rozwi(cid:261)za(cid:252) równie(cid:298) w inny sposób. Tak jak pokaza(cid:225)am w poprzednim (cid:252)wiczeniu — je(cid:298)eli funkcja COUNT jako parametr przyjmuje nazw(cid:266) kolumny, wówczas zlicza tylko te warto(cid:286)ci z tej kolumny, które nie s(cid:261) warto(cid:286)ciami NULL. Powy(cid:298)sze zapytanie mo(cid:298)na wi(cid:266)c równie(cid:298) zapisa(cid:252) w nast(cid:266)puj(cid:261)cy sposób: SELECT COUNT(SecondName) FROM Employee (cid:231)wiczenie 4.3 Policz wszystkich aktywnych pracowników. Oczekiwany wynik Rysunek 4.3. Oczekiwany wynik (cid:252)wiczenia 4.3 Rozwi(cid:241)zanie Je(cid:286)li u(cid:298)ywamy funkcji agreguj(cid:261)cych, nic nie stoi na przeszkodzie, aby u(cid:298)ywa(cid:252) rów- nie(cid:298) poznanych ju(cid:298) wcze(cid:286)niej elementów j(cid:266)zyka — w tym wypadku warunków, których u(cid:298)yjemy w sekcji WHERE. Aby policzy(cid:252) wszystkich aktywnych pracowników, u(cid:298)yjemy funkcji agreguj(cid:261)cej COUNT(*) dla wierszy, które spe(cid:225)niaj(cid:261) warunek Active = 1. Zapytanie wi(cid:266)c b(cid:266)dzie wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT COUNT(*) as LiczbaAktywnychPracowników FROM Employee WHERE Active = 1 Poleć książkęKup książkę 136 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) (cid:231)wiczenie 4.4 Policz, ilu pracowników pracuje w dziale IT. Oczekiwany wynik Rysunek 4.4. Oczekiwany wynik (cid:252)wiczenia 4.4 Rozwi(cid:241)zanie Informacje o pracownikach mamy w tabeli Employee, natomiast informacje o dziale, w którym pracuj(cid:261), mamy w tabeli Department. Musimy wi(cid:266)c z(cid:225)(cid:261)czy(cid:252) te dwie tabele oraz zdefiniowa(cid:252) warunek tak, aby zosta(cid:225)y wy(cid:286)wietlone dane tylko tych pracowników, którzy s(cid:261) zatrudnieni w dziale IT: SELECT * FROM Employee INNER JOIN Department ON Employee.DepartmentId = Department.Id WHERE Department.Name = IT Teraz wystarczy ju(cid:298) tylko zliczy(cid:252) wiersze za pomoc(cid:261) funkcji agreguj(cid:261)cej COUNT(*): SELECT COUNT(*) as LiczbaPracowników FROM Employee INNER JOIN Department ON Employee.DepartmentId = Department.Id WHERE Department.Name = IT (cid:231)wiczenie 4.5 Policz wszystkich pracowników, którzy pracuj(cid:261) w dzia(cid:225)ach znajduj(cid:261)cych si(cid:266) w Warszawie. Oczekiwany wynik Rysunek 4.5. Oczekiwany wynik (cid:252)wiczenia 4.5 Rozwi(cid:241)zanie Informacje o pracownikach znajduj(cid:261) si(cid:266) w tabeli Employee, dane dzia(cid:225)ów — w tabeli Department, dane miast — w tabeli City. Musimy wi(cid:266)c po(cid:225)(cid:261)czy(cid:252) te trzy tabele. Nast(cid:266)pnie definiujemy warunek wy(cid:286)wietlaj(cid:261)cy tylko wiersze, w których Name ma warto(cid:286)(cid:252) Warsaw, i zliczamy wiersze za pomoc(cid:261) funkcji agreguj(cid:261)cej COUNT: SELECT COUNT(*) as LiczbaPracownikow FROM Employee INNER JOIN Department ON Employee.DepartmentId = Department.Id INNER JOIN City ON Department.CityId = City.Id WHERE City.Name = Warsaw Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 137 (cid:231)wiczenie 4.6 Policz, ile pracodawca wydaje miesi(cid:266)cznie na pensje. Zauwa(cid:298), (cid:298)e pracodawca p(cid:225)aci pensje tylko aktywnym pracownikom. Oczekiwany wynik Rysunek 4.6. Oczekiwany wynik (cid:252)wiczenia 4.6 Rozwi(cid:241)zanie (cid:297)eby policzy(cid:252), ile pracodawca wydaje miesi(cid:266)cznie na pensje, musimy policzy(cid:252) sum(cid:266) zarobków wszystkich aktywnych pracowników. Aktywnych pracowników znajdziemy, u(cid:298)ywaj(cid:261)c zapytania: SELECT * FROM Employee WHERE Active = 1 Aby obliczy(cid:252) sum(cid:266), skorzystamy z funkcji agreguj(cid:261)cej SUM, która jako parametr przyj- muje nazw(cid:266) kolumny i zlicza sum(cid:266) warto(cid:286)ci z tej kolumny. Aby wy(cid:286)wietli(cid:252) sum(cid:266) za- robków, u(cid:298)yjemy funkcji SUM w sekcji SELECT, zamiast *: SELECT SUM(Salary) as SumaPensji FROM Employee WHERE Active = 1 (cid:231)wiczenie 4.7 Policz, ile pracodawca wydaje rocznie na pensje. Oczekiwany wynik Rysunek 4.7. Oczekiwany wynik (cid:252)wiczenia 4.7 Rozwi(cid:241)zanie Aby policzy(cid:252) roczn(cid:261) sum(cid:266) zarobków, nale(cid:298)y pomno(cid:298)y(cid:252) miesi(cid:266)czne zarobki przez 12. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT SUM(Salary) * 12 as RocznaSumaPensji FROM Employee WHERE Active = 1 Poleć książkęKup książkę 138 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Mo(cid:298)na je równie(cid:298) zapisa(cid:252) w taki sposób: SELECT SUM(Salary * 12) as RocznaSumaPensji FROM Employee WHERE Active = 1 (cid:231)wiczenie 4.8 Znajd(cid:296) minimalne zarobki spo(cid:286)ród wszystkich pracowników. Oczekiwany wynik Rysunek 4.8. Oczekiwany wynik (cid:252)wiczenia 4.8 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) minimalne zarobki, u(cid:298)yjemy funkcji MIN, która jako parametr przyjmuje nazw(cid:266) kolumny i zwraca najmniejsz(cid:261) warto(cid:286)(cid:252) spo(cid:286)ród wszystkich w tej kolumnie. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT MIN(Salary) as MinimalneZarobki FROM Employee (cid:231)wiczenie 4.9 Policz, z ilu liter sk(cid:225)ada si(cid:266) najkrótsze imi(cid:266) pracownika spo(cid:286)ród zatrudnionych. Oczekiwany wynik Rysunek 4.9. Oczekiwany wynik (cid:252)wiczenia 4.9 Rozwi(cid:241)zanie Liczb(cid:266) liter w imieniu mo(cid:298)emy policzy(cid:252) za pomoc(cid:261) funkcji LEN: SELECT FirstName, LEN(FirstName) as LiczbaLiter FROM Employee Po wykonaniu tego zapytania otrzymamy wynik widoczny na rysunku 4.10. Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 139 Rysunek 4.10. Wynik obliczenia liczby liter w imionach wszystkich pracowników Na rysunku widzimy, (cid:298)e spo(cid:286)ród wy(cid:286)wietlonych d(cid:225)ugo(cid:286)ci imion najkrótsze z nich ma 4 znaki. Aby napisa(cid:252) zapytanie, które znajdzie najkrótsze imi(cid:266), musimy u(cid:298)y(cid:252) funkcji MIN, jako parametr podaj(cid:261)c wynik funkcji LEN(FirstName): SELECT MIN(LEN(FirstName)) as NajmniejLiter FROM Employee (cid:231)wiczenie 4.10 Policz, ile lat (cid:225)(cid:261)cznie przepracowali w firmie aktywni pracownicy. Oczekiwany wynik Rysunek 4.11. Oczekiwany wynik (cid:252)wiczenia 4.10 Rozwi(cid:241)zanie Aby wy(cid:286)wietli(cid:252), ile lat przepracowali firmie aktywni pracownicy, u(cid:298)yjemy funkcji DATEDIFF — do policzenia ró(cid:298)nicy lat pomi(cid:266)dzy dat(cid:261) zatrudnienia a dat(cid:261) dzisiejsz(cid:261): SELECT DATEDIFF(year,HireDate,GETDATE()) FROM Employee WHERE Active = 1 Aby obliczy(cid:252) sum(cid:266) tych lat, u(cid:298)yjemy funkcji SUM, jako argument podaj(cid:261)c wynik funkcji DATEDIFF: SELECT SUM(DATEDIFF(year,HireDate,GETDATE())) FROM Employee WHERE Active = 1 Poleć książkęKup książkę 140 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) (cid:231)wiczenie 4.11 Sprawd(cid:296), jaka jest ró(cid:298)nica pomi(cid:266)dzy minimaln(cid:261) a maksymaln(cid:261) pensj(cid:261). Oczekiwany wynik Rysunek 4.12. Oczekiwany wynik (cid:252)wiczenia 4.11 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) wysoko(cid:286)(cid:252) minimalnej pensji, u(cid:298)yjemy poznanej ju(cid:298) funkcji MIN. SELECT MIN(Salary) FROM Employee Aby znale(cid:296)(cid:252) wysoko(cid:286)(cid:252) maksymalnej pensji, u(cid:298)yjemy analogicznej funkcji MAX. SELECT MAX(Salary) FROM Employee Aby policzy(cid:252) ró(cid:298)nic(cid:266) pomi(cid:266)dzy minimaln(cid:261) a maksymaln(cid:261) wysoko(cid:286)ci(cid:261) pensji, u(cid:298)yjemy tych dwóch funkcji w jednym zapytaniu i znajdziemy ró(cid:298)nic(cid:266) pomi(cid:266)dzy nimi za pomoc(cid:261) operatora odejmowania: SELECT MAX(Salary) - MIN(Salary) as RoznicaPensji FROM Employee (cid:231)wiczenie 4.12 Policz (cid:286)redni(cid:261), minimaln(cid:261) i maksymaln(cid:261) wysoko(cid:286)(cid:252) pensji pracowników w dziale IT. Oczekiwany wynik Rysunek 4.13. Oczekiwany wynik (cid:252)wiczenia 4.12 Rozwi(cid:241)zanie Poznali(cid:286)my ju(cid:298) funkcje MIN i MAX, które zwracaj(cid:261) odpowiednio najni(cid:298)sz(cid:261) i najwy(cid:298)sz(cid:261) warto(cid:286)(cid:252). Istnieje jeszcze jedna funkcja agreguj(cid:261)ca AVG, która zwraca (cid:286)redni(cid:261) warto(cid:286)(cid:252). Zastosujemy te trzy funkcje w kolumnie Salary w wynikach po(cid:225)(cid:261)czonych tabel Employee oraz Department: SELECT AVG(Salary) as AvgSalary, MIN(Salary) as MinSalary, MAX(Salary) as MaxSalary FROM Employee INNER JOIN Department ON Employee.DepartmentId = Department.Id WHERE Name = IT Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 141 (cid:231)wiczenie 4.13 O ile nale(cid:298)a(cid:225)oby podnie(cid:286)(cid:252) pensj(cid:266) pracownikowi, który zarabia najmniej, (cid:298)eby jego pensja wynosi(cid:225)a tyle, ile (cid:286)rednia pensja? Oczekiwany wynik Rysunek 4.14. Oczekiwany wynik (cid:252)wiczenia 4.13 Rozwi(cid:241)zanie Pensj(cid:266) pracownika, który zarabia najmniej, znajdziemy za pomoc(cid:261) funkcji MIN, a wy- soko(cid:286)(cid:252) (cid:286)redniej pensji — za pomoc(cid:261) funkcji AVG. Aby dowiedzie(cid:252) si(cid:266), o ile nale(cid:298)a(cid:225)oby podnie(cid:286)(cid:252) wysoko(cid:286)(cid:252) tej minimalnej pensji, (cid:298)eby wynosi(cid:225)a ona tyle, co (cid:286)rednia, nale(cid:298)y znale(cid:296)(cid:252) ró(cid:298)nic(cid:266) pomi(cid:266)dzy tymi kwotami: SELECT AVG(Salary) - MIN(Salary) FROM Employee (cid:231)wiczenie 4.14 Policz (cid:286)redni wiek wszystkich pracowników. Oczekiwany wynik Rysunek 4.15. Oczekiwany wynik (cid:252)wiczenia 4.14 Rozwi(cid:241)zanie Aby wy(cid:286)wietli(cid:252) wiek pracowników, nale(cid:298)y obliczy(cid:252) liczb(cid:266) lat, która min(cid:266)(cid:225)a od dnia ich urodzin do dnia dzisiejszego: SELECT DATEDIFF(year, BirthDate, GETDATE()) FROM Employee Nast(cid:266)pnie za pomoc(cid:261) funkcji AVG znajdujemy (cid:286)redni(cid:261) z tych warto(cid:286)ci: SELECT AVG(DATEDIFF(year, BirthDate, GETDATE())) as SredniWiek FROM Employee Poleć książkęKup książkę 142 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) (cid:231)wiczenie 4.15 Policz (cid:286)redni(cid:261) liczb(cid:266) miesi(cid:266)cy przepracowanych przez tych pracowników, którzy ju(cid:298) w firmie nie pracuj(cid:261). Oczekiwany wynik Rysunek 4.16. Oczekiwany wynik (cid:252)wiczenia 4.15 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) liczb(cid:266) miesi(cid:266)cy, które przepracowali pracownicy niezatrudnieni ju(cid:298) w fir- mie, u(cid:298)yjemy funkcji DATEDIFF — do obliczenia, ile miesi(cid:266)cy min(cid:266)(cid:225)o od daty zatrud- nienia (HireDate) do daty zwolnienia (RelieveDate), ale tylko dla tych pracowników, którzy maj(cid:261) wpisan(cid:261) dat(cid:266) zwolnienia. Nast(cid:266)pnie za pomoc(cid:261) funkcji AVG znajdujemy (cid:286)redni(cid:261) z tych warto(cid:286)ci: SELECT AVG(DATEDIFF(month, HireDate, RelieveDate)) as SredniaLiczbaMiesiecy FROM Employee WHERE RelieveDate IS NOT NULL (cid:231)wiczenie 4.16 Znajd(cid:296) najpó(cid:296)niejsz(cid:261) dat(cid:266) urodzenia spo(cid:286)ród wszystkich pracowników. Oczekiwany wynik Rysunek 4.17. Oczekiwany wynik (cid:252)wiczenia 4.16 Rozwi(cid:241)zanie Funkcji agreguj(cid:261)cych mo(cid:298)na u(cid:298)ywa(cid:252) nie tylko na liczbach, ale równie(cid:298) na datach: SELECT MAX(BirthDate) as MaksymalnaDataUrodzenia FROM Employee (cid:231)wiczenie 4.17 Wy(cid:286)wietl wszystkie unikalne wysoko(cid:286)ci p(cid:225)ac w firmie i dla ka(cid:298)dej z tych warto(cid:286)ci policz, ilu pracowników zarabia tak(cid:261) w(cid:225)a(cid:286)nie kwot(cid:266). Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 143 Oczekiwany wynik Rysunek 4.18. Oczekiwany wynik (cid:252)wiczenia 4.17 Rozwi(cid:241)zanie Umiemy ju(cid:298) stosowa(cid:252) funkcje agreguj(cid:261)ce na wszystkich wierszach zapytania, czyli np. policzy(cid:252) liczb(cid:266) wierszy w tabeli. Kolejnym krokiem jest mo(cid:298)liwo(cid:286)(cid:252) stosowania funk- cji agreguj(cid:261)cych na grupach rekordów. Poka(cid:298)(cid:266) to na prostym przyk(cid:225)adzie. Za(cid:225)ó(cid:298)my, (cid:298)e mamy tabel(cid:266) Samochody, która jest wype(cid:225)niona danymi jak w tabeli 4.1. Tabela 4.1. Przyk(cid:225)adowe dane dla samochodów Marka Toyota Toyota Fiat Fiat Toyota Rok_produkcji Model 2013 2014 2013 2012 2013 Yaris Auris Bravo Punto Corolla Chcieliby(cid:286)my policzy(cid:252), ile mamy modeli samochodów dla poszczególnych marek. W tym celu musimy pogrupowa(cid:252) je wed(cid:225)ug marki, dodaj(cid:261)c klauzul(cid:266) GROUP BY Marka. Pogru- powan(cid:261) tabel(cid:266) mo(cid:298)emy sobie wyobrazi(cid:252) jako tabel(cid:266) przedstawion(cid:261) poni(cid:298)ej tabela 4.2. Tabela 4.2. Wyniki pogrupowania samochodów wed(cid:225)ug marki Marka Toyota Fiat Rok_produkcji Model 2013 2014 2013 2013 2012 Yaris Auris Corolla Bravo Punto Ka(cid:298)da marka jest teraz nag(cid:225)ówkiem grupy. Ka(cid:298)da grupa posiada wiersze, które pasuj(cid:261) do grupy wed(cid:225)ug kryterium grupowania. Na tych wierszach mo(cid:298)emy stosowa(cid:252) teraz funkcje grupuj(cid:261)ce (agreguj(cid:261)ce), które b(cid:266)d(cid:261) wykonywa(cid:252) dzia(cid:225)ania w ramach grupy. Poleć książkęKup książkę 144 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Tabeli 4.2 nie mo(cid:276)emy wy(cid:264)wietli(cid:232). Narysowa(cid:228)am j(cid:241) w celu lepszego zobrazowania tego, w jaki sposób wygl(cid:241)da grupowanie. Je(cid:286)li wi(cid:266)c wykonamy zapytanie: SELECT Marka, COUNT(*) as Liczba FROM Samochody GROUP BY Marka wówczas otrzymamy wynik zaprezentowany w tabeli 4.3. Tabela 4.3. Wynik policzenia liczby modeli samochodów dla ka(cid:298)dej marki Marka Toyota Fiat Liczba 3 2 Je(cid:286)li zastosujemy klauzul(cid:266) GROUP BY, to w sekcji SELECT mo(cid:298)emy wy(cid:286)wietla(cid:252) tylko i wy(cid:225)(cid:261)cznie: (cid:141) kolumny, które s(cid:261) kryterium grupowania, tak jak marka samochodu w powy(cid:298)szym przyk(cid:225)adzie, (cid:141) wyniki funkcji grupuj(cid:261)cych (agreguj(cid:261)cych). Nie mo(cid:298)emy ju(cid:298) odwo(cid:225)ywa(cid:252) si(cid:266) do pozosta(cid:225)ych kolumn. Przyk(cid:225)adowo, je(cid:286)li napisaliby(cid:286)my: SELECT Marka, Model FROM Samochody GROUP BY Marka to jaki model samochodu mia(cid:225)by by(cid:252) wy(cid:286)wietlony? Yaris, Auris czy Corolla? Nie wiadomo. Grup(cid:266) utworzyli(cid:286)my po to, (cid:298)eby mie(cid:252) tylko jeden wiersz dla danej grupy, a wi(cid:266)c nie mo(cid:298)emy wy(cid:286)wietli(cid:252) kolumn, które nie zosta(cid:225)y u(cid:298)yte do grupowania. Je(cid:286)li na- piszemy takie zapytanie, w wyniku otrzymamy b(cid:225)(cid:261)d: Column Samochody.Model is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause. Pami(cid:246)taj, (cid:276)e je(cid:264)li u(cid:276)yjesz grupowania, w sekcji SELECT mo(cid:276)esz u(cid:276)ywa(cid:232) tylko funkcji grupuj(cid:241)cych (agreguj(cid:241)cych) oraz kolumn, które wyst(cid:241)pi(cid:228)y w sekcji GROUP BY. Grup(cid:266) mo(cid:298)na równie(cid:298) utworzy(cid:252) na podstawie wielu kolumn. Na przyk(cid:225)ad, je(cid:286)li chcemy policzy(cid:252), ile modeli danej marki zosta(cid:225)o wyprodukowanych w poszczególnych latach, mo(cid:298)emy pogrupowa(cid:252) dane wed(cid:225)ug marki oraz roku produkcji: GROUP BY Marka, Rok_produkcji Wyobra(cid:298)amy sobie wtedy wyniki pogrupowania tak, jak to przedstawiono w tabeli 4.4. Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 145 Tabela 4.4. Wyniki pogrupowania samochodów wed(cid:225)ug marki i roku produkcji Marka Rok_produkcji Model Toyota Fiat 2013 2014 2013 2012 Yaris Corolla Auris Bravo Punto Mo(cid:298)emy teraz np. policzy(cid:252) liczb(cid:266) wierszy w danej grupie. SELECT Marka, Rok_produkcji, COUNT(*) as Liczba FROM Samochody GROUP BY Marka, Rok_produkcji Wynik tego zapytania zosta(cid:225) zaprezentowany w tabeli 4.5. Tabela 4.5. Wynik zapytania o liczb(cid:266) wierszy w danej grupie Marka Toyota Toyota Fiat Fiat Rok_produkcji Liczba 2013 2014 2013 2012 2 1 1 1 Nawet je(cid:264)li widzimy, (cid:276)e w danej grupie znajduje si(cid:246) tylko jeden wiersz, trzymamy si(cid:246) zasady, (cid:276)e nie wolno nam w sekcji SELECT wy(cid:264)wietla(cid:232) kolumn, które nie s(cid:241) kry- terium grupowania. Wró(cid:252)my wi(cid:266)c do (cid:252)wiczenia. Mamy wy(cid:286)wietli(cid:252) wszystkie unikalne warto(cid:286)ci zarobków i policzy(cid:252), ilu pracowników zarabia tak(cid:261) w(cid:225)a(cid:286)nie kwot(cid:266). Budujemy wi(cid:266)c grup(cid:266) wed(cid:225)ug zarobków: GROUP BY Salary Nast(cid:266)pnie zliczamy liczb(cid:266) wierszy w ka(cid:298)dej grupie: SELECT Salary, COUNT(*) as LiczbaPracownikow FROM Employee GROUP BY Salary Poleć książkęKup książkę 146 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) (cid:231)wiczenie 4.18 Wy(cid:286)wietl wszystkie unikalne wysoko(cid:286)ci p(cid:225)ac w firmie. Oczekiwany wynik Rysunek 4.19. Oczekiwany wynik (cid:252)wiczenia 4.18 Rozwi(cid:241)zanie Umiemy ju(cid:298) rozwi(cid:261)za(cid:252) powy(cid:298)sze (cid:252)wiczenie za pomoc(cid:261) klauzuli DISTINCT: SELECT DISTINCT Salary FROM Employee Mo(cid:298)emy to jednak równie(cid:298) zrobi(cid:252), u(cid:298)ywaj(cid:261)c grupowania: SELECT Salary FROM Employee GROUP BY Salary To, (cid:276)e w klauzuli SELECT mo(cid:276)esz u(cid:276)y(cid:232) tylko kolumn wyst(cid:246)puj(cid:241)cych w sekcji GROUP BY, nie oznacza, (cid:276)e musisz ich u(cid:276)y(cid:232). Zale(cid:276)y to tylko i wy(cid:228)(cid:241)cznie od Twoich wymaga(cid:254) i po- trzeb. W klauzuli SELECT mo(cid:276)e wyst(cid:241)pi(cid:232) dowolny podzbiór kolumn z sekcji GROUP BY, mog(cid:241) te(cid:276) zosta(cid:232) u(cid:276)yte same funkcje grupuj(cid:241)ce (agreguj(cid:241)ce). Przyk(cid:228)ady poprawnego u(cid:276)ycia: SELECT X, COUNT(*), SUM(Z) FROM Tabela GROUP BY X, Y SELECT COUNT(*) FROM Tabela GROUP BY X, Y, Z SELECT X, Z FROM Tabela GROUP BY X, Y, Z Zawsze je(cid:264)li patrzysz na zapytanie grupuj(cid:241)ce, upewnij si(cid:246), (cid:276)e w sekcji SELECT nie ma kolumn, które nie wyst(cid:246)puj(cid:241) w sekcji GROUP BY. Po(cid:264)wi(cid:246)ci(cid:228)am temu zagadnieniu tak wiele miejsca, poniewa(cid:276) jest to jeden z najcz(cid:246)(cid:264)ciej pope(cid:228)nianych b(cid:228)(cid:246)dów dotycz(cid:241)cych grupowania. Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 147 (cid:231)wiczenie 4.19 Wy(cid:286)wietl, ilu pracowników pracuje w poszczególnych dzia(cid:225)ach. Oczekiwany wynik Rysunek 4.20. Oczekiwany wynik (cid:252)wiczenia 4.19 Rozwi(cid:241)zanie Informacje o pracownikach mamy w tabeli Employee, natomiast informacje o dzia(cid:225)ach — w tabeli Department. Musimy wi(cid:266)c po(cid:225)(cid:261)czy(cid:252) te dwie tabele: SELECT * FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name Nast(cid:266)pnie wyniki po(cid:225)(cid:261)czenia tabel musimy pogrupowa(cid:252) wed(cid:225)ug nazwy dzia(cid:225)u i poli- czy(cid:252) liczb(cid:266) wierszy w ka(cid:298)dej grupie, czyli liczb(cid:266) pracowników przypisanych danemu dzia(cid:225)owi: SELECT Name, COUNT(*) as LiczbaPracownikow FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name (cid:231)wiczenie 4.20 Wy(cid:286)wietl, ilu pracowników pracuje w poszczególnych dzia(cid:225)ach. Wyniki rozszerz rów- nie(cid:298) o te dzia(cid:225)y, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika. Oczekiwany wynik Rysunek 4.21. Oczekiwany wynik (cid:252)wiczenia 4.20 Poleć książkęKup książkę 148 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Rozwi(cid:241)zanie Aby uwzgl(cid:266)dni(cid:252) równie(cid:298) dzia(cid:225)y, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika, u(cid:298)yjemy z(cid:225)(cid:261)czenia zewn(cid:266)trznego LEFT JOIN. Grupowanie i sposób liczenia pracowników b(cid:266)d(cid:261) dok(cid:225)adnie takie same, jak w poprzednim (cid:252)wiczeniu: SELECT Name, COUNT(*) as LiczbaPracownikow FROM Department LEFT JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name Je(cid:286)li wykonamy to zapytanie, okazuje si(cid:266), (cid:298)e dla dzia(cid:225)ów, które nie maj(cid:261) przypisane- go (cid:298)adnego pracownika, np. Controlling, otrzymali(cid:286)my wynik 1 (rysunek 4.22). Rysunek 4.22. Wyniki z b(cid:225)(cid:266)dnie zwrócon(cid:261) liczb(cid:261) pracowników dla dzia(cid:225)ów, w których nikt nie pracuje Dla dzia(cid:225)u Controlling istnieje jeden wiersz zawieraj(cid:261)cy informacje o tym dziale, ale brakuje informacji o pracownikach, poniewa(cid:298) nie istnieje (cid:298)aden z nich przypisany temu dzia(cid:225)owi. Pami(cid:266)taj o tym, jak dzia(cid:225)a funkcja COUNT. Je(cid:286)li parametrem wywo(cid:225)ania tej funkcji jest *, zlicza ona wszystkie wiersze — bez wzgl(cid:266)du na to, czy wiersz ten posiada warto(cid:286)ci z obu tabel, czy te(cid:298) zosta(cid:225) uzupe(cid:225)niony warto(cid:286)ciami NULL dla z(cid:225)(cid:261)czenia zewn(cid:266)trznego LEFT JOIN. Je(cid:286)li parametrem wywo(cid:225)ania tej funkcji jest nazwa kolumny — zlicza ona tylko te wiersze, w których warto(cid:286)(cid:252) tej kolumny jest ró(cid:298)na od NULL. Mo- (cid:298)emy wykorzysta(cid:252) to dzia(cid:225)anie w wypadku powy(cid:298)szego (cid:252)wiczenia i jako parametr do funkcji COUNT przekaza(cid:252) kolumn(cid:266) Employee.Id: SELECT Name, COUNT(Employee.Id) as LiczbaPracownikow FROM Department LEFT JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name (cid:231)wiczenie 4.21 Dla ka(cid:298)dego dzia(cid:225)u policz liczb(cid:266) pracowników zarabiaj(cid:261)cych wi(cid:266)cej ni(cid:298) 1500 z(cid:225). Oczekiwany wynik Rysunek 4.23. Oczekiwany wynik (cid:252)wiczenia 4.21 Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 149 Rozwi(cid:241)zanie Je(cid:286)li u(cid:298)ywamy grupowania, wci(cid:261)(cid:298) mo(cid:298)emy u(cid:298)ywa(cid:252) warunków w stosunku do ko- lumn, które nie wyst(cid:266)puj(cid:261) jako kryterium grupowania. W tym przyk(cid:225)adzie b(cid:266)dziemy grupowa(cid:252) wed(cid:225)ug nazwy dzia(cid:225)ów, a w klauzuli WHERE sprawdzimy wysoko(cid:286)(cid:252) zarobków. Przy przetwarzaniu zapytania najpierw s(cid:261) wykonywane warunki z sekcji WHERE, mamy wi(cid:266)c wówczas dost(cid:266)pne jeszcze wszystkie kolumny, a dopiero potem jest wykonywane grupowanie. Sekcja GROUP BY znajduje si(cid:266) w zapytaniu po sekcji WHERE. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT Name, COUNT(*) as LiczbaPracownikow FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id WHERE Salary 1500 GROUP BY Name (cid:231)wiczenie 4.22 Dla ka(cid:298)dego dzia(cid:225)u wy(cid:286)wietl (cid:286)redni(cid:261) pensj(cid:266). Wyniki posortuj wed(cid:225)ug nazwy dzia(cid:225)u. Oczekiwany wynik Rysunek 4.24. Oczekiwany wynik (cid:252)wiczenia 4.22 Rozwi(cid:241)zanie Aby policzy(cid:252) (cid:286)redni(cid:261) pensj(cid:266) w dziale, po(cid:225)(cid:261)czymy tabele Employee i Department. Wyniki pogrupujemy wed(cid:225)ug nazwy dzia(cid:225)u i u(cid:298)yjemy funkcji AVG, której argumentem b(cid:266)dzie kolumna Salary, aby policzy(cid:252) (cid:286)redni(cid:261) pensj(cid:266): SELECT Name, AVG(Salary) as SredniaPensja FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id Otrzymane wyniki posortujemy za pomoc(cid:261) klauzuli ORDER BY. T(cid:266) klazul(cid:266) obowi(cid:261)zuj(cid:261) takie same zasady jak klauzul(cid:266) SELECT: mo(cid:298)emy tu u(cid:298)ywa(cid:252) tylko tych kolumn, które by(cid:225)y kryterium grupowania, oraz funkcji agreguj(cid:261)cych. Je(cid:286)li b(cid:266)dziemy chcieli posortowa(cid:252) wyniki wed(cid:225)ug nazwiska pracownika (kolumna LastName w tabeli Employee), która to kolumna nie jest kryterium grupowania, otrzymamy znany ju(cid:298) b(cid:225)(cid:261)d: Column Employee.LastName is invalid in the ORDER BY clause because it is not contained in either an aggregate function or the GROUP BY clause. Poleć książkęKup książkę 150 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Sekcja ORDER BY znajduje si(cid:266) na samym ko(cid:276)cu zapytania, po sekcji GROUP BY. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT Name, AVG(Salary) as SredniaPensja FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name ORDER BY Name (cid:231)wiczenie 4.23 Dla ka(cid:298)dego dzia(cid:225)u policz, ile pieni(cid:266)dzy idzie miesi(cid:266)cznie na wyp(cid:225)aty (czyli dla ak- tywnych pracowników). Uwzgl(cid:266)dnij równie(cid:298) dzia(cid:225)y, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika. Oczekiwany wynik Rysunek 4.25. Oczekiwany wynik (cid:252)wiczenia 4.23 Rozwi(cid:241)zanie Po(cid:225)(cid:261)czymy tabel(cid:266) Department z tabel(cid:261) Employee przy u(cid:298)yciu z(cid:225)(cid:261)czenia zewn(cid:266)trznego LEFT JOIN, tak aby uwzgl(cid:266)dni(cid:252) równie(cid:298) dzia(cid:225)y, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika. Nast(cid:266)pnie wyniki pogrupujemy wed(cid:225)ug nazwy dzia(cid:225)u i dla ka(cid:298)dej grupy, czyli dla ka(cid:298)dego dzia(cid:225)u, policzymy sum(cid:266) wynagrodze(cid:276) pracowników tego dzia(cid:225)u: SELECT Name, SUM(Salary) as SumaWynagrodzen FROM Department LEFT JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name Po wykonaniu zapytania otrzymamy wynik jak na rysunku 4.26. Rysunek 4.26. Wynik obliczenia sumy wynagrodze(cid:276) dla ka(cid:298)dego dzia(cid:225)u Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 151 Zauwa(cid:298), (cid:298)e po wykonaniu tego zapytania, dla dzia(cid:225)ów, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika, otrzymasz warto(cid:286)(cid:252) NULL, poniewa(cid:298) wynik dzia(cid:225)ania funkcji SUM (je(cid:286)li nie zosta(cid:225) zwrócony (cid:298)aden wiersz z powodu braku pracowników) jest równy NULL. Aby pokaza(cid:252) wyniki w bardziej czytelnej postaci, zast(cid:261)pimy warto(cid:286)(cid:252) NULL warto(cid:286)ci(cid:261) 0, za pomoc(cid:261) funkcji ISNULL: SELECT Name, SUM(ISNULL(Salary,0)) as SumaWynagrodzen FROM Department LEFT JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name (cid:231)wiczenie 4.24 Wy(cid:286)wietl nazw(cid:266) dzia(cid:225)u, w którym (cid:286)rednia pensja jest najwy(cid:298)sza. Oczekiwany wynik Rysunek 4.27. Oczekiwany wynik (cid:252)wiczenia 4.24 Rozwi(cid:241)zanie Po(cid:225)(cid:261)czymy tabele Department i tabele Employee, u(cid:298)ywaj(cid:261)c z(cid:225)(cid:261)czenia wewn(cid:266)trznego INNER JOIN (nie musimy wy(cid:286)wietla(cid:252) danych tych dzia(cid:225)ów, które nie maj(cid:261) przypisanego (cid:298)adnego pracownika, bo skoro nie ma w nich pracowników, to wiersze te na pewno nie spe(cid:225)ni(cid:261) warunków zadania — je(cid:286)li dzia(cid:225) nie ma pracowników, to ich (cid:286)rednia pensja wynosi zero). Wyniki pogrupujemy wed(cid:225)ug nazwy dzia(cid:225)u i policzymy (cid:286)redni(cid:261) pensj(cid:266) dla dzia(cid:225)u za pomoc(cid:261) funkcji AVG: SELECT Name, AVG(Salary) FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name Aby znale(cid:296)(cid:252) dzia(cid:225), w którym s(cid:261) najwy(cid:298)sze zarobki, mo(cid:298)emy posortowa(cid:252) wyniki ma- lej(cid:261)co wed(cid:225)ug tych (cid:286)rednich zarobków. W sekcji ORDER BY mo(cid:298)emy równie(cid:298) u(cid:298)ywa(cid:252) funkcji grupuj(cid:261)cych (agreguj(cid:261)cych): ORDER BY AVG(Salary) DESC Nast(cid:266)pnie u(cid:298)yjemy klauzuli TOP 1, aby wy(cid:286)wietli(cid:252) tylko jeden wiersz, znajduj(cid:261)cy si(cid:266) na górze — poniewa(cid:298) posortowali(cid:286)my wyniki malej(cid:261)co wed(cid:225)ug (cid:286)rednich zarobków, na górze b(cid:266)dzie znajdowa(cid:225) si(cid:266) wiersz z najwy(cid:298)szymi (cid:286)rednimi zarobkami. W tre(cid:286)ci zadania by(cid:225)o napisane tylko „wy(cid:286)wietl nazw(cid:266) dzia(cid:225)u” — nie by(cid:225)o mowy o (cid:286)red- nich zarobkach, usuwamy wi(cid:266)c z klauzuli SELECT funkcj(cid:266) AVG(Salary). Poleć książkęKup książkę 152 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Ostatecznie zapytanie b(cid:266)dzie wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT TOP 1 Name FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id GROUP BY Name ORDER BY AVG(Salary) DESC (cid:231)wiczenie 4.25 Policz, ilu pracowników urodzi(cid:225)o si(cid:266) w poszczególnych latach. Oczekiwany wynik Rysunek 4.28. Oczekiwany wynik (cid:252)wiczenia 4.25 Rozwi(cid:241)zanie W klauzuli GROUP BY mo(cid:298)emy u(cid:298)ywa(cid:252) nie tylko kolumn, ale równie(cid:298) funkcji skalarnych operuj(cid:261)cych na kolumnach. Mo(cid:298)emy wi(cid:266)c pogrupowa(cid:252) pracowników wed(cid:225)ug roku ich urodzenia, który wyliczymy z daty urodzenia za pomoc(cid:261) funkcji YEAR: GROUP BY YEAR(BirthDate) Dla ka(cid:298)dej z grup wy(cid:286)wietlamy rok urodzenia oraz liczb(cid:266) pracowników, którzy urodzili si(cid:266) w tym roku: SELECT YEAR(BirthDate) as Rok, COUNT(*) as LiczbaPracownikow FROM Employee GROUP BY YEAR(BirthDate) Pami(cid:246)taj, (cid:276)e je(cid:264)li grupujesz dane wed(cid:228)ug funkcji skalarnej, której argumentem jest okre(cid:264)lona kolumna, w klauzuli SELECT mo(cid:276)esz wy(cid:264)wietli(cid:232) warto(cid:264)(cid:232) tej funkcji (tak jak w powy(cid:276)szym wypadku), ale nie mo(cid:276)esz próbowa(cid:232) wy(cid:264)wietlania tej kolumny, np. poni(cid:276)sze zapytanie zwróci b(cid:228)(cid:241)d: SELECT BirthDate FROM Employee GROUP BY YEAR(BirthDate) Natomiast je(cid:264)li grupujesz dane wed(cid:228)ug kolumny, w klauzuli SELECT mo(cid:276)esz wy- (cid:264)wietli(cid:232) nie tylko t(cid:246) kolumn(cid:246), ale równie(cid:276) korzysta(cid:232) z ró(cid:276)nych funkcji wyliczaj(cid:241)cych warto(cid:264)(cid:232) na podstawie tej kolumny, np. poni(cid:276)sze zapytanie jest poprawne: SELECT YEAR(BirthDate) FROM Employee GROUP BY BirthDate Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 153 (cid:231)wiczenie 4.26 Wy(cid:286)wietl wszystkie pierwsze litery imion aktywnych pracowników i policz, ilu pra- cowników ma imi(cid:266) zaczynaj(cid:261)ce si(cid:266) na dan(cid:261) liter(cid:266). Oczekiwany wynik Rysunek 4.29. Oczekiwany wynik (cid:252)wiczenia 4.26 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) pierwsz(cid:261) liter(cid:266) imienia pracownika, u(cid:298)yjemy funkcji SUBSTRING, która wy(cid:286)wietla okre(cid:286)lony podci(cid:261)g dla danego ci(cid:261)gu znaków. Dla przypomnienia napisz(cid:266), (cid:298)e ta funkcja przyjmuje nast(cid:266)puj(cid:261)ce parametry: (cid:141) nazw(cid:266) kolumny, która jest ci(cid:261)giem znaków, (cid:141) numer znaku w ci(cid:261)gu, od którego chcemy rozpocz(cid:261)(cid:252) dany podci(cid:261)g znaków, (cid:141) liczb(cid:266) znaków, która b(cid:266)dzie d(cid:225)ugo(cid:286)ci(cid:261) podci(cid:261)gu. Pierwsz(cid:261) liter(cid:266) imienia znajdziemy wi(cid:266)c w nast(cid:266)puj(cid:261)cy sposób: SUBSTRING(FirstName,1,1) Teraz dla tabeli Employee, dla aktywnych pracowników, utworzymy grupy na podstawie pierwszej litery imion i dla ka(cid:298)dej grupy policzymy liczb(cid:266) wierszy: SELECT SUBSTRING(FirstName,1,1) as PierwszaLitera, COUNT(*) as Liczbapracownikow FROM Employee WHERE Active = 1 GROUP BY SUBSTRING(FirstName,1,1) (cid:231)wiczenie 4.27 Dla ka(cid:298)dego dzia(cid:225)u policz, ile pracuje w nim kobiet i ilu m(cid:266)(cid:298)czyzn. Oczekiwany wynik Rysunek 4.30. Oczekiwany wynik (cid:252)wiczenia 4.27 Poleć książkęKup książkę 154 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Rozwi(cid:241)zanie Po(cid:225)(cid:261)czymy tabel(cid:266) Department oraz tabel(cid:266) Employee przy u(cid:298)yciu z(cid:225)(cid:261)czenia wewn(cid:266)trz- nego INNER JOIN. Nast(cid:266)pnie otrzymane wyniki pogrupujemy wed(cid:225)ug nazwy dzia(cid:225)u oraz p(cid:225)ci pracownika. Poniewa(cid:298) nie ka(cid:298)dy z pracowników ma wpisan(cid:261) w bazie danych p(cid:225)e(cid:252), u(cid:298)yjemy warunku, który wy(cid:286)wietli tylko tych pracowników, którzy maj(cid:261) podan(cid:261) p(cid:225)e(cid:252). Nast(cid:266)pnie u(cid:298)yjemy funkcji COUNT, aby policzy(cid:252) liczb(cid:266) wierszy w ka(cid:298)dej grupie. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT Name, Gender, COUNT(*) as LiczbaPracowników FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id WHERE Gender IS NOT NULL GROUP BY Name, Gender (cid:231)wiczenie 4.28 Dla ka(cid:298)dego dzia(cid:225)u znajd(cid:296) (cid:286)redni(cid:261), najwi(cid:266)ksz(cid:261) i najmniejsz(cid:261) kwot(cid:266) pensji. Oczekiwany wynik Rysunek 4.31. Oczekiwany wynik (cid:252)wiczenia 4.28 Rozwi(cid:241)zanie Do tej pory w (cid:252)wiczeniach u(cid:298)ywali(cid:286)my zazwyczaj jednej funkcji grupuj(cid:261)cej w danym zapytaniu. Nic nie stoi na przeszkodzie, aby u(cid:298)y(cid:252) ich wi(cid:266)cej w jednym zapytaniu i obli- czy(cid:252) wi(cid:266)cej warto(cid:286)ci dla danej grupy: SELECT Name, AVG(Salary) as (cid:294)rednia pensja , MIN(Salary) as Minimalna pensja , MAX(Salary) as Maksymalna pensja FROM Employee INNER JOIN Department ON Employee.DepartmentId = Department.Id GROUP BY Name (cid:231)wiczenie 4.29 Dla ka(cid:298)dego kierownika wy(cid:286)wietl (cid:286)rednie zarobki w jego dziale oraz (cid:225)(cid:261)czn(cid:261) sum(cid:266), któr(cid:261) przeznacza on miesi(cid:266)cznie na wyp(cid:225)aty (oczywi(cid:286)cie dla aktywnych pracowników). Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 155 Oczekiwany wynik Rysunek 4.32. Oczekiwany wynik (cid:252)wiczenia 4.29 Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) dane kierowników, po(cid:225)(cid:261)czymy tabel(cid:266) Department z tabel(cid:261) Employee na podstawie warunku z(cid:225)(cid:261)czenia ON Manager.Id = Department.ManagerId. Dodatkowo po raz kolejny do(cid:225)(cid:261)czymy tabel(cid:266) Employee — (cid:298)eby znale(cid:296)(cid:252) wszystkich aktywnych pra- cowników tego dzia(cid:225)u. U(cid:298)yjemy tu wi(cid:266)c innego warunku z(cid:225)(cid:261)czenia ON Department.Id = Employee.DepartmentId. Pami(cid:266)tamy o tym, aby nada(cid:252) aliasy tabeli Employee, poniewa(cid:298) u(cid:298)ywamy jej dwa razy w tym samym zapytaniu. Nast(cid:266)pnie zbudujemy grup(cid:266) w oparciu o dane kierownika (imi(cid:266) i nazwisko) oraz nazw(cid:266) dzia(cid:225)u. Dla ka(cid:298)dej z tych grup policzymy (cid:286)redni(cid:261), minimaln(cid:261) i maksymaln(cid:261) wysoko(cid:286)(cid:252) zarobków. Zapytanie b(cid:266)dzie wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT Manager.FirstName, Manager.LastName, Department.Name, AVG(Employee.Salary) as (cid:295)rednie zarobki , SUM(Employee.Salary) as Suma wyp(cid:273)at FROM Employee as Manager INNER JOIN Department ON Manager.Id = Department.ManagerId INNER JOIN Employee ON Department.Id = Employee.DepartmentId WHERE Active = 1 GROUP BY Manager.FirstName, Manager.LastName, Department.Name (cid:231)wiczenie 4.30 Oblicz wysoko(cid:286)(cid:252) (cid:286)redniej p(cid:225)acy aktywnych pracowników w dzia(cid:225)ach. Wyniki ogra- nicz tylko do tych dzia(cid:225)ów, w których (cid:286)rednie zarobki przekraczaj(cid:261) 1500 z(cid:225). Wyniki posortuj wed(cid:225)ug nazwy dzia(cid:225)u. Oczekiwany wynik Rysunek 4.33. Oczekiwany wynik (cid:252)wiczenia 4.30 Poleć książkęKup książkę 156 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Rozwi(cid:241)zanie Aby znale(cid:296)(cid:252) wysoko(cid:286)(cid:252) (cid:286)redniej p(cid:225)acy aktywnych pracowników w poszczególnych dzia- (cid:225)ach, napiszemy zapytanie: SELECT Name, AVG(Salary) as Srednia_pensja FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id WHERE Active = 1 GROUP BY Name Chcemy jednak ograniczy(cid:252) te wyniki tylko do tych dzia(cid:225)ów, w których (cid:286)rednia pensja jest wi(cid:266)ksza ni(cid:298) 1500 z(cid:225). Musimy wi(cid:266)c porówna(cid:252) t(cid:266) warto(cid:286)(cid:252) ze (cid:286)redni(cid:261) pensj(cid:261) w ka(cid:298)- dej grupie (w tym wypadku: w ka(cid:298)dym dziale). Aby rozdzieli(cid:252) warunki nak(cid:225)adane na wiersze przed pogrupowaniem (sekcja WHERE) od warunków nak(cid:225)adanych na grup(cid:266), zosta(cid:225)a utworzona nowa sekcja — HAVING. W tej sekcji mamy dost(cid:266)pne tylko kolumny grup, czyli te kolumny, które zosta(cid:225)y u(cid:298)yte do grupowania, oraz funkcje agreguj(cid:261)ce (grupuj(cid:261)ce). Sekcja HAVING wyst(cid:266)puje w zapytaniu po sekcji GROUP BY. Ostatni(cid:261) sekcj(cid:261) zapytania jest sekcja ORDER BY. Zapytanie b(cid:266)dzie wi(cid:266)c wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: SELECT Name, AVG(Salary) as Srednia_pensja FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id WHERE Active = 1 GROUP BY Name HAVING AVG(Salary) 1500 ORDER BY Name Poniewa(cid:276) podczas przetwarzania zapytania sekcja HAVING jest wykonywana przed sekcj(cid:241) SELECT, nie mo(cid:276)emy w sekcji HAVING u(cid:276)y(cid:232) aliasu, który zosta(cid:228) nadany w sekcji SELECT. Alias ten w tym momencie nie jest jeszcze znany. Próba wykonania poni(cid:276)szego zapytania zako(cid:254)czy(cid:228)aby si(cid:246) wi(cid:246)c b(cid:228)(cid:246)dem: SELECT AVG(Salary) as Srednia_pensja FROM Employee GROUP BY LastName HAVING Srednia_pensja 1500 (cid:231)wiczenie 4.31 Wy(cid:286)wietl miasta, w których znajduje si(cid:266) wi(cid:266)cej ni(cid:298) jeden dzia(cid:225). Oczekiwany wynik Rysunek 4.34. Oczekiwany wynik (cid:252)wiczenia 4.31 Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 157 Rozwi(cid:241)zanie Aby otrzyma(cid:252) informacj(cid:266), w jakim mie(cid:286)cie znajduje si(cid:266) dany dzia(cid:225), musimy po(cid:225)(cid:261)czy(cid:252) tabel(cid:266) Department z tabel(cid:261) City. Utworzymy grupy wed(cid:225)ug nazwy miasta i tak zdefi- niujemy dla nich warunek, aby zosta(cid:225)y wy(cid:286)wietlone tylko te grupy, które maj(cid:261) wi(cid:266)cej ni(cid:298) jeden wiersz: SELECT City.Name FROM City INNER JOIN Department ON Department.CityId = City.Id GROUP BY City.Name HAVING COUNT(*) 1 (cid:231)wiczenie 4.32 Policz (cid:286)redni(cid:261) wieku aktywnych pracowników w poszczególnych dzia(cid:225)ach. Wy(cid:286)wietl tylko te dzia(cid:225)y, w których (cid:286)rednia wieku jest wi(cid:266)ksza ni(cid:298) 27 lat. Oczekiwany wynik Rysunek 4.35. Oczekiwany wynik (cid:252)wiczenia 4.32 Rozwi(cid:241)zanie Aby policzy(cid:252) wiek pracownika, u(cid:298)yjemy funkcji DATEDIFF, która policzy liczb(cid:266) lat od daty urodzenia pracownika do dnia dzisiejszego. Po(cid:225)(cid:261)czymy tabel(cid:266) Employee z tabel(cid:261) Department i pogrupujemy wyniki wed(cid:225)ug nazwy dzia(cid:225)u i obliczymy (cid:286)redni(cid:261) wieku. W sekcji HAVING mo(cid:298)emy równie(cid:298) u(cid:298)ywa(cid:252) ró(cid:298)nych oblicze(cid:276), mo(cid:298)emy wi(cid:266)c u(cid:298)y(cid:252) funkcji DATEDIFF (która b(cid:266)dzie parametrem funkcji agreguj(cid:261)cej AVG), aby wy(cid:286)wietli(cid:252) tylko te grupy, gdzie (cid:286)redni wiek pracownika jest wy(cid:298)szy ni(cid:298) 30 lat. Zapytanie b(cid:266)dzie wygl(cid:261)da(cid:252) nast(cid:266)puj(cid:261)co: SELECT Name, AVG(DATEDIFF(year,BirthDate,GETDATE())) as Sredni_wiek FROM Department INNER JOIN Employee ON Employee.DepartmentId = Department.Id WHERE Active = 1 GROUP BY Name HAVING AVG(DATEDIFF(year,BirthDate,GETDATE())) 30 Poleć książkęKup książkę 158 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Zadania do samodzielnego wykonania Zadanie 4.1 Policz wszystkie towary z tabeli Product. Oczekiwany wynik Rysunek 4.36. Oczekiwany wynik zadania 4.1 Zadanie 4.2 Policz wszystkie towary, których sugerowana cena (kolumna Price) jest ni(cid:298)sza ni(cid:298) 100 z(cid:225). Oczekiwany wynik Rysunek 4.37. Oczekiwany wynik zadania 4.2 Zadanie 4.3 Policz wszystkie zamówienia (tabela Orders) z(cid:225)o(cid:298)one w 2015 roku (kolumna OrderDate). Oczekiwany wynik Rysunek 4.38. Oczekiwany wynik zadania 4.3 Zadanie 4.4 Znajd(cid:296) (cid:286)redni(cid:261) oraz najni(cid:298)sz(cid:261) i najwy(cid:298)sz(cid:261) sugerowan(cid:261) cen(cid:266) spo(cid:286)ród wszystkich towarów. Oczekiwany wynik Rysunek 4.39. Oczekiwany wynik zadania 4.4 Poleć książkęKup książkę Rozdzia(cid:228) 4. (cid:105) Funkcje agreguj(cid:241)ce 159 Zadanie 4.5 Wy(cid:286)wietl (cid:286)redni(cid:261) cen(cid:266) produktów z kategorii Drive. Oczekiwany wynik Rysunek 4.40. Oczekiwany wynik zadania 4.5 Zadanie 4.6 Wy(cid:286)wietl (cid:225)(cid:261)czn(cid:261) sum(cid:266) warto(cid:286)ci wszystkich zamówie(cid:276) z(cid:225)o(cid:298)onych w lutym 2015 roku. Oczekiwany wynik Rysunek 4.41. Oczekiwany wynik zadania 4.6 Zadanie 4.7 Policz sum(cid:266) warto(cid:286)ci zamówie(cid:276) wystawionych przez kobiety. Oczekiwany wynik Rysunek 4.42. Oczekiwany wynik zadania 4.7 Zadanie 4.8 Wy(cid:286)wietl nazwy wszystkich grup produktów oraz liczb(cid:266) produktów znajduj(cid:261)cych si(cid:266) w danej grupie. Oczekiwany wynik Rysunek 4.43. Oczekiwany wynik zadania 4.8 Poleć książkęKup książkę 160 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) Zadanie 4.9 Dla ka(cid:298)dego pracownika wy(cid:286)wietl sum(cid:266) warto(cid:286)ci z(cid:225)o(cid:298)onych przez niego zamówie(cid:276). W wynikach nie uwzgl(cid:266)dniaj pracowników, którzy nie z(cid:225)o(cid:298)yli (cid:298)adnego zamówienia. Oczekiwany wynik Rysunek 4.44. Oczekiwany wynik zadania 4.9 Zadanie 4.10 Wy(cid:286)wietl imi(cid:266) i nazwisko pracownika oraz sum(cid:266) z(cid:225)o(cid:298)onych przez niego zamówie(cid:276) w 2015 roku. Wyniki ogranicz tylko do tych pracowników, dla których ta suma zamówie(cid:276) wynosi pomi(cid:266)dzy 2000 z(cid:225) i 3000 z(cid:225). Oczekiwany wynik Rysunek 4.45. Oczekiwany wynik zadania 4.10 Zadanie 4.11 Dla ka(cid:298)dego towaru wy(cid:286)wietl (cid:225)(cid:261)czn(cid:261) liczb(cid:266) tych z nich, które zosta(cid:225)y zamówione. Oczekiwany wynik Rysunek 4.46. Oczekiwany wynik zadania 4.11 Zadanie 4.12 Dla ka(cid:298)dego produktu, który by(cid:225) kiedykolwiek zamówiony, wy(cid:286)wietl dat(cid:266), kiedy sta(cid:225)o si(cid:266) to po raz pierwszy. Poleć książkęKup książkę Skorowidz , 28 *, 113 [], 29 [^], 29 _, 28 AND, 13 apostrof, 29 ASC, 35 ascending, 35 AVG, 133, 140 CASE, 223 CAST, 224 CONVERT, 224, 225 COUNT, 133 CROSS JOIN, 95, 118 A C D DATEDIFF, 65, 78, 139, 157 DATENAME, 63 month, 63 weekday, 63 datepart, 65 DATEPART, 62 day, 65 hour, 65 minute, 66 month, 65 second, 66 year, 65 day, 62 month, 62 year, 62 DAY, 62 DESC, 35 descending, 35 DISTINCT, 39, 102 EXCEPT, 174, 185 E F format zapisu daty, 12 FROM, 7 FULL OUTER JOIN, 94, 117 funkcja YEAR, 62 funkcje agreguj(cid:261)ce, 133 skalarne, 61 wbudowane, 61 GETDATE, 65, 78 G H HAVING, 156 I INNER JOIN, 92, 98, 102 INTERSECT, 175 IS NOT NULL, 40 ISNULL, 42, 45, 98, 108 J j(cid:266)zykiem deklaratywnym, 7 JOIN, 92 Poleć książkęKup książkę 288 SQL. Jak osi(cid:241)gn(cid:241)(cid:232) mistrzostwo w konstruowaniu zapyta(cid:254) K klauzula ORDER BY, 34 SELECT, 7 kolumna wyliczalna, 17 komunikat No column name, 17 konwersja typów, 224 L LEFT JOIN, 117 LEFT OUTER JOIN, 93 LEN, 74, 139 LOWER, 75 MAX, 133 MIN, 133, 139 MONTH, 62 NULL, 40, 42 M N O operacje na zbiorach, 173 operator, 10 AND, 13 BETWEEN, 24, 27 IN, 24, 25, 27 mniejszo(cid:286)ci =, 10 nierówno(cid:286)ci , 10, 27 NOT, 27 OR, 13, 24 porównania =, 10 wi(cid:266)kszo(cid:286)ci =, 10 OR, 13 ORDER BY, 34, 79, 101 P pe(cid:225)ne z(cid:225)(cid:261)czenie zewn(cid:266)trzne, 94, 117 podzapytania, 193 porz(cid:261)dek malej(cid:261)cy, 35 rosn(cid:261)cy, 35 R RIGHT OUTER JOIN, 93 S SELECT, 7, 10, 152 s(cid:225)owo kluczowe DISTINCT, 39 LIKE, 29 SQL, 7 sk(cid:225)adnia, 7 SUBSTRING, 73, 111 SUM, 133 T TOP(N) PERCENT, 39 TOP(N) WITH TIES, 38 TOP(N), 37, 38, 39 TOP, 37, 39, 101 typ danych, 224 daty i czasu, 224 date, 224 datetime, 224 time, 224 numeryczne, 224 decimal, 224 int, 224 znakowe, 224 char, 224 nchar, 224 nvarchar, 224 varchar, 224 U UNION ALL, 173, 177, 181 UPPER, 75 warunek, 13 WHERE, 7, 10 WITH TIES, 38, 39 wzorzec, 28 YEAR, 62, 71 W Y Z z(cid:225)(cid:261)czenia, 91 krzy(cid:298)owe, 95 wewn(cid:266)trzne, 92, 98, 102 zewn(cid:266)trzne, 117 lewostronne, 93 prawostronne, 93 znak , 28 *, 113 [], 29 [^], 29 _, 28 Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

SQL. Jak osiągnąć mistrzostwo w konstruowaniu zapytań
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: