Riassumere, esercizi spiegati
Cinque esempi con gli oggetti smarriti, a fine mese
- 25 minuti di lettura
A fine mese Bruno Fontana, capostazione di Porta Codice, deve consegnare alla direzione il resoconto degli oggetti smarriti: quanti sono, quanto valgono, dove si accumulano. Non gli servono gli elenchi: gli servono i numeri. Cinque esempi sulla tabella oggetti_smarriti, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi la query e scrivi su un foglio quante righe escono e che numeri. Prima di aprire la risposta.
- In italiano: cosa chiede la query, a parole.
- Passo per passo: la query letta dal
FROM, con cosa resta dopo ogni passo. - Cosa portiamo a casa.
Per provarli: psql -d sql_riassumere, poi incolla la query. Ecco la tabella (senza la data del ritrovamento), per avere tutto davanti. Le caselle vuote sono NULL: in ritirato_il vuol dire «nessuno è venuto a prenderlo», in valore «non si sa quanto vale».
id | descrizione | stazione_id | ritirato_il | valore
----+--------------------------+-------------+-------------+--------
1 | Zaino blu con libri | 4 | 2026-09-22 | 45.00
2 | Ombrello nero | 1 | 2026-10-04 | 12.00
3 | Mazzo di chiavi | 2 | |
4 | ombrello a pois | 5 | | 8.50
5 | Telefono con cover rossa | 1 | 2026-11-12 | 220.00
6 | Guanto di lana | 7 | | 5.00
7 | Bicicletta pieghevole | 9 | 2026-09-15 | 380.00
8 | OMBRELLO verde | 3 | |
9 | Quaderno a quadretti | 5 | | 2.00
10 | Guanto di lana | 7 | | 5.00
11 | Occhiali da sole | 4 | 2026-07-20 | 90.00
12 | Sciarpa a righe | 10 | |
13 | Libro d'avventura | 2 | | 9.90
14 | Valigia rossa | 4 | 2026-06-03 |
15 | Cuffie senza fili | 1 | | 60.00
16 | Portafoglio marrone | 3 | | 30.00
(16 rows)A · Quanti oggetti? Quanti con un valore?
Bruno comincia dalle domande più semplici: quanti oggetti ci sono, per quanti conosciamo il valore, quante descrizioni diverse.
SELECT COUNT(*) AS oggetti,
COUNT(valore) AS con_valore,
COUNT(DISTINCT descrizione) AS descrizioni_diverse
FROM oggetti_smarriti;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Una riga sola, tre numeri. Il primo è facile (16). Gli altri due sono diversi: COUNT(valore) salta i NULL, COUNT(DISTINCT …) conta i valori una volta sola.
oggetti | con_valore | descrizioni_diverse
---------+------------+---------------------
16 | 12 | 15
(1 row)16 oggetti, 12 con un valore (quattro caselle vuote), 15 descrizioni diverse (il «Guanto di lana» è scritto due volte, uguale: conta una).
In italiano. Dalla tabella degli oggetti, conta le righe; conta quante hanno un valore; conta quante descrizioni diverse ci sono.
Passo per passo.
| Passo | Cosa fa | Cosa resta |
|---|---|---|
FROM oggetti_smarriti | parte dalla tabella | 16 righe |
COUNT(*) | conta le righe, qualunque cosa contengano | 16 |
COUNT(valore) | conta le righe in cui valore non è vuoto | 12 (le righe 3, 8, 12, 14 hanno NULL) |
COUNT(DISTINCT descrizione) | toglie i doppioni, poi conta | 15 (i guanti sono 6 e 10) |
SELECT | tutti e tre i risultati, in una sola riga | 1 riga, 3 colonne |
Non c'è GROUP BY: l'intera tabella è un gruppo solo, e un gruppo dà una riga.
Cosa portiamo a casa. COUNT(*) conta le righe, COUNT(colonna) conta i valori presenti. Quando i due numeri sono diversi, c'è un NULL da qualche parte, e va tenuto d'occhio.
B · Il valore, la media e gli estremi
La direzione chiede: «Quanto valgono in tutto gli oggetti in deposito? E in media?»
SELECT SUM(valore) AS totale,
ROUND(AVG(valore), 2) AS media,
MIN(valore) AS minimo,
MAX(valore) AS massimo
FROM oggetti_smarriti;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Il totale somma i 12 valori conosciuti. E la media? Dipende da quante righe conta: 12 o 16?
totale | media | minimo | massimo
--------+-------+--------+---------
867.40 | 72.28 | 2.00 | 380.00
(1 row)867,40 diviso 12 fa 72,28: la media guarda solo le righe con un valore.
In italiano. Somma il valore, fanne la media (due decimali), trova il più piccolo e il più grande.
Passo per passo.
| Funzione | Righe che guarda | Risultato |
|---|---|---|
SUM(valore) | le 12 con un valore | 867.40 |
AVG(valore) | le stesse 12 | 867.40 / 12 = 72.2833… |
ROUND(…, 2) | arrotonda a due decimali | 72.28 |
MIN(valore) · MAX(valore) | le stesse 12 | 2.00 (il quaderno) · 380.00 (la bicicletta) |
Se Bruno dividesse a mano per 16 invece che per 12, otterrebbe un'altra media, e sbagliata:
SELECT SUM(valore) / COUNT(*) AS sbagliata,
SUM(valore) / COUNT(valore) AS giusta
FROM oggetti_smarriti; sbagliata | giusta
---------------------+---------------------
54.2125000000000000 | 72.2833333333333333
(1 row)Quattro oggetti di cui non si sa il valore non valgono zero: non si sa. AVG lo sa da sola; chi divide per COUNT(*) no.
MIN e MAX funzionano anche con date e testi:
SELECT MIN(trovato_il) AS il_primo,
MAX(trovato_il) AS l_ultimo,
MIN(descrizione) AS prima_in_ordine
FROM oggetti_smarriti; il_primo | l_ultimo | prima_in_ordine
------------+------------+-----------------------
2026-06-01 | 2026-11-17 | Bicicletta pieghevole
(1 row)La data più vecchia, la più recente, e il primo testo in ordine alfabetico.
Cosa portiamo a casa. Le funzioni saltano i NULL: la media è quella dei valori conosciuti. ROUND(x, 2) per le code lunghe. MIN e MAX valgono per numeri, date e testi.
C · Quanti oggetti in ogni stazione?
Ora Bruno vuole sapere dove si accumulano gli oggetti: una riga per stazione.
SELECT stazione_id, COUNT(*) AS oggetti
FROM oggetti_smarriti
GROUP BY stazione_id
ORDER BY stazione_id;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Quante righe? Una per ogni stazione che compare nella tabella, non per ogni oggetto. Le stazioni sono 10, ma non in tutte c'è qualcosa.
stazione_id | oggetti
-------------+---------
1 | 3
2 | 2
3 | 2
4 | 3
5 | 2
7 | 2
9 | 1
10 | 1
(8 rows)Otto righe: mancano la 6 (Vecchia Fiera, chiusa) e l'8 (Corso Funzione). Chi non ha righe non ha un gruppo.
In italiano. Metti insieme gli oggetti con la stessa stazione. Per ogni gruppo, mostra la stazione e quanti oggetti ha.
Passo per passo.
| Passo | Cosa fa | Cosa resta |
|---|---|---|
FROM oggetti_smarriti | la tabella | 16 righe |
GROUP BY stazione_id | un gruppo per ogni valore di stazione_id | 8 gruppi (per esempio: stazione 1 con le righe 2, 5, 15) |
SELECT stazione_id, COUNT(*) | per ogni gruppo, la stazione e quante righe | 8 righe, 2 colonne |
ORDER BY stazione_id | in ordine |
Se provi ad aggiungere una colonna qualunque, PostgreSQL ti ferma:
SELECT stazione_id, descrizione, COUNT(*)
FROM oggetti_smarriti
GROUP BY stazione_id;ERROR: column "oggetti_smarriti.descrizione" must appear in the GROUP BY clause or be used in an aggregate function
LINE 1: SELECT stazione_id, descrizione, COUNT(*) FROM oggetti_smarr...
^Nella stazione 1 ci sono tre oggetti con tre descrizioni diverse: quale mostrare? Non c'è una risposta. Se ti interessa una, scegli come: MIN(descrizione), per esempio, che dà la prima in ordine alfabetico.
Per il nome della stazione, si unisce con stazioni e si raggruppa per nome. Se in più vuole il valore totale, aggiunge una SUM:
SELECT s.nome AS stazione,
COUNT(*) AS oggetti,
SUM(o.valore) AS valore_totale
FROM oggetti_smarriti o
JOIN stazioni s ON s.id = o.stazione_id
GROUP BY s.nome
ORDER BY oggetti DESC, s.nome; stazione | oggetti | valore_totale
----------------+---------+---------------
Ponte Ciclo | 3 | 135.00
Porta Codice | 3 | 292.00
Corso Tupla | 2 | 10.00
Largo Lista | 2 | 30.00
Piazza Query | 2 | 10.50
Via Variabile | 2 | 9.90
Borgo Stringa | 1 | 380.00
Darsena Indice | 1 |
(8 rows)Darsena Indice ha un oggetto, ma il suo valore non è noto: la SUM di soli NULL è NULL (casella vuota), non zero. Due stazioni a pari oggetti? ORDER BY oggetti DESC, s.nome risolve i pari merito con il nome.
Cosa portiamo a casa. GROUP BY dà una riga per gruppo; nel SELECT solo le colonne del GROUP BY e le funzioni. Dopo una JOIN si raggruppa per il nome. E un totale si ordina con ORDER BY totale DESC.
D · Le stazioni con almeno due oggetti non ritirati
Gli oggetti ritirati non sono più un problema: a Bruno servono le stazioni con almeno due oggetti ancora in deposito.
Due condizioni, di due tipi: «non ritirato» riguarda la riga; «almeno due» riguarda il gruppo. Ognuna va al suo posto:
SELECT stazione_id, COUNT(*) AS non_ritirati
FROM oggetti_smarriti
WHERE ritirato_il IS NULL
GROUP BY stazione_id
HAVING COUNT(*) >= 2
ORDER BY non_ritirati DESC, stazione_id;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Prima i non ritirati (10 righe), poi i gruppi: in sei stazioni c'è qualcosa, in quattro ce n'è almeno due.
stazione_id | non_ritirati
-------------+--------------
2 | 2
3 | 2
5 | 2
7 | 2
(4 rows)In italiano. Tieni gli oggetti non ritirati. Mettili in gruppi per stazione. Tieni i gruppi con almeno due oggetti. Mostra la stazione e il numero.
Il disegno.
Passo per passo.
| Passo | Cosa fa | Cosa resta |
|---|---|---|
FROM | la tabella | 16 righe |
WHERE ritirato_il IS NULL | scarta le righe già ritirate | 10 righe |
GROUP BY stazione_id | un gruppo per stazione | 6 gruppi: stazione 1 (1 oggetto), 2 (2), 3 (2), 5 (2), 7 (2), 10 (1) |
HAVING COUNT(*) >= 2 | scarta i gruppi con meno di 2 righe | 4 gruppi: 2, 3, 5, 7 |
SELECT | stazione e conteggio | 4 righe |
ORDER BY | numero decrescente, poi stazione |
Senza l'HAVING i gruppi sarebbero sei, con la stazione 1 e la 10 a quota 1. Se scambi i posti:
SELECT stazione_id, COUNT(*) AS oggetti
FROM oggetti_smarriti
WHERE COUNT(*) >= 2
GROUP BY stazione_id;ERROR: aggregate functions are not allowed in WHERE
LINE 1: ..., COUNT(*) AS oggetti FROM oggetti_smarriti WHERE COUNT(*) >...
^Il WHERE guarda una riga alla volta, prima che i gruppi esistano: non può sapere quanti oggetti ha una stazione. E il contrario:
SELECT stazione_id, COUNT(*) AS non_ritirati
FROM oggetti_smarriti
GROUP BY stazione_id
HAVING ritirato_il IS NULL;ERROR: column "oggetti_smarriti.ritirato_il" must appear in the GROUP BY clause or be used in an aggregate function
LINE 1: ...FROM oggetti_smarriti GROUP BY stazione_id HAVING ritirato_i...
^Nell'HAVING una colonna sola non ha senso: dopo i gruppi esistono solo le colonne del GROUP BY e le funzioni.
Cosa portiamo a casa. Filtri sulla riga (una colonna): WHERE, prima. Filtri sul gruppo (un conteggio, una somma): HAVING, dopo. Le due frasi del problema dicono già dove vanno.
E · Anche le stazioni senza niente
Ultima domanda di Bruno: «L'elenco di tutte le stazioni, con quanti oggetti hanno. Anche quelle a zero».
Con una JOIN semplice le stazioni senza oggetti sparirebbero: Corso Funzione e Vecchia Fiera non hanno righe a destra. Serve una LEFT JOIN, e un COUNT che guardi la colonna di destra:
SELECT s.nome AS stazione,
COUNT(o.id) AS oggetti
FROM stazioni s
LEFT JOIN oggetti_smarriti o ON o.stazione_id = s.id
GROUP BY s.nome
ORDER BY oggetti DESC, s.nome;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Dieci righe, una per ogni stazione. Due stazioni arrivano a zero.
stazione | oggetti
----------------+---------
Ponte Ciclo | 3
Porta Codice | 3
Corso Tupla | 2
Largo Lista | 2
Piazza Query | 2
Via Variabile | 2
Borgo Stringa | 1
Darsena Indice | 1
Corso Funzione | 0
Vecchia Fiera | 0
(10 rows)In italiano. Parti da tutte le stazioni; a ognuna attacca i suoi oggetti, se ce ne sono; raggruppa per stazione; conta gli oggetti veri (quelli con un id).
Il disegno.
Passo per passo.
| Passo | Cosa fa | Cosa resta |
|---|---|---|
FROM stazioni s | tutte le stazioni | 10 righe |
LEFT JOIN oggetti_smarriti o … | attacca gli oggetti; chi non ne ha riceve una riga con NULL a destra | 18 righe: 16 oggetti, più una riga vuota per Corso Funzione e una per Vecchia Fiera |
GROUP BY s.nome | un gruppo per stazione | 10 gruppi |
COUNT(o.id) | conta gli id di destra: i NULL non contano | Corso Funzione 0, Vecchia Fiera 0, le altre come prima |
Ora la versione con COUNT(*), che sembra uguale:
SELECT s.nome AS stazione, COUNT(*) AS oggetti
FROM stazioni s
LEFT JOIN oggetti_smarriti o ON o.stazione_id = s.id
WHERE s.nome IN ('Vecchia Fiera', 'Corso Funzione', 'Porta Codice')
GROUP BY s.nome
ORDER BY s.nome; stazione | oggetti
----------------+---------
Corso Funzione | 1
Porta Codice | 3
Vecchia Fiera | 1
(3 rows)Corso Funzione e Vecchia Fiera dicono 1, ma di oggetti non ne hanno: COUNT(*) ha contato la riga vuota che la LEFT JOIN ha creato apposta. È un errore che non dà errore. Per questo: COUNT(colonna di destra).
Cosa portiamo a casa. Per contare gli zeri: LEFT JOIN e COUNT(o.id). Con COUNT(*) gli zeri diventano uno. Il segnale d'allarme è un conteggio «1» dove ti aspetti niente.