Riassumere
Contare, sommare, fare la media, e farlo gruppo per gruppo
- 12 minuti di lettura
Bruno Fontana, il capostazione di Porta Codice, chiude i conti del mese. La direzione non vuole l'elenco delle corse: vuole un numero. «Quanti passeggeri in tutto?»
Fin qui hai letto le righe e le hai contate a occhio, guardando (N rows). Per un numero solo c'è una funzione:
SELECT SUM(passeggeri) AS passeggeri
FROM corse; passeggeri
------------
2661
(1 row)Venti righe entrano, una esce. Questo è riassumere: il database prende tante righe e le schiaccia in un valore. In questo capitolo impari cinque funzioni (contare, sommare, media, minimo, massimo) e come usarle gruppo per gruppo: i passeggeri di ogni giorno, i biglietti di ogni stazione.
Il database è quello della Linea Menta, in linea_menta.sql. Se non l'hai caricato, i comandi sono in Tabelle, tipi e psql. Per filtrare e ordinare ti serve Leggere, e per le stazioni con il loro nome JOIN.
Le cinque funzioni
Si chiamano funzioni di aggregazione: tante righe dentro, un valore fuori.
| Funzione | Cosa dà | Esempio |
|---|---|---|
COUNT(*) | quante righe | COUNT(*) → 20 corse |
COUNT(colonna) | quante righe hanno un valore (non NULL) in quella colonna | COUNT(ritardo_min) → 17 |
COUNT(DISTINCT colonna) | quanti valori diversi | COUNT(DISTINCT data) → 3 giorni |
SUM(colonna) | la somma | SUM(passeggeri) → 2661 |
AVG(colonna) | la media | AVG(ritardo_min) |
MIN(colonna) · MAX(colonna) | il più piccolo · il più grande | MAX(ritardo_min) → 15 |
Si usano nel SELECT, e se ne possono mettere quante vuoi nella stessa query:
SELECT COUNT(*) AS corse,
COUNT(ritardo_min) AS ritardi_registrati,
MAX(ritardo_min) AS ritardo_massimo
FROM corse; corse | ritardi_registrati | ritardo_massimo
-------+--------------------+-----------------
20 | 17 | 15
(1 row)20 contro 17: tre corse hanno il ritardo NULL (il tabellone era guasto). Ed è la regola più importante del capitolo.
Le funzioni non vedono i NULL
SUM, AVG, MIN, MAX e COUNT(colonna) saltano le righe con NULL, come se non ci fossero. Solo COUNT(*) conta le righe e basta, qualunque cosa contengano.
Per la media significa questo: AVG(ritardo_min) è la media delle 17 corse con il ritardo registrato, non delle 20. Le tre corse col tabellone guasto non sono «ritardo zero»: sono «non si sa», e non entrano nel conto. Se le facessi entrare come zero, la media scenderebbe: sarebbe una bugia.
SELECT AVG(ritardo_min) AS media,
ROUND(AVG(ritardo_min), 2) AS media_tonda
FROM corse; media | media_tonda
--------------------+-------------
3.9411764705882353 | 3.94
(1 row)ROUND(x, 2) arrotonda a due decimali. Una media esce quasi sempre con una coda lunga: arrotondala.
MIN e MAX non servono solo per i numeri. Con le date danno la più vecchia e la più recente; con i testi, la prima e l'ultima in ordine alfabetico:
SELECT MIN(data) AS primo_giorno, MAX(data) AS ultimo_giorno
FROM corse; primo_giorno | ultimo_giorno
--------------+---------------
2026-11-16 | 2026-11-18
(1 row)Una funzione, una riga (anche se non c'è niente)
Una query con solo funzioni dà sempre una riga, anche se il WHERE non lascia passare nessuna riga. COUNT(*) allora vale 0, ma SUM e AVG valgono NULL: la somma di niente non è zero, è «niente da sommare».
SELECT COUNT(*) AS corse, SUM(passeggeri) AS passeggeri
FROM corse
WHERE data = '2026-12-25'; corse | passeggeri
-------+------------
0 |
(1 row)GROUP BY: un risultato per gruppo
Il totale di tutto va bene per un conto. Ma Bruno vuole anche sapere ogni giorno quanti passeggeri. GROUP BY dice: «metti insieme le righe con lo stesso valore in questa colonna, e applica le funzioni a ogni gruppo».
SELECT data,
COUNT(*) AS corse,
SUM(passeggeri) AS passeggeri
FROM corse
GROUP BY data
ORDER BY data; data | corse | passeggeri
------------+-------+------------
2026-11-16 | 7 | 1033
2026-11-17 | 7 | 802
2026-11-18 | 6 | 826
(3 rows)Ecco cosa succede dentro, riga per riga. Il database prende le 20 corse, le divide in gruppi (uno per data) e per ogni gruppo calcola le funzioni:
corse (20 righe) i gruppi il risultato
16/11 112 ┌─ 16/11 ─────────┐
16/11 140 │ 112 140 38 198 │ COUNT(*) = 7
16/11 38 GROUP BY │ 175 160 210 │ SUM(passeggeri) = 1033 ──▶ 2026-11-16 | 7 | 1033
16/11 198 data └─────────────────┘
16/11 175 ─────────▶ ┌─ 17/11 ─────────┐
16/11 160 │ 188 104 150 22 │ COUNT(*) = 7
16/11 210 │ 120 17 201 │ SUM(passeggeri) = 802 ──▶ 2026-11-17 | 7 | 802
17/11 188 └─────────────────┘
17/11 104 … ┌─ 18/11 ─────────┐
… │ 158 225 41 99 │ COUNT(*) = 6
18/11 ecc. │ 170 133 │ SUM(passeggeri) = 826 ──▶ 2026-11-18 | 6 | 826
└─────────────────┘
20 righe in ───────────────▶ 3 gruppi ───────────────▶ 3 righe fuori: una per gruppoUna riga per gruppo, sempre. E senza GROUP BY? L'intera tabella è un gruppo solo: per questo il SUM di prima dava una riga.
La regola del SELECT
Dopo un GROUP BY ogni riga del risultato rappresenta un gruppo. Quindi nel SELECT puoi mettere solo:
- le colonne del
GROUP BY(hanno lo stesso valore in tutto il gruppo:data); - le funzioni (
COUNT,SUM, …), che dal gruppo ricavano un valore.
Una colonna qualunque no: in un gruppo di sette corse, quale partenza mostrerebbe? PostgreSQL non lo indovina e ti ferma:
SELECT data, partenza, COUNT(*) FROM corse GROUP BY data;ERROR: column "corse.partenza" must appear in the GROUP BY clause or be used in an aggregate function
LINE 1: SELECT data, partenza, COUNT(*) FROM corse GROUP BY data;
^Vuol dire: «ogni colonna del SELECT o sta nel GROUP BY o sta dentro una funzione». È un errore utile: ti dice che la tua domanda non ha una risposta sola. Se vuoi la partenza più tardi di ogni giorno, la domanda è MAX(partenza).
Puoi raggruppare per più colonne (GROUP BY data, treno_id): un gruppo per ogni coppia di valori.
GROUP BY dopo una JOIN
Il gruppo si fa sulle righe che escono dalla JOIN. Per avere il nome della stazione invece del suo id, si unisce e si raggruppa per nome:
SELECT s.nome AS stazione, COUNT(*) AS vendite
FROM vendite v
JOIN stazioni s ON s.id = v.stazione_id
GROUP BY s.nome
ORDER BY vendite DESC, s.nome
LIMIT 3; stazione | vendite
--------------+---------
Porta Codice | 9
Piazza Query | 6
Ponte Ciclo | 3
(3 rows)Prima la JOIN mette insieme le righe, poi GROUP BY le divide in gruppi. Se due stazioni avessero lo stesso nome, finirebbero nello stesso gruppo: qui i nomi sono unici, e per sicurezza si può raggruppare per s.id, s.nome.
HAVING: filtrare i gruppi
WHERE tiene o scarta le righe. Ma «le date con più di 900 passeggeri» non è una condizione su una riga: è una condizione sul totale di un gruppo, che esiste solo dopo GROUP BY. Per questo c'è HAVING:
SELECT data, SUM(passeggeri) AS passeggeri
FROM corse
GROUP BY data
HAVING SUM(passeggeri) > 900; data | passeggeri
------------+------------
2026-11-16 | 1033
(1 row)HAVING lavora sui gruppi già fatti: può usare COUNT, SUM, AVG. WHERE non può: se ci scrivi una funzione, PostgreSQL risponde aggregate functions are not allowed in WHERE.
WHERE o HAVING?
È la domanda del capitolo. La risposta è una: quando vuoi filtrare, chiediti «su cosa?».
| Filtri su… | Dove | Esempio |
|---|---|---|
| una colonna della riga (la data, il ritardo, la stazione) | WHERE, prima dei gruppi | WHERE ritardo_min > 5 |
| un risultato del gruppo (il totale, il conteggio, la media) | HAVING, dopo i gruppi | HAVING COUNT(*) >= 2 |
E spesso servono tutti e due, ognuno al suo posto. «I giorni in cui ci sono state almeno due corse con più di 5 minuti di ritardo»:
SELECT data, COUNT(*) AS corse_in_ritardo
FROM corse
WHERE ritardo_min > 5
GROUP BY data
HAVING COUNT(*) >= 2
ORDER BY data; data | corse_in_ritardo
------------+------------------
2026-11-17 | 2
2026-11-18 | 2
(2 rows)Prima il WHERE scarta le corse puntuali (restano 5 righe: una il 16, due il 17, due il 18). Poi GROUP BY le divide per giorno. Poi HAVING butta i gruppi con meno di due righe: il 16 ne ha una sola, sparisce.
Scambiarli non è un dettaglio. WHERE COUNT(*) >= 2 dà errore. HAVING ritardo_min > 5 dà errore anche lui (ritardo_min non è né nel GROUP BY né dentro una funzione). E un filtro che si può fare nel WHERE conviene farlo lì: scarta le righe prima, e il database ha meno lavoro da fare.
Contare anche gli zeri
Una JOIN perde chi non ha coppie: i treni senza corse, le stazioni senza oggetti. Per contare «anche gli zeri» serve una LEFT JOIN, e un COUNT giusto: COUNT(colonna della tabella di destra), non COUNT(*).
Il motivo: la LEFT JOIN per una stazione senza oggetti produce una riga con tutti NULL a destra. COUNT(*) conta quella riga e dice 1. COUNT(o.id) guarda l'id a destra, vede NULL e dice 0. Lo vedrai su una query vera negli esercizi spiegati.
L'ordine di lettura, con i gruppi
Come per ogni query, si scrive dal SELECT e si legge dal FROM. I gruppi hanno il loro posto nel mezzo:
FROM vendite v JOIN stazioni s … 24 righe, tutte le colonne
│
▼
WHERE v.data >= '2026-11-01' le righe di novembre
│
▼
GROUP BY s.nome un gruppo per stazione
│
▼
HAVING SUM(v.prezzo_pagato) >= 8 tieni i gruppi con almeno 8 euro
│
▼
SELECT s.nome, COUNT(*), SUM(…) una riga per gruppo, le colonne da mostrare
│
▼
ORDER BY incasso DESC i totali si possono ordinare
│
▼
LIMIT … le primeORDER BY arriva dopo il SELECT: per questo può ordinare per un totale (ORDER BY incasso DESC), cosa che non si può fare con il WHERE.
Gli schemi che tornano
| Domanda | Come si scrive |
|---|---|
| «Quante righe?» | COUNT(*) |
| «Quante hanno un valore in…?» | COUNT(colonna) |
| «Quanti valori diversi?» | COUNT(DISTINCT colonna) |
| «Quanto in totale?» | SUM(colonna) |
| «Quanto in media?» | ROUND(AVG(colonna), 2) |
| «Il più grande / il più recente» | MAX(colonna) |
| «Per ogni…» | GROUP BY (la colonna di «per ogni» sta anche nel SELECT) |
| «Solo i … con almeno…» | HAVING COUNT(*) >= n |
| «Prima filtro le righe, poi conto» | WHERE prima, GROUP BY dopo |
| «Contare anche chi ne ha zero» | LEFT JOIN + COUNT(colonna di destra) |
| «I più… per totale» | ORDER BY totale DESC + LIMIT |
Cosa viene dopo
Finora hai solo letto: nessuna query ha cambiato i dati. Con Scrivere comincia la parte in cui il database cambia: INSERT, UPDATE, DELETE.
Una cosa fuori dal corso: «la riga con il massimo di ogni gruppo» (per esempio, la corsa più affollata di ogni giorno con la sua partenza). Con GROUP BY si ottiene il numero (MAX(passeggeri)), ma non la riga intera: servono altri strumenti (le sottoquery, le funzioni finestra) che qui non usiamo.
Ricorda
COUNT,SUM,AVG,MIN,MAXschiacciano tante righe in un valore.COUNT(*)conta le righe;COUNT(colonna)solo quelle con un valore.- Le funzioni saltano i
NULL: la media dei ritardi è la media di quelli registrati. IlNULLnon è zero. GROUP BY colonnadà una riga per gruppo. NelSELECTentrano solo le colonne delGROUP BYe le funzioni: altrimenti PostgreSQL ferma la query.WHEREfiltra le righe, prima dei gruppi.HAVINGfiltra i gruppi, dopo. Una funzione nelWHEREè un errore.- Per contare anche gli zeri:
LEFT JOINeCOUNT(colonna di destra).COUNT(*)conterebbe la riga vuota. - Senza
ORDER BYi gruppi escono in un ordine qualunque. Un totale si ordina conORDER BY totale DESC.