SQL Cross Join

Questo articolo fornisce una panoramica del CROSS JOIN in SQL, oltre ad alcuni esempi di base.

Il CROSS JOIN di SQL (o FULL OUTER JOIN ) restituisce righe che combinano ogni riga della prima tabella con ogni riga della seconda tabella.

In altre parole, restituisce il prodotto cartesiano delle righe delle tabelle nel join.

Sintassi

Specificare un cross join nel FROM clausola.

La sintassi è questa:

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

Esempio 1

Ecco un esempio da dimostrare.

Dati di esempio

Innanzitutto, ecco le tabelle che useremo per l'esempio.

Il t1 tabella:

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

Il t2 tabella:

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

La query di unione incrociata

Ecco un esempio di esecuzione di un cross join su queste due tabelle.

SELECT * FROM t1 
CROSS JOIN t2;

Risultato:

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

Quindi la nostra query restituisce 9 righe, anche se ci sono solo 3 righe in ogni tabella.

Ciò è dovuto al modo in cui funziona il cross join. Il numero di righe restituito è il numero di righe nella tabella di sinistra, moltiplicato per il numero di righe nella tabella di destra.

Guarda come scorre la tabella di sinistra, generando ogni riga nella tabella di destra per ogni riga nella tabella di sinistra.

Questo ha lo stesso effetto delle seguenti operazioni:

SELECT * FROM t1, t2

Risultato:

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

Esempio 2

Ecco cosa succede se aggiungiamo un WHERE clausola al nostro cross join.

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

Risultato:

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

Esempio 3

Supponiamo di avere le seguenti tabelle.

I PetTypes tabella:

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

Gli Pets tabella:

+---------+-------------+-----------+-----------+------------+
| 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 questo caso, il Pets.PetTypeId column è una chiave esterna di PetTypes.PetTypeId colonna.

Ora, ecco un esempio di esecuzione di un cross join su queste due tabelle, ma utilizzando un WHERE clausola.

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

Risultato:

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

Aggiungendo il WHERE la clausola al cross join l'ha trasformata in un inner join.

Ecco cosa succede se rimuoviamo WHERE clausola.

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

Risultato:

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

Otteniamo un cross join che restituisce 32 righe.