Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

SQL4. JOINp. 89

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.

sql-join-soluzioni.zip21 KB

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.

SQL
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 sbagliatoCosa succedeIl test rosso
Come sopra ma senza ORDER BYLe righe sono quelle giuste, ma escono nell'ordine della tabella: la corsa delle 07:05 prima di quella delle 06:10test_es01_dalla_partenza_piu_presto
JOIN treni t ON t.id = c.idL'ON confronta l'id del treno con l'id della corsa: i codici escono abbinati a caso, o mancanotest_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.

SQL
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 sbagliatoCosa succedeIl test rosso
LEFT JOIN stazioni s ON s.id = p.stazione_idRestano anche le quattro persone senza stazione, con il nome vuoto: 16 righe invece di 12test_es02_solo_chi_ha_una_stazione
JOIN stazioni s ON s.id = p.idL'ON abbina l'id della stazione al badge della persona: Sergio (B-04) finirebbe a Ponte Ciclo solo perché 4 = 4test_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.

SQL
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 sbagliatoCosa succedeIl test rosso
ORDER BY c.ritardo_min (senza DESC)Le righe sono giuste ma vanno dal ritardo più piccolotest_es03_dal_ritardo_piu_grande
WHERE c.ritardo_min >= 5Entra 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.

SQL
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 sbagliatoCosa succedeIl test rosso
Una sola JOIN stazioni s ON s.id = c.da_stazione_id, poi SELECT c.partenza, s.nome, s.nomeNessun errore, ma partenza e arrivo sono uguali: hai la stazione di partenza due voltetest_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_idGli ON sono incrociati: i nomi escono scambiatitest_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.

inizio FROM treni t per ogni treno se ha corse sì: passo attacca ogni corsa no: passo una riga con c.id vuoto per ogni riga se c.id IS NULL no: passo scarta la riga SELECT t.codiceFROM treni tper ogni trenoha corseuna riga con c.id vuotoattacca ogni corsaper ogni rigac.id IS NULLscarta la rigaSELECT t.codicenosìfinitinosìfiniti
Il LEFT JOIN, poi il filtro
SQL
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 sbagliatoCosa succedeIl test rosso
JOIN corse c ON … al posto di LEFT JOINT31 non ha coppie e sparisce prima del WHERE: zero righetest_es05_i_treni_senza_nessuna_corsa
WHERE c.id = NULL= NULL non è mai vero: zero righe, senza nessun erroretest_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.

SQL
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.

PezzoCosa resta
FROM patenti pa3 righe: metro, tram, funicolare
LEFT JOIN personale_patenti pp ON pp.patente_id = pa.id10 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_id10 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.cognomeLe tre colonne

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Tutte e due JOIN sempliciLa funicolare non ha coppie nel ponte e sparisce: 9 righe invece di 10test_es06_ogni_patente_anche_quella_che_non_ha_nessuno
LEFT JOIN per il ponte, JOIN semplice per personaleLa funicolare passa la prima, ma alla seconda la sua persona è NULL e la riga viene scartata: ancora 9 righetest_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.

SQL
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.

PezzoCosa resta
FROM treni t8 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.partenzaLe 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 sbagliatoCosa succedeIl 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 salvatotest_es07_tutti_i_treni_con_le_corse_del_17
Nessuna condizione sul giornoEscono le partenze di tutti e tre i giorni, non solo del 17test_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.

SQL
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.

PezzoCosa resta
FROM vendite v24 vendite
JOIN tariffe t ON t.id = v.tariffa_id24 righe, ognuna con il nome e il prezzo di oggi della sua tariffa
JOIN stazioni s ON s.id = v.stazione_id24 righe, ognuna con il nome della stazione
WHERE v.prezzo_pagato <> t.prezzo6 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 sbagliatoCosa succedeIl test rosso
WHERE v.prezzo_pagato = t.prezzoIl contrario di quello chiesto: escono le 18 vendite al prezzo di oggitest_es08_solo_le_vendite_con_il_prezzo_vecchio
JOIN tariffe t ON t.id = v.idL'ON confronta l'id della tariffa con l'id della vendita: il prezzo attuale è quello di un'altra tariffa, o mancatest_es08_solo_le_vendite_con_il_prezzo_vecchio