Vai al contenuto
code-to-code

Apro l'indice…

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

SQL5. Riassumerep. 106

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:

  1. Prevedi: leggi la query e scrivi su un foglio quante righe escono e che numeri. Prima di aprire la risposta.
  2. In italiano: cosa chiede la query, a parole.
  3. Passo per passo: la query letta dal FROM, con cosa resta dopo ogni passo.
  4. 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.

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

PassoCosa faCosa resta
FROM oggetti_smarritiparte dalla tabella16 righe
COUNT(*)conta le righe, qualunque cosa contengano16
COUNT(valore)conta le righe in cui valore non è vuoto12 (le righe 3, 8, 12, 14 hanno NULL)
COUNT(DISTINCT descrizione)toglie i doppioni, poi conta15 (i guanti sono 6 e 10)
SELECTtutti e tre i risultati, in una sola riga1 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?»

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

FunzioneRighe che guardaRisultato
SUM(valore)le 12 con un valore867.40
AVG(valore)le stesse 12867.40 / 12 = 72.2833…
ROUND(…, 2)arrotonda a due decimali72.28
MIN(valore) · MAX(valore)le stesse 122.00 (il quaderno) · 380.00 (la bicicletta)

Se Bruno dividesse a mano per 16 invece che per 12, otterrebbe un'altra media, e sbagliata:

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

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

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

PassoCosa faCosa resta
FROM oggetti_smarritila tabella16 righe
GROUP BY stazione_idun gruppo per ogni valore di stazione_id8 gruppi (per esempio: stazione 1 con le righe 2, 5, 15)
SELECT stazione_id, COUNT(*)per ogni gruppo, la stazione e quante righe8 righe, 2 colonne
ORDER BY stazione_idin ordine

Se provi ad aggiungere una colonna qualunque, PostgreSQL ti ferma:

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

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

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

inizio FROM oggetti_smarriti per ogni riga se ritirato_il IS NULL no: passo scarta la riga GROUP BY stazione_id per ogni gruppo se COUNT(*) >= 2 no: passo scarta il gruppo SELECT stazione_id, COUNT(*) ORDER BY non_ritirati DESC, stazione_id fine quattro righeFROM oggetti_smarritiper ogni rigaritirato_il IS NULLscarta la rigaGROUP BY stazione_idper ogni gruppoCOUNT(*) >= 2scarta il gruppoSELECT stazione_id, COUNT(*)ORDER BY non_ritirati DESC,stazione_idquattro righenosìfinitinosìfiniti
Prima le righe, poi i gruppi

Passo per passo.

PassoCosa faCosa resta
FROMla tabella16 righe
WHERE ritirato_il IS NULLscarta le righe già ritirate10 righe
GROUP BY stazione_idun gruppo per stazione6 gruppi: stazione 1 (1 oggetto), 2 (2), 3 (2), 5 (2), 7 (2), 10 (1)
HAVING COUNT(*) >= 2scarta i gruppi con meno di 2 righe4 gruppi: 2, 3, 5, 7
SELECTstazione e conteggio4 righe
ORDER BYnumero decrescente, poi stazione

Senza l'HAVING i gruppi sarebbero sei, con la stazione 1 e la 10 a quota 1. Se scambi i posti:

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

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

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

inizio FROM stazioni s per ogni stazione se ha oggetti sì: passo attacca ogni oggetto no: passo una riga con o.id vuoto GROUP BY s.nome SELECT s.nome, COUNT(o.id) ORDER BY oggetti DESC, s.nomeFROM stazioni sper ogni stazioneha oggettiuna riga con o.id vuotoattacca ogni oggettoGROUP BY s.nomeSELECT s.nome, COUNT(o.id)ORDER BY oggetti DESC,s.nomenosìfiniti
La LEFT JOIN e il conteggio

Passo per passo.

PassoCosa faCosa resta
FROM stazioni stutte le stazioni10 righe
LEFT JOIN oggetti_smarriti o …attacca gli oggetti; chi non ne ha riceve una riga con NULL a destra18 righe: 16 oggetti, più una riga vuota per Corso Funzione e una per Vecchia Fiera
GROUP BY s.nomeun gruppo per stazione10 gruppi
COUNT(o.id)conta gli id di destra: i NULL non contanoCorso Funzione 0, Vecchia Fiera 0, le altre come prima

Ora la versione con COUNT(*), che sembra uguale:

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