Coding Interview Prep · Lezione

LEFT JOIN e conservazione delle righe senza corrispondenza

Capire quali righe conserva LEFT JOIN e come compaiono i NULL nelle righe senza corrispondenza

LEFT JOIN e conservazione delle righe senza corrispondenza è una lezione Coding Interview Prep 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 Coding Interview Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Coding Interview Prep include 4 lezioni in totale.

Lo scenario del colloquio

L'intervistatore dice: "Elenchi ogni cliente e i relativi ordini, includendo i clienti che non hanno mai effettuato ordini." Un INNER JOIN elimina i clienti senza ordini, quindi non soddisfa il requisito. La soluzione è un LEFT JOIN.

Un LEFT JOIN mantiene ogni riga della tabella a sinistra (quella indicata per prima) e aggiunge le righe corrispondenti della tabella a destra, quando esistono. Questa lezione costruisce il modello mentale preciso che gli intervistatori si aspettano.

Cosa garantisce LEFT JOIN

La promessa fondamentale è questa: ogni riga della tabella a sinistra compare nell'output almeno una volta, indipendentemente dal fatto che abbia trovato una corrispondenza.

Se una riga a sinistra trova corrispondenze a destra, si ottiene una riga di output per ogni corrispondenza.
Se una riga a sinistra non trova corrispondenze, si ottiene comunque una riga di output, con tutte le colonne della tabella a destra impostate su NULL.

Per questo gli intervistatori lo chiamano JOIN esterno: le righe che non rientrano nell'insieme delle corrispondenze vengono preservate invece di essere eliminate.

Le due tabelle

Per tutta la lezione useremo due tabelle semplici. customers contiene tutti i clienti; orders registra gli acquisti e fa riferimento a un cliente tramite customer_id.

Noti che il cliente 3 (Carol) non ha nessuna riga in orders. È proprio questo cliente senza corrispondenze che un LEFT JOIN deve preservare.

-- customers
-- id | name
--  1 | Alice
--  2 | Bob
--  3 | Carol

-- orders
-- id | customer_id | amount
-- 10 |     1       |  50
-- 11 |     1       |  75
-- 12 |     2       |  20

Scrivere il LEFT JOIN

La sintassi ricalca quella di un INNER JOIN, sostituendo INNER con LEFT (la parola OUTER è facoltativa: LEFT JOIN e LEFT OUTER JOIN sono identici).

La tabella scritta prima della parola chiave è il lato sinistro preservato. L'ordine è importante: customers LEFT JOIN orders mantiene tutti i clienti, non tutti gli ordini.

SELECT c.name, o.amount
FROM customers c
LEFT JOIN orders o
  ON o.customer_id = c.id;

Leggere il risultato

Ecco l'output di quella query. Alice ha trovato due corrispondenze, quindi compare due volte. Bob ha trovato una corrispondenza. Carol non ha trovato corrispondenze, quindi compare comunque con NULL nella colonna amount.

Quella singola riga di Carol con NULL è il segno distintivo di un LEFT JOIN. Un intervistatore che osserva il suo ragionamento ad alta voce vuole sentirle dire: "le righe a sinistra senza corrispondenze restano con NULL a destra".

-- name  | amount
-- Alice |  50
-- Alice |  75
-- Bob   |  20
-- Carol | NULL   <-- preserved, no match

Da dove provengono i NULL

Il NULL non è memorizzato in alcun punto. Il database lo genera perché non esiste una riga della tabella a destra da cui ricavare amount.

Ogni colonna proveniente dalla tabella a destra diventa NULL per una riga a sinistra senza corrispondenze: o.id, o.customer_id e o.amount sono tutti NULL nella riga di Carol. Questo è importante perché o.customer_id uguale a NULL non significa che il cliente non abbia un id; significa che non esisteva alcun ordine corrispondente.

Contare gli ordini per cliente

Una domanda frequente è: "Quanti ordini ha ogni cliente, inclusi gli zeri?" Un LEFT JOIN insieme a COUNT risolve il problema, ma è necessario contare la colonna della tabella a destra, non *.

COUNT(o.id) ignora i NULL, quindi per Carol restituisce 0. COUNT(*) restituirebbe erroneamente 1 per Carol, perché anche la riga con NULL generata dal JOIN conta come riga.

SELECT c.name, COUNT(o.id) AS order_count
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;
-- Alice | 2
-- Bob   | 1
-- Carol | 0

Il tranello COUNT(*) rispetto a COUNT(column)

È un classico tranello da colloquio. Dopo un LEFT JOIN, la riga a sinistra senza corrispondenze esiste fisicamente nel risultato, con colonne a destra impostate su NULL.

COUNT(*) conta quella riga e restituisce 1 per un cliente senza ordini.
COUNT(o.id) ignora il NULL e restituisce correttamente 0.

Quando servono veri valori zero, conti sempre una colonna che è NULL sul lato senza corrispondenze.

-- WRONG: Carol shows 1
SELECT c.name, COUNT(*) AS n
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;

Sommare con LEFT JOIN

Le aggregazioni diverse da COUNT gestiscono con naturalezza i NULL generati. SUM ignora i NULL, quindi per un cliente senza corrispondenze restituisce NULL (non un errore).

Nei report, gli intervistatori spesso vogliono zero invece di NULL. Racchiuda l'aggregazione in COALESCE per sostituirla con un valore predefinito.

SELECT c.name,
       COALESCE(SUM(o.amount), 0) AS total_spent
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;
-- Alice | 125
-- Bob   |  20
-- Carol |   0

Tabella sinistra e tabella destra, in modo chiaro

Quando un intervistatore chiede "quale tabella viene preservata?", risponda con sicurezza: quella a sinistra della parola chiave JOIN. La lettura va fatta da sinistra a destra.

A LEFT JOIN B = mantiene tutte le righe di A. Per mantenere invece tutte le righe di B, si può invertire l'ordine con B LEFT JOIN A oppure usare un RIGHT JOIN. La maggior parte dei team preferisce usare esclusivamente LEFT JOIN per maggiore leggibilità, semplicemente riordinando le tabelle.

Una checklist mentale

Quando vede un LEFT JOIN durante un colloquio, esponga ad alta voce questa checklist:

Lato preservato? La tabella a sinistra: tutte le righe vengono mantenute.
Righe senza corrispondenze? Compaiono una volta, con NULL provenienti dalla tabella a destra.
Si deve contare? Usi COUNT(right_col) per ottenere veri zeri.
Si deve sommare? Racchiuda l'espressione in COALESCE se serve 0 invece di NULL.

Esporre questa checklist a parole dimostra un rigore da livello senior.

Verifica rapida

Metta alla prova la sua intuizione sui LEFT JOIN applicata al conteggio.

Riepilogo

LEFT JOIN preserva ogni riga della tabella a sinistra. Le righe a sinistra con corrispondenze vengono associate alle rispettive righe a destra; quelle senza corrispondenze rimangono una volta sola, con NULL in tutte le colonne della tabella a destra.

La tabella a sinistra è quella che precede la parola chiave JOIN.
I NULL generati indicano le righe senza corrispondenze.
COUNT(right_col) restituisce veri zeri; COUNT(*) no.
COALESCE(SUM(...), 0) trasforma i totali NULL in zero.

Questa è la base per individuare i dati mancanti e gli anti-join nelle lezioni successive.

Domande Frequenti

La lezione «LEFT JOIN e conservazione delle righe senza corrispondenza» è gratuita?

Sì — il testo completo di «LEFT JOIN e conservazione delle righe senza corrispondenza» è 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 Coding Interview Prep, passa a CoddyKit PRO. Il corso Coding Interview Prep include 4 lezioni in totale.

Cosa imparerò in «LEFT JOIN e conservazione delle righe senza corrispondenza»?

Capire quali righe conserva LEFT JOIN e come compaiono i NULL nelle righe senza corrispondenza Eserciti Coding Interview Prep 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 Coding Interview Prep?

Non è richiesta alcuna esperienza precedente. Coding Interview Prep 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 «LEFT JOIN e conservazione delle righe senza corrispondenza»?

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 Coding Interview Prep?

Sì. Ogni lezione Coding Interview Prep 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

LEFT JOIN e conservazione delle righe senza corrispondenza
Semantica di RIGHT e FULL OUTER JOIN
Trovare le righe senza corrispondenza (anti-join)
La trappola di WHERE sui full outer join

← Torna a Coding Interview Prep