0Pricing
SQL Interview Prep · Lezione

COUNT(*) contro COUNT(column) e COUNT(DISTINCT)

La domanda classica su come ciascuna forma di COUNT tratta NULL e duplicati

COUNT(*) contro COUNT(column) e COUNT(DISTINCT) è una lezione SQL Interview Prep gratuita su CoddyKit. Questa è la lezione 1 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 Interview Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso SQL Interview Prep include 4 lezioni in totale.

La domanda che Le verrà posta

Se affronta un colloquio SQL, si aspetti questa domanda entro i primi dieci minuti: Qual è la differenza tra COUNT(*), COUNT(column) e COUNT(DISTINCT column)?

Sembra banale, ma gli intervistatori la usano per verificare se comprende davvero come le funzioni di aggregazione trattano i valori NULL e i duplicati. Una risposta sicura e precisa dimostra che ha scritto query reali, non che ha soltanto memorizzato la sintassi.

In questa lezione costruiremo un modello mentale solido, così potrà rispondere immediatamente e spiegare il perché.

COUNT(*) conta le righe

COUNT(*) conta le righe. Non considera affatto i valori delle colonne, quindi i NULL sono irrilevanti. Se la tabella contiene 100 righe, COUNT(*) restituisce 100, senza eccezioni.

Qui l'asterisco non moltiplica né espande le colonne. È un token speciale che significa "conta ogni riga che soddisfa i criteri". È la forma da usare quando la domanda è semplicemente "quanti record ci sono?"

SELECT COUNT(*) AS total_rows
FROM employees;

Dati di esempio su cui ragionare

Ancoriamo tutto a una piccola tabella. Immagini una tabella employees con una colonna department che può contenere NULL:

  • Alice, Sales
  • Bob, Sales
  • Carol, NULL
  • Dan, Engineering
  • Eve, NULL

In totale sono 5 righe. Tre righe hanno un valore per il reparto (Sales, Sales, Engineering) e due righe hanno NULL. Tenga a mente questi numeri: conteremo questa tabella in tre modi diversi.

COUNT(column) ignora i NULL

COUNT(column) conta solo le righe in cui quella colonna è non NULL. Ignora completamente i valori NULL.

Con i nostri dati di esempio, COUNT(department) restituisce 3, non 5, perché due valori di department sono NULL. Questo è il fatto più importante dell'intera lezione: COUNT di una colonna non conta mai i NULL.

SELECT COUNT(department) AS depts_present
FROM employees;
-- returns 3 on our sample data

Confronto tra i due finora

Considerando la stessa tabella di 5 righe:

  • COUNT(*) = 5 (tutte le righe)
  • COUNT(department) = 3 (department non NULL)

La differenza tra i due valori, 5 meno 3, corrisponde al numero di department NULL. Un utile trucco da colloquio: COUNT(*) - COUNT(col) fornisce il numero di NULL in quella colonna senza dover scrivere una clausola WHERE separata.

SELECT COUNT(*) - COUNT(department) AS null_departments
FROM employees;
-- returns 2

COUNT(DISTINCT column)

COUNT(DISTINCT column) conta il numero di valori univoci non NULL. Prima rimuove i duplicati, poi ignora i NULL e infine conta ciò che rimane.

Nei nostri dati, i valori distinti di department sono Sales ed Engineering, quindi COUNT(DISTINCT department) restituisce 2. I due NULL non vengono conteggiati e il valore Sales duplicato viene considerato una sola volta.

SELECT COUNT(DISTINCT department) AS unique_depts
FROM employees;
-- returns 2

Tutti e tre insieme

Il quadro completo sulla nostra tabella di 5 righe:

  • COUNT(*) = 5 — righe
  • COUNT(department) = 3 — valori non NULL
  • COUNT(DISTINCT department) = 2 — valori univoci non NULL

Se sa ripetere questo ordine, prima con attenzione ai NULL e poi ai duplicati, ha compreso l'intero concetto. Noti che ogni forma restituisce un valore minore o uguale a quello precedente.

SELECT
  COUNT(*)                       AS rows_total,
  COUNT(department)              AS depts_present,
  COUNT(DISTINCT department)     AS unique_depts
FROM employees;

Una variante di colloquio svolta

Gli intervistatori spesso riformulano la domanda: "Quanti dipendenti sono assegnati a un reparto e quanti reparti distinti esistono?"

La prima parte corrisponde a COUNT(department) (assegnato significa non NULL). La seconda parte corrisponde a COUNT(DISTINCT department). Riconoscere a quale COUNT corrisponde ciascuna frase è esattamente la competenza che si vuole verificare.

SELECT
  COUNT(department)          AS assigned_employees,
  COUNT(DISTINCT department) AS distinct_departments
FROM employees;

COUNT con una condizione

Una domanda successiva molto comune è: contare solo le righe che soddisfano una condizione. Un trucco semplice e portabile consiste nell'applicare COUNT a un'espressione CASE. Poiché COUNT(column) ignora i NULL, faccia in modo che CASE restituisca NULL per le righe da escludere.

Qui contiamo i dipendenti Sales. CASE restituisce un valore solo per le righe Sales e NULL negli altri casi, quindi COUNT conta esclusivamente quelle righe.

SELECT
  COUNT(CASE WHEN department = 'Sales' THEN 1 END) AS sales_count
FROM employees;
-- returns 2

Errori comuni da evitare

Faccia attenzione a queste insidie usate dagli intervistatori:

  • Supporre che COUNT(column) sia uguale a COUNT(*) — lo è solo quando la colonna non contiene alcun NULL.
  • Pensare che COUNT(DISTINCT col) includa NULL come un valore distinto — non è così.
  • Scrivere COUNT(1) aspettandosi che ignori i NULL — si comporta come COUNT(*) e conta tutte le righe.

Esponga spontaneamente questi punti durante un colloquio per dimostrare la sua preparazione.

COUNT(1) e COUNT(constant)

I candidati spesso chiedono quale sia più veloce tra COUNT(*) e COUNT(1). La risposta è: sono semanticamente identici — entrambi contano ogni riga indipendentemente dai NULL — e gli ottimizzatori moderni li trattano allo stesso modo, quindi non c'è una reale differenza di prestazioni.

La costante all'interno di COUNT(1) non è mai NULL, quindi nessuna riga viene ignorata. Preferisca COUNT(*) per chiarezza: è la forma idiomatica.

SELECT COUNT(*) AS a, COUNT(1) AS b
FROM employees;
-- a and b are always equal

Controllo rapido

Verifichi il suo modello mentale sulla tabella di esempio.

Riepilogo

Ora conosce la domanda sulle funzioni di aggregazione più frequente nei colloqui:

  • COUNT(*) conta ogni riga, inclusi i NULL.
  • COUNT(column) conta solo i valori non NULL.
  • COUNT(DISTINCT column) conta i valori univoci non NULL.
  • COUNT(*) - COUNT(col) fornisce gratuitamente il numero di NULL.
  • COUNT(1) è uguale a COUNT(*) — non ignora i NULL e non offre differenze di velocità.

Lo enunci con chiarezza e ne spieghi il motivo. Il prossimo argomento è il comportamento di SUM e AVG con i NULL.

Domande Frequenti

La lezione «COUNT(*) contro COUNT(column) e COUNT(DISTINCT)» è gratuita?

Sì — il testo completo di «COUNT(*) contro COUNT(column) e COUNT(DISTINCT)» è 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 Interview Prep, passa a CoddyKit PRO. Il corso SQL Interview Prep include 4 lezioni in totale.

Cosa imparerò in «COUNT(*) contro COUNT(column) e COUNT(DISTINCT)»?

La domanda classica su come ciascuna forma di COUNT tratta NULL e duplicati Eserciti SQL Interview Prep 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 Interview Prep?

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

Quanto tempo richiede la lezione «COUNT(*) contro COUNT(column) e COUNT(DISTINCT)»?

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 Interview Prep?

Sì. Ogni lezione SQL Interview Prep 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. COUNT(*) contro COUNT(column) e COUNT(DISTINCT)
  2. SUM e AVG con i NULL
  3. MIN, MAX e aggregazione non numerica
  4. Aggregati senza GROUP BY
← Torna a SQL Interview Prep