Połączenie krzyżowe SQL

Ten artykuł zawiera omówienie CROSS JOIN w SQL, a także kilka podstawowych przykładów.

SQL CROSS JOIN (lub FULL OUTER JOIN ) zwraca wiersze, które łączą każdy wiersz z pierwszej tabeli z każdym wierszem z drugiej tabeli.

Innymi słowy, zwraca iloczyn kartezjański wierszy z tabel w łączeniu.

Składnia

Określasz sprzężenie krzyżowe w FROM klauzula.

Składnia wygląda tak:

SELECT *
FROM Table1 CROSS JOIN Table2 
ON Table1.Column = Table2.Column;

Przykład 1

Oto przykład do zademonstrowania.

Przykładowe dane

Najpierw oto tabele, których użyjemy w przykładzie.

t1 tabela:

+--------+
| col1   |
|--------|
| a      |
| b      |
| c      |
+--------+

t2 tabela:

+--------+
| col1   |
|--------|
| 1      |
| 2      |
| 3      |
+--------+

Zapytanie o połączenie krzyżowe

Oto przykład wykonania sprzężenia krzyżowego dla tych dwóch tabel.

SELECT * FROM t1 
CROSS JOIN t2;

Wynik:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Zatem nasze zapytanie zwraca 9 wierszy, mimo że w każdej tabeli są tylko 3 wiersze.

Wynika to ze sposobu, w jaki działa łączenie krzyżowe. Liczba zwróconych wierszy to liczba wierszy w lewej tabeli pomnożona przez liczbę wierszy w prawej tabeli.

Zobacz, jak iteruje po lewej tabeli, wyświetlając każdy wiersz w prawej tabeli dla każdego wiersza w lewej tabeli.

Daje to taki sam efekt, jak wykonanie następujących czynności:

SELECT * FROM t1, t2

Wynik:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Przykład 2

Oto, co się stanie, jeśli dodamy WHERE klauzula o naszym połączeniu krzyżowym.

SELECT * FROM t1 
CROSS JOIN t2
WHERE t1.col1 = 'a';

Wynik:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| a      | 2      |
| a      | 3      |
+--------+--------+
(3 rows affected)

Przykład 3

Załóżmy, że mamy następujące tabele.

PetTypes tabela:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Pets tabela:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

W tym przypadku Pets.PetTypeId kolumna jest kluczem obcym PetTypes.PetTypeId kolumna.

Oto przykład uruchomienia sprzężenia krzyżowego na tych dwóch tabelach, ale przy użyciu WHERE klauzula.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p 
CROSS JOIN PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

Wynik:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Dodawanie WHERE klauzula sprzężenia krzyżowego zmieniła je w sprzężenie wewnętrzne.

Oto, co się stanie, jeśli usuniemy WHERE klauzula.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p 
CROSS JOIN PetTypes pt;

Wynik:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Bird      |
| Fetch     | Bird      |
| Scratch   | Bird      |
| Wag       | Bird      |
| Tweet     | Bird      |
| Fluffy    | Bird      |
| Bark      | Bird      |
| Meow      | Bird      |
| Fluffy    | Cat       |
| Fetch     | Cat       |
| Scratch   | Cat       |
| Wag       | Cat       |
| Tweet     | Cat       |
| Fluffy    | Cat       |
| Bark      | Cat       |
| Meow      | Cat       |
| Fluffy    | Dog       |
| Fetch     | Dog       |
| Scratch   | Dog       |
| Wag       | Dog       |
| Tweet     | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Dog       |
| Fluffy    | Rabbit    |
| Fetch     | Rabbit    |
| Scratch   | Rabbit    |
| Wag       | Rabbit    |
| Tweet     | Rabbit    |
| Fluffy    | Rabbit    |
| Bark      | Rabbit    |
| Meow      | Rabbit    |
+-----------+-----------+
(32 rows affected)

Otrzymujemy sprzężenie krzyżowe, które zwraca 32 wiersze.