Vai al contenuto
code-to-code

Apro l'indice…

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

SQL2. Leggerep. 19

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ì:

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

Ma 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 6

Ed ecco la risposta, vera:

SQL
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

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

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

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

ScriviVuol 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:

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

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

ScriviTiene la riga se
a AND bsono vere tutte e due
a OR bè vera almeno una
NOT aa è falsa
SQL
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:

SQL
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 modelloVuol dire
%qualunque cosa, anche niente
_esattamente un carattere, qualunque
SQL
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

SQL
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

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

SQL
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ì:

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

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

SQL
WHERE ritardo_min <> 0 OR ritardo_min IS NULL

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

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

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

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

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

SQL
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

DomandaCome 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 SELECT e si legge dal FROM: tabella, poi WHERE, poi le colonne, poi ORDER BY, poi LIMIT.
  • 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'.
  • AND lega più forte di OR: con tutti e due, le parentesi.
  • LIKE con % e _; ILIKE ignora le maiuscole. IN per «uno tra tanti». BETWEEN ha gli estremi compresi.
  • NULL si cerca con IS NULL. = NULL non trova niente, e un confronto come <> 0 lascia fuori i NULL.
  • ORDER BY per mettere in fila (DESC rovescia; i NULL vanno in fondo con ASC, in cima con DESC). LIMIT solo dopo un ORDER BY senza pari merito.