JOIN, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste (un ON scritto al contrario, un soprannome diverso). Confronta il ragionamento, non le singole parole.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · Il treno di ogni corsa
In italiano. Per ogni corsa, il treno con quell'id; tieni le corse del 16 novembre; metti in ordine di partenza.
SELECT c.partenza, t.codice
FROM corse c
JOIN treni t ON t.id = c.treno_id
WHERE c.data = '2026-11-16'
ORDER BY c.partenza; partenza | codice
----------+--------
05:42:00 | M12
06:10:00 | M14
06:25:00 | T28
07:05:00 | M12
07:30:00 | M16
08:15:00 | M18
18:40:00 | M12
(7 rows)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Come sopra ma senza ORDER BY | Le righe sono quelle giuste, ma escono nell'ordine della tabella: la corsa delle 07:05 prima di quella delle 06:10 | test_es01_dalla_partenza_piu_presto |
JOIN treni t ON t.id = c.id | L'ON confronta l'id del treno con l'id della corsa: i codici escono abbinati a caso, o mancano | test_es01_le_corse_del_16_con_il_codice_del_treno e test_es01_dalla_partenza_piu_presto |
2 · Chi lavora dove
In italiano. Per ogni persona, la stazione con l'id uguale al suo stazione_id. La JOIN semplice butta chi non ha una stazione, che è quello che chiede la consegna.
SELECT p.nome, p.cognome, s.nome
FROM personale p
JOIN stazioni s ON s.id = p.stazione_id; nome | cognome | nome
---------+----------+---------------
Lucia | Ferri | Porta Codice
Nadia | Russo | Vecchia Fiera
Sergio | Colombo | Porta Codice
Elena | Marchi | Via Variabile
Marta | Villa | Piazza Query
Tommaso | Greco | Largo Lista
Rita | Galbiati | Ponte Ciclo
Paolo | Riva | Piazza Query
Anna | Colombo | Via Variabile
Giulia | Bassi | Largo Lista
Bruno | Fontana | Porta Codice
Carla | Meroni | Corso Tupla
(12 rows)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
LEFT JOIN stazioni s ON s.id = p.stazione_id | Restano anche le quattro persone senza stazione, con il nome vuoto: 16 righe invece di 12 | test_es02_solo_chi_ha_una_stazione |
JOIN stazioni s ON s.id = p.id | L'ON abbina l'id della stazione al badge della persona: Sergio (B-04) finirebbe a Ponte Ciclo solo perché 4 = 4 | test_es02_solo_chi_ha_una_stazione |
3 · I ritardi più seri
In italiano. Dalle corse, attacca il treno e il macchinista (due JOIN, una per chiave esterna); tieni i ritardi sopra 5 minuti; dal ritardo più grande.
SELECT c.data, t.codice, p.cognome, c.ritardo_min
FROM corse c
JOIN treni t ON t.id = c.treno_id
JOIN personale p ON p.id = c.macchinista_id
WHERE c.ritardo_min > 5
ORDER BY c.ritardo_min DESC; data | codice | cognome | ritardo_min
------------+--------+---------+-------------
2026-11-18 | M12 | Colombo | 15
2026-11-16 | M12 | Pozzi | 12
2026-11-18 | M12 | Greco | 9
2026-11-17 | T05 | Colombo | 8
2026-11-17 | M20 | Colombo | 6
(5 rows)I ritardi NULL (il tabellone guasto) non sono maggiori di 5: il WHERE li lascia fuori da solo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ORDER BY c.ritardo_min (senza DESC) | Le righe sono giuste ma vanno dal ritardo più piccolo | test_es03_dal_ritardo_piu_grande |
WHERE c.ritardo_min >= 5 | Entra anche la corsa con esattamente 5 minuti: una riga in più | test_es03_i_ritardi_con_treno_e_macchinista e test_es03_dal_ritardo_piu_grande |
4 · Da dove a dove
In italiano. La tabella delle stazioni serve due volte: una per il nome della partenza, una per quello dell'arrivo. Due JOIN alla stessa tabella con due soprannomi, ognuna con la sua chiave esterna.
SELECT c.partenza, da.nome, a.nome
FROM corse c
JOIN stazioni da ON da.id = c.da_stazione_id
JOIN stazioni a ON a.id = c.a_stazione_id
WHERE c.data = '2026-11-17'
ORDER BY c.partenza; partenza | nome | nome
----------+----------------+----------------
05:42:00 | Porta Codice | Piazza Query
06:50:00 | Via Variabile | Largo Lista
07:12:00 | Corso Funzione | Darsena Indice
07:45:00 | Ponte Ciclo | Piazza Query
08:20:00 | Piazza Query | Porta Codice
09:05:00 | Darsena Indice | Borgo Stringa
17:55:00 | Largo Lista | Corso Tupla
(7 rows)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Una sola JOIN stazioni s ON s.id = c.da_stazione_id, poi SELECT c.partenza, s.nome, s.nome | Nessun errore, ma partenza e arrivo sono uguali: hai la stazione di partenza due volte | test_es04_partenza_e_arrivo_con_i_nomi e test_es04_dalla_partenza_piu_presto |
da legato a a_stazione_id e a legato a da_stazione_id | Gli ON sono incrociati: i nomi escono scambiati | test_es04_partenza_e_arrivo_con_i_nomi e test_es04_dalla_partenza_piu_presto |
5 · I treni mai usati
In italiano. Parti dai treni (è l'elenco che vuoi). Attacca le corse con LEFT JOIN: un treno senza corse resta, con le colonne di corse vuote. Tieni solo quelli con la chiave di corse vuota.
Il disegno.
SELECT t.codice
FROM treni t
LEFT JOIN corse c ON c.treno_id = t.id
WHERE c.id IS NULL; codice
--------
T31
(1 row)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
JOIN corse c ON … al posto di LEFT JOIN | T31 non ha coppie e sparisce prima del WHERE: zero righe | test_es05_i_treni_senza_nessuna_corsa |
WHERE c.id = NULL | = NULL non è mai vero: zero righe, senza nessun errore | test_es05_i_treni_senza_nessuna_corsa |
6 · Le patenti e chi le ha
In italiano. Tutte le patenti devono restare, anche quella che nessuno ha: si parte da patenti con LEFT JOIN. Dalla patente al ponte, dal ponte alla persona. Tutte e due le JOIN sono LEFT, perché la riga vuota della funicolare deve attraversare anche la seconda.
SELECT pa.nome, p.nome, p.cognome
FROM patenti pa
LEFT JOIN personale_patenti pp ON pp.patente_id = pa.id
LEFT JOIN personale p ON p.id = pp.personale_id; nome | nome | cognome
------------+---------+----------
metro | Sergio | Colombo
tram | Sergio | Colombo
metro | Rita | Galbiati
metro | Tommaso | Greco
tram | Tommaso | Greco
tram | Paolo | Riva
metro | Ernesto | Pozzi
tram | Ernesto | Pozzi
tram | Ivo | Brambati
funicolare | |
(10 rows)Passo per passo.
| Pezzo | Cosa resta |
|---|---|
FROM patenti pa | 3 righe: metro, tram, funicolare |
LEFT JOIN personale_patenti pp ON pp.patente_id = pa.id | 10 righe: le 9 righe del ponte, più la funicolare con le colonne del ponte a NULL |
LEFT JOIN personale p ON p.id = pp.personale_id | 10 righe: ogni riga del ponte riceve la sua persona. Per la funicolare pp.personale_id è NULL e non punta a nessuna persona: la riga resta, con nome e cognome vuoti |
SELECT pa.nome, p.nome, p.cognome | Le tre colonne |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Tutte e due JOIN semplici | La funicolare non ha coppie nel ponte e sparisce: 9 righe invece di 10 | test_es06_ogni_patente_anche_quella_che_non_ha_nessuno |
LEFT JOIN per il ponte, JOIN semplice per personale | La funicolare passa la prima, ma alla seconda la sua persona è NULL e la riga viene scartata: ancora 9 righe | test_es06_ogni_patente_anche_quella_che_non_ha_nessuno |
Il secondo errore è il più subdolo: una LEFT JOIN salva la riga solo fino alla JOIN successiva. Quando metti insieme più tabelle e vuoi tenere le righe senza coppia, tutte le JOIN che vengono dopo devono essere LEFT.
7 · Tutti i treni, un giorno solo
In italiano. Tutti i treni restano (LEFT JOIN). Delle corse contano solo quelle del 17 novembre: la condizione sul giorno fa parte di «quali coppie contano», quindi sta nell'ON, unita con AND.
SELECT t.codice, c.partenza
FROM treni t
LEFT JOIN corse c ON c.treno_id = t.id AND c.data = '2026-11-17'; codice | partenza
--------+----------
M14 | 06:50:00
M12 | 08:20:00
M12 | 05:42:00
T28 | 09:05:00
M16 | 07:45:00
T05 | 07:12:00
M18 |
M20 | 17:55:00
T31 |
(9 rows)Passo per passo.
| Pezzo | Cosa resta |
|---|---|
FROM treni t | 8 treni |
LEFT JOIN corse c ON c.treno_id = t.id AND c.data = '2026-11-17' | Le coppie sono solo treno e corsa di quel giorno. M12 ne ha due (due righe), 5 treni ne hanno una; M18 e T31 non ne hanno: restano con partenza vuota. In tutto 9 righe |
SELECT t.codice, c.partenza | Le due colonne |
M18 ha corso il 16 e il 18, ma il 17 no: nell'ON quelle corse non fanno coppia, e il treno resta con la casella vuota.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
LEFT JOIN corse c ON c.treno_id = t.id e poi WHERE c.data = '2026-11-17' | Per M18 e T31 la data è vuota, il WHERE li scarta: 7 righe invece di 9. Il WHERE disfa quello che la LEFT JOIN aveva salvato | test_es07_tutti_i_treni_con_le_corse_del_17 |
| Nessuna condizione sul giorno | Escono le partenze di tutti e tre i giorni, non solo del 17 | test_es07_tutti_i_treni_con_le_corse_del_17 |
8 · Il prezzo di quel giorno
In italiano. Dalle vendite, attacca la tariffa (per il prezzo attuale) e la stazione (per il nome). Poi confronta due colonne di due tabelle diverse: tieni le vendite in cui prezzo_pagato è diverso da prezzo.
SELECT s.nome, t.nome, v.prezzo_pagato, t.prezzo
FROM vendite v
JOIN tariffe t ON t.id = v.tariffa_id
JOIN stazioni s ON s.id = v.stazione_id
WHERE v.prezzo_pagato <> t.prezzo; nome | nome | prezzo_pagato | prezzo
--------------+-------------+---------------+--------
Piazza Query | giornaliero | 7.60 | 8.00
Porta Codice | ordinario | 2.20 | 2.50
Porta Codice | giornaliero | 7.60 | 8.00
Ponte Ciclo | ordinario | 2.20 | 2.50
Piazza Query | ordinario | 2.20 | 2.50
Porta Codice | ordinario | 2.20 | 2.50
(6 rows)Passo per passo.
| Pezzo | Cosa resta |
|---|---|
FROM vendite v | 24 vendite |
JOIN tariffe t ON t.id = v.tariffa_id | 24 righe, ognuna con il nome e il prezzo di oggi della sua tariffa |
JOIN stazioni s ON s.id = v.stazione_id | 24 righe, ognuna con il nome della stazione |
WHERE v.prezzo_pagato <> t.prezzo | 6 righe: le vendite fatte prima del 1° novembre, al prezzo che c'era |
SELECT … | Le quattro colonne |
Questo esercizio mostra perché la fotografia ha senso: prezzo_pagato resta quello di quel giorno anche se il listino cambia. La JOIN ti dà il prezzo di oggi accanto a quello vecchio.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
WHERE v.prezzo_pagato = t.prezzo | Il contrario di quello chiesto: escono le 18 vendite al prezzo di oggi | test_es08_solo_le_vendite_con_il_prezzo_vecchio |
JOIN tariffe t ON t.id = v.id | L'ON confronta l'id della tariffa con l'id della vendita: il prezzo attuale è quello di un'altra tariffa, o manca | test_es08_solo_le_vendite_con_il_prezzo_vecchio |