Wat is een self-join?

Question

Accepted Answer

Een **self-join** is een join waarbij een tabel **met zichzelf wordt joined** — nuttig wanneer rijen in een tabel gerelateerd zijn aan *andere rijen in dezelfde tabel*, zoals hiërarchieën (werknemers en hun managers) of het vergelijken van rijen binnen een tabel.

## Het klassieke voorbeeld: werknemers en 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
```

De sleutel is **table aliases** (`e` en `m`) — hiermee kun je de enkele tabel als twee "kopieën" behandelen zodat je de werknemerij met de bijbehorende managerij in dezelfde tabel kunt verbinden. (Het gebruiken van LEFT JOIN behoudt werknemers zonder manager.)

## Andere toepassingen van self-joins

```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)
```

Self-joins worden ook gebruikt om rijen binnen een tabel te vergelijken (duplicaten, paren of gerelateerde entries vinden) — de voorwaarde `a.id < b.id` is een veelgebruikte trick om te voorkomen dat een rij met zichzelf wordt gekoppeld en om dubbele paren te vermijden.

## Hoe het conceptueel werkt

```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.
```

## Waarom het belangrijk is

Self-joins zijn een handige SQL-techniek voor het afhandelen van **relaties binnen een enkele tabel** — met name hiërarchische of zelf-referentiële gegevens, wat een veelvoorkomend patroon in de praktijk is, dus het begrijpen ervan is waardevol voor deze scenario's.

Het klassieke en belangrijkste gebruik is **hiërarchieën** waarbij rijen naar andere rijen in dezelfde tabel verwijzen (werknemers die hun managers refereren, categorieën met bovenliggende categorieën, organisatiestructuren, threaded comments) — self-joins stellen je in staat deze relaties op te vragen (elke werknemer met hun manager koppelen) wat eenvoudigere queries niet kunnen uitdrukken.

Begrijpen dat het kernmechanisme **table aliases** is (twee logische "exemplaren" van de tabel creëren zodat rijen tegen elkaar kunnen worden vergeleken binnen dezelfde tabel) demystificeert de techniek — het is slechts een normale join waar beide zijden dezelfde tabel zijn.

Self-joins verwerken ook het vergelijken van rijen binnen een tabel (paren, duplicaten of gerelateerde entries vinden, vaak met een voorwaarde zoals `a.id < b.id` om zelf-koppeling en duplicaten te voorkomen).

Omdat zelf-referentiële en hiërarchische gegevens veel voorkomen (org charts, categorybomen, managerrelaties, records vergelijken binnen een tabel), en omdat self-joins de standaardmanier zijn om dergelijke relaties binnen een enkele tabel op te vragen, is het begrijpen van self-joins — dat een tabel met zichzelf kan worden samengevoegd met behulp van aliases, en de veelgebruikte patronen (hiërarchieën, rijvergelijkingen) — nuttige, praktisch relevante SQL-kennis voor het afhandelen van een klasse van queries met intra-tabel relaties die regelmatig voorkomen in echte gegevensmodellen, en een veelvoorkomend interviewonderwerp dat aantoont dat je joins dieper begrijpt.