SQL Academy · Lezione

Dipendenti e responsabili

Un classico esempio di gerarchia

Dipendenti e responsabili è una lezione SQL Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Che cos'è un self join

Un self join consiste nel collegare una tabella a se stessa. Può sembrare insolito, ma è estremamente utile quando le righe di una tabella hanno una relazione con altre righe della stessa tabella.

L'esempio classico è una tabella employees in cui ogni dipendente può avere un responsabile, che è a sua volta un dipendente memorizzato nella stessa tabella.

La tabella employees

Creiamo una semplice tabella employees. Ogni dipendente ha un id, un name e un manager_id che fa riferimento a un'altra riga della stessa tabella.

Quando manager_id è NULL, il dipendente non ha un responsabile: si trova al vertice della gerarchia, ad esempio è il CEO.

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(100) NOT NULL,
  manager_id INT REFERENCES employees(id)
);

Inserire dati di esempio

Popoliamo la tabella con una piccola gerarchia aziendale. Alice è il CEO e non ha un responsabile. Bob e Carol riportano entrambi ad Alice. Dave ed Eve riportano a Bob.

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

Interrogare senza un join

Se selezioniamo semplicemente tutte le righe, vediamo i numeri grezzi di manager_id, non i nomi dei responsabili. Questo è difficile da leggere e non è utile agli utenti finali.

SELECT id, name, manager_id
FROM employees;

Scrivere il self join

Per mostrare il nome del responsabile accanto a ogni dipendente, colleghiamo la tabella employees a se stessa. Assegniamo un alias diverso a ogni copia: e per il dipendente e m per il responsabile.

La condizione di join collega il manager_id del dipendente all'id del responsabile.

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

Includere i dipendenti senza responsabile

L'INNER JOIN precedente nasconde Alice perché il suo manager_id è NULL: non esiste una riga corrispondente sul lato destro. Per includere tutti, anche il dipendente al vertice, usi un LEFT JOIN.

Alice comparirà con NULL nella colonna del responsabile.

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

Usare COALESCE per migliorare la leggibilità

NULL nella colonna del responsabile può creare confusione. Possiamo usare COALESCE per sostituire NULL con un'etichetta leggibile come 'Nessun responsabile', rendendo l'output più chiaro nei report.

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

Trovare i collaboratori diretti

Possiamo invertire la query e chiederci: chi riporta direttamente a un responsabile specifico? Questa operazione consiste nel trovare i collaboratori diretti. Qui troviamo tutti i dipendenti che riportano direttamente ad Alice (id = 1).

SELECT e.name AS direct_report
FROM employees e
WHERE e.manager_id = 1;

Contare i collaboratori per responsabile

Combinare un self join con GROUP BY e COUNT permette di vedere quanti collaboratori diretti ha ogni responsabile. È utile per analizzare la distribuzione del carico di lavoro.

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

Due livelli di profondità

Per visualizzare contemporaneamente due livelli della gerarchia, ovvero il dipendente, il suo responsabile e il responsabile di quest'ultimo, possiamo collegare la tabella una terza volta. Ogni join aggiunge un altro livello della gerarchia.

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

I limiti dei self join

I self join funzionano bene per gerarchie fisse e poco profonde (1–3 livelli). Se la profondità è sconosciuta o illimitata, come nel caso di un organigramma aziendale che può raggiungere 10 livelli, sono necessarie le CTE ricorsive.

Per la maggior parte delle query pratiche sui rapporti tra dipendenti e responsabili, l'approccio con self join illustrato in questa lezione è lo strumento più adatto.

Verifica rapida

Verifichi la Sua comprensione dei self join e della gerarchia dipendenti-responsabili.

Riepilogo della lezione

In questa lezione ha imparato a usare un self join per modellare e interrogare una classica gerarchia dipendenti-responsabili memorizzata in una singola tabella.

Punti chiave:

Un self join collega una tabella a se stessa usando due alias diversi.
La condizione di join collega manager_id a id nella stessa tabella.
Usi INNER JOIN per visualizzare solo i dipendenti che hanno un responsabile e LEFT JOIN per includere tutti.
COALESCE può sostituire i valori NULL del responsabile con un'etichetta leggibile.
Per gerarchie di profondità illimitata, valuti l'uso di CTE ricorsive.

Domande Frequenti

La lezione «Dipendenti e responsabili» è gratuita?

Sì — il testo completo di «Dipendenti e responsabili» è 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 «Dipendenti e responsabili»?

Un classico esempio di gerarchia 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 2 di 4.

Quanto tempo richiede la lezione «Dipendenti e responsabili»?

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

← Torna a SQL Academy