Che cos'è un self-join?

Question

Accepted Answer

Un **self-join** è un join dove una tabella è unita **a se stessa** — utile quando le righe in una tabella si relazionano con *altre righe nella stessa tabella*, come le gerarchie (dipendenti e i loro manager) o il confronto di righe all'interno di una tabella.

## L'esempio classico: dipendenti e manager

```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 chiave sono gli **alias di tabella** (`e` e `m`) — ti permettono di trattare la singola tabella come due "copie" così puoi unire la riga del dipendente alla riga del suo manager all'interno della stessa tabella. (Usare LEFT JOIN mantiene i dipendenti senza manager.)

## Altri usi dei self-join

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

I self-join sono anche usati per confrontare righe all'interno di una tabella (trovando duplicati, coppie, o voci correlate) — la condizione `a.id < b.id` è un trucco comune per evitare di accoppiare una riga con se stessa e evitare coppie duplicate.

## Come funziona concettualmente

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

## Perché è importante

I self-join sono una tecnica SQL utile per gestire **relazioni all'interno di una singola tabella** — in particolare per dati gerarchici o auto-referenziali, che è un modello molto comune nel mondo reale, quindi comprendere i self-join è prezioso per questi scenari.

L'uso classico e più importante è **le gerarchie** dove le righe fanno riferimento ad altre righe nella stessa tabella (dipendenti che fanno riferimento ai loro manager, categorie con categorie padre, strutture organizzative, commenti in thread) — i self-join ti permettono di interrogare queste relazioni (accoppiando ogni dipendente con il suo manager) che query più semplici non riescono a esprimere.

Comprendere che il meccanismo chiave è **gli alias di tabella** (creando due "istanze" logiche della tabella così le righe possono essere abbinate l'una all'altra all'interno della stessa tabella) demistifica la tecnica — è solo un join normale dove entrambi i lati sono la stessa tabella.

I self-join gestiscono anche il confronto di righe all'interno di una tabella (trovando coppie, duplicati, o voci correlate, spesso con una condizione come `a.id < b.id` per evitare l'auto-accoppiamento e i duplicati).

Poiché i dati auto-referenziali e gerarchici sono comuni (organigrammi, alberi di categorie, relazioni di manager, confronto di record all'interno di una tabella), e poiché i self-join sono il modo standard per interrogare tali relazioni all'interno di una singola tabella, comprendere i self-join — che una tabella può essere unita a se stessa usando alias, e i pattern comuni (gerarchie, confronti di righe) — è una conoscenza SQL utile e praticamente rilevante per gestire una classe di query che coinvolgono relazioni intra-tabella che sorgono frequentemente nei modelli dati reali, e un argomento comune nelle interviste che dimostra una comprensione più profonda dei join.