0Pricing
SQL Academy · Lezione

NULL negli aggregati e nei join

Scopra come si comporta NULL in COUNT, SUM e JOIN

NULL negli aggregati e nei join è una lezione SQL Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento SQL Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso SQL Academy include 4 lezioni in totale.

I NULL cambiano i calcoli

Le funzioni di aggregazione e le JOIN trattano NULL in modo speciale. Se non si conoscono queste regole, i totali e i conteggi possono risultare silenziosamente errati.

Questa lezione mostra come COUNT, SUM, AVG, GROUP BY e le JOIN esterne interagiscono con i valori mancanti.

SELECT amount FROM payments;
-- amount
-- -------
--    100
--   NULL   <- missing
--    200

Le funzioni di aggregazione ignorano i NULL

La maggior parte delle funzioni di aggregazione — SUM, AVG, MIN, MAX — si limita a ignorare i valori NULL. Vengono aggregate solo le righe che contengono dati.

Quindi un importo NULL non altera SUM: viene semplicemente escluso dal totale.

-- Using amounts 100, NULL, 200
SELECT
  SUM(amount) AS total,  -- 300 (NULL skipped)
  MIN(amount) AS lo,     -- 100
  MAX(amount) AS hi      -- 200
FROM payments;

Anche AVG ignora i NULL

AVG divide la somma dei valori diversi da NULL per il conteggio dei valori diversi da NULL. I NULL vengono esclusi da entrambi.

Questo è importante: la media di {100, NULL, 200} è 150, non 100 — il NULL non viene conteggiato come zero.

-- (100 + 200) / 2 = 150, the NULL row is ignored
SELECT AVG(amount) AS avg_amount FROM payments;

-- If you WANT NULLs counted as 0, COALESCE first:
SELECT AVG(COALESCE(amount, 0)) AS avg_with_zeros FROM payments; -- 100

COUNT(*) e COUNT(column) a confronto

Questa distinzione trae in inganno molte persone:

  • COUNT(*) conta le righe, comprese quelle con valori NULL.
  • COUNT(column) conta solo le righe in cui la colonna non è NULL.
-- 3 rows total, but only 2 have a non-NULL amount
SELECT
  COUNT(*)       AS row_count,    -- 3
  COUNT(amount)  AS has_amount    -- 2
FROM payments;

COUNT(DISTINCT) e NULL

COUNT(DISTINCT col) conta il numero di valori distinti diversi da NULL. I NULL sono esclusi completamente — non incrementano mai il conteggio dei valori distinti.

Lo tenga presente quando misura «quanti X unici» ci sono.

-- statuses: 'paid', NULL, 'paid', 'void'
SELECT COUNT(DISTINCT status) AS distinct_statuses
FROM payments;
-- 2  (paid, void) -- NULL not counted

Aggregazioni su insiemi vuoti

Quando una funzione di aggregazione opera su zero righe, il risultato dipende dalla funzione:

  • COUNT(...) restituisce 0.
  • SUM, AVG, MIN, MAX restituiscono NULL.

Utilizzi COALESCE per trasformare una somma NULL in 0 quando appropriato.

-- No rows match -> SUM is NULL, not 0
SELECT COALESCE(SUM(amount), 0) AS total
FROM payments
WHERE status = 'refunded';  -- no such rows

GROUP BY raggruppa i NULL

Sebbene altrove NULL = NULL abbia valore sconosciuto, GROUP BY inserisce tutti i NULL in un unico gruppo.

Quindi una categoria NULL diventa un gruppo a sé nei risultati, consentendo di riepilogare insieme le righe con dati mancanti.

SELECT category, COUNT(*) AS n
FROM products
GROUP BY category;

-- category | n
-- ---------+---
-- books    | 5
-- toys     | 3
-- NULL     | 2   <- all NULL categories in one group

NULL dalle JOIN esterne

Le JOIN esterne sono una fonte importante di NULL. Una LEFT JOIN conserva ogni riga a sinistra; quando non esiste una corrispondenza a destra, le colonne del lato destro diventano NULL.

Questi NULL significano «nessuna riga corrispondente», non «un valore NULL memorizzato».

SELECT c.name, o.id AS order_id
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

-- name  | order_id
-- ------+---------
-- Alice | 10
-- Bob   | NULL     <- Bob has no orders

Contare le corrispondenze dopo una LEFT JOIN

Per contare solo le corrispondenze reali dopo una LEFT JOIN, conti una colonna non NULL della tabella a destra, non COUNT(*).

COUNT(o.id) ignora le righe NULL prodotte dalle righe a sinistra senza corrispondenza, fornendo il numero effettivo di ordini.

SELECT c.name, COUNT(o.id) AS order_count
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;

-- Bob shows 0, not 1×NULL

Escludere le righe senza corrispondenza

Un dettaglio insidioso: inserire una condizione sulla tabella a destra in WHERE dopo una LEFT JOIN la trasforma in una INNER JOIN, perché NULL = value è sconosciuto e viene quindi filtrato.

Se desidera conservare le righe senza corrispondenza, inserisca la condizione nella clausola ON oppure verifichi esplicitamente la presenza di NULL.

-- Accidentally drops Bob (his o.status is NULL)
SELECT c.name FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.status = 'open';

-- Keep unmatched rows: move the test into ON
SELECT c.name FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id AND o.status = 'open';

Regole pratiche

Porti con sé queste regole in ogni query che combina aggregazioni e JOIN:

  • Le funzioni di aggregazione ignorano i NULL (tranne COUNT(*)).
  • COUNT(col) < COUNT(*) quando col contiene NULL.
  • La SUM/AVG su un insieme vuoto è NULL — racchiuda il risultato in COALESCE.
  • Una LEFT JOIN produce NULL per le righe senza corrispondenza; conti una chiave del lato destro.
  • I filtri sulla tabella a destra vanno in ON, non in WHERE.
SELECT c.name,
  COALESCE(SUM(o.amount), 0) AS spent,
  COUNT(o.id)                AS orders
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;

Verifica rapida

Una colonna amount contiene i valori 100, NULL e 200 distribuiti su tre righe. Che cosa restituiscono COUNT(*) e COUNT(amount)?

Riepilogo

Ha imparato come i NULL si propagano nelle aggregazioni e nelle JOIN: le funzioni di aggregazione ignorano i NULL, COUNT(*) conta le righe mentre COUNT(col) conta i valori non NULL, le somme su insiemi vuoti sono NULL e GROUP BY raggruppa i NULL in un unico gruppo.

Ha anche visto che le JOIN esterne generano NULL per le righe senza corrispondenza e perché i filtri sulla tabella a destra vanno in ON. Questo completa il corso Working with NULLs — ora è in grado di gestire con sicurezza i dati mancanti.

-- A NULL-safe summary query
SELECT c.name,
  COUNT(o.id)                AS orders,
  COALESCE(SUM(o.amount), 0) AS total_spent
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name
ORDER BY total_spent DESC;

Domande Frequenti

La lezione «NULL negli aggregati e nei join» è gratuita?

Sì — il testo completo di «NULL negli aggregati e nei join» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso SQL Academy, passa a CoddyKit PRO. Il corso SQL Academy include 4 lezioni in totale.

Cosa imparerò in «NULL negli aggregati e nei join»?

Scopra come si comporta NULL in COUNT, SUM e JOIN Eserciti SQL Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare SQL Academy?

Non è richiesta alcuna esperienza precedente. SQL Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «NULL negli aggregati e nei join»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione SQL Academy?

Sì. Ogni lezione SQL Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Il vero significato di NULL
  2. IS NULL e IS NOT NULL
  3. COALESCE e NULLIF
  4. NULL negli aggregati e nei join
← Torna a SQL Academy