Leggere
Fare una domanda al database, una riga alla volta
- 12 minuti di lettura
Lucia Ferri, la capotreno, ha una domanda: «Quali corse hanno fatto più di dieci minuti di ritardo?»
A voce è facile. A un database si chiede così:
SELECT data, partenza, ritardo_min
FROM corse
WHERE ritardo_min > 10; data | partenza | ritardo_min
------------+----------+-------------
2026-11-16 | 18:40:00 | 12
2026-11-18 | 05:42:00 | 15
(2 rows)Tre righe di SQL, due righe di risposta. In questo capitolo impari a fare tutte le domande che si fanno a una tabella sola: filtrare le righe, scegliere le colonne, metterle in ordine, prenderne solo le prime. Tutto con una sola parola chiave in più per volta.
Il database è quello della Linea Menta, dentro linea_menta.sql. Se non l'hai ancora caricato, i comandi sono in Tabelle, tipi e psql. Come si accende PostgreSQL: PostgreSQL e psql.
Il disegno: si scrive dal SELECT, si legge dal FROM
Una query ha sempre la stessa forma. Le parti si scrivono in questo ordine:
SELECT codice, vagoni ← 3. quali colonne tieni
FROM treni ← 1. da quale tabella parti
WHERE tipo = 'metro' ← 2. quali righe tieni
ORDER BY vagoni DESC, codice ← 4. in che ordine le metti
LIMIT 2; ← 5. quante ne prendiMa il database le esegue nell'ordine dei numeri. Per capire una query, leggila come lui: dal FROM.
FROM treni 8 righe, tutte le colonne
│
▼
WHERE tipo = 'metro' 5 righe: M14, M12, M16, M18, M20
│
▼
SELECT codice, vagoni sempre 5 righe, ma solo 2 colonne
│
▼
ORDER BY vagoni DESC, codice M12 6, M16 6, M20 5, M14 4, M18 4
│
▼
LIMIT 2 M12 6, M16 6Ed ecco la risposta, vera:
SELECT codice, vagoni
FROM treni
WHERE tipo = 'metro'
ORDER BY vagoni DESC, codice
LIMIT 2; codice | vagoni
--------+--------
M12 | 6
M16 | 6
(2 rows)Le parti sono tutte facoltative, tranne SELECT. Ma l'ordine in cui le scrivi no: WHERE prima di ORDER BY, LIMIT per ultimo. Il punto e virgola alla fine è obbligatorio.
SELECT: le colonne
SELECT codice, vagoni FROM treni; -- le colonne che elenchi, in quest'ordine
SELECT * FROM treni; -- tutte le colonne (la stella)La stella va bene per guardare. Quando scrivi una query vera, elenca le colonne: così sai cosa ti torna, e in che ordine.
AS dà un altro nome a una colonna, solo nel risultato:
SELECT codice AS treno, vagoni AS carrozze
FROM treni
WHERE vagoni >= 5; treno | carrozze
-------+----------
M12 | 6
M16 | 6
M20 | 5
(3 rows)DISTINCT toglie i doppioni: ogni riga uguale compare una volta sola.
SELECT DISTINCT tipo FROM treni; tipo
-------
metro
tram
(2 rows)Senza DISTINCT usciva metro cinque volte e tram tre.
WHERE: tenere solo le righe giuste
WHERE guarda una riga alla volta e la tiene se la condizione è vera. I confronti sono sei:
| Scrivi | Vuol dire |
|---|---|
= | uguale (uno solo, non due come in Python) |
<> | diverso |
< · > | minore · maggiore |
<= · >= | minore o uguale · maggiore o uguale |
La differenza tra > e >= è quella dell'estremo. «Più di 5 minuti» è > 5: il 5 resta fuori. «Almeno 5» è >= 5: il 5 entra.
Testi e date vogliono gli apici
Un testo si scrive tra apici singoli. Una data o un'ora anche:
WHERE tipo = 'metro'
WHERE data = '2026-11-17'
WHERE partenza > '07:00'Senza apici, 2026-11-17 per PostgreSQL è una sottrazione (2026 meno 11 meno 17) e ti risponde con un errore:
ERROR: operator does not exist: date = integer
LINE 1: SELECT data, partenza FROM corse WHERE data = 2026-11-17;
^
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.I testi sono precisi: 'Porta' e 'porta' non sono uguali. Se il testo ha un apostrofo, lo raddoppi:
WHERE descrizione = 'Libro d''avventura'Le virgolette doppie "…" non sono testo: in SQL sono il nome di una colonna. WHERE nome = "Porta Codice" si legge «la colonna chiamata Porta Codice» e PostgreSQL risponde column "Porta Codice" does not exist. Apici singoli, sempre, per i testi.
I booleani non hanno apici: WHERE aperta tiene le stazioni aperte, WHERE NOT aperta quelle chiuse.
AND, OR, NOT e le parentesi
Per mettere insieme due condizioni:
| Scrivi | Tiene la riga se |
|---|---|
a AND b | sono vere tutte e due |
a OR b | è vera almeno una |
NOT a | a è falsa |
SELECT nome, zona, binari
FROM stazioni
WHERE zona = 'urbana' AND binari > 2; nome | zona | binari
--------------+--------+--------
Porta Codice | urbana | 4
Piazza Query | urbana | 4
(2 rows)Il pericolo è mescolare AND e OR senza parentesi. AND lega più forte di OR: è come in matematica la moltiplicazione con l'addizione. a OR b AND c si legge a OR (b AND c). Se volevi l'altra cosa, devi dirlo tu:
SELECT nome, zona, binari
FROM stazioni
WHERE aperta AND (zona = 'extraurbana' OR binari = 4); nome | zona | binari
----------------+-------------+--------
Porta Codice | urbana | 4
Piazza Query | urbana | 4
Corso Funzione | extraurbana | 2
Borgo Stringa | extraurbana | 1
Darsena Indice | extraurbana | 1
(5 rows)Regola pratica: se nel WHERE c'è un OR, metti le parentesi, anche quando non servirebbero. Costano niente, e chi legge sa cosa volevi.
LIKE, ILIKE, IN, BETWEEN
Quattro scorciatoie per scrivere condizioni lunghe in modo corto.
LIKE e ILIKE: cercare un pezzo di testo
LIKE confronta un testo con un modello, dove due caratteri hanno un potere speciale:
| Nel modello | Vuol dire |
|---|---|
% | qualunque cosa, anche niente |
_ | esattamente un carattere, qualunque |
SELECT nome FROM stazioni WHERE nome LIKE 'Corso%'; nome
----------------
Corso Tupla
Corso Funzione
(2 rows)'Corso%': comincia per «Corso», poi qualunque cosa. '%Lista' finisce per Lista. '%ponte%' contiene «ponte». '_orso%' va bene per Corso, ma anche per Morso.
LIKE bada alle maiuscole. ILIKE no: è «LIKE che ignora le maiuscole». Nell'elenco degli oggetti smarriti ci sono Ombrello nero, ombrello a pois e OMBRELLO verde: per trovarli tutti serve ILIKE '%ombrello%'. (ILIKE esiste in PostgreSQL; in altri database si fa in altri modi.)
IN: uno tra tanti
SELECT codice, vagoni FROM treni WHERE vagoni IN (1, 5); codice | vagoni
--------+--------
T05 | 1
M20 | 5
(2 rows)vagoni IN (1, 5) vuol dire vagoni = 1 OR vagoni = 5, ma si legge meglio, soprattutto con cinque valori. Con i testi: nome IN ('Porta Codice', 'Largo Lista'). Il contrario è NOT IN.
BETWEEN: da… a…, estremi compresi
SELECT codice, vagoni FROM treni WHERE vagoni BETWEEN 4 AND 5; codice | vagoni
--------+--------
M14 | 4
M18 | 4
M20 | 5
(3 rows)BETWEEN 4 AND 5 è >= 4 AND <= 5: il 4 e il 5 entrano. Va bene anche con le date (BETWEEN '2026-11-05' AND '2026-11-12') e con le ore. Se ti servono estremi esclusi, scrivi > e < a mano.
NULL: la casella vuota
Nel capitolo precedente l'hai vista come una casella vuota. Ora c'è da cercarla. NULL vuol dire «non si sa»: il treno M20 non è mai stato revisionato, il tabellone di una corsa era guasto e il ritardo non è stato scritto.
Ti verrebbe da scrivere = NULL. Non funziona:
SELECT codice FROM treni WHERE ultima_revisione = NULL; codice
--------
(0 rows)Perché? Se non sai una cosa, e non sai un'altra cosa, non sai nemmeno se sono uguali. PostgreSQL te lo dice così:
SELECT NULL = NULL AS uguali, NULL IS NULL AS vuoto; uguali | vuoto
--------+-------
| t
(1 row)NULL = NULL non è né vero né falso: è NULL, e WHERE tiene solo le righe vere. Per cercare le caselle vuote c'è una parola sola:
SELECT codice, ultima_revisione FROM treni WHERE ultima_revisione IS NULL; codice | ultima_revisione
--------+------------------
M20 |
T31 |
(2 rows)IS NULL cerca i vuoti, IS NOT NULL i pieni.
La stessa logica ha una conseguenza che sorprende. Un confronto con un NULL non è mai vero, nemmeno un <>: ritardo_min <> 0 non tiene le corse con il ritardo non registrato. Non sono zero, ma nemmeno «diverse da zero»: sono sconosciute. Se le vuoi, le chiedi:
WHERE ritardo_min <> 0 OR ritardo_min IS NULLORDER BY: mettere in fila
Senza ORDER BY il database non promette nessun ordine: le righe escono come gli capita, e il giorno dopo possono essere diverse. Se l'ordine conta, lo chiedi tu.
SELECT nome, cognome FROM personale WHERE cognome = 'Colombo' ORDER BY nome; nome | cognome
--------+---------
Anna | Colombo
Sergio | Colombo
(2 rows)Per default è dal più piccolo (ASC, si può non scrivere): numeri dal basso, date dalla più vecchia, testi in ordine alfabetico. DESC rovescia.
Puoi mettere più colonne, separate da virgole: la seconda decide solo tra le righe che hanno pari merito sulla prima. Ci sono due Colombo, e per mettere in fila tutto il personale serve la seconda chiave:
SELECT nome, cognome FROM personale ORDER BY cognome, nome LIMIT 4; nome | cognome
--------+----------
Giulia | Bassi
Ivo | Brambati
Anna | Colombo
Sergio | Colombo
(4 rows)Dove vanno i NULL? In fondo con ASC, in cima con DESC. Un treno mai revisionato, ordinando le revisioni dalla più recente:
SELECT codice, ultima_revisione FROM treni ORDER BY ultima_revisione DESC; codice | ultima_revisione
--------+------------------
T31 |
M20 |
M16 | 2026-10-12
M14 | 2026-09-30
M12 | 2026-06-15
M18 | 2026-03-03
T28 | 2025-11-20
T05 | 2024-04-02
(8 rows)I due vuoti in cima, e tra loro (T31, M20) nessun ordine particolare. Se non li vuoi, togli i NULL con WHERE ultima_revisione IS NOT NULL.
LIMIT: solo le prime
LIMIT 3 ferma il risultato alla terza riga. Da solo è una trappola: prende le prime tre righe, quali che siano.
SELECT codice, vagoni FROM treni LIMIT 3; codice | vagoni
--------+--------
M14 | 4
M12 | 6
T28 | 2
(3 rows)Sono i primi tre treni della tabella: non i più grandi, non i più vecchi, solo i primi che il database ha trovato. Per «le tre corse più affollate» serve prima l'ordine, poi il limite:
SELECT partenza, passeggeri
FROM corse
WHERE data = '2026-11-16'
ORDER BY passeggeri DESC
LIMIT 3; partenza | passeggeri
----------+------------
18:40:00 | 210
07:05:00 | 198
07:30:00 | 175
(3 rows)LIMIT ha senso solo dopo un ORDER BY che non lascia pari merito al confine: se due righe hanno lo stesso valore e ne entra una sola, quale entra lo decide il caso. Aggiungi una seconda colonna all'ordine.
Gli schemi che tornano
| Domanda | Come si scrive |
|---|---|
| «Tutte le righe che…» | WHERE condizione |
| «Questa o quella» | WHERE a OR b, con le parentesi se c'è anche un AND |
| «Uno di questi valori» | WHERE colonna IN (…) |
| «Da… a…» | WHERE colonna BETWEEN x AND y |
| «Comincia per… / contiene…» | LIKE 'ab%' · LIKE '%ab%', e ILIKE se le maiuscole non contano |
| «Che manca» | IS NULL, mai = NULL |
| «Dal più grande» | ORDER BY colonna DESC |
| «I primi tre» | ORDER BY … poi LIMIT 3 |
| «Quali valori ci sono» | SELECT DISTINCT colonna |
Cosa viene dopo
Per ora una tabella alla volta. Il nome di una stazione, per esempio, sta nella tabella stazioni, non nelle corse: le corse hanno solo il suo id. Perché è fatto così lo vedi in Le relazioni; come si uniscono le tabelle in JOIN. Contare e sommare («quante corse?», «quanti passeggeri in tutto?») è Riassumere: qui le righe si guardano e basta, e il numero lo leggi in (N rows).
Ricorda
- Una query si scrive dal
SELECTe si legge dalFROM: tabella, poiWHERE, poi le colonne, poiORDER BY, poiLIMIT. - I testi, le date e le ore vogliono gli apici singoli. Le virgolette doppie sono nomi di colonna. L'apostrofo dentro un testo si raddoppia:
'Libro d''avventura'. ANDlega più forte diOR: con tutti e due, le parentesi.LIKEcon%e_;ILIKEignora le maiuscole.INper «uno tra tanti».BETWEENha gli estremi compresi.NULLsi cerca conIS NULL.= NULLnon trova niente, e un confronto come<> 0lascia fuori iNULL.ORDER BYper mettere in fila (DESCrovescia; iNULLvanno in fondo conASC, in cima conDESC).LIMITsolo dopo unORDER BYsenza pari merito.