SQL Interview Prep · Leçon

SELF JOIN pour les hiérarchies

Joindre une table à elle-même pour modéliser les relations employé-responsable et parent-enfant

SELF JOIN pour les hiérarchies est une leçon SQL Interview Prep gratuite sur CoddyKit. Ceci est la leçon 2 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 Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Interview Prep comprend 4 leçons au total.

Ce qu'est réellement SELF JOIN

Une auto-jointure est simplement une jointure dans laquelle une table apparaît des deux côtés. Il n'existe aucun mot-clé spécial SELF JOIN ; vous écrivez une INNER ou une LEFT JOIN normale et référencez deux fois la même table.

L'astuce qui permet cette opération repose sur les alias de table. Vous donnez un alias différent à chaque copie afin que le moteur les traite comme deux tables indépendantes.

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

Pourquoi les alias sont indispensables

Sans alias distincts, la requête est ambiguë : chaque nom de colonne apparaît deux fois et le moteur ne peut pas déterminer quelle copie vous désignez. Donner un alias à chaque instance résout le problème.

Interprétez la jointure ainsi : « associer chaque ligne d'employé à la ligne d'employé qui est son responsable ». L'alias e désigne l'employé, m le responsable, et tous deux proviennent de la même table physique.

-- e = the employee, m = that employee's manager
SELECT e.id, e.name, m.name AS reports_to
FROM employees AS e
JOIN employees AS m ON e.manager_id = m.id;

Le modèle employé-responsable

Le scénario classique d'auto-jointure est une liste d'adjacence : une seule table stocke les lignes, et chaque ligne pointe vers son parent au moyen d'une clé étrangère vers cette même table.

Une table employees avec un manager_id qui référence employees.id modélise un organigramme entier dans une seule table. Chaque responsable est simplement une autre ligne d'employé.

-- One table holds the whole hierarchy
-- employees(id, name, manager_id)
-- manager_id -> employees.id

Lister tout le monde avec son responsable

La question d'entretien la plus fréquente sur les auto-jointures : afficher chaque employé à côté du nom de son responsable. Joignez la copie des employés à la copie des responsables avec e.manager_id = m.id.

Cette requête renvoie une ligne par employé dont le responsable existe. Notez qu'au sommet de l'organisation, le CEO possède un NULL manager_id et sera exclu par une jointure interne.

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

Utiliser LEFT JOIN pour conserver la racine de l'arbre

Pour inclure le CEO, dont le manager_id vaut NULL, utilisez une LEFT JOIN. Le côté des employés est conservé ; les colonnes du responsable valent NULL pour les lignes sans parent.

Les personnes qui vous interrogent utilisent cet exemple pour vérifier que vous vous souvenez qu'une auto-jointure interne supprime les nœuds racines. La correction est la même que dans toute situation de jointure externe où il faut « conserver les lignes sans correspondance ».

SELECT e.name AS employee,
       COALESCE(m.name, '(top level)') AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id;

Compter les collaborateurs directs de chaque responsable

Question complémentaire fréquente : combien de personnes dépendent directement de chaque responsable ? Effectuez une auto-jointure, puis regroupez par responsable.

Nous joignons les employés aux responsables, regroupons selon l'identité du responsable et comptons les employés. Cela compte uniquement les collaborateurs directs, et non toute la sous-arborescence située en dessous d'eux.

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

Descendre de deux niveaux

Pour obtenir un employé, son responsable et le responsable de celui-ci, enchaînez trois copies de la table. Chaque niveau correspond à une nouvelle auto-jointure.

Cette méthode fonctionne pour une profondeur fixe et connue. Si vous avez besoin d'une profondeur arbitraire, une auto-jointure ne suffit pas : c'est le signe qu'il faut utiliser une CTE récursive, que les personnes qui vous interrogent s'attendent à vous voir mentionner.

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

Auto-jointure ou CTE récursive

Distinction essentielle vérifiée en entretien :

Une auto-jointure gère un nombre fixe de niveaux. Trois copies correspondent à trois niveaux, pas davantage.
Une CTE récursive gère une profondeur illimitée en rejoignant de nouveau la table à elle-même jusqu'à ce qu'aucune nouvelle ligne n'apparaisse.

Ainsi, « afficher chaque employé et son responsable direct » nécessite une auto-jointure, tandis que « lister tous les ascendants dans la chaîne » nécessite la récursivité.

Catégories parent-enfant

Le même schéma permet de modéliser n'importe quel arbre : catégories de produits, fils de discussion, régions géographiques. Une table categories dont le parent_id référence son propre id a exactement la même structure que le cas employé-responsable.

Comprendre qu'une « table avec une clé étrangère qui se référence elle-même » équivaut à « une auto-jointure ou de la récursivité » est une connaissance réutilisable.

SELECT c.name AS category,
       p.name AS parent_category
FROM categories c
LEFT JOIN categories p ON c.parent_id = p.id;

Erreurs courantes avec les auto-jointures

Surveillez les erreurs suivantes en entretien :

Oublier les alias, ce qui provoque des erreurs de colonnes ambiguës.
Utiliser INNER JOIN et supprimer silencieusement les lignes racines (parent NULL).
Joindre dans le mauvais sens : e.id = m.manager_id au lieu de e.manager_id = m.id.

Indiquez toujours à voix haute quel alias désigne l'enfant et lequel désigne le parent avant d'écrire le ON.

Quand utiliser une auto-jointure

Utilisez une auto-jointure dès qu'une table relie des lignes à d'autres lignes de cette même table :

Hiérarchies avec un seul niveau de recherche fixe (employé vers responsable).
Associer ou comparer les lignes d'une même table (voir la leçon suivante).

Si la relation est récursive et sans limite, mentionnez une CTE récursive comme outil plus adapté. Cette nuance permet de distinguer les débutants des développeurs de niveau intermédiaire.

Vérification rapide

Vérifiez votre compréhension des auto-jointures dans les hiérarchies.

Récapitulatif : SELF JOIN pour les hiérarchies

Points essentiels :

Une auto-jointure est une jointure normale avec la même table des deux côtés, différenciée par des alias.
Une liste d'adjacence (clé étrangère qui se référence elle-même, comme manager_id) modélise un arbre dans une seule table.
Utilisez INNER JOIN pour les paires correspondantes ; LEFT JOIN pour conserver les lignes racines dont le parent vaut NULL.
Les auto-jointures gèrent une profondeur fixe ; un parcours sans limite nécessite une CTE récursive.

Questions Fréquemment Posées

La leçon « SELF JOIN pour les hiérarchies » est-elle gratuite ?

Oui — le texte complet de « SELF JOIN pour les hiérarchies » 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 Interview Prep, passe à CoddyKit PRO. Le cours SQL Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « SELF JOIN pour les hiérarchies » ?

Joindre une table à elle-même pour modéliser les relations employé-responsable et parent-enfant Tu pratiques SQL Interview Prep 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 Interview Prep ?

Aucune expérience préalable n'est requise. SQL Interview Prep 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 2 sur 4.

Combien de temps prend la leçon « SELF JOIN pour les hiérarchies » ?

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 Interview Prep ?

Oui. Chaque leçon SQL Interview Prep 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

CROSS JOIN et produits cartésiens
SELF JOIN pour les hiérarchies
Comparer des lignes au sein d’une même table
Choisir le bon type de jointure

← Retour à SQL Interview Prep