Vad är en self-join?

Question

Accepted Answer

En **self-join** är en join där en tabell joins **mot sig själv** — användbar när rader i en tabell relaterar till *andra rader i samma tabell*, såsom hierarkier (anställda och deras chefer) eller jämförande av rader inom en tabell.

## Det klassiska exemplet: anställda och 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
```

Nyckelkomponenten är **tabellalias** (`e` och `m`) — de låter dig behandla den enskilda tabellen som två "kopior" så du kan joinsa anställdraden med dess chefrad inom samma tabell. (Med LEFT JOIN behålls anställda utan chef.)

## Andra användningsområden för 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 används också för att jämföra rader inom en tabell (hitta dubbletter, par eller relaterade poster) — villkoret `a.id < b.id` är ett vanligt trick för att undvika att para en rad med sig själv och undvika duplicerade par.

## Hur det fungerar konceptuellt

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

## Varför det är viktigt

Self-joins är en användbar SQL-teknik för att hantera **relationer inom en enskild tabell** — särskilt hierarkisk eller självreferentiell data, vilket är ett vanligt verkligt mönster, så att förstå dem är värdefullt för dessa scenarier.

Det klassiska och viktigaste användningsområdet är **hierarkier** där rader refererar till andra rader i samma tabell (anställda refererar till sina chefer, kategorier med överordnade kategorier, organisationsstrukturer, trådade kommentarer) — self-joins låter dig fråga dessa relationer (para ihop varje anställd med sin chef) vilket enklare queries inte kan uttrycka.

Att förstå att nyckelmekanismen är **tabellalias** (skapa två logiska "instanser" av tabellen så rader kan matchas mot varandra inom samma tabell) avmystifierar tekniken — det är bara en vanlig join där båda sidorna är samma tabell.

Self-joins hanterar också jämförande av rader inom en tabell (hitta par, dubbletter eller relaterade poster, ofta med ett villkor som `a.id < b.id` för att undvika själv-parning och dubbletter).

Då självreferentiell och hierarkisk data är vanlig (organisationsscheman, kategoriträd, chefrelationer, jämförande av poster inom en tabell), och då self-joins är standardsättet att fråga sådana relationer inom en enskild tabell, är förståelse för self-joins — att en tabell kan joinsa mot sig själv med alias, och de vanliga mönstren (hierarkier, radjämförelser) — användbar, praktiskt relevant SQL-kunskap för att hantera en klass av queries som involverar intra-tabellrelationer som uppstår ofta i verkliga datamodeller, och ett vanligt intervjuämne som demonstrerar djupare förståelse för joins.