Comment gérez-vous les doublons avec DISTINCT ?

Question

Accepted Answer

**`DISTINCT`** supprime les lignes en doublon d'un résultat, en renvoyant uniquement les valeurs uniques. Il est utilisé pour obtenir les valeurs distinctes d'une colonne (ou d'une combinaison de colonnes) — courant pour trouver des entrées uniques ou construire des listes déroulantes.

## DISTINCT — valeurs uniques

```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` s'applique à toutes les colonnes sélectionnées ensemble — `DISTINCT country, city` retourne des *combinaisons* uniques, pas des pays uniques et des villes uniques séparément.

## DISTINCT avec 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)` compte les valeurs uniques — utile pour « combien de différents X y a-t-il ? »

## Trouver les vraies lignes en doublon

```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
```

Pour *trouver* les doublons (pas simplement les supprimer), utilisez `GROUP BY` + `HAVING COUNT(*) > 1` — cela identifie quelles valeurs sont dupliquées et combien de fois.

## 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
```

## Une remarque sur les performances

```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).
```

## Pourquoi c'est important

`DISTINCT` est une fonctionnalité SQL utile et couramment nécessaire pour **gérer les doublons** — obtenir des valeurs uniques est un besoin fréquent (catégories uniques pour une liste déroulante, entrées distinctes, comptage d'éléments uniques), donc la comprendre est une connaissance pratique quotidienne.

Comprendre comment fonctionne `DISTINCT` (suppression des lignes en doublon, et que sur plusieurs colonnes il retourne des *combinaisons* uniques — un point de confusion courant) et comment utiliser `COUNT(DISTINCT)` pour compter les valeurs uniques couvre les utilisations typiques.

Également précieux est de savoir comment **trouver les vrais doublons** (en utilisant `GROUP BY` + `HAVING COUNT(*) > 1`) — une tâche courante et importante pour le nettoyage et la validation des données (identification des e-mails en doublon, des enregistrements, etc.).

Comprendre la relation entre `DISTINCT` et `GROUP BY` (souvent équivalents pour la déduplication, `GROUP BY` étant plus flexible) et la **remarque sur les performances** (DISTINCT nécessite de comparer/trier et peut être coûteux, et signale parfois une JOIN produisant des doublons indésirables) est aussi utile.

Puisque gérer les doublons — à la fois les supprimer (DISTINCT) et les trouver (GROUP BY/HAVING) — est un besoin pratique courant dans l'interrogation et le travail de qualité des données, et puisque comprendre le comportement de DISTINCT (en particulier sur plusieurs colonnes) et ses alternatives prévient la confusion et l'inefficacité, savoir comment gérer les doublons avec DISTINCT est une connaissance utile et fréquemment appliquée pour travailler avec des données réelles qui contiennent souvent ou exigent des valeurs uniques.