Cours MariaDB / Lire les lignes liées avec INNER JOIN

INNER JOIN renvoie les combinaisons de lignes pour lesquelles la condition de jointure est vraie. Pour afficher le client associé à chaque commande dans MariaDB, reliez leurs identifiants avec ON, puis vérifiez ce que représente une ligne du résultat : plusieurs commandes d’un même client produisent plusieurs lignes, sans que ce soit une erreur de doublon.

Choisir la clé de jointure et l’unité du résultat

Une jointure interne rassemble les colonnes de tables liées et conserve seulement les correspondances. Ici, une commande contient un customer_id qui désigne la clé primaire du client. La conception des relations et des clés étrangères explique pourquoi ce lien est pertinent. Relier deux colonnes uniquement parce que leurs noms se ressemblent ne garantit pas une relation correcte.

Les alias o et c, déclarés avec AS, abrègent respectivement les noms des tables de commandes et de clients. Ainsi, o.customer_id et c.customer_id indiquent clairement à quelle table appartient chaque colonne.

Élément Exemple Question à laquelle il répond
Table de départ c26_orders AS o Quelles commandes examine-t-on ?
Table liée c26_customers AS c Où trouver le nom du client ?
Condition ON c.customer_id=o.customer_id Quel client correspond à cette commande ?
Filtre WHERE o.status='paid' Quelles commandes liées faut-il afficher ?

Le résultat visé comporte une ligne par commande. Une table de clients contient une seule ligne pour le client 1, mais ce client peut être associé à plusieurs commandes. La jointure ne transforme pas ces commandes distinctes en une seule. Elle n’ajoute pas non plus de contrainte aux tables et ne modifie pas les données : c’est une opération de lecture.

Préparer toutes les données de l’exercice

Connectez-vous au serveur d’apprentissage avec course_user et utilisez la base shopcourse. Le compte doit disposer des droits nécessaires à la création, au remplissage, à la lecture et au nettoyage de ces tables. Le guide du client MariaDB et des fichiers SQL UTF-8 explique la connexion et la commande SOURCE.

  1. Dans le client MariaDB, vérifiez le serveur et la base avec SELECT VERSION(), DATABASE();, puis les noms présents avec SHOW TABLES;. Les instructions SQL s’exécutent dans cette connexion, et non directement à l’invite PowerShell ou à celle du système.
  2. Les quatre noms préfixés par c26_ doivent être disponibles. S’ils existent, inspectez leurs définitions et leurs lignes. Ne les supprimez que si vous avez établi qu’il s’agit d’objets d’exercice sans données à conserver ; ne remplacez pas des tables d’application.
  3. Enregistrez le bloc complet ci-dessous dans un fichier UTF-8, par exemple C:/mariadb-lab/c26-inner-join.sql, en créant le dossier si nécessaire. Dans le client, exécutez SOURCE C:/mariadb-lab/c26-inner-join.sql; en adaptant le chemin au fichier réel. Vous pouvez aussi exécuter le bloc entier dans votre éditeur SQL connecté.
USE shopcourse;
CREATE TABLE c26_customers (
 customer_id INT NOT NULL PRIMARY KEY,
 customer_name VARCHAR(50) NOT NULL,
 city VARCHAR(30) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
CREATE TABLE c26_products (
 product_id INT NOT NULL PRIMARY KEY,
 product_name VARCHAR(100) NOT NULL,
 category VARCHAR(30) NOT NULL,
 price DECIMAL(10,2) NOT NULL CHECK (price >= 0),
 stock INT NOT NULL CHECK (stock >= 0)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
CREATE TABLE c26_orders (
 order_id INT NOT NULL PRIMARY KEY,
 customer_id INT NOT NULL,
 ordered_at DATETIME NOT NULL,
 status VARCHAR(20) NOT NULL,
 shipping_fee DECIMAL(10,2) NOT NULL DEFAULT 1000,
 CONSTRAINT fk_c26_order_customer FOREIGN KEY (customer_id)
  REFERENCES c26_customers(customer_id) ON DELETE RESTRICT
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
CREATE TABLE c26_items (
 order_id INT NOT NULL,
 product_id INT NOT NULL,
 quantity INT NOT NULL CHECK (quantity > 0),
 unit_price DECIMAL(10,2) NOT NULL CHECK (unit_price >= 0),
 PRIMARY KEY (order_id, product_id),
 CONSTRAINT fk_c26_item_order FOREIGN KEY (order_id)
  REFERENCES c26_orders(order_id) ON DELETE RESTRICT,
 CONSTRAINT fk_c26_item_product FOREIGN KEY (product_id)
  REFERENCES c26_products(product_id) ON DELETE RESTRICT
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
INSERT INTO c26_customers VALUES
 (1,'김민수','서울'),(2,'이서연','부산'),
 (3,'박지우','서울'),(4,'최하늘','대전');
INSERT INTO c26_products VALUES
 (1,'노트','문구',3500,20),(2,'볼펜','문구',1500,50),
 (3,'머그컵','생활',8000,12),(4,'스탠드','생활',25000,5);
INSERT INTO c26_orders
 (order_id,customer_id,ordered_at,status,shipping_fee) VALUES
 (101,1,'2026-01-10 10:00:00','paid',1000),
 (102,1,'2026-01-20 11:00:00','paid',1000),
 (103,2,'2026-02-05 12:00:00','paid',1000),
 (104,3,'2026-02-10 13:00:00','canceled',1000);
INSERT INTO c26_items VALUES
 (101,1,2,3500),(101,2,3,1500),(102,3,1,8000),
 (103,1,1,3500),(103,3,2,8000),(104,2,1,1500);

Le jeu comporte quatre clients, quatre produits, quatre commandes et six lignes de commande. Les tables de produits et de lignes sont fournies pour que le modèle soit complet et autonome ; les requêtes de jointure ci-dessous utilisent surtout les clients et les commandes. Aucun autre exercice JOIN n’a besoin d’avoir été exécuté auparavant.

Les textes coréens restent identiques dans toutes les traductions pour permettre de reproduire les résultats. Les produits 1 à 4 sont un carnet, un stylo, une tasse et une lampe. La ville des clients 1 et 3 est 서울 (Séoul), celle du client 2 est 부산 (Busan), celle du client 4 est 대전 (Daejeon). Conservez ces chaînes UTF-8 et utilisez les identifiants pour suivre les exemples.

Les clés étrangères imposent ici un client existant à chaque commande ; NOT NULL interdit une référence vide. En revanche, un client peut n’avoir aucune commande : c’est le cas du client 4. Cette différence aide à comprendre les lignes conservées par la jointure.

Afficher les commandes avec leur client

Exécutez cette requête après la préparation, dans la même base shopcourse. Chaque commande cherche la ligne cliente dont la clé primaire égale sa référence customer_id.

SELECT o.order_id,c.customer_id,c.customer_name,o.status
FROM c26_orders AS o
INNER JOIN c26_customers AS c ON c.customer_id=o.customer_id
ORDER BY o.order_id;
order_id customer_id customer_name status
101 1 김민수 paid
102 1 김민수 paid
103 2 이서연 paid
104 3 박지우 canceled

Le nom 김민수 apparaît deux fois, car les commandes 101 et 102 appartiennent au client 1. Les deux lignes ne sont pas identiques : leur order_id diffère. La clé primaire des clients garantit au maximum une ligne cliente correspondante par commande ; avec la référence obligatoire valide, les quatre commandes obtiennent chacune une correspondance.

Le client 4 ne figure pas dans le résultat puisqu’aucune commande ne lui correspond. Une jointure interne ne fabrique pas une commande vide pour le représenter. Si l’objectif devient une liste de clients ayant commandé, une seule fois chacun, il faut changer l’unité du résultat : un test d’existence ou une agrégation adaptée peut convenir. Ajouter DISTINCT aux quatre colonnes ci-dessus ne fusionnerait pas les commandes 101 et 102, dont les identifiants sont distincts.

ORDER BY o.order_id demande explicitement l’ordre 101, 102, 103, 104. Sans tri, ne supposez pas que l’ordre de stockage ou d’insertion sera celui de l’affichage.

Distinguer la correspondance et le filtre métier

Pour afficher uniquement les commandes payées, conservez la relation dans ON et ajoutez la condition de statut dans WHERE.

SELECT o.order_id,c.customer_name,o.ordered_at
FROM c26_orders AS o
INNER JOIN c26_customers AS c ON c.customer_id=o.customer_id
WHERE o.status='paid' ORDER BY o.order_id;

Le résultat contient les commandes 101, 102 et 103. Leurs dates sont respectivement 2026-01-10 10:00:00, 2026-01-20 11:00:00 et 2026-02-05 12:00:00. La commande 104 possède bien un client, mais son statut canceled l’exclut de ce résultat filtré.

ON exprime ici l’appartenance de la commande au client ; WHERE sélectionne l’état métier demandé. Pour cette jointure interne et cette condition de statut, placer aussi le filtre dans ON donnerait les mêmes lignes. Cette équivalence ne doit pas être appliquée mécaniquement aux jointures externes : un filtre dans WHERE peut alors éliminer les lignes sans correspondance que l’on voulait garder.

Pour contrôler un lien dans une requête que vous adaptez, affichez temporairement les deux références, par exemple o.customer_id et c.customer_id, dans la liste SELECT. Elles doivent correspondre sur chaque ligne. Ne remplacez pas cette égalité par une comparaison de noms modifiables ou par o.order_id=c.customer_id : un numéro de commande et un numéro de client représentent des objets différents.

Comparer quatre correspondances à seize combinaisons

La requête suivante demande volontairement toutes les paires possibles, sans imposer la relation client-commande. Elle fournit un point de comparaison pour repérer un produit cartésien accidentel.

SELECT COUNT(*) AS unconstrained_pairs
FROM c26_customers AS c CROSS JOIN c26_orders AS o;

Quatre clients multipliés par quatre commandes donnent 16 combinaisons, contre 4 lignes pour la jointure sur la bonne clé. Parmi ces 16 paires, certaines associent une commande à un client qui ne l’a jamais passée. CROSS JOIN est utile lorsque toutes les combinaisons sont réellement recherchées ; il ne décrit pas ici l’appartenance des commandes.

La documentation officielle de la syntaxe JOIN dans MariaDB précise que MariaDB accepte des formes de INNER JOIN sans condition et traite CROSS JOIN comme un équivalent syntaxique. Oublier ON n’est donc pas nécessairement une erreur de syntaxe : vérifiez toujours la condition et le nombre de lignes. Dans cet exercice, écrivez explicitement la relation pour la jointure interne et réservez la forme sans condition à la comparaison de toutes les paires.

Une augmentation du nombre de lignes peut aussi être légitime. Relier ensuite les commandes à leurs lignes de produits changerait l’unité en « ligne de commande » : les six lignes initiales ne représentent pas six commandes. Compter ou additionner après une jointure exige donc de vérifier à quel niveau chaque valeur est répétée.

Diagnostiquer les résultats et refaire l’essai

  • Colonne ambiguë : si MariaDB signale Column 'customer_id' ... is ambiguous, les deux tables exposent ce nom. Précisez o.customer_id ou c.customer_id selon la colonne voulue.
  • Trop de lignes : recherchez une condition manquante, une clé non unique du côté référencé, ou une relation un-à-plusieurs attendue. N’effacez pas les différences utiles avec DISTINCT avant de comprendre leur cause.
  • Trop peu de lignes : contrôlez les filtres, les valeurs des clés et les correspondances absentes. Les comparaisons ordinaires avec NULL ne sont pas vraies ; une référence nulle ne correspond donc pas par une égalité simple.
  • Clients sans commande à conserver : partez des clients avec une jointure externe LEFT JOIN plutôt qu’une jointure interne. Le client 4 est un exemple concret de ligne que la jointure interne ne conserve pas.

Sur les données initiales, les points de contrôle sont : quatre lignes liées, trois commandes payées et seize paires sans condition. Pour vérifier que vos essais de lecture n’ont pas modifié le jeu, relancez la première requête de jointure et comparez ses quatre lignes au tableau.

Avant de recommencer depuis zéro, vérifiez la base, les définitions et les lignes, puis sauvegardez toute donnée à garder. Le bloc suivant supprime seulement les quatre tables d’exercice c26_, des enfants vers les parents. Comme le rappelle la documentation de DROP TABLE, cette opération enlève structures et données ; un ROLLBACK ordinaire ne la restaure pas.

DROP TABLE shopcourse.c26_items;
DROP TABLE shopcourse.c26_orders;
DROP TABLE shopcourse.c26_products;
DROP TABLE shopcourse.c26_customers;

Après ce nettoyage, réexécutez le bloc de préparation complet, puis les trois lectures de comparaison. Vous devez retrouver les résultats 4, 3 et 16. Les tables d’autres exercices, notamment celles préfixées c25_ ou une table générale products, ne font pas partie de ce nettoyage.