Vai al contenuto
code-to-code

Apro l'indice…

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

SQL5. Riassumerep. 99

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:

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

FunzioneCosa dàEsempio
COUNT(*)quante righeCOUNT(*) → 20 corse
COUNT(colonna)quante righe hanno un valore (non NULL) in quella colonnaCOUNT(ritardo_min) → 17
COUNT(DISTINCT colonna)quanti valori diversiCOUNT(DISTINCT data) → 3 giorni
SUM(colonna)la sommaSUM(passeggeri) → 2661
AVG(colonna)la mediaAVG(ritardo_min)
MIN(colonna) · MAX(colonna)il più piccolo · il più grandeMAX(ritardo_min) → 15

Si usano nel SELECT, e se ne possono mettere quante vuoi nella stessa query:

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

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

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

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

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

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

  1. le colonne del GROUP BY (hanno lo stesso valore in tutto il gruppo: data);
  2. 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:

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

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

SQL
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…DoveEsempio
una colonna della riga (la data, il ritardo, la stazione)WHERE, prima dei gruppiWHERE ritardo_min > 5
un risultato del gruppo (il totale, il conteggio, la media)HAVING, dopo i gruppiHAVING 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»:

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

ORDER 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

DomandaCome 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, MAX schiacciano 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. Il NULL non è zero.
  • GROUP BY colonna dà una riga per gruppo. Nel SELECT entrano solo le colonne del GROUP BY e le funzioni: altrimenti PostgreSQL ferma la query.
  • WHERE filtra le righe, prima dei gruppi. HAVING filtra i gruppi, dopo. Una funzione nel WHERE è un errore.
  • Per contare anche gli zeri: LEFT JOIN e COUNT(colonna di destra). COUNT(*) conterebbe la riga vuota.
  • Senza ORDER BY i gruppi escono in un ordine qualunque. Un totale si ordina con ORDER BY totale DESC.