SQL Academy · Lezione

Contare i valori univoci

Utilizzi COUNT(DISTINCT ...) nella pratica

Contare i valori univoci è 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.

Perché contare i valori univoci?

Quando usa COUNT(*), conta ogni riga, inclusi i duplicati. A volte, però, si desidera sapere solo quanti valori distinti esistono in una colonna.

Ad esempio: da quanti paesi diversi provengono i clienti? Quanti prodotti univoci sono stati ordinati il mese scorso? È qui che entra in gioco COUNT(DISTINCT ...).

Creazione di una tabella di esempio

Crei una tabella orders per fare pratica. Ogni ordine contiene il nome di un cliente, un prodotto e un paese.

Noti che alcuni clienti e paesi compaiono più di una volta: è intenzionale, così può osservare la differenza tra il conteggio di tutte le righe e quello dei valori distinti.

CREATE TABLE orders (
  id INT,
  customer VARCHAR(50),
  product VARCHAR(50),
  country VARCHAR(50)
);

INSERT INTO orders VALUES
  (1, 'Alice', 'Laptop', 'USA'),
  (2, 'Bob', 'Phone', 'UK'),
  (3, 'Alice', 'Tablet', 'USA'),
  (4, 'Carol', 'Laptop', 'Canada'),
  (5, 'Bob', 'Laptop', 'UK'),
  (6, 'Dave', 'Phone', 'USA'),
  (7, 'Carol', 'Phone', 'Canada'),
  (8, 'Eve', 'Tablet', 'Germany');

COUNT(*) e COUNT(DISTINCT) a confronto

Esegua entrambe le query e confronti i risultati. COUNT(*) restituisce 8, una per ogni riga. COUNT(DISTINCT customer) restituisce 5, perché ci sono solo 5 clienti univoci (Alice, Bob, Carol, Dave, Eve).

Questa è l'idea fondamentale: COUNT(DISTINCT column) ignora i valori ripetuti e conta solo quelli univoci.

SELECT COUNT(*) AS total_orders,
       COUNT(DISTINCT customer) AS unique_customers
FROM orders;

Conteggio dei paesi distinti

Determiniamo da quanti paesi diversi provengono i nostri clienti. Sebbene la tabella orders contenga 8 righe, diverse righe condividono lo stesso paese.

Il risultato sarà 4: USA, Regno Unito, Canada e Germania, indipendentemente dal numero di volte in cui compare ciascun paese.

SELECT COUNT(DISTINCT country) AS unique_countries
FROM orders;

Conteggio dei prodotti distinti

Lo stesso schema si può applicare a qualsiasi colonna. Qui contiamo quanti prodotti diversi sono stati ordinati.

Sebbene 'Laptop' compaia tre volte e 'Phone' compaia tre volte, ogni prodotto viene contato una sola volta. La risposta è 3: Laptop, Phone, Tablet.

SELECT COUNT(DISTINCT product) AS unique_products
FROM orders;

Usare COUNT(DISTINCT) con WHERE

È possibile combinare COUNT(DISTINCT ...) con una clausola WHERE per restringere le righe prima del conteggio. Qui contiamo i prodotti distinti ordinati solo dai clienti degli USA.

Vengono considerate solo le righe in cui country = 'USA', quindi si contano i prodotti univoci tra queste righe.

SELECT COUNT(DISTINCT product) AS usa_unique_products
FROM orders
WHERE country = 'USA';

COUNT(DISTINCT) con GROUP BY

Se abbinato a GROUP BY, COUNT(DISTINCT ...) fornisce conteggi distinti per gruppo. Questa query risponde alla domanda: per ogni paese, quanti clienti univoci hanno effettuato ordini?

Ogni gruppo viene elaborato indipendentemente, perciò i duplicati all'interno del gruppo vengono rimossi prima del conteggio.

SELECT country,
       COUNT(DISTINCT customer) AS unique_customers
FROM orders
GROUP BY country
ORDER BY unique_customers DESC;

Conteggio dei valori distinti in più colonne

È possibile usare diverse espressioni COUNT(DISTINCT ...) nella stessa SELECT. In questo modo si ottiene una rapida panoramica della cardinalità, cioè di quanti valori univoci contiene ogni colonna, con una sola query.

La cardinalità è una metrica utile quando si esplora un nuovo dataset.

SELECT COUNT(DISTINCT customer) AS unique_customers,
       COUNT(DISTINCT product)  AS unique_products,
       COUNT(DISTINCT country)  AS unique_countries
FROM orders;

Gestione dei valori NULL

Proprio come il normale COUNT(column), COUNT(DISTINCT column) ignora i valori NULL. Un NULL non viene conteggiato come valore univoco.

In questo esempio, due righe hanno un paese NULL. Il risultato resta quindi di 4 paesi distinti non NULL, non 5.

INSERT INTO orders VALUES
  (9,  'Frank', 'Phone',  NULL),
  (10, 'Grace', 'Laptop', NULL);

SELECT COUNT(DISTINCT country) AS unique_countries_no_null
FROM orders;

Confronto tra COUNT(*), COUNT(col) e COUNT(DISTINCT col)

È utile vedere affiancate tutte e tre le forme di COUNT:

COUNT(*): conta ogni riga, inclusi i valori NULL
COUNT(country): conta le righe in cui country non è NULL
COUNT(DISTINCT country): conta i valori univoci non NULL di country

Esegua questa query sulla tabella aggiornata, che ora contiene 10 righe, 2 delle quali con country NULL, per verificare le differenze.

SELECT COUNT(*)                AS total_rows,
       COUNT(country)          AS non_null_countries,
       COUNT(DISTINCT country) AS unique_countries
FROM orders;

Caso d'uso reale: utenti attivi giornalieri

Uno degli usi più comuni di COUNT(DISTINCT ...) nell'analisi dei dati consiste nel conteggio degli utenti attivi giornalieri (DAU). Si dispone di un registro di eventi e si desidera sapere quanti utenti univoci sono stati attivi ogni giorno.

Raggruppi per data e usi COUNT(DISTINCT user_id) per ottenere il conteggio degli utenti distinti per giorno: i duplicati dovuti a più clic dello stesso utente vengono esclusi automaticamente.

CREATE TABLE user_events (
  event_date DATE,
  user_id    INT
);

INSERT INTO user_events VALUES
  ('2024-01-01', 1), ('2024-01-01', 2), ('2024-01-01', 1),
  ('2024-01-02', 2), ('2024-01-02', 3), ('2024-01-02', 2),
  ('2024-01-03', 1), ('2024-01-03', 4);

SELECT event_date,
       COUNT(DISTINCT user_id) AS daily_active_users
FROM user_events
GROUP BY event_date
ORDER BY event_date;

Verifica rapida

Metta alla prova la Sua comprensione di COUNT(DISTINCT ...) con questa domanda.

Riepilogo della lezione

Ottimo lavoro! Ecco un riepilogo di ciò che ha imparato su COUNT(DISTINCT ...):

COUNT(DISTINCT column) conta solo i valori univoci e non NULL di una colonna.
Differisce da COUNT(*), che conta tutte le righe, e da COUNT(column), che conta le righe non NULL.
Funziona con WHERE per filtrare le righe prima del conteggio.
Funziona con GROUP BY per contare i valori distinti per gruppo.
I valori NULL vengono sempre esclusi dal conteggio dei valori distinti.
È possibile inserire più espressioni COUNT(DISTINCT ...) nella stessa SELECT.
Tra gli usi comuni nella pratica rientrano il conteggio di utenti, prodotti, paesi e sessioni univoci.

La padronanza di questa funzione offre uno strumento potente per l'esplorazione dei dati e l'analisi.

Domande Frequenti

La lezione «Contare i valori univoci» è gratuita?

Sì — il testo completo di «Contare i valori univoci» è 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 «Contare i valori univoci»?

Utilizzi COUNT(DISTINCT ...) nella pratica 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 «Contare i valori univoci»?

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

← Torna a SQL Academy