SQL Server

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

Découvrez pourquoi une jointure un-à-plusieurs répète les valeurs client, comment vérifier les clés et quand agréger le résultat.

Par JaviPublié 12 min de lectureDébutant

Après avoir étudié INNER JOIN et LEFT JOIN, vous pouvez voir un nom de client répété et penser que la requête a renvoyé des données en double. Souvent, les lignes sont correctes : un client peut avoir plusieurs commandes. Avant de supprimer les répétitions, posez la question la plus utile pour une jointure : que doit représenter une ligne du résultat ?

Un client, plusieurs commandes

Dans JaviBuildsLab, Ana Torres est une seule ligne dans dbo.Customers, avec CustomerId 1. Elle possède trois lignes dans dbo.Orders : la commande 1001 du 2025-02-01 pour 125.50, la commande 1002 du 2025-04-12 pour 49.99 et la commande 1007 du 2025-07-04 pour 75.00. La jointure renvoie trois lignes pour Ana, car chacune représente une commande différente.

Requête SQL: Un client, plusieurs commandesT-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.

Le résultat inclut Ana trois fois, une fois pour chaque OrderId : 1001, 1002 et 1007. David Kim (CustomerId 4) a aussi deux commandes, 1004 et 1005. Ben a la commande 1003 et Grace les commandes 1006 et 6. Huit commandes produisent huit lignes jointes. C’est le comportement attendu d’une relation un-à-plusieurs : un client peut être associé à plusieurs commandes.

  1. Customers : Ana (CustomerId 1) — une ligne
  2. Orders : 1001, 1002, 1007 — trois lignes correspondantes
  3. Résultat JOIN : Ana + 1001 ; + 1002 ; + 1007 — trois lignes
Un client et trois commandes correspondantes produisent trois lignes

Le diagramme décrit une relation entre les lignes, pas des doublons dans le stockage. Les attributs du client sont répétés parce que le résultat associe un client à chacune de ses commandes. OrderId, OrderDate et Amount décrivent des faits différents. Si vous ne sélectionnez que les colonnes de nom, Ana peut sembler apparaître deux fois avec des valeurs visibles identiques ; les lignes proviennent néanmoins de commandes distinctes. Ajouter une colonne identifiant la commande aide à comprendre le résultat.

Comprendre la cardinalité

La cardinalité décrit le nombre de lignes qui peuvent être liées. Dans une relation un-à-un, une ligne d’un côté correspond au plus à une ligne de l’autre. Dans une relation un-à-plusieurs, une ligne peut correspondre à plusieurs lignes de l’autre côté : c’est le cas de Customers et Orders. Dans une relation plusieurs-à-plusieurs, plusieurs éléments de chaque côté peuvent être reliés, souvent par une table d’association. La jointure renvoie les combinaisons qui satisfont sa condition ; la forme de la relation influence donc le nombre de lignes.

Des valeurs répétées ne sont pas nécessairement des lignes en double. Deux lignes jointes peuvent partager CustomerId et nom tout en ayant un OrderId différent. Elles représentent des commandes différentes, pas des doublons accidentels. Déterminez si les lignes sont réellement identiques pour les colonnes et le sens qui vous intéressent, puis choisissez entre détails et résumé.

Vérifier la condition de jointure

Reliez les colonnes qui définissent la relation : ici c.CustomerId = o.CustomerId. Il serait tentant, mais incorrect, de joindre sur State si les deux tables contenaient un état ou une région. State n’est pas une clé client unique. Si plusieurs clients partagent cette valeur, la condition associe des enregistrements sans lien et multiplie les résultats. Orders ne contient pas State dans cette démonstration ; ne lancez donc pas cet exemple comme une vraie requête. Retenez qu’une valeur similaire ou répétée n’est pas automatiquement une clé de relation.

Omettre la condition ON peut être pire : chaque client peut être associé à chaque commande. Dix clients et huit commandes pourraient produire 80 combinaisons. Ce produit cartésien est parfois voulu, mais il n’est généralement pas la bonne réponse pour relier clients et commandes. Vérifiez les clés du schéma et indiquez explicitement la relation.

DISTINCT n’est pas la solution par défaut

DISTINCT supprime les lignes identiques parmi les colonnes sélectionnées. Il ne corrige pas une mauvaise clé et ne transforme pas une relation un-à-plusieurs en relation un-à-un. Par exemple :

Requête SQL: DISTINCT n’est pas la solution par défautT-SQL
SELECT DISTINCT c.CustomerId, c.FirstName, c.LastName
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId;
T-SQL4 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Comme OrderId n’est pas sélectionné, cette requête renvoie une ligne visible par client ayant commandé. C’est légitime si la question est « quels clients ont au moins une commande ? ». Mais si vous avez besoin des détails de commande, DISTINCT masquerait des commandes différentes. Vérifiez d’abord la clé et le sens attendu des lignes. Utilisez DISTINCT uniquement si éliminer les lignes projetées identiques fait réellement partie de la demande.

Définir le grain du résultat

Le « grain » décrit ce que représente une ligne. La première requête renvoie une ligne par paire client-commande, ce qui revient à une ligne par commande puisque chaque commande appartient à un client. Si le rapport demande plutôt une ligne par client avec le nombre de commandes, agrégez volontairement :

Requête SQL: Définir le grain du résultatT-SQL
SELECT
    c.CustomerId,
    c.FirstName,
    c.LastName,
    COUNT(o.OrderId) AS OrderCount
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId
GROUP BY
    c.CustomerId,
    c.FirstName,
    c.LastName;
T-SQL12 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Chaque client apparaît une fois, y compris ceux sans commande. COUNT(o.OrderId) renvoie zéro pour eux, car OrderId vaut NULL après le JOIN et COUNT(colonne) ignore NULL. COUNT(*) compterait la ligne client préservée et renverrait un, ce qui ne serait pas le nombre de commandes. GROUP BY transforme le grain : les détails client-commande deviennent une ligne par client. Les prochaines leçons approfondiront les agrégats.

Avant d’écrire une jointure, exprimez son grain : une ligne par commande, par client ou par paire client-commande ? Vérifiez ensuite les clés, la cardinalité et les colonnes sélectionnées. Si le nombre de lignes surprend, examinez quelques identifiants des deux côtés au lieu de cacher les valeurs d’emblée.

Diagnostiquer un résultat qui semble répété

Commencez par ajouter temporairement la clé de chaque table à la requête d’inspection. Pour Customers et Orders, gardez visibles c.CustomerId et o.OrderId. Si l’identifiant client reste identique alors que OrderId change, la requête affiche des commandes distinctes. Si la même paire d’identifiants apparaît plusieurs fois, vérifiez si une autre table a été jointe à un grain plus fin, si la condition est incomplète ou si la source contient réellement des lignes répétées. Les identifiants permettent de distinguer une multiplicité attendue d’un vrai problème de jointure.

Examinez ensuite le nombre de lignes de droite associées à une clé de gauche. Ana est un exemple simple : CustomerId 1 est lié aux commandes 1001, 1002 et 1007. Le résultat attendu pour Ana est de trois lignes. Les deux commandes de David offrent une autre vérification, tandis que Ben apporte une ligne et Grace deux. Les six autres clients n’ajoutent rien à INNER JOIN puisqu’ils n’ont aucune commande. Réfléchir à quelques exemples connus est souvent plus rapide et plus clair que supprimer les répétitions en espérant que les totaux paraissent plausibles.

La même relation répond à des questions de grains différents. Pour examiner les transactions, une ligne par commande est utile, car chacune a sa date et son montant. Pour une liste de relance, une ligne par client peut être nécessaire. Un résumé peut regrouper les détails, mais il doit indiquer la clé du client qui définit chaque groupe et la mesure calculée. GROUP BY ne sert pas à masquer des lignes : il définit un résultat résumé avec une ligne pour chaque clé de regroupement distincte.

Soyez particulièrement attentif lorsque la requête joint plus de deux tables. Si chaque commande comporte plusieurs articles et que vous joignez Customers, Orders puis OrderItems, un client peut apparaître une fois par article. Cela ne signifie pas que le client ou la commande a été copié dans le stockage. Le grain est passé de client-commande à client-commande-article. Après une telle jointure, vérifiez que chaque mesure est calculée au bon niveau : additionner le total d’une commande une fois par article pourrait le surestimer. Gardez les clés qui révèlent le grain pendant la validation, puis retirez les colonnes seulement lorsque le résultat est compris.

Cette leçon porte sur le sens des résultats et la forme des relations. SQL Server peut exécuter une jointure avec différentes stratégies internes, sans changer les combinaisons logiques demandées. Commencez par définir correctement la relation et le grain ; les performances relèvent d’un sujet plus avancé.

Pendant le développement, vous pouvez noter le grain attendu dans un commentaire au-dessus de la requête : « une ligne par commande » ou « une ligne par client ». Cette note donne aux personnes qui relisent un critère concret pour vérifier si une jointure ou une colonne ajoutée change le résultat. Elle est utile lorsqu’un rapport évolue et qu’une autre personne ajoute une table. Si cette table peut fournir plusieurs lignes pour chaque ligne existante, le grain change même si la requête s’exécute sans erreur. Revérifiez les totaux et les identifiants après chaque relation supplémentaire au lieu de supposer que le nombre de lignes reste stable.

Erreurs courantes et exercices

Les erreurs habituelles consistent à prendre un nom répété pour une preuve de données erronées, à utiliser immédiatement DISTINCT, à joindre une colonne non clé, à ignorer les relations un-à-plusieurs et à ne pas définir ce qu’une ligne représente. Rappelez-vous qu’un LEFT JOIN conserve les entités de gauche mais peut renvoyer plusieurs lignes pour chacune si plusieurs lignes de droite correspondent.

Exercices : (1) afficher les commandes et montants d’Ana ; (2) produire une ligne par client et compter ses commandes, même s’il n’en a aucune ; (3) lister chaque client qui a commandé sans afficher le détail des commandes ; (4) expliquer pourquoi FirstName seul peut faire paraître différentes commandes identiques ; (5) nommer le grain de la première requête.

Réponses

Requête SQL: RéponsesT-SQL
-- 1
SELECT c.FirstName, o.OrderId, o.Amount
FROM dbo.Customers AS c JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId
WHERE c.CustomerId = 1;
-- 2
SELECT c.CustomerId, c.FirstName, COUNT(o.OrderId) AS OrderCount
FROM dbo.Customers AS c LEFT JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId
GROUP BY c.CustomerId, c.FirstName;
-- 3 : DISTINCT convient, car la question porte sur les clients, pas les commandes.
SELECT DISTINCT c.CustomerId, c.FirstName
FROM dbo.Customers AS c JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId;
T-SQL11 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La prochaine leçon présente les alias de tables et de colonnes, utiles lorsque les jointures contiennent des noms répétés. Retrouvez JOIN expliqués ou comparez INNER et LEFT JOIN. Consultez aussi le hub SQL Server Foundations.

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Pourquoi une jointure peut-elle renvoyer des lignes qui semblent répétées ?
Question 2 sur 2Que faut-il examiner d’abord si une jointure multiplie les lignes ?

Fondamentaux de SQL Server

Leçon 11 sur 25

Continuer vers la leçon suivante

Utiliser des alias de tables et de colonnes dans SQL Server

Continuer vers la leçon 12

Étiquettes

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