Hva er en self-join?

Question

IT Interview Practice · Accepted Answer

En **self-join** er en join der en tabell blir joinettet **med seg selv** — nyttig når rader i en tabell er relatert til *andre rader i samme tabell*, for eksempel hierarkier (ansatte og deres ledere) eller sammenligning av rader innenfor en tabell.

## Det klassiske eksemplet: ansatte og ledere

```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økkelen er **tabelaliaser** (`e` og `m`) — de lar deg behandle den enkelte tabellen som to "kopier" slik at du kan joine ansattraden med leder-raden innenfor samme tabell. (Bruk av LEFT JOIN opprettholder ansatte uten leder.)

## Andre bruksområder for 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 brukes også til å sammenligne rader innenfor en tabell (finne duplikater, par eller relaterte oppføringer) — betingelsen `a.id < b.id` er et vanlig triks for å unngå å pare en rad med seg selv og unngå dupliserte par.

## Hvordan det fungerer konseptuelt

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

Self-joins er en nyttig SQL-teknikk for å håndtere **relasjoner innenfor en enkelt tabell** — spesielt hierarkiske eller selvreferende data, som er et vanlig mønster i virkeligheten, så forståelse av dem er verdifullt i disse scenarioene.

Det klassiske og viktigste bruket er **hierarkier** der rader refererer til andre rader i samme tabell (ansatte som refererer til lederne sine, kategorier med overordnede kategorier, organisasjonsstrukturer, kommentartråder) — self-joins lar deg spørre om disse relasjonene (pare hver ansatt med sin leder) som enklere spørsmål ikke kan uttrykke.

Forståelse av at nøkelmekanismen er **tabelaliaser** (opprettelse av to logiske "instanser" av tabellen slik at rader kan matches mot hverandre innenfor samme tabell) demystifiserer teknikken — det er bare en vanlig join der begge sider er samme tabell.

Self-joins håndterer også sammenligning av rader innenfor en tabell (finne par, duplikater eller relaterte oppføringer, ofte med en betingelse som `a.id < b.id` for å unngå selvpairing og duplikater).

Siden selvreferende og hierarkiske data er vanlig (organisasjonskart, kategorier, lederrelasjoner, sammenligning av poster innenfor en tabell), og siden self-joins er standardmåten å spørre om slike relasjoner innenfor en enkelt tabell på, er forståelse av self-joins — at en tabell kan joines med seg selv ved hjelp av aliaser, og de vanlige mønstrene (hierarkier, radsammenligninger) — nyttig, praktisk relevant SQL-kunnskap for håndtering av en klasse spørsmål som involverer intra-tabelrelasjoner som oppstår hyppig i virkelige datamodeller, og et vanlig intervjuemne som demonstrerer dypere forståelse av joins.

Det klassiske eksemplet: ansatte og ledere

Andre bruksområder for self-joins

Hvordan det fungerer konseptuelt

Hvorfor det betyr noe

Relaterte spørsmål