0Pricing
SQL Academy · Leçon

Comparer des lignes d’une même table

Trouvez des paires et des relations.

Comparer des lignes d’une même table est une leçon SQL Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce qu'une auto-jointure ?

Une auto-jointure consiste à joindre une table à elle-même. Cela peut sembler inhabituel au premier abord, mais c'est une technique puissante pour comparer des lignes au sein d'une même table.

Imaginez une table employees dans laquelle chaque employé possède un manager_id qui pointe vers une autre ligne de la même table. Une auto-jointure vous permet d'associer chaque employé à son responsable dans une seule requête.

Préparer la table d'exemple

Créons une table employees simple que nous utiliserons tout au long de cette leçon. Chaque ligne possède un id, un name, un salary et un manager_id qui référence un autre employé de la même table.

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(50),
  salary     INT,
  manager_id INT
);

INSERT INTO employees VALUES
  (1, 'Alice',   90000, NULL),
  (2, 'Bob',     70000, 1),
  (3, 'Carol',   65000, 1),
  (4, 'Dave',    55000, 2),
  (5, 'Eve',     60000, 2),
  (6, 'Frank',   48000, 3);

Syntaxe de base d'une auto-jointure

Pour effectuer une auto-jointure, référencez deux fois la même table en utilisant deux alias différents. Les alias donnent l'impression que vous disposez de deux copies distinctes de la table. Vous indiquez ensuite la condition de jointure qui relie les deux copies.

Ici, nous donnons à employees l'alias e (l'employé) et à m l'alias du responsable, puis nous effectuons la correspondance sur e.manager_id = m.id.

SELECT
  e.name   AS employee,
  m.name   AS manager
FROM employees e
JOIN employees m ON e.manager_id = m.id;

Inclure les lignes au sommet avec LEFT JOIN

Une INNER JOIN classique supprime les lignes dont manager_id vaut NULL, ce qui signifie que l'employé au sommet de la hiérarchie (Alice, le CEO) serait exclu des résultats.

Utilisez une LEFT JOIN pour que chaque employé apparaisse, y compris ceux qui n'ont pas de responsable. La colonne du responsable vaudra simplement NULL pour ces employés.

SELECT
  e.name          AS employee,
  m.name          AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id
ORDER BY m.name NULLS LAST, e.name;

Trouver les paires qui partagent une propriété

Les auto-jointures sont également utiles pour trouver des paires de lignes qui partagent une valeur. Par exemple, vous pouvez trouver toutes les paires d'employés qui dépendent du même responsable.

La condition a.id < b.id empêche les paires en double comme (Bob, Carol) et (Carol, Bob) d'apparaître toutes les deux dans les résultats.

SELECT
  a.name       AS employee_1,
  b.name       AS employee_2,
  a.manager_id AS shared_manager
FROM employees a
JOIN employees b
  ON a.manager_id = b.manager_id
 AND a.id < b.id;

Comparer les salaires entre les lignes

Vous pouvez utiliser une auto-jointure pour comparer des valeurs numériques entre les lignes. La requête ci-dessous trouve chaque employé dont le salaire est supérieur à celui de son propre responsable — une vérification analytique classique.

SELECT
  e.name       AS employee,
  e.salary     AS emp_salary,
  m.name       AS manager,
  m.salary     AS mgr_salary
FROM employees e
JOIN employees m ON e.manager_id = m.id
WHERE e.salary > m.salary;

Trouver les lignes sans correspondance

Une auto-jointure avec une LEFT JOIN et une vérification WHERE ... IS NULL vous permet de trouver les lignes qui n'ont aucun homologue correspondant. Ici, nous trouvons les employés qui n'ont personne sous leur responsabilité — les nœuds feuilles de la hiérarchie.

SELECT e.name AS employee
FROM employees e
LEFT JOIN employees sub ON sub.manager_id = e.id
WHERE sub.id IS NULL
ORDER BY e.name;

Compter les subordonnés directs

En joignant la table à elle-même et en regroupant les résultats du côté des responsables, vous pouvez compter le nombre de subordonnés directs de chaque responsable. Les employés sans aucun subordonné sont inclus grâce à la LEFT JOIN.

SELECT
  m.name           AS manager,
  COUNT(e.id)      AS direct_reports
FROM employees m
LEFT JOIN employees e ON e.manager_id = m.id
GROUP BY m.id, m.name
ORDER BY direct_reports DESC;

Utiliser des CTE pour clarifier les auto-jointures

Lorsqu'une requête utilisant une auto-jointure devient complexe, l'encapsuler dans une expression de table commune (CTE) rend la logique plus facile à lire. Définissez une CTE pour la hiérarchie, puis interrogez-la clairement.

WITH hierarchy AS (
  SELECT
    e.id         AS emp_id,
    e.name       AS employee,
    e.salary     AS emp_salary,
    m.name       AS manager,
    m.salary     AS mgr_salary
  FROM employees e
  LEFT JOIN employees m ON e.manager_id = m.id
)
SELECT *
FROM hierarchy
WHERE mgr_salary IS NOT NULL
  AND emp_salary > mgr_salary;

Auto-jointure sur une table non hiérarchique

Les auto-jointures ne sont pas limitées aux hiérarchies de responsables et d'employés. L'exemple ci-dessous utilise une table products pour trouver toutes les paires de produits appartenant à la même catégorie, ce qui est utile pour les moteurs de recommandation ou les vérifications de similarité.

CREATE TABLE products (
  id       INT PRIMARY KEY,
  name     VARCHAR(50),
  category VARCHAR(30)
);

INSERT INTO products VALUES
  (1, 'Laptop',  'Electronics'),
  (2, 'Phone',   'Electronics'),
  (3, 'Tablet',  'Electronics'),
  (4, 'Shirt',   'Clothing'),
  (5, 'Jeans',   'Clothing');

SELECT
  a.name AS product_1,
  b.name AS product_2,
  a.category
FROM products a
JOIN products b
  ON a.category = b.category
 AND a.id < b.id;

Pièges : produits cartésiens et doublons

Deux erreurs courantes dans les auto-jointures sont les produits cartésiens (oublier complètement la condition de jointure) et les paires en double (utiliser a.id <> b.id au lieu de a.id < b.id).

Vérifiez toujours que votre condition de jointure est correcte et utilisez < plutôt que <> lorsque vous avez uniquement besoin de paires non ordonnées, et non de paires ordonnées.

-- Wrong: returns every ordered pair (A,B) AND (B,A)
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id <> b.id;

-- Correct: returns each unordered pair once
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id < b.id;

Vérification rapide

Vérifiez votre compréhension des auto-jointures et de la comparaison de lignes dans une même table.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris à utiliser les auto-jointures pour comparer des lignes au sein d'une même table.

Points clés :

  • Attribuez deux alias à la table (par exemple, e et m) afin que la base de données les traite comme des sources distinctes.
  • Utilisez INNER JOIN lorsque vous n'avez besoin que des lignes ayant une correspondance, et LEFT JOIN lorsque vous souhaitez également inclure les lignes sans correspondance.
  • Utilisez a.id < b.id pour éviter les doublons de paires non ordonnées.
  • Les auto-jointures sont utiles pour les hiérarchies (responsable/employé), les recherches de similarité (même catégorie) et toute comparaison où deux lignes de la même table doivent être mises en relation.
  • Les CTE peuvent rendre les requêtes d'auto-jointure complexes bien plus faciles à lire et à maintenir.

Questions Fréquemment Posées

La leçon « Comparer des lignes d’une même table » est-elle gratuite ?

Oui — le texte complet de « Comparer des lignes d’une même table » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Academy, passe à CoddyKit PRO. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comparer des lignes d’une même table » ?

Trouvez des paires et des relations. Tu pratiques SQL Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Academy ?

Aucune expérience préalable n'est requise. SQL Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Comparer des lignes d’une même table » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Academy ?

Oui. Chaque leçon SQL Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Qu’est-ce qu’une auto-jointure ?
  2. Employés et responsables
  3. Comparer des lignes d’une même table
  4. Limites des auto-jointures
← Retour à SQL Academy