Qu'est-ce qu'une auto-jointure (self-join) ?

Question

Accepted Answer

Une **auto-jointure (self-join)** est une jointure où une table est jointe **à elle-même** — utile quand des lignes dans une table sont en relation avec *d'autres lignes de la même table*, comme dans les hiérarchies (employés et leurs managers) ou pour comparer des lignes au sein d'une table.

## L'exemple classique : employés et managers

```sql
-- join employees to itself to pair each employee with their manager
SELECT e.name AS employee, m.name AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id;   -- same table, two aliases!
-- → Bob | Ann, Carol | Ann, Ann | NULL
```

La clé est les **alias de table** (`e` et `m`) — ils vous permettent de traiter la table unique comme deux « copies » pour que vous puissiez joindre la ligne employé à sa ligne manager au sein de la même table. (L'utilisation de LEFT JOIN maintient les employés sans manager.)

## Autres utilisations des auto-jointures

```sql
-- find pairs of products with the same price
SELECT a.name, b.name, a.price
FROM products a
JOIN products b ON a.price = b.price AND a.id < b.id;   -- a.id < b.id avoids duplicates/self-pairs

-- find rows related to other rows in the same table (sequences, comparisons)
```

Les auto-jointures servent aussi à comparer des lignes au sein d'une table (trouver les doublons, les paires ou les entrées liées) — la condition `a.id < b.id` est une astuce courante pour éviter d'associer une ligne à elle-même et pour éviter les paires dupliquées.

## Comment cela fonctionne conceptuellement

```text
A self-join is just a regular join where both sides happen to be the SAME table.
The aliases create two logical "instances" of the table, so each row of one instance
can be matched against rows of the other instance.
→ Nothing special syntactically — it's a normal join, with the trick being aliases.
```

## Pourquoi c'est important

Les auto-jointures sont une technique SQL utile pour gérer les **relations au sein d'une seule table** — particulièrement les données hiérarchiques ou auto-référencées, ce qui est un modèle très courant dans le monde réel, donc comprendre les auto-jointures est précieux pour ces scénarios.

L'utilisation classique et la plus importante est les **hiérarchies** où les lignes font référence à d'autres lignes de la même table (employés faisant référence à leurs managers, catégories avec catégories parentes, structures organisationnelles, commentaires en fil de discussion) — les auto-jointures vous permettent d'interroger ces relations (appairant chaque employé avec son manager) ce que les requêtes plus simples ne peuvent pas exprimer.

Comprendre que le mécanisme clé est les **alias de table** (créer deux « instances » logiques de la table pour que les lignes puissent être mises en correspondance les unes avec les autres au sein de la même table) démystifie la technique — c'est juste une jointure normale où les deux côtés sont la même table.

Les auto-jointures gèrent aussi la comparaison de lignes au sein d'une table (trouver des paires, des doublons ou des entrées liées, souvent avec une condition comme `a.id < b.id` pour éviter l'auto-appairage et les doublons).

Comme les données auto-référencées et hiérarchiques sont courantes (organigrammes, arbres de catégories, relations manager, comparaison d'enregistrements au sein d'une table), et comme les auto-jointures sont le moyen standard pour interroger ces relations au sein d'une seule table, comprendre les auto-jointures — qu'une table peut être jointe à elle-même en utilisant des alias, et les modèles courants (hiérarchies, comparaisons de lignes) — est une connaissance SQL utile et pratiquement pertinente pour traiter une classe de requêtes impliquant des relations intra-table qui apparaissent fréquemment dans les modèles de données réels, et c'est un sujet courant en entretien d'embauche qui démontre une compréhension plus approfondie des jointures.