Jointures SQL expliquées : INNER, LEFT, RIGHT JOIN (schémas et exercices)

Tu as une table clients et une table commandes. Comment afficher le nom de chaque client à côté de ses commandes ? Comment trouver les clients qui n’ont jamais commandé ? Comment repérer des commandes « orphelines » ? Toutes ces questions ont la même réponse : les jointures SQL.

Une jointure (JOIN) combine les lignes de plusieurs tables à partir d’une condition, le plus souvent l’égalité entre une clé étrangère et une clé primaire. C’est la base de toute base de données relationnelle : sans jointures, impossible d’exploiter correctement des données bien normalisées.

Le principe d’une jointure SQL

Dans une base relationnelle, on évite de répéter l’information. Plutôt que d’écrire le nom et la ville du client dans chaque commande, la table commandes contient seulement client_id, qui pointe vers clients.id. La jointure SQL reconstitue l’information au moment de la requête.

La syntaxe générale est toujours la même :

SELECT colonnes
FROM table_a AS a
[INNER | LEFT | RIGHT | CROSS] JOIN table_b AS b
    ON a.colonne = b.colonne
WHERE ...;

SELECT colonnes
FROM table_a AS a
[INNER | LEFT | RIGHT | CROSS] JOIN table_b AS b
    ON a.colonne = b.colonne
WHERE ...;

• FROM désigne la table de gauche (A) ;
• JOIN désigne la table de droite (B) ;
• ON indique la condition de jointure, c’est-à-dire comment relier les lignes ;
• les alias (c, o) rendent la requête lisible et évitent les ambiguïtés de colonnes.

Les tables de l’exemple pour tester les jointures SQL

Tous les exemples de ce tutoriel utilisent ces deux petites tables. Regarde bien les pièges glissés volontairement : David n’a aucune commande, et la commande 104 pointe vers un client 9 qui n’existe pas.

Copie ce script dans phpMyAdmin, MySQL Workbench ou DBeaver pour tester chaque requête en même temps que tu lis :

CREATE TABLE clients (
    id    INT PRIMARY KEY,
    nom   VARCHAR(50) NOT NULL,
    ville VARCHAR(50) NOT NULL
);

CREATE TABLE commandes (
    id        INT PRIMARY KEY,
    client_id INT NOT NULL,
    total     DECIMAL(8,2) NOT NULL,
    INDEX idx_commandes_client (client_id)
);

INSERT INTO clients VALUES
    (1, 'Alice', 'Liège'), (2, 'Bruno', 'Namur'),
    (3, 'Chloé', 'Bruxelles'), (4, 'David', 'Mons');

INSERT INTO commandes VALUES
    (101, 1, 120.00), (102, 1, 45.00),
    (103, 3, 80.00),  (104, 9, 60.00);

CREATE TABLE clients (
    id    INT PRIMARY KEY,
    nom   VARCHAR(50) NOT NULL,
    ville VARCHAR(50) NOT NULL
);

CREATE TABLE commandes (
    id        INT PRIMARY KEY,
    client_id INT NOT NULL,
    total     DECIMAL(8,2) NOT NULL,
    INDEX idx_commandes_client (client_id)
);

INSERT INTO clients VALUES
    (1, 'Alice', 'Liège'), (2, 'Bruno', 'Namur'),
    (3, 'Chloé', 'Bruxelles'), (4, 'David', 'Mons');

INSERT INTO commandes VALUES
    (101, 1, 120.00), (102, 1, 45.00),
    (103, 3, 80.00),  (104, 9, 60.00);

INNER JOIN : la jointure SQL des correspondances

INNER JOIN est la jointure la plus utilisée. Elle ne renvoie que les lignes pour lesquelles la condition ON est vraie des deux côtés. Le mot INNER est d’ailleurs facultatif : un simple JOIN est un INNER JOIN.

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
INNER JOIN commandes AS o
    ON o.client_id = c.id;

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
INNER JOIN commandes AS o
    ON o.client_id = c.id;

Remarque trois choses :

• Alice apparaît deux fois : une jointure duplique la ligne de gauche autant de fois qu’il y a de correspondances à droite. C’est normal (relation un-à-plusieurs).
• Bruno et David disparaissent : ils n’ont aucune commande.
• La commande 104 disparaît aussi : son client 9 n’existe pas.

LEFT JOIN : la jointure SQL qui garde toute la table de gauche

LEFT JOIN (ou LEFT OUTER JOIN) garde toutes les lignes de la table de gauche, même sans correspondance. Les colonnes de la table de droite valent alors NULL.

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
LEFT JOIN commandes AS o
    ON o.client_id = c.id;

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
LEFT JOIN commandes AS o
    ON o.client_id = c.id;

C’est la jointure idéale pour les rapports : « tous les clients avec leur chiffre d’affaires, même ceux à zéro ». Combine-la avec COALESCE pour remplacer le NULL par 0 :

SELECT c.nom,
       COUNT(o.id)               AS nb_commandes,
       COALESCE(SUM(o.total), 0) AS chiffre_affaires
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
GROUP BY c.id, c.nom
ORDER BY chiffre_affaires DESC;

SELECT c.nom,
       COUNT(o.id)               AS nb_commandes,
       COALESCE(SUM(o.total), 0) AS chiffre_affaires
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
GROUP BY c.id, c.nom
ORDER BY chiffre_affaires DESC;

RIGHT JOIN : la jointure SQL miroir

RIGHT JOIN fait exactement l’inverse : il garde toutes les lignes de la table de droite. Ici, il fait apparaître la commande orpheline :

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
RIGHT JOIN commandes AS o
    ON o.client_id = c.id;

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
RIGHT JOIN commandes AS o
    ON o.client_id = c.id;

FULL OUTER JOIN : la jointure SQL complète (et comment faire en MySQL)

FULL OUTER JOIN renvoie toutes les lignes des deux tables, avec des NULL là où il n’y a pas de correspondance. PostgreSQL, SQL Server et Oracle le supportent… mais MySQL et MariaDB, non. On le simule en combinant un LEFT JOIN et un RIGHT JOIN avec UNION :

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id

UNION

SELECT c.nom, o.id, o.total
FROM clients AS c
RIGHT JOIN commandes AS o ON o.client_id = c.id;

SELECT c.nom, o.id AS commande, o.total
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id

UNION

SELECT c.nom, o.id, o.total
FROM clients AS c
RIGHT JOIN commandes AS o ON o.client_id = c.id;

UNION supprime les doublons (les correspondances présentes dans les deux requêtes). Sur de gros volumes, UNION ALL est plus rapide, mais il faut alors exclure les correspondances de la seconde requête avec WHERE c.id IS NULL.

LEFT JOIN … IS NULL : la jointure SQL pour trouver ce qui manque

C’est la jointure la plus utile au quotidien, et la moins connue. En ajoutant WHERE b.id IS NULL à un LEFT JOIN, tu obtiens les lignes de gauche sans correspondance : clients sans commande, articles jamais vendus, utilisateurs inactifs…

SELECT c.id, c.nom
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
WHERE o.id IS NULL;

SELECT c.id, c.nom
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
WHERE o.id IS NULL;

La même logique, inversée, détecte les données orphelines (commandes dont le client a été supprimé) :

SELECT o.*
FROM commandes AS o
LEFT JOIN clients AS c ON c.id = o.client_id
WHERE c.id IS NULL;

SELECT o.*
FROM commandes AS o
LEFT JOIN clients AS c ON c.id = o.client_id
WHERE c.id IS NULL;

Alternative équivalente avec NOT EXISTS, souvent tout aussi rapide et parfois plus lisible :

SELECT c.id, c.nom
FROM clients AS c
WHERE NOT EXISTS (
    SELECT 1 FROM commandes AS o WHERE o.client_id = c.id
);

SELECT c.id, c.nom
FROM clients AS c
WHERE NOT EXISTS (
    SELECT 1 FROM commandes AS o WHERE o.client_id = c.id
);

CROSS JOIN : la jointure SQL de toutes les combinaisons

CROSS JOIN n’a pas de condition : il produit le produit cartésien, c’est-à-dire toutes les combinaisons possibles. 4 tailles × 5 couleurs = 20 lignes. C’est parfait pour générer un catalogue de variantes, un calendrier ou une grille de planning :

SELECT t.taille, c.couleur, CONCAT('TS-', t.taille, '-', c.couleur) AS sku
FROM tailles AS t
CROSS JOIN couleurs AS c
ORDER BY t.ordre, c.couleur;

SELECT t.taille, c.couleur, CONCAT('TS-', t.taille, '-', c.couleur) AS sku
FROM tailles AS t
CROSS JOIN couleurs AS c
ORDER BY t.ordre, c.couleur;

SELF JOIN : joindre une table avec elle-même

Un SELF JOIN n’est pas un mot-clé, mais une technique : on joint une table à elle-même grâce à deux alias différents. Exemple classique, une table d’employés où chaque employé a un responsable :

SELECT e.nom AS employe,
       r.nom AS responsable
FROM employes AS e
LEFT JOIN employes AS r ON r.id = e.responsable_id
ORDER BY responsable, employe;

SELECT e.nom AS employe,
       r.nom AS responsable
FROM employes AS e
LEFT JOIN employes AS r ON r.id = e.responsable_id
ORDER BY responsable, employe;

Le LEFT JOIN permet de garder la directrice, qui n’a pas de responsable (responsable_id à NULL). On utilise aussi le self join pour comparer des lignes entre elles : produits plus chers que la moyenne de leur catégorie, mesures consécutives d’un capteur, doublons dans une table…

Jointures SQL sur 3 tables ou plus

Les jointures s’enchaînent naturellement. Ajoutons une table lignes_commande et une table produits pour obtenir le détail complet d’une commande :

SELECT c.nom        AS client,
       o.id         AS commande,
       p.libelle    AS produit,
       l.quantite,
       l.quantite * p.prix AS sous_total
FROM commandes AS o
INNER JOIN clients         AS c ON c.id = o.client_id
INNER JOIN lignes_commande AS l ON l.commande_id = o.id
INNER JOIN produits        AS p ON p.id = l.produit_id
WHERE o.id = 101;

SELECT c.nom        AS client,
       o.id         AS commande,
       p.libelle    AS produit,
       l.quantite,
       l.quantite * p.prix AS sous_total
FROM commandes AS o
INNER JOIN clients         AS c ON c.id = o.client_id
INNER JOIN lignes_commande AS l ON l.commande_id = o.id
INNER JOIN produits        AS p ON p.id = l.produit_id
WHERE o.id = 101;

Une règle simple : une jointure par relation, chacune avec sa propre clause ON. Si tu mélanges INNER et LEFT JOIN, sois attentif : un INNER JOIN placé après un LEFT JOIN peut annuler l’effet de ce dernier en éliminant les lignes NULL.

ON ou WHERE : la différence qui change tout

Avec un INNER JOIN, placer une condition dans ON ou dans WHERE donne le même résultat. Avec un LEFT JOIN, ce n’est plus vrai :

-- ❌ Transforme le LEFT JOIN en INNER JOIN : Bruno et David disparaissent
SELECT c.nom, o.total
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
WHERE o.total > 50;

-- ❌ Transforme le LEFT JOIN en INNER JOIN : Bruno et David disparaissent
SELECT c.nom, o.total
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
WHERE o.total > 50;

-- ✅ Tous les clients, avec seulement leurs commandes de plus de 50 €
SELECT c.nom, o.total
FROM clients AS c
LEFT JOIN commandes AS o
    ON o.client_id = c.id
   AND o.total > 50;

-- ✅ Tous les clients, avec seulement leurs commandes de plus de 50 €
SELECT c.nom, o.total
FROM clients AS c
LEFT JOIN commandes AS o
    ON o.client_id = c.id
   AND o.total > 50;

Pourquoi ? Le WHERE s’applique après la jointure : pour Bruno, o.total vaut NULL, et NULL > 50 n’est pas vrai, donc la ligne est filtrée. Dans le ON, la condition sert seulement à choisir quelles commandes associer.

Des jointures SQL rapides grâce aux index

Une jointure entre deux grosses tables peut être très lente si MySQL doit, pour chaque client, parcourir toute la table des commandes. La solution : un index sur la colonne de jointure (ici commandes.client_id). Les clés primaires sont indexées automatiquement, les clés étrangères InnoDB aussi, mais pas une simple colonne INT.

CREATE INDEX idx_commandes_client ON commandes (client_id);

-- Vérifier que l'index est utilisé
EXPLAIN SELECT c.nom, o.total
FROM clients AS c
JOIN commandes AS o ON o.client_id = c.id;

CREATE INDEX idx_commandes_client ON commandes (client_id);

-- Vérifier que l'index est utilisé
EXPLAIN SELECT c.nom, o.total
FROM clients AS c
JOIN commandes AS o ON o.client_id = c.id;

Aide-mémoire des jointures SQL

10 exercices corrigés sur les jointures SQL

Rien ne vaut la pratique. Utilise les tables clients et commandes créées plus haut, écris ta requête, puis déplie la correction. Les exercices sont classés du plus simple au plus difficile.

SELECT o.id, o.total, c.nom, c.ville
FROM commandes AS o
INNER JOIN clients AS c ON c.id = o.client_id;

SELECT c.nom, o.id AS commande
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id;

SELECT c.nom
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
WHERE o.id IS NULL;

SELECT o.id
FROM commandes AS o
LEFT JOIN clients AS c ON c.id = o.client_id
WHERE c.id IS NULL;

SELECT c.nom, COUNT(o.id) AS nb
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
GROUP BY c.id, c.nom;

SELECT c.ville, COALESCE(SUM(o.total), 0) AS ca
FROM clients AS c
LEFT JOIN commandes AS o ON o.client_id = c.id
GROUP BY c.ville
ORDER BY ca DESC;

SELECT c.nom, SUM(o.total) AS total
FROM clients AS c
INNER JOIN commandes AS o ON o.client_id = c.id
GROUP BY c.id, c.nom
HAVING SUM(o.total) > 100;

SELECT c.nom, o.id, o.total
FROM clients AS c
LEFT JOIN commandes AS o
    ON o.client_id = c.id
   AND o.total > 50;

SELECT c.nom, o.id FROM clients c LEFT JOIN commandes o ON o.client_id = c.id
UNION
SELECT c.nom, o.id FROM clients c RIGHT JOIN commandes o ON o.client_id = c.id;

SELECT c.nom, o.id, o.total
FROM clients AS c
JOIN commandes AS o ON o.client_id = c.id
LEFT JOIN commandes AS o2
    ON o2.client_id = o.client_id
   AND o2.total > o.total
WHERE o2.id IS NULL;

Les erreurs courantes avec les jointures SQL

FAQ sur les jointures SQL

Conclusion

Les jointures SQL se résument à une question : quelles lignes veux-tu garder quand il n’y a pas de correspondance ? Aucune → INNER JOIN. Celles de gauche → LEFT JOIN. Celles de droite → RIGHT JOIN. Toutes → FULL OUTER JOIN. Et pour trouver ce qui manque, l’anti-jointure LEFT JOIN … IS NULL deviendra vite ton réflexe.

Pour mettre tout ça en pratique dans un vrai projet, découvre nos tutoriels application de gestion de stock en PHP/MySQL et application de planning en PHP et MySQL, qui utilisent des jointures à chaque écran. La documentation officielle de MySQL sur la syntaxe JOIN reste la référence pour les cas avancés.