Hvad er et self-join?

Question

Accepted Answer

Et **self-join** er et join, hvor en tabel joines **til sig selv** — brugbar når rækker i en tabel er relateret til *andre rækker i samme tabel*, som f.eks. hierarkier (medarbejdere og deres chefer) eller sammenligning af rækker inden for en tabel.

## Klassisk eksempel: medarbejdere og chefer

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

Nøglen er **table aliases** (`e` og `m`) — de lader dig behandle den enkle tabel som to "kopier", så du kan joine medarbejderrækken til dens chefrakke inden for samme tabel. (Brug af LEFT JOIN bevarer medarbejdere uden chef.)

## Andre anvendelser af 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 bruges også til at sammenligne rækker inden for en tabel (finde dubletter, par eller relaterede poster) — betingelsen `a.id < b.id` er et almindeligt trick til at undgå at parre en rakke med sig selv og undgå duplikerede par.

## Hvordan det fungerer konceptuelt

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

## Hvorfor det har betydning

Self-joins er en brugbar SQL-teknik til at håndtere **relationer inden for en enkelt tabel** — særligt hierarkisk eller selvreferentiel data, hvilket er et almindeligt mønster i den virkelige verden, så forståelse af dem er værdifuld for disse scenarier.

Den klassiske og vigtigste anvendelse er **hierarkier**, hvor rækker refererer til andre rækker i samme tabel (medarbejdere, der refererer til deres chefer, kategorier med overordnede kategorier, organisatoriske strukturer, kommentarkæder) — self-joins lader dig forespørge disse relationer (pairing hver medarbejder med deres chef), hvilket enklere forespørgsler ikke kan udtrykke.

Forståelse af, at nøglemekanismen er **table aliases** (oprettelse af to logiske "instanser" af tabellen, så rækker kan matches mod hinanden inden for samme tabel), demystificerer teknikken — det er blot et normalt join, hvor begge sider er samme tabel.

Self-joins håndterer også sammenligning af rækker inden for en tabel (finde par, dubletter eller relaterede poster, ofte med en betingelse som `a.id < b.id` til at undgå selvpairing og dubletter).

Da selvreferentiel og hierarkisk data er almindelig (organigrammer, kategorityetræer, chefrelationer, sammenligning af poster inden for en tabel), og da self-joins er standardmåden at forespørge sådanne relationer inden for en enkelt tabel på, er forståelse af self-joins — at en tabel kan joines til sig selv ved hjælp af aliases, og de almindelige mønstre (hierarkier, rækkesammenligninger) — værdifuld, praktisk relevant SQL-viden til håndtering af en klasse af forespørgsler, der involverer intra-table relationer, som hyppigt opstår i virkelige datamodeller, og et almindeligt interviewemne, der demonstrerer dybere forståelse af joins.