Jointure interne SQL

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

Le SQL INNER JOIN renvoie des lignes lorsqu'au moins une ligne dans les deux tables correspond à la condition de jointure. Il supprime les lignes sans correspondance des deux tables. Il s'agit du type de jointure par défaut.

Syntaxe

Il existe deux manières de spécifier une jointure interne :dans le FROM clause (en utilisant la INNER JOIN syntaxe), ou en utilisant le WHERE clause.

Pour spécifier une jointure interne dans le FROM clause :

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

Pour spécifier une jointure interne dans WHERE clause :

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

Vous trouverez ci-dessous des exemples de chacun.

Exemples

Ici, nous avons des exemples pour chaque méthode de spécification d'une jointure interne.

Exemple de données

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

Les PetTypes tableau :

+---------------------+-----------+| IDTypeAnimal | TypeAnimal ||-------------+-----------|| 1 | Oiseau || 2 | Chat || 3 | Chien || 4 | Lapin |+-------------+-----------+(4 lignes concernées)

Les Pets tableau :

+---------+-------------+-----------+---------- -+------------+| ID animal | IDTypeAnimal | Identifiant du propriétaire | NomAnimal | Date de naissance ||---------+------------+-----------+----------- +--------------------|| 1 | 2 | 3 | Moelleux | 2020-11-20 || 2 | 3 | 3 | Récupérer | 2019-08-16 || 3 | 2 | 2 | gratter | 2018-10-01 || 4 | 3 | 3 | remuer | 2020-03-15 || 5 | 1 | 1 | Tweeter | 2020-11-28 || 6 | 3 | 4 | Moelleux | 2020-09-17 || 7 | 3 | 2 | Écorce | NUL || 8 | 2 | 4 | Miaou | NULL |+---------+-------------+-----------+----------- +--------------------+(8 lignes concernées)

Les Owners tableau :

+-----------+-------------+------------+------- ---------+-------------------+| Identifiant du propriétaire   | Prénom   | Nom   | Téléphone          | E-mail             ||-----------+-------------+------------+-------- --------+-------------------|| 1         | Homère       | Conner   | (308) 555-0100 | [email protected] || 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  || 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              || 4         | Boris       | Atout      | (349) 611-8908 | NULL              |+-----------+-------------+------------+-------- --------+-------------------+

Notez que :

Le PetTypeId colonne des Pets table est une clé étrangère de PetTypeId des PetTypes table (qui est la clé primaire de cette table).
Le OwnerId colonne des Pets table est une clé étrangère de OwnerId colonne des Owners tableau.

Exemple utilisant la syntaxe INNER JOIN

Voici un exemple de base de spécification d'une jointure interne à l'aide de INNER JOIN syntaxe.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Résultat :

-----------+-----------+| NomAnimal | TypeAnimal ||-----------+-----------|| Moelleux | Chat || Récupérer | Chien || gratter | Chat || remuer | Chien || Tweeter | Oiseau || Moelleux | Chien || Écorce | Chien || Miaou | Chat |+-----------+-----------+(8 lignes concernées)

Pour spécifier une jointure interne dans le FROM clause, nous utilisons INNER JOIN . Nous utilisons également le ON mot-clé pour définir le prédicat à évaluer pour chaque paire de lignes jointes.

Quel que soit le type de jointure, nous qualifions nos noms de colonne avec les noms de table. La raison pour laquelle nous faisons cela est d'éviter toute ambiguïté concernant les noms de colonne entre les tables. Les deux tables peuvent avoir des colonnes du même nom (comme dans notre exemple), et dans de tels cas, le SGBD ne saura pas à quelle colonne vous faites référence. Préfixer les noms de colonne avec leurs noms de table garantit que vous faites référence à la bonne colonne et évite toute erreur pouvant résulter d'une ambiguïté sur la colonne à laquelle vous faites référence.

Dans cet exemple, les deux tables ont un PetTypeId colonne. Le Pets.PetTypeId colonne est une clé étrangère vers PetTypes.PetTypeId colonne, qui est la clé primaire de cette table.

Dans cet exemple, nous pouvons voir que tous les animaux sont renvoyés, mais que tous les types d'animaux ne sont pas renvoyés. Il n'y a pas de lapins dans les Pets table, et donc les Rabbits le type d'animal n'est pas renvoyé.

La raison pour laquelle les Rabbits type n'est pas renvoyé parce que le INNER JOIN ne renvoie des lignes que lorsqu'il y a au moins une ligne dans les deux tables qui correspondent à la condition de jointure. Dans ce cas, Rabbits est dans une seule table (le PetTypes tableau).

Le type de jointure est facultatif

Notez que le type de jointure est facultatif. Par conséquent, la plupart (sinon tous) les SGBD vous permettent d'omettre le INNER mot-clé. Lorsque vous omettez ceci (c'est-à-dire ne spécifiez que JOIN ), il est supposé être une jointure interne.

Par conséquent, nous pourrions réécrire l'exemple ci-dessus :

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets
JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;

Formatage

Comme pour toute instruction SQL, vous pouvez utiliser des espaces et des retraits, etc. pour formater vos requêtes.

Par exemple, le FROM clause peut être sur une ligne entière si vous préférez :

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId;

Lorsque vous écrivez des tableaux plus volumineux qui joignent plusieurs tableaux, l'indentation peut être très utile.

Exemple utilisant la clause WHERE

La jointure ci-dessus peut également être appelée équi-jointure . Une équi-jointure est une jointure contenant uniquement des comparaisons d'égalité dans le prédicat de jointure.

Voici un exemple de spécification d'une jointure interne à l'aide de WHERE clause :

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

Résultat :

+-----------+-----------+| NomAnimal   | TypeAnimal   ||-----------+-----------|| Moelleux    | Chat       || Récupérer     | Chien       || Gratter   | Chat       || Bouger       | Chien       || Tweeter     | Oiseau      || Moelleux    | Chien       || Écorce      | Chien       || Miaou      | Chat       |+-----------+-----------+(8 lignes concernées)

Cela a renvoyé le même résultat que l'exemple précédent.

Ici, nous avons simplement fourni une liste des tables séparées par des virgules, puis un WHERE état. Si nous avions omis le WHERE condition, nous aurions fini avec un CROSS JOIN .

De nombreux débutants trouvent la syntaxe ci-dessus beaucoup plus facile à comprendre que le INNER JOIN syntaxe. N'hésitez pas à utiliser cette syntaxe si vous préférez, cependant, sachez que la plupart des professionnels de SQL préfèrent utiliser le INNER JOIN syntaxe de l'exemple précédent..

Jointure interne sur 3 tables

Voici un exemple d'exécution d'une jointure interne sur 3 tables.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
INNER JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Résultat :

+-----------+-----------+---------------+| NomAnimal   | Type d'animal de compagnie   | Propriétaire       ||-----------+-----------+---------------|| Moelleux    | Chat       | Nancy Simpson || Récupérer     | Chien       | Nancy Simpson || Gratter   | Chat       | Bart Pitt     || Bouger       | Chien       | Nancy Simpson || Tweeter     | Oiseau      | Homer Connery || Moelleux    | Chien       | Boris Trump   || Écorce      | Chien       | Bart Pitt     || Miaou      | Chat       | Boris Trump   |+-----------+-----------+---------------+(8 lignes concernées) 
 Dans cet exemple, nous avons apporté les Owners table dans le mix car nous avions besoin de cette requête pour renvoyer des informations sur le propriétaire. 
 
 Pour utiliser une troisième table, nous n'avons fait qu'ajouter un autre INNER JOIN... ON argument avec les détails pertinents de la table/colonne.
 
 Dans ce cas, j'ai utilisé le CONCAT() de T-SQL pour concaténer deux colonnes, mais cela n'a aucun rapport avec la jointure.