SQL Academy · Leçon

Employés et responsables

Un exemple classique de hiérarchie.

Leçon 2 sur 413 étapes

Employés et responsables est une leçon SQL Academy 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 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, mais c'est extrêmement utile lorsque des lignes d'une table ont une relation avec d'autres lignes de cette même table.

L'exemple classique est une table des employés dans laquelle chaque employé peut avoir un responsable — et ce responsable est lui aussi un employé enregistré dans la même table.

La table des employés

Créons une table employees simple. Chaque employé possède un id, un name et un manager_id qui pointe vers une autre ligne de la même table.

Lorsque manager_id vaut NULL, l'employé n'a pas de responsable : il se trouve au sommet de la hiérarchie (par exemple, le CEO).

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(100) NOT NULL,
  manager_id INT REFERENCES employees(id)
);

Insérer des données d'exemple

Remplissons la table avec une petite hiérarchie d'entreprise. Alice est le CEO (elle n'a pas de responsable). Bob et Carol dépendent tous deux d'Alice. Dave et Eve dépendent de Bob.

INSERT INTO employees (id, name, manager_id) VALUES
  (1, 'Alice',   NULL),
  (2, 'Bob',     1),
  (3, 'Carol',   1),
  (4, 'Dave',    2),
  (5, 'Eve',     2),
  (6, 'Frank',   3);

Interroger les données sans jointure

Si nous sélectionnons simplement toutes les lignes, nous voyons les nombres bruts de manager_id, et non les noms des responsables. Ces données sont difficiles à lire et peu utiles pour les utilisateurs finaux.

SELECT id, name, manager_id
FROM employees;

Écrire l'auto-jointure

Pour afficher le nom du responsable à côté de chaque employé, nous joignons la table employees à elle-même. Nous donnons un alias différent à chaque copie : e pour l'employé et m pour le responsable.

La condition de jointure relie le manager_id de l'employé à l'id du responsable.

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

Inclure les employés sans responsable

La INNER JOIN précédente masque Alice, car son manager_id vaut NULL : aucune ligne correspondante n'existe du côté droit. Pour inclure tout le monde (y compris l'employé au sommet de la hiérarchie), utilisez une LEFT JOIN.

Alice apparaîtra avec NULL dans la colonne du responsable.

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

Utiliser COALESCE pour améliorer la lisibilité

La valeur NULL dans la colonne du responsable peut prêter à confusion. Nous pouvons utiliser COALESCE pour remplacer NULL par un libellé clair comme 'Aucun responsable', afin de rendre les résultats plus lisibles dans les rapports.

SELECT
  e.name                              AS employee,
  COALESCE(m.name, 'No Manager')      AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id
ORDER BY manager, employee;

Trouver les subordonnés directs

Nous pouvons inverser la requête pour poser la question suivante : qui dépend d'un responsable précis ? On appelle cela trouver les subordonnés directs. Ici, nous trouvons tous les employés qui dépendent directement d'Alice (id = 1).

SELECT e.name AS direct_report
FROM employees e
WHERE e.manager_id = 1;

Compter les subordonnés par responsable

Associer une auto-jointure à GROUP BY et COUNT permet de voir combien de subordonnés directs chaque responsable possède. Cela est utile pour analyser la charge de travail.

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

Deux niveaux de profondeur

Pour voir simultanément deux niveaux de hiérarchie — l'employé, son responsable et le responsable de celui-ci — nous pouvons joindre la table une troisième fois. Chaque jointure ajoute un niveau supplémentaire à la hiérarchie.

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

Quand les auto-jointures atteignent leurs limites

Les auto-jointures fonctionnent bien pour les hiérarchies fixes et peu profondes (1–3 niveaux). Si la profondeur est inconnue ou illimitée — comme dans un organigramme d'entreprise pouvant comporter 10 niveaux — vous devez utiliser des CTE récursives.

Pour la plupart des requêtes pratiques concernant les employés et leurs responsables, l'approche par auto-jointure présentée dans cette leçon est l'outil adapté.

Vérification rapide

Vérifiez votre compréhension des auto-jointures et de la hiérarchie des employés et des responsables.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris à utiliser une auto-jointure pour modéliser et interroger une hiérarchie classique d'employés et de responsables stockée dans une seule table.

Points essentiels :

Une auto-jointure joint une table à elle-même à l'aide de deux alias différents.
La condition de jointure relie manager_id à id dans la même table.
Utilisez INNER JOIN pour afficher uniquement les employés qui ont un responsable, et LEFT JOIN pour inclure tout le monde.
COALESCE peut remplacer les valeurs NULL des responsables par un libellé clair.
Pour les hiérarchies d'une profondeur illimitée, envisagez d'utiliser des CTE récursives.

Gratuit pour commencer

Apprends SQL avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 46
Leçons: 183

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Employés et responsables » est-elle gratuite ?

Oui — le texte complet de « Employés et responsables » 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 « Employés et responsables » ?

Un exemple classique de hiérarchie. 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 2 sur 4.

Combien de temps prend la leçon « Employés et responsables » ?

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

← Retour à SQL Academy