Guide des jointures MySQL : maîtrise les jointures avec des exemples

Si tu as déjà essayé de récupérer des données depuis plusieurs tables MySQL et que tu t’es senti perdu, tu n’es pas seul. Les jointures font partie de ces concepts qui semblent intimidants au début, mais qui deviennent incroyablement puissants une fois qu’on les a bien en main.

Vois les jointures comme une façon de dire à MySQL « hé, je veux récupérer des données de cette table ET de celle-là, mais seulement là où certaines conditions correspondent ». Une fois les schémas de base compris, tu combineras des données comme un pro.

🔖 Référence rapide : Besoin d’un aide-mémoire ? Jette un œil à notre antisèche des JOIN SQL avec tous les types de JOIN, des diagrammes visuels et des exemples de code au même endroit.

L’arbre généalogique des jointures

Au fond, une jointure te permet de combiner des lignes de différentes tables quand elles ont quelque chose en commun. C’est comme présenter deux groupes d’amis qui ont des connaissances communes.

Voici les types de jointures qu’on va voir :

• INNER JOIN - Montre-moi uniquement les enregistrements présents dans les deux tables
• LEFT JOIN - Montre-moi tout de la table de gauche, plus les correspondances de la droite
• RIGHT JOIN - L’inverse de LEFT JOIN (même si, honnêtement, la plupart des gens inversent simplement leurs tables)
• FULL JOIN - Tout des deux tables (MySQL nous fait un peu travailler pour celle-ci)
• CROSS JOIN - Toutes les combinaisons possibles (à utiliser avec prudence !)
• SELF JOIN - Quand une table doit se parler à elle-même

INNER JOIN - La perfectionniste

INNER JOIN est exigeante. Elle ne te renvoie que les lignes pour lesquelles les deux tables ont des données correspondantes. Vois-la comme l’intersection d’un diagramme de Venn.

Exemple :

Travaillons avec deux tables simples - employees et departments :

-- Employees Table
+----+----------+-------------+
| id | name     | department_id|
+----+----------+-------------+
| 1  | Alice    | 1           |
| 2  | Bob      | 2           |
| 3  | Charlie  | NULL        |
+----+----------+-------------+

-- Departments Table
+----+-------------+
| id | department  |
+----+-------------+
| 1  | HR          |
| 2  | IT          |
+----+-------------+

Requête INNER JOIN :

SELECT employees.name, departments.department
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

Résultat :

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

LEFT JOIN - L’inclusive

LEFT JOIN est plus généreuse qu’INNER JOIN. Elle dit « je veux tout de la table de gauche, et s’il y a des correspondances dans la table de droite, super ! Sinon, je mets juste NULL. »

Remarque que Charlie apparaît cette fois, même s’il n’a pas de département :

Requête LEFT JOIN :

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id;

Résultat :

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

RIGHT JOIN - Le revers de la médaille

RIGHT JOIN, c’est simplement LEFT JOIN avec les tables inversées. La plupart des développeurs l’évitent et réorganisent plutôt leur clause FROM - c’est moins déroutant.

Requête RIGHT JOIN :

SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Résultat :

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

FULL JOIN - L’approche « tout y passe »

C’est là que MySQL devient un peu pénible : il n’a pas de FULL JOIN intégré. Mais on peut le simuler avec une astuce à base d’UNION :

Simulation de FULL JOIN :

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id
UNION
SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Résultat :

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

CROSS JOIN - La créatrice de chaos

CROSS JOIN, c’est comme cet ami qui veut présenter tout le monde à tout le monde lors d’une soirée. Elle associe chaque ligne de la première table à chaque ligne de la seconde. Avec 3 employés et 2 départements, on obtient 6 combinaisons :

Requête CROSS JOIN :

SELECT employees.name, departments.department
FROM employees
CROSS JOIN departments;

Résultat :

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Alice | IT         |
| Bob   | HR         |
| Bob   | IT         |
| Charlie | HR       |
| Charlie | IT       |
+-------+------------+

SELF JOIN - L’introspective

Les auto-jointures se produisent quand une table fait référence à elle-même. L’exemple classique est une table d’employés où certains employés en managent d’autres.

Exemple :

Voici une table managers où mgr_id pointe vers une autre ligne de la même table :

-- Managers Table
+----+----------+--------+
| id | name     | mgr_id |
+----+----------+--------+
| 1  | Tom      | NULL   |
| 2  | Jerry    | 1      |
| 3  | Spike    | 1      |
+----+----------+--------+

Requête SELF JOIN :

SELECT m1.name AS manager, m2.name AS employee
FROM managers m1
LEFT JOIN managers m2 ON m1.id = m2.mgr_id;

Résultat :

+---------+----------+
| manager | employee |
+---------+----------+
| Tom     | Jerry    |
| Tom     | Spike    |
| Jerry   | NULL     |
| Spike   | NULL     |
+---------+----------+

Pour conclure

Les jointures peuvent sembler écrasantes au début, mais ce ne sont en réalité que différentes façons de dire « montre-moi des données de plusieurs tables selon ces règles ». Commence par les jointures INNER et LEFT : elles couvriront 90 % de tes besoins.

La meilleure façon de te familiariser avec les jointures, c’est de t’entraîner avec tes propres données. Crée quelques tables de test, ajoute des données d’exemple et commence à expérimenter. Très vite, tu feras des jointures à gauche comme à droite (jeu de mots assumé).

Et n’oublie pas : si ta jointure renvoie beaucoup plus de lignes que prévu, tu as probablement fait un CROSS JOIN par accident. On est tous passés par là !