Część 1-Połączenia i związki

Ta odpowiedź obejmuje:

1. Część 1
   W 1999 roku w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel" w ramach projektu "tworzenie nowych tabel"]}
   • Jak korzystać z zapytania Unii
   • LEWE I Prawe Złącza zewnętrzne (ta odpowiedź stackOverflow jest doskonała do opisania typów połączeń)
   • Intersect queries (i jak je odtworzyć, jeśli baza danych ich nie obsługuje) - jest to funkcja SQL-Server (zobacz info ) i część powodu, dla którego napisałem to wszystko w pierwszej kolejności.
2. część 2
   • Subqueries - czym są, gdzie można ich używać i na co uważać]}
   • Kartezjusz dołączył AKA-Oh, the misery!

Istnieje wiele sposobów pobierania danych z wielu tabel w bazie danych. W tej odpowiedzi będę używał składni ANSI-92 join. Może się to różnić od kilku inne samouczki, które używają starszej składni ANSI-89 (a jeśli jesteś przyzwyczajony do 89, mogą wydawać się znacznie mniej intuicyjne - ale wszystko, co mogę powiedzieć, to spróbować), ponieważ jest {116]}dużo {117]} łatwiejsze do zrozumienia, gdy zapytania zaczynają się bardziej złożone. Po co go używać? Czy jest poprawa wydajności? krótka odpowiedź brzmi nie, ale jest łatwiejsza do odczytania, gdy się do niej przyzwyczaisz. Łatwiej jest odczytać zapytania napisane przez innych ludzi używających tej składni.

Zamierzam również użyć koncepcja małego warsztatu samochodowego, który ma bazę danych do śledzenia dostępnych samochodów. Właściciel zatrudnił cię jako swojego informatyka i oczekuje, że będziesz w stanie upuścić mu dane, o które prosi w mgnieniu oka.

Zrobiłem kilka tabel wyszukiwania, które będą używane przez tabelę końcową. To da nam rozsądny model do pracy. Na początek będę uruchamiał moje zapytania na przykładowej bazie danych, która ma następującą strukturę. Postaram się myśleć o typowe błędy, które są popełniane na początku i wyjaśnić, co z nimi nie tak - a także oczywiście pokazując, jak je poprawić.

Pierwsza tabela to po prostu lista kolorów, dzięki czemu wiemy, jakie kolory mamy na podwórku samochodu.

mysql> create table colors(id int(3) not null auto_increment primary key, 
    -> color varchar(15), paint varchar(10));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from colors;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| color | varchar(15) | YES  |     | NULL    |                |
| paint | varchar(10) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
3 rows in set (0.01 sec)

mysql> insert into colors (color, paint) values ('Red', 'Metallic'), 
    -> ('Green', 'Gloss'), ('Blue', 'Metallic'), 
    -> ('White' 'Gloss'), ('Black' 'Gloss');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> select * from colors;
+----+-------+----------+
| id | color | paint    |
+----+-------+----------+
|  1 | Red   | Metallic |
|  2 | Green | Gloss    |
|  3 | Blue  | Metallic |
|  4 | White | Gloss    |
|  5 | Black | Gloss    |
+----+-------+----------+
5 rows in set (0.00 sec)

Tabela marek określa różne marki samochodów, które mogą być sprzedawane przez caryard.

mysql> create table brands (id int(3) not null auto_increment primary key, 
    -> brand varchar(15));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from brands;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| brand | varchar(15) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.01 sec)

mysql> insert into brands (brand) values ('Ford'), ('Toyota'), 
    -> ('Nissan'), ('Smart'), ('BMW');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> select * from brands;
+----+--------+
| id | brand  |
+----+--------+
|  1 | Ford   |
|  2 | Toyota |
|  3 | Nissan |
|  4 | Smart  |
|  5 | BMW    |
+----+--------+
5 rows in set (0.00 sec)

Tabela modeli obejmie różne typy samochodów, łatwiej będzie korzystać z różnych typów samochodów zamiast rzeczywistych modeli samochodów.

mysql> create table models (id int(3) not null auto_increment primary key, 
    -> model varchar(15));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from models;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| model | varchar(15) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)

mysql> insert into models (model) values ('Sports'), ('Sedan'), ('4WD'), ('Luxury');
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0

mysql> select * from models;
+----+--------+
| id | model  |
+----+--------+
|  1 | Sports |
|  2 | Sedan  |
|  3 | 4WD    |
|  4 | Luxury |
+----+--------+
4 rows in set (0.00 sec)

I wreszcie, aby związać wszystkie inne Stoły, stół, który łączy wszystko razem. Pole ID jest w rzeczywistości unikalnym numerem partii używanym do identyfikacji samochodów.

mysql> create table cars (id int(3) not null auto_increment primary key, 
    -> color int(3), brand int(3), model int(3));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from cars;
+-------+--------+------+-----+---------+----------------+
| Field | Type   | Null | Key | Default | Extra          |
+-------+--------+------+-----+---------+----------------+
| id    | int(3) | NO   | PRI | NULL    | auto_increment |
| color | int(3) | YES  |     | NULL    |                |
| brand | int(3) | YES  |     | NULL    |                |
| model | int(3) | YES  |     | NULL    |                |
+-------+--------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

mysql> insert into cars (color, brand, model) values (1,2,1), (3,1,2), (5,3,1), 
    -> (4,4,2), (2,2,3), (3,5,4), (4,1,3), (2,2,1), (5,2,3), (4,5,1);
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

mysql> select * from cars;
+----+-------+-------+-------+
| id | color | brand | model |
+----+-------+-------+-------+
|  1 |     1 |     2 |     1 |
|  2 |     3 |     1 |     2 |
|  3 |     5 |     3 |     1 |
|  4 |     4 |     4 |     2 |
|  5 |     2 |     2 |     3 |
|  6 |     3 |     5 |     4 |
|  7 |     4 |     1 |     3 |
|  8 |     2 |     2 |     1 |
|  9 |     5 |     2 |     3 |
| 10 |     4 |     5 |     1 |
+----+-------+-------+-------+
10 rows in set (0.00 sec)

To da nam wystarczająco dużo danych (mam nadzieję), aby przykryć poniższe przykłady różnych typów połączeń, a także dać wystarczająco dużo danych, aby były warte zachodu.

Więc wchodząc w to zamieszanie, szef chce znać identyfikatory wszystkich sportowych samochodów, które miał. has .

Jest to proste połączenie dwóch tabel. Mamy tabelę, która identyfikuje model i tabelę z dostępnymi zapasami w nim. Jak widać, dane w kolumnie {[26] } tabeli cars odnoszą się do kolumny models tabeli cars, którą mamy. Teraz wiemy, że tabela modeli ma ID 1 dla Sports, więc zapisujmy join.

select
    ID,
    model
from
    cars
        join models
            on model=ID

Więc to zapytanie wygląda dobrze, prawda? Zidentyfikowaliśmy dwie tabele i zawierają potrzebne nam informacje i korzystamy z połączenia to poprawnie określa, które kolumny połączyć.

ERROR 1052 (23000): Column 'ID' in field list is ambiguous

Oh noes! Błąd w naszym pierwszym zapytaniu! Tak, i to jest śliwka. Widzisz, zapytanie rzeczywiście ma właściwe kolumny, ale niektóre z nich istnieją w obu tabelach, więc baza danych jest zdezorientowana co do tego, co mamy na myśli i gdzie. Istnieją dwa rozwiązania tego problemu. Pierwszy jest prosty i przyjemny, możemy użyć tableName.columnName, aby powiedzieć bazie danych dokładnie, co mamy na myśli, w następujący sposób:

select
    cars.ID,
    models.model
from
    cars
        join models
            on cars.model=models.ID

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
|  2 | Sedan  |
|  4 | Sedan  |
|  5 | 4WD    |
|  7 | 4WD    |
|  9 | 4WD    |
|  6 | Luxury |
+----+--------+
10 rows in set (0.00 sec)

Drugi jest prawdopodobnie częściej używany i nazywa się aliasing tabeli. Tabele w tym przykładzie mają ładne i krótkie proste nazwy, ale wpisanie czegoś w stylu KPI_DAILY_SALES_BY_DEPARTMENT prawdopodobnie szybko się zestarzeje, więc prostym sposobem jest nazwanie tabeli w ten sposób: {]}

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID

Wróćmy do prośby. Jak widać mamy informacje, których potrzebujemy, ale mamy również informacje, o które nie poproszono, więc musimy zawrzeć klauzulę where w oświadczeniu, aby uzyskać tylko samochody sportowe, o które poproszono. Jako że wolę metodę table alias raczej niż używanie nazw tabel w kółko, będę się go trzymać od tego momentu.

Oczywiście, musimy dodać klauzulę where do naszego zapytania. Samochody sportowe możemy rozpoznać po ID=1 lub model='Sports'. Ponieważ ID jest indeksowane i klucz główny (i zdarza się, że jest mniej wpisywania), możemy użyć tego w naszym zapytaniu.

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID
where
    b.ID=1

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)

Bingo! Szef jest szczęśliwy. Oczywiście, będąc szefem i nigdy nie będąc zadowolonym z tego, o co prosił, patrzy na informacje, a następnie mówi[116]}chcę kolorów jako cóż .

Ok, więc mamy już napisaną część naszego zapytania, ale musimy użyć trzeciej tabeli, która jest kolorami. Teraz nasza główna tabela informacyjna cars Przechowuje identyfikator koloru samochodu, a to odsyła do kolumny colors ID. Tak więc, w sposób podobny do oryginału, możemy dołączyć trzecią tabelę: {]}

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
where
    b.ID=1

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)

Cholera, chociaż tabela została poprawnie połączona i powiązane kolumny zostały połączone, zapomnieliśmy wyciągnąć rzeczywiste informacje z nowej tabeli, że po prostu połączone.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
where
    b.ID=1

+----+--------+-------+
| ID | model  | color |
+----+--------+-------+
|  1 | Sports | Red   |
|  8 | Sports | Green |
| 10 | Sports | White |
|  3 | Sports | Black |
+----+--------+-------+
4 rows in set (0.00 sec)

/ Align = "left" / Teraz wyjaśnię to trochę bardziej szczegółowo. Jak widzisz, klauzula from w naszym oświadczeniu łączy naszą główną tabelę (często używam tabeli zawierającej informacje, a nie tabeli lookup lub tabeli wymiarów. Zapytanie będzie działać tak samo dobrze z tabelami, ale ma mniej sensu, gdy wrócimy do tego zapytania, aby przeczytać go w ciągu kilku miesięcy, więc często najlepiej jest spróbować napisać zapytanie to będzie miłe i łatwe do zrozumienia - ułóż je intuicyjnie, użyj ładnego wcięcia, aby wszystko było tak jasne, jak to tylko możliwe. Jeśli dalej uczysz innych, spróbuj zaszczepić te cechy w ich zapytaniach - zwłaszcza jeśli będziesz ich rozwiązywać.

Jest całkowicie możliwe łączenie coraz większej liczby tabel w ten sposób.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1

Chociaż zapomniałem dodać tabelę, w której możemy chcieć połączyć więcej niż jedną kolumnę w instrukcji join, oto przykład. Jeśli tabela models miała modele specyficzne dla marki, a zatem miała również kolumnę o nazwie brand, która łączyła się z tabelą brands w polu ID, można to zrobić tak:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
            and b.brand=d.ID
where
    b.ID=1

Powyższe zapytanie nie tylko łączy połączone tabele z główną tabelą cars, ale także określa połączenia pomiędzy już połączonymi tabelami. Jeśli tego nie zrobiono, wynik nazywa się połączeniem kartezjańskim - czyli dba mówi źle. Złącze kartezjańskie to takie, w którym zwracane są wiersze ponieważ informacje nie mówią bazie danych, jak ograniczyć wyniki, więc zapytanie zwraca wszystkie wiersze, które pasują do kryteriów.

Więc, aby podać przykład złączenia kartezjańskiego, uruchom następujące zapytanie:

select
    a.ID,
    b.model
from
    cars a
        join models b

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  1 | Sedan  |
|  1 | 4WD    |
|  1 | Luxury |
|  2 | Sports |
|  2 | Sedan  |
|  2 | 4WD    |
|  2 | Luxury |
|  3 | Sports |
|  3 | Sedan  |
|  3 | 4WD    |
|  3 | Luxury |
|  4 | Sports |
|  4 | Sedan  |
|  4 | 4WD    |
|  4 | Luxury |
|  5 | Sports |
|  5 | Sedan  |
|  5 | 4WD    |
|  5 | Luxury |
|  6 | Sports |
|  6 | Sedan  |
|  6 | 4WD    |
|  6 | Luxury |
|  7 | Sports |
|  7 | Sedan  |
|  7 | 4WD    |
|  7 | Luxury |
|  8 | Sports |
|  8 | Sedan  |
|  8 | 4WD    |
|  8 | Luxury |
|  9 | Sports |
|  9 | Sedan  |
|  9 | 4WD    |
|  9 | Luxury |
| 10 | Sports |
| 10 | Sedan  |
| 10 | 4WD    |
| 10 | Luxury |
+----+--------+
40 rows in set (0.00 sec)

Dobry Boże, to brzydkie. Jednakże, jeśli chodzi o bazę danych, to jest to dokładnie, o co poproszono. W zapytaniu poprosiliśmy o ID Z cars i model z models. Jednakże, ponieważ nie sprecyzowaliśmy jak aby dołączyć tabele, baza danych dopasowała co wiersz z pierwszej tabeli z co wiersz z drugiej tabeli. / Align = "center" bgcolor = "# e0ffe0 " / król Danii / / align = center / chcę tę samą listę, ale dołącz do niej również 4WDs . To jednak daje nam świetną wymówkę, by przyjrzeć się dwóm różnym sposobom osiągnięcia tego celu. Możemy dodać kolejny warunek do klauzuli where w ten sposób:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1
    or b.ID=3

Podczas gdy powyżej będzie działać doskonale, spójrzmy na to inaczej, jest to świetna wymówka, aby pokazać, jak będzie działać zapytanie union.

Wiemy, że następujące zwrócą wszystkie sportowe samochody:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1

I następujące zwróci wszystkie 4WDs:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=3

Tak więc dodając klauzulę union all pomiędzy nimi, wyniki drugiego zapytania zostaną dołączone do wyników pierwszego zapytania.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1
union all
select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=3

+----+--------+-------+
| ID | model  | color |
+----+--------+-------+
|  1 | Sports | Red   |
|  8 | Sports | Green |
| 10 | Sports | White |
|  3 | Sports | Black |
|  5 | 4WD    | Green |
|  7 | 4WD    | White |
|  9 | 4WD    | Black |
+----+--------+-------+
7 rows in set (0.00 sec)

Jak widać, wyniki pierwszego zapytania są zwracane jako pierwsze, następnie wyniki drugiego zapytania.

W tym przykładzie byłoby oczywiście znacznie łatwiej po prostu użyć pierwszego zapytania, ale union zapytania mogą być świetne dla konkretnych przypadków. Są one świetnym sposobem na zwrócenie konkretnych wyników z tabel z tabel, które nie są łatwo ze sobą połączone - lub w tym przypadku całkowicie niepowiązanych tabel. Istnieje jednak kilka zasad do przestrzegania.

• typy kolumn z pierwszego zapytania muszą być zgodne z typami kolumn z każdego innego zapytania poniżej.
• nazwy kolumn z pierwszego zapytania zostaną użyte do identyfikacji całego zestawu wyników.
• Liczba kolumn w każdym zapytaniu musi być taka sama.

Teraz możesz zastanawiać się, jaka jest różnica między używaniem union a union all. Zapytanie union usunie duplikaty, podczas gdy zapytanie union all nie usunie. Oznacza to, że jest mały hit wydajności przy użyciu union over union all, ale wyniki mogą być warte Nie będę spekulował na ten temat.

W tej notce, może warto zwrócić uwagę na kilka dodatkowych uwag tutaj.

• jeśli chcemy zamówić wyniki, możemy użyć order by, ale nie możesz już używać aliasu. W powyższym zapytaniu dodanie order by a.ID spowodowałoby błąd-jeśli chodzi o wyniki, kolumna nazywa się ID, a nie a.ID - mimo że w obu zapytaniach użyto tego samego aliasu.
• możemy mieć tylko jedną order by oświadczenie, i to musi być jako ostatnie oświadczenie.

W następnych przykładach dodaję kilka dodatkowych wierszy do naszych tabel.

Dodałem Holden do tabeli marek. Dodałem również wiersz do cars, który ma color wartość 12 - który nie ma odniesienia w tabeli kolorów.

/ Align = "center" bgcolor = "# e0ffe0 " / cesarz Chin / / align = center / '- Typowe, po prostu dostajemy się do interesującego część naszej dyskusji i szef chce więcej pracy.

Racja, więc pierwszą rzeczą, którą musimy zrobić, to uzyskać pełną listę możliwych marek.

select
    a.brand
from
    brands a

+--------+
| brand  |
+--------+
| Ford   |
| Toyota |
| Nissan |
| Smart  |
| BMW    |
| Holden |
+--------+
6 rows in set (0.00 sec)

Teraz, kiedy dołączymy to do naszej tabeli samochodów, otrzymamy następujący wynik:

select
    a.brand
from
    brands a
        join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+
| brand  |
+--------+
| BMW    |
| Ford   |
| Nissan |
| Smart  |
| Toyota |
+--------+
5 rows in set (0.00 sec)

Co jest oczywiście problemem - nie widzimy żadnej wzmianki o uroczej Holden marce, którą dodałem.

To dlatego, że połączenie szuka pasujących wierszy w obu tabelach. Ponieważ nie ma danych w samochodach, które są typu Nie jest zwracana. Tutaj możemy użyć outer join. To zwróci wszystkie wyniki z jednej tabeli niezależnie od tego, czy są one dopasowane w drugiej tabeli, czy nie:

select
    a.brand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+
| brand  |
+--------+
| BMW    |
| Ford   |
| Holden |
| Nissan |
| Smart  |
| Toyota |
+--------+
6 rows in set (0.00 sec)

Teraz, kiedy to mamy, możemy dodać uroczą funkcję agregacji, aby policzyć i zdjąć szefa z nas na chwilę.

select
    a.brand,
    count(b.id) as countOfBrand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+--------------+
| brand  | countOfBrand |
+--------+--------------+
| BMW    |            2 |
| Ford   |            2 |
| Holden |            0 |
| Nissan |            1 |
| Smart  |            1 |
| Toyota |            5 |
+--------+--------------+
6 rows in set (0.00 sec)

I z tym, away szef skulks.

Teraz, aby wyjaśnić to bardziej szczegółowo, zewnętrzne połączenia mogą być typu left lub right. / Align = "Left" / Prawo określa, która tabela jest w pełni włączona. A left outer join będzie zawierać wszystkie wiersze z tabeli po lewej stronie, podczas gdy (zgadłeś) a right outer join przeniesie wszystkie wyniki z tabeli po prawej stronie do wyników.

Niektóre bazy danych zezwalają na full outer join, które zwracają wyniki (dopasowane lub nie) z obu tabel, ale nie jest to obsługiwane we wszystkich bazach danych.

Teraz, prawdopodobnie domyślam się w tym momencie, zastanawiasz się, czy jesteś można łączyć typy przyłączeń w zapytaniu - a odpowiedź brzmi tak, absolutnie można.

select
    b.brand,
    c.color,
    count(a.id) as countOfBrand
from
    cars a
        right outer join brands b
            on b.ID=a.brand
        join colors c
            on a.color=c.ID
group by
    a.brand,
    c.color

+--------+-------+--------------+
| brand  | color | countOfBrand |
+--------+-------+--------------+
| Ford   | Blue  |            1 |
| Ford   | White |            1 |
| Toyota | Black |            1 |
| Toyota | Green |            2 |
| Toyota | Red   |            1 |
| Nissan | Black |            1 |
| Smart  | White |            1 |
| BMW    | Blue  |            1 |
| BMW    | White |            1 |
+--------+-------+--------------+
9 rows in set (0.00 sec)

Więc dlaczego nie tego oczekiwano? Dzieje się tak dlatego, że chociaż wybraliśmy zewnętrzne połączenie od samochodów do marek, nie zostało ono określone w połączeniu do kolorów - tak, że konkretne połączenie przywróci tylko wyniki, które pasują do obu tabel.

Oto zapytanie, które zadziała, aby uzyskać oczekiwane wyniki:

select
    a.brand,
    c.color,
    count(b.id) as countOfBrand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
        left outer join colors c
            on b.color=c.ID
group by
    a.brand,
    c.color

+--------+-------+--------------+
| brand  | color | countOfBrand |
+--------+-------+--------------+
| BMW    | Blue  |            1 |
| BMW    | White |            1 |
| Ford   | Blue  |            1 |
| Ford   | White |            1 |
| Holden | NULL  |            0 |
| Nissan | Black |            1 |
| Smart  | White |            1 |
| Toyota | NULL  |            1 |
| Toyota | Black |            1 |
| Toyota | Green |            2 |
| Toyota | Red   |            1 |
+--------+-------+--------------+
11 rows in set (0.00 sec)

Jak widać, mamy dwa zewnętrzne złącza w zapytanie i wyniki idą zgodnie z oczekiwaniami.

A co z innymi rodzajami połączeń, o które pytasz? A co z skrzyżowaniami?

Cóż, nie wszystkie bazy danych obsługują intersection, ale prawie wszystkie bazy danych pozwolą Ci stworzyć przecięcie poprzez join (lub przynajmniej dobrze skonstruowane polecenie where).

Przecięcie jest rodzajem połączenia nieco podobnego do {[48] } jak opisano powyżej - ale różnica polega na tym, że tylko zwraca rzędy danych, które są identyczne (i mam na myśli identyczne) między różnymi indywidualnymi zapytaniami połączonymi przez Unię. Zwracane będą tylko wiersze, które są identyczne pod każdym względem.

Prosty przykład byłby taki:

select
    *
from
    colors
where
    ID>2
intersect
select
    *
from
    colors
where
    id<4

Podczas gdy zwykłe zapytanie union zwróci wszystkie wiersze tabeli (pierwsze zapytanie zwraca cokolwiek ponad ID>2, a drugie cokolwiek ma ID<4), co spowoduje pełny zestaw, zapytanie intersektowe zwróci tylko pasujący wiersz id=3 ponieważ spełnia oba kryteria.

Teraz, jeśli twoja baza danych nie obsługuje zapytania intersect, powyższe można łatwo połączyć z następującym zapytaniem:

select
    a.ID,
    a.color,
    a.paint
from
    colors a
        join colors b
            on a.ID=b.ID
where
    a.ID>2
    and b.ID<4

+----+-------+----------+
| ID | color | paint    |
+----+-------+----------+
|  3 | Blue  | Metallic |
+----+-------+----------+
1 row in set (0.00 sec)

Jeśli chcesz wykonać przecięcie dwóch różnych tabel przy użyciu bazy danych, która nie obsługuje zapytania przecięcia, musisz utworzyć połączenie na każdej kolumnie tabel.