Unione completa dei dati con FULL OUTER JOIN

Oggi vediamo la forma più democratica di unione dei dati — FULL OUTER JOIN. Qui tutti sono i benvenuti nel risultato, anche se non hanno una "coppia".

FULL OUTER JOIN è un tipo di join che restituisce tutte le righe da entrambe le tabelle. Se una riga in una tabella non trova corrispondenza nell'altra, i valori mancanti nel risultato saranno NULL. È come tenere traccia di tutte le persone che sono venute a due feste diverse: anche se qualcuno è venuto solo a una, sarà comunque presente nella lista.

Visivamente puoi immaginarlo così:

Tabella A                     Tabella B
+----+----------+             +----+----------+
| id | nome     |             | id | corso    |
+----+----------+             +----+----------+
| 1  | Alice    |             | 2  | Matematica|
| 2  | Bob      |             | 3  | Fisica   |
| 4  | Charlie  |             | 5  | Storia   |
+----+----------+             +----+----------+

FULL OUTER JOIN RISULTATO:
+----+----------+----------+
| id | nome     | corso    |
+----+----------+----------+
| 1  | Alice    | NULL     |
| 2  | Bob      | Matematica|
| 3  | NULL     | Fisica   |
| 4  | Charlie  | NULL     |
| 5  | NULL     | Storia   |
+----+----------+----------+

Le righe senza corrispondenza rimangono, ma i dati delle colonne mancanti saranno riempiti con NULL.

Sintassi di FULL OUTER JOIN

La sintassi è semplice, ma il suo potere è grande:

SELECT
    colonne
FROM 
    tabella1
FULL OUTER JOIN 
    tabella2
ON tabella1.colonna_comune = tabella2.colonna_comune;

La parte chiave qui è FULL OUTER JOIN, che dice a PostgreSQL di prendere tutte le righe da entrambe le tabelle. Se una riga non trova una coppia secondo la condizione ON, i valori vengono sostituiti da NULL.

Esempi di utilizzo

Vediamo esempi reali usando il database university con le tabelle students e enrollments.

Esempio 1: lista completa di studenti e corsi

Immagina di avere due tabelle:

Tabella students:

Tabella enrollments:

Il nostro obiettivo è creare una lista completa di studenti e corsi, inclusi gli studenti non iscritti a nessun corso e i corsi senza studenti.

Ecco la query:

SELECT
    s.student_id, 
    s.nome, 
    e.corso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Risultato:

Come vedi, nel risultato ci sono tutti gli studenti e tutti i corsi. Lo studente Charlie non è iscritto a nessun corso, quindi il campo corso è NULL. Il corso Storia non ha studenti, quindi student_id e nome sono NULL.

Esempio 2: Analisi di vendite e prodotti

Pensiamo ora a un negozio. Abbiamo due tabelle:

Tabella products:

Tabella sales:

Vogliamo ottenere la lista completa di tutti i prodotti e tutte le vendite, inclusi i prodotti mai venduti e le vendite con product_id errato.

Query:

SELECT
    p.product_id,
    p.nome AS nome_prodotto,
    s.quantità
FROM 
    products p
FULL OUTER JOIN 
    sales s
ON 
    p.product_id = s.product_id;

Risultato:

Qui vediamo che Smartphone non ha vendite (quantità = NULL), e la vendita con product_id = 4 non corrisponde a nessun prodotto.

Esercizio pratico

Prova a scrivere una query per le tabelle departments e employees:

Tabella departments:

Tabella employees:

Scrivi un FULL OUTER JOIN per ottenere la lista completa di dipartimenti e dipendenti. Riempi i dati mancanti con NULL.

Come gestire i valori NULL

Il problema dei valori NULL è una conseguenza inevitabile dell'uso di FULL OUTER JOIN. Ad esempio, nella vita reale potresti voler sostituire i NULL con valori più significativi. In PostgreSQL puoi farlo con la funzione COALESCE().

Esempio:

SELECT
    COALESCE(s.nome, 'Nessuno Studente') AS nome_studente,
    COALESCE(e.corso, 'Nessun Corso') AS nome_corso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Risultato:

Ora invece di NULL vediamo valori più chiari che rendono i report più leggibili.

Quando usare FULL OUTER JOIN

FULL OUTER JOIN è utile quando vuoi vedere tutti i dati da entrambe le tabelle, anche se non sono completamente collegati. Esempi:

• Report di vendite e prodotti — per vedere sia i prodotti venduti che quelli non venduti.
• Analisi di studenti e corsi — per controllare se ci sono dati non considerati.
• Confronto di liste — ad esempio, per trovare differenze tra due insiemi di dati.

Spero che questa lezione ti abbia dato una buona idea di FULL OUTER JOIN. Ora ti aspetta il mondo affascinante delle join più complesse e della manipolazione dei dati!