Tutoriel sur les jointures en SQL

SQL Server est un système de gestion de base de données relationnelle. L’un des principes clés d’une base relationnelle est que les données sont réparties sur plusieurs tables.

Pour extraire les informations dont nous avons besoin, nous devons pouvoir joindre ces tables. On utilise des clés primaires et étrangères pour effectuer ces jointures.

Clé primaire

Une clé primaire est une colonne qui identifie de façon unique chaque ligne d’une table. Cette unicité peut être obtenue via un entier séquentiel (colonne identité). Parfois, des colonnes existantes contiennent naturellement des valeurs uniques et peuvent être utilisées.

Dans l’exemple ci-dessous, on voit les premières lignes de la table artist. Elle comporte deux colonnes, artist_id et name. La colonne artist_id sert de clé primaire pour cette table : c’est une colonne entière et chaque valeur est différente.

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

Regardons maintenant la table album. Reconnaissez-vous la clé primaire ? Oui, c’est la colonne album_id. Il est courant de nommer une clé primaire « nom-de-table underscore id ». Mais vous aurez aussi remarqué la présence d’une colonne artist_id. Elle contient également des entiers et porte le même nom que la colonne artist_id de la table artist. Qu’est-ce que cela implique ?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Clés étrangères

D’après ce résultat, il est clair que la colonne artist_id de la table artist joue le rôle de Foreign_key pour la table album. La contrainte FOREIGN KEY empêche les actions qui briseraient les liens entre tables.

• table artist

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

• table album

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Cela signifie que lorsque l’artist_id de la table album correspond à l’artist_id de la table artist, ces lignes peuvent être reliées via une JOIN.

Joindre album et artist

Les lignes 1 et 4 de la table artist ont un artist_id égal à 1. L’artist_id 1 dans la table artist correspond à AC/DC. Ainsi, en joignant les deux tables, on récupère les informations d’album depuis la table album et les informations d’artiste correspondantes depuis la table artist, reliées via le champ artist_id, commun aux deux tables.

C’est ce qu’on appelle une jointure inner.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|

Nous avons joint les tables album et artist en faisant correspondre l’artist_id de la table artist avec l’artist_id de la table album.

Lorsque vous sélectionnez des colonnes portant le même nom dans des tables différentes, vous devez qualifier entièrement le nom de la colonne. Sinon, SQL Server ne saura pas de quelle table SELECT la colonne.

Pour qualifier une colonne, préfixez-la du nom de la table concernée, suivi d’un point.

Syntaxe d’une jointure interne

Voici un exemple générique pour vous rappeler la syntaxe. On sélectionne les colonnes pertinentes depuis la table principale, ici table_A, puis toute colonne supplémentaire de la table à joindre, ici table_B. Ensuite, on précise la jointure avec les mots-clés INNER JOIN et ON, en fournissant les colonnes clés nécessaires des deux tables.

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;

Sans clause WHERE

Dans cet exemple, nous ne précisons pas de clause WHERE, nous renvoyons donc TOUTES les combinaisons de TOUTES les correspondances entre les tables artist et album, toujours sur la base de la colonne artist_id, commune aux deux.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+

Jointures internes multiples

Vous pouvez également joindre plus de deux tables avec des INNER JOINS. Il suffit d’ajouter une clause INNER JOIN pour chaque combinaison de tables. Dans le code ci-dessous, nous joignons les tables A et B, puis B et C.

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;

Pour aller plus loin sur les jointures, regardez cette vidéo issue de notre cours Introduction to SQL Server.

Ce contenu est tiré du cours Introduction to SQL Server de DataCamp, par John MacKintosh.