SQL Server

INNER JOIN ou LEFT JOIN dans SQL Server

Comparez INNER JOIN et LEFT JOIN dans SQL Server pour conserver les clients sans commande, filtrer les commandes et repérer les absences.

Par JaviPublié 12 min de lectureDébutant

Dans la leçon précédente, vous avez relié dbo.Customers à dbo.Orders avec CustomerId. Il faut maintenant choisir les lignes à conserver lorsqu’un côté n’a pas de correspondance. Voulez-vous uniquement les paires client/commande existantes, ou chaque client, y compris ceux qui n’ont jamais commandé ? C’est le choix pratique entre INNER JOIN et LEFT JOIN.

Dans le jeu de démonstration, un client peut avoir plusieurs commandes. Ana (CustomerId 1) a les commandes 1001, 1002 et 1007 ; Ben (2) en a une, David (4) en a deux, Grace (7) en a deux, et les six autres clients n’en ont aucune. Ces données rendent la différence visible sans inventer d’exemples.

INNER JOIN conserve les correspondances

INNER JOIN renvoie une ligne uniquement lorsque la condition ON trouve une ligne correspondante des deux côtés :

Requête SQL: INNER JOIN conserve les correspondancesT-SQL
SELECT
    c.CustomerId,
    c.FirstName,
    c.LastName,
    o.OrderId,
    o.OrderDate,
    o.Amount
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId;
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La table Orders contient huit lignes, et sa clé étrangère garantit que chacune référence un client existant : cette requête renvoie donc huit lignes. Ana apparaît trois fois et David deux fois, car leurs commandes sont des enregistrements distincts. Les clients sans commande n’apparaissent pas. La jointure ne les supprime pas de la base ; ils ne répondent simplement pas à la question posée : afficher des paires client/commande correspondantes.

Cette jointure convient lorsque le résultat porte sur des commandes associées à un client. Par exemple, un rapport de commandes avec le nom du client peut utiliser INNER JOIN si une commande sans client valide ne doit pas être présentée comme une paire complète. Dans cette base, la clé étrangère garantit les correspondances. Dans des données moins encadrées, une commande sans client serait exclue par une jointure interne.

LEFT JOIN conserve le côté gauche

LEFT JOIN conserve toutes les lignes de la table écrite avant la jointure. Les valeurs correspondantes de droite sont ajoutées ; sans correspondance, les colonnes sélectionnées à droite valent NULL :

Requête SQL: LEFT JOIN conserve le côté gaucheT-SQL
SELECT
    c.CustomerId,
    c.FirstName,
    c.LastName,
    o.OrderId,
    o.OrderDate,
    o.Amount
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId;
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La requête représente les dix clients sur quatorze lignes : huit lignes de commande correspondantes et six clients sans commande. Les clients 3, 5, 6, 8, 9 et 10 apparaissent chacun une fois avec NULL dans les colonnes de commande sélectionnées. Un client ayant plusieurs commandes apparaît toujours plusieurs fois : conserver la ligne de gauche ne regroupe pas les lignes de droite correspondantes.

L’ordre des tables exprime la population à préserver. Customers LEFT JOIN Orders signifie « conserver chaque client ». Orders LEFT JOIN Customers signifie « conserver chaque commande », même si aucun client correspondant n’existe. L’intention n’est donc pas la même, même si une clé étrangère garantit actuellement que chaque commande a un client. Commencez par l’entité dont toutes les lignes doivent rester, puis placez-la à gauche.

Jointure Lignes conservées Sans correspondance à droite
INNER JOIN Les paires correspondantes uniquement La ligne de gauche est omise
LEFT JOIN Chaque ligne de gauche et ses correspondances éventuelles Les colonnes de droite valent NULL
  1. INNER : client + commande correspondants → renvoyés
  2. INNER : client sans commande → exclu
  3. LEFT : chaque client → renvoyé
  4. LEFT : commande correspondante → ajoutée
  5. LEFT : aucune correspondance → colonnes NULL
Ce que chaque jointure fait d’un client

Filtrer après une LEFT JOIN

Supposons que vous vouliez garder tous les clients et afficher uniquement leurs commandes expédiées. Cette requête semble plausible :

Requête SQL: Filtrer après une LEFT JOINT-SQL
SELECT c.CustomerId, c.FirstName, o.OrderId, o.Status
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId
WHERE o.Status = N'Shipped';
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Mais WHERE filtre les lignes jointes après la recherche des correspondances. Pour un client sans commande, o.Status vaut NULL ; la comparaison avec N'Shipped' n’est pas vraie, donc la ligne est retirée. Le résultat ne contient que les clients ayant une commande expédiée. Pour cette condition, la jointure externe ne préserve plus les clients sans commande admissible.

Pour garder chaque client et associer uniquement les commandes expédiées, placez la condition côté droit dans ON :

Requête SQL: Filtrer après une LEFT JOIN (2)T-SQL
SELECT c.CustomerId, c.FirstName, o.OrderId, o.Status
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId
   AND o.Status = N'Shipped';
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les dix clients restent. David reçoit sa commande expédiée 1004 ; les autres ont NULL côté commande lorsqu’aucune commande expédiée ne correspond. ON décide quelles lignes de droite sont des correspondances ; WHERE décide quelles lignes du résultat final restent. Si vous voulez seulement les commandes expédiées, INNER JOIN avec un filtre WHERE exprime plus clairement cette intention. La leçon sur NULL explique ces valeurs plus en détail.

Trouver les clients sans commande

La clé de droite sans correspondance vaut NULL. Testez une colonne de commande qui ne peut pas être nulle :

Requête SQL: Trouver les clients sans commandeT-SQL
SELECT c.CustomerId, c.FirstName, c.LastName
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId
WHERE o.OrderId IS NULL;
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

OrderId est la clé primaire d’une commande et ne peut pas être NULL dans une vraie ligne stockée. Ici, NULL est produit par la jointure externe pour indiquer l’absence de correspondance. La requête renvoie les clients 3, 5, 6, 8, 9 et 10. Ce modèle sert à trouver les lignes de gauche sans ligne liée à droite.

Choisir selon la question

Utilisez INNER JOIN pour « afficher les commandes avec le nom du client » ou « afficher les clients qui ont commandé ». Utilisez LEFT JOIN pour « afficher chaque client et ses commandes éventuelles ». Utilisez LEFT JOIN avec WHERE o.OrderId IS NULL pour demander « quels clients n’ont jamais commandé ? ». Définissez les lignes attendues avant de choisir la jointure : le mot-clé découle du résultat voulu.

Les erreurs fréquentes consistent à choisir INNER JOIN alors que les lignes non appariées comptent, à filtrer une colonne de droite dans WHERE sans penser à NULL, à relier des colonnes qui ne sont pas les clés de relation et à supposer qu’un LEFT JOIN produit une ligne par client. Vérifiez aussi quelle table est à gauche : c’est elle qui est préservée. RIGHT JOIN et FULL OUTER JOIN existent, mais les situations courantes sont généralement plus faciles à exprimer avec INNER ou LEFT.

Prévoir les lignes avant d’exécuter la requête

Prenez l’habitude d’écrire les entités attendues, puis vérifiez que la requête les renvoie. Pour INNER JOIN, prévoyez seulement les clients ayant au moins une commande : dans ces données, ce sont Ana, Ben, David et Grace. Ana a trois commandes, David deux, et Ben en a une et Grace deux : le résultat compte huit lignes. Pour LEFT JOIN depuis Customers, prévoyez les dix noms ; six clients sans commande auront des colonnes de commande NULL. Le résultat compte quatorze lignes, car les quatre clients ayant commandé contribuent huit lignes. Cette prévision des entités et du nombre de lignes aide à repérer une mauvaise clé ou un filtre mal placé.

Elle précise aussi ce que signifie une « correspondance ». La condition vérifie l’égalité des identifiants clients, pas la ressemblance des noms ni la ville. Chaque commande porte un CustomerId, et la clé étrangère le relie à un client. Plusieurs commandes peuvent utiliser le même identifiant ; chacune forme alors une paire correspondante supplémentaire. Une jointure renvoie des paires, elle ne remplace pas une ligne d’un côté par l’autre.

Dans un rapport, décidez ce que doivent devenir les clients sans commande. Une liste de détails de commandes n’a rien à afficher pour eux ; INNER JOIN convient. Une équipe de service client peut avoir besoin du registre complet, avec les champs de commande vides : choisissez LEFT JOIN. Une liste de relance peut ne contenir que les clients sans commande : LEFT JOIN avec un test de clé NULL répond à la question. Les mêmes tables produisent des résultats différents selon le besoin métier.

Si un LEFT JOIN renvoie moins de lignes que la table de gauche, vérifiez d’abord les filtres WHERE sur les colonnes de droite. S’il en renvoie plus que prévu, plusieurs correspondances peuvent être correctes ; vérifiez aussi que ON emploie les bonnes clés. Remplacer INNER par LEFT ne corrigera pas une condition erronée. Le type détermine quelles lignes sans correspondance sont conservées ; ON définit la correspondance. Ces deux éléments ont des rôles distincts.

Pour une vérification fiable, comparez le résultat aux clés, pas seulement aux noms affichés. Les noms ne sont pas nécessairement uniques : deux clients pourraient partager un nom, tandis que CustomerId identifie une ligne. Comptez les identifiants clients distincts si la question porte sur la couverture des clients, et examinez OrderId si elle porte sur les commandes. Un LEFT JOIN peut conserver tous les clients tout en répétant certains identifiants lorsque ces clients ont plusieurs commandes. Lire les identifiants évite de croire que ces lignes ont disparu ou ont été dupliquées accidentellement.

Pour tester l’absence de commande, utilisez une clé non nullable. Si vous testez une colonne de commande facultative, une vraie commande peut elle-même contenir NULL et sembler absente. OrderId évite cette confusion puisque chaque commande stockée doit avoir sa clé primaire. Ce détail rend le modèle anti-jointure fiable.

Exercices

Essayez avant de lire les réponses : (1) afficher les commandes correspondantes et les noms des clients ; (2) conserver chaque client et son éventuel OrderId ; (3) trouver les clients sans commande ; (4) conserver chaque client mais n’associer que les commandes Complete ; (5) lister les commandes de plus de 100. Les statuts de la base sont Complete, Pending et Shipped.

Réponses

Requête SQL: RéponsesT-SQL
-- 1
SELECT c.FirstName, c.LastName, o.OrderId
FROM dbo.Customers AS c INNER JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId;
-- 2
SELECT c.CustomerId, c.FirstName, o.OrderId
FROM dbo.Customers AS c LEFT JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId;
-- 3
SELECT c.CustomerId, c.FirstName
FROM dbo.Customers AS c LEFT JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId
WHERE o.OrderId IS NULL;
-- 4
SELECT c.CustomerId, c.FirstName, o.OrderId, o.Status
FROM dbo.Customers AS c LEFT JOIN dbo.Orders AS o
  ON c.CustomerId = o.CustomerId AND o.Status = N'Complete';
-- 5
SELECT OrderId, Amount FROM dbo.Orders WHERE Amount > 100.00;
T-SQL16 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La prochaine étape explique pourquoi un client peut apparaître sur plusieurs lignes de jointure. La feuille de route Foundations indique la leçon suivante ; JOIN expliqués revient sur les clés partagées.

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Quelles lignes INNER JOIN renvoie-t-il ?
Question 2 sur 2Que préserve LEFT JOIN ?

Fondamentaux de SQL Server

Leçon 10 sur 25

Continuer vers la leçon suivante

Pourquoi les JOIN SQL produisent des lignes répétées

Continuer vers la leçon 11

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL