0Pricing
SQL Academy · Lezione

Che cos'è un self join

Esegua il join di una tabella con se stessa usando gli alias

Che cos'è un self join è una lezione SQL Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento SQL Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso SQL Academy include 4 lezioni in totale.

Collegare una tabella a se stessa

Un self join consiste nel collegare una tabella a se stessa. All'inizio può sembrare insolito, ma è una tecnica potente, utilizzata quando le righe di una singola tabella sono correlate ad altre righe della stessa tabella.

L'esempio più comune è una tabella employees in cui ogni riga relativa a un dipendente contiene anche l'ID del suo responsabile, che è a sua volta un dipendente della stessa tabella.

La tabella employees

Consideri una tabella employees in cui ogni riga contiene un id, un name e un manager_id che fa riferimento a un'altra riga della stessa tabella.

Questa struttura è chiamata relazione autorreferenziale o ricorsiva. Esegua la query seguente per creare e popolare la tabella.

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(50),
  manager_id INT
);

INSERT INTO employees VALUES
  (1, 'Alice',   NULL),
  (2, 'Bob',     1),
  (3, 'Carol',   1),
  (4, 'Dave',    2),
  (5, 'Eve',     2),
  (6, 'Frank',   3);

Perché i join normali non funzionano in questo caso

Se desidera visualizzare ogni dipendente insieme al nome del suo responsabile, entrambe le informazioni si trovano nella stessa tabella. Un join normale collega due tabelle diverse (o almeno due origini diverse).

Per leggere due volte dalla stessa tabella, una volta per il dipendente e una volta per il responsabile, è necessario usare un self join combinato con gli alias delle tabelle.

Presentazione degli alias

Per eseguire un self join, scriva due volte lo stesso nome di tabella nella clausola FROM / JOIN e assegni un alias diverso a ogni occorrenza. Gli alias consentono a SQL di trattarle come due tabelle logiche separate.

La convenzione consiste nell'usare alias brevi e descrittivi, come e per employee e m per manager.

-- Conceptual structure (not yet a full query)
-- FROM employees AS e
-- JOIN employees AS m ON e.manager_id = m.id

Il primo self join

Ecco un self join completo che elenca ogni dipendente insieme al nome del suo responsabile. La condizione ON collega il manager_id del dipendente all'id del responsabile.

Alice non ha un responsabile, quindi viene esclusa da INNER JOIN: non esiste una riga corrispondente sul lato del responsabile.

SELECT
  e.name   AS employee,
  m.name   AS manager
FROM employees AS e
INNER JOIN employees AS m
  ON e.manager_id = m.id;

Includere le righe senza responsabile

Quando usa INNER JOIN, le righe che non hanno corrispondenze vengono eliminate. Alice ha manager_id = NULL, quindi scompare dai risultati.

Passi a LEFT JOIN per mantenere tutti i dipendenti e visualizzare semplicemente NULL (o un'etichetta) quando non esiste un responsabile.

SELECT
  e.name             AS employee,
  COALESCE(m.name, 'No Manager') AS manager
FROM employees AS e
LEFT JOIN employees AS m
  ON e.manager_id = m.id;

Filtrare i risultati del self join

Può aggiungere una clausola WHERE a un self join proprio come a qualsiasi altra query. L'esempio seguente recupera solo i dipendenti il cui responsabile diretto è Alice (id = 1).

SELECT
  e.name  AS employee,
  m.name  AS manager
FROM employees AS e
INNER JOIN employees AS m
  ON e.manager_id = m.id
WHERE m.name = 'Alice';

Contare i collaboratori diretti

I self join si combinano naturalmente con le funzioni di aggregazione. La query seguente conta quanti collaboratori diretti ha ogni responsabile raggruppando in base all'alias del responsabile.

SELECT
  m.name           AS manager,
  COUNT(e.id)      AS direct_reports
FROM employees AS e
INNER JOIN employees AS m
  ON e.manager_id = m.id
GROUP BY m.name
ORDER BY direct_reports DESC;

Self join su dati non gerarchici

I self join non sono limitati alle gerarchie. Ogni volta che le righe di una tabella sono correlate ad altre righe della stessa tabella, un self join può essere utile.

Per esempio, può trovare tutte le coppie di dipendenti che hanno lo stesso responsabile collegando la tabella a se stessa sui valori corrispondenti di manager_id e assicurandosi di non associare un dipendente a se stesso.

SELECT
  a.name AS employee_1,
  b.name AS employee_2,
  a.manager_id
FROM employees AS a
INNER JOIN employees AS b
  ON a.manager_id = b.manager_id
  AND a.id < b.id;

Il ruolo dell'alias

Gli alias sono obbligatori in un self join: senza di essi, il database non può determinare a quale copia della tabella faccia riferimento ogni colonna e restituirà un errore di ambiguità.

Può usare i nomi di alias che preferisce. La regola fondamentale è anteporre l'alias corretto a ogni riferimento a una colonna, in modo che SQL sappia quale istanza della tabella consultare.

-- This will fail: column 'name' is ambiguous
-- SELECT name FROM employees JOIN employees ON manager_id = id;

-- This works: aliases remove the ambiguity
SELECT e.name, m.name
FROM employees AS e
JOIN employees AS m ON e.manager_id = m.id;

Casi d'uso reali

I self join sono frequenti nei database reali. Tra i casi d'uso comuni ci sono:

  • Organigrammi — dipendenti e relativi responsabili
  • Alberi di categorie — categorie padre e figlie
  • Distinte base — componenti costituiti da altri componenti
  • Social network — individuare gli amici degli amici in una singola tabella delle connessioni

Riconoscere una chiave esterna autorreferenziale in uno schema è il primo indizio che potrebbe essere necessario un self join.

Verifica rapida

Verifichi la Sua comprensione dei self join prima di proseguire.

Riepilogo della lezione

In questa lezione ha imparato che cos'è un self join e quando usarlo:

  • Un self join collega una tabella a se stessa facendovi riferimento due volte con alias diversi
  • Usi INNER JOIN per escludere le righe senza corrispondenza, ad esempio i responsabili al vertice, oppure LEFT JOIN per mantenerle
  • Aggiunga WHERE, GROUP BY e funzioni di aggregazione esattamente come farebbe in qualsiasi altro join
  • Usi a.id < b.id nella clausola ON per evitare coppie duplicate quando confronta righe della stessa tabella
  • I self join sono lo strumento principale per i dati gerarchici, gli alberi di categorie e qualsiasi relazione autorreferenziale

Prossimo argomento: esplorare gerarchie a più livelli con le CTE ricorsive.

Domande Frequenti

La lezione «Che cos'è un self join» è gratuita?

Sì — il testo completo di «Che cos'è un self join» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso SQL Academy, passa a CoddyKit PRO. Il corso SQL Academy include 4 lezioni in totale.

Cosa imparerò in «Che cos'è un self join»?

Esegua il join di una tabella con se stessa usando gli alias Eserciti SQL Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare SQL Academy?

Non è richiesta alcuna esperienza precedente. SQL Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Che cos'è un self join»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione SQL Academy?

Sì. Ogni lezione SQL Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Che cos'è un self join
  2. Dipendenti e responsabili
  3. Confrontare righe nella stessa tabella
  4. Limiti dei self join
← Torna a SQL Academy