Jointure croisée SQL

Cet article donne un aperçu du CROSS JOIN en SQL, ainsi que quelques exemples de base.

Le SQL CROSS JOIN (ou FULL OUTER JOIN ) renvoie des lignes qui combinent chaque ligne de la première table avec chaque ligne de la seconde table.

En d'autres termes, il renvoie le produit cartésien des lignes des tables de la jointure.

Syntaxe

Vous spécifiez une jointure croisée dans le FROM clause.

La syntaxe ressemble à ceci :

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

Exemple 1

Voici un exemple pour illustrer.

Exemple de données

Tout d'abord, voici les tableaux que nous utiliserons pour l'exemple.

Le t1 tableau :

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

Le t2 tableau :

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

La requête de jointure croisée

Voici un exemple d'exécution d'une jointure croisée sur ces deux tables.

SELECT * FROM t1 
CROSS JOIN t2;

Résultat :

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

Notre requête renvoie donc 9 lignes, même s'il n'y a que 3 lignes dans chaque table.

Cela est dû au fonctionnement de la jointure croisée. Le nombre de lignes renvoyées correspond au nombre de lignes dans le tableau de gauche, multiplié par le nombre de lignes dans le tableau de droite.

Voyez comment il parcourt le tableau de gauche, en affichant chaque ligne du tableau de droite pour chaque ligne du tableau de gauche.

Cela a le même effet que de faire ce qui suit :

SELECT * FROM t1, t2

Résultat :

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

Exemple 2

Voici ce qui se passe si nous ajoutons un WHERE clause à notre jointure croisée.

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

Résultat :

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

Exemple 3

Supposons que nous ayons les tables suivantes.

Les PetTypes tableau :

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

Les Pets tableau :

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

Dans ce cas, le Pets.PetTypeId colonne est une clé étrangère de PetTypes.PetTypeId colonne.

Maintenant, voici un exemple d'exécution d'une jointure croisée sur ces deux tables, mais en utilisant un WHERE clause.

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

Résultat :

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

Ajouter le WHERE clause à la jointure croisée l'a transformée en jointure interne.

Voici ce qui se passe si nous supprimons le WHERE clause.

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

Résultat :

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

Nous obtenons une jointure croisée qui renvoie 32 lignes.