SQL Cross Join

Dit artikel geeft een overzicht van de CROSS JOIN in SQL, evenals enkele basisvoorbeelden.

De SQL CROSS JOIN (of FULL OUTER JOIN ) retourneert rijen die elke rij uit de eerste tabel combineren met elke rij uit de tweede tabel.

Met andere woorden, het retourneert het Cartesiaanse product van rijen uit tabellen in de join.

Syntaxis

U specificeert een cross join in de FROM clausule.

De syntaxis gaat als volgt:

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

Voorbeeld 1

Hier is een voorbeeld om te demonstreren.

Voorbeeldgegevens

Ten eerste zijn hier de tabellen die we voor het voorbeeld zullen gebruiken.

De t1 tafel:

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

De t2 tafel:

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

The Cross Join Query

Hier is een voorbeeld van het uitvoeren van een cross join tegen die twee tafels.

SELECT * FROM t1 
CROSS JOIN t2;

Resultaat:

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

Onze zoekopdracht retourneert dus 9 rijen, ook al zijn er maar 3 rijen in elke tabel.

Dit komt door de manier waarop de kruisverbinding werkt. Het aantal geretourneerde rijen is het aantal rijen in de linkertabel, vermenigvuldigd met het aantal rijen in de rechtertabel.

Kijk hoe het door de linkertabel gaat en elke rij in de rechtertabel voor elke rij in de linkertabel uitvoert.

Dit heeft hetzelfde effect als het volgende doen:

SELECT * FROM t1, t2

Resultaat:

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

Voorbeeld 2

Dit is wat er gebeurt als we een WHERE . toevoegen clausule aan onze cross join.

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

Resultaat:

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

Voorbeeld 3

Stel dat we de volgende tabellen hebben.

De PetTypes tafel:

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

De Pets tafel:

+---------+-------------+-----------+-----------+------------+
| 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)

In dit geval is de Pets.PetTypeId kolom is een externe sleutel van de PetTypes.PetTypeId kolom.

Hier is een voorbeeld van het uitvoeren van een cross join op die twee tabellen, maar met een WHERE clausule.

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

Resultaat:

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

De WHERE . toevoegen clausule aan de cross join maakte er een inner join van.

Dit is wat er gebeurt als we de WHERE . verwijderen clausule.

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

Resultaat:

+-----------+-----------+
| 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)

We krijgen een cross join die 32 rijen retourneert.