Come gestisci i duplicati con DISTINCT?

Question

Accepted Answer

**`DISTINCT`** rimuove le righe duplicate dal risultato, restituendo solo valori univoci. Viene usato per ottenere valori distinti di una colonna (o combinazione di colonne) — comune per trovare voci univoche o creare elenchi a discesa.

## DISTINCT — valori univoci

```sql
-- get the unique countries (no duplicates)
SELECT DISTINCT country FROM users;
-- → each country appears once, even if many users share it

-- DISTINCT on multiple columns → unique COMBINATIONS
SELECT DISTINCT country, city FROM users;
-- → each unique (country, city) pair appears once
```

`DISTINCT` si applica a tutte le colonne selezionate insieme — `DISTINCT country, city` restituisce *combinazioni* univoche, non paesi univoci e città univoche separatamente.

## DISTINCT con COUNT

```sql
-- count how many UNIQUE countries there are
SELECT COUNT(DISTINCT country) FROM users;

-- vs COUNT(*) which counts all rows (with duplicates)
SELECT COUNT(*) FROM users;
```

`COUNT(DISTINCT column)` conta i valori univoci — utile per "quanti X diversi ci sono?"

## Trovare righe effettivamente duplicate

```sql
-- find values that appear MORE THAN ONCE (duplicates)
SELECT email, COUNT(*) AS count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;          -- groups with more than one row = duplicates
```

Per *trovare* duplicati (non solo rimuoverli), usa `GROUP BY` + `HAVING COUNT(*) > 1` — questo identifica quali valori sono duplicati e quante volte.

## DISTINCT vs GROUP BY

```sql
-- these are often equivalent for getting unique values:
SELECT DISTINCT country FROM users;
SELECT country FROM users GROUP BY country;
-- GROUP BY is more flexible (can add aggregates); DISTINCT is simpler for pure deduplication
```

## Una nota sulle prestazioni

```text
DISTINCT requires the database to compare/sort rows to find uniques → can be costly
on large datasets. Often a sign you might restructure the query (e.g. a JOIN producing
duplicates that DISTINCT then removes — consider whether the JOIN is the issue).
```

## Perché è importante

`DISTINCT` è una funzione SQL utile e comunemente necessaria per **gestire i duplicati** — ottenere valori univoci è un'esigenza frequente (categorie univoche per un elenco a discesa, voci distinte, contare elementi univoci), quindi comprenderla è una conoscenza pratica quotidiana.

Sapere come funziona `DISTINCT` (rimuove le righe duplicate, e che su più colonne restituisce *combinazioni* univoche — un punto di confusione comune) e come usare `COUNT(DISTINCT)` per contare i valori univoci copre gli usi tipici.

Equalmente prezioso è sapere come **trovare duplicati effettivi** (usando `GROUP BY` + `HAVING COUNT(*) > 1`) — un'attività comune e importante per la pulizia e la convalida dei dati (identificare email duplicate, record, ecc.).

Comprendere la relazione tra `DISTINCT` e `GROUP BY` (spesso equivalenti per la deduplicazione, con GROUP BY più flessibile) e la **nota sulle prestazioni** (DISTINCT richiede il confronto/ordinamento e può essere costoso, e a volte segnala un JOIN che produce duplicati indesiderati) è utile.

Poiché gestire i duplicati — sia rimuoverli (DISTINCT) che trovarli (GROUP BY/HAVING) — è un'esigenza pratica comune nelle query e nel lavoro di qualità dei dati, e poiché comprendere il comportamento di DISTINCT (specialmente su più colonne) e le sue alternative previene confusione e inefficienza, sapere come gestire i duplicati con DISTINCT è una conoscenza utile e frequentemente applicata per lavorare con dati reali che spesso contengono o richiedono valori univoci.