Hoe handel je duplicaten af met DISTINCT?

Question

Accepted Answer

**`DISTINCT`** verwijdert duplicate rijen uit een resultaat en retourneert alleen unieke waarden. Het wordt gebruikt om unieke waarden van een kolom (of combinatie van kolommen) te krijgen — gebruikelijk voor het vinden van unieke vermeldingen of het bouwen van vervolgkeuzelijsten.

## DISTINCT — unieke waarden

```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` is van toepassing op alle geselecteerde kolommen samen — `DISTINCT country, city` retourneert unieke *combinaties*, niet unieke landen en unieke steden afzonderlijk.

## DISTINCT met 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)` telt unieke waarden — nuttig voor "hoeveel verschillende X zijn er?".

## Werkelijke duplicate rijen vinden

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

Om duplicaten te *vinden* (niet alleen te verwijderen), gebruik je `GROUP BY` + `HAVING COUNT(*) > 1` — dit identificeert welke waarden duplicaat zijn en hoe vaak.

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

## Een opmerking over prestaties

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

## Waarom het belangrijk is

`DISTINCT` is een nuttig, veel gebruikt SQL-feature voor **het afhandelen van duplicaten** — unieke waarden krijgen is een frequente behoefte (unieke categorieën voor een vervolgkeuzelijst, onderscheidende vermeldingen, tellen van unieke items), dus het begrijpen ervan is praktische dagelijkse kennis.

Het begrijpen hoe `DISTINCT` werkt (duplicate rijen verwijderen, en dat het op meerdere kolommen unieke *combinaties* retourneert — een gebruikelijk verwarrend punt) en hoe je `COUNT(DISTINCT)` gebruikt voor het tellen van unieke waarden, dekt de typische toepassingen af.

Evenals waardevol is het weten hoe je werkelijke duplicaten **kunt vinden** (met `GROUP BY` + `HAVING COUNT(*) > 1`) — een veelvoorkomende, belangrijke taak voor gegevensschoonmaak en validatie (het identificeren van dubbele e-mails, records, enz.).

Het begrijpen van de relatie tussen `DISTINCT` en `GROUP BY` (vaak gelijkwaardig voor deduplicatie, waarbij GROUP BY flexibeler is) en de **prestatiesopmerking** (DISTINCT vereist vergelijken/sorteren en kan kostbaar zijn, en signaleert soms een JOIN die ongewenste duplicaten oplevert) is ook nuttig.

Omdat het afhandelen van duplicaten — zowel het verwijderen ervan (DISTINCT) als het vinden ervan (GROUP BY/HAVING) — een veelvoorkomende praktische behoefte is bij het uitvoeren van query's en kwaliteitswerk van gegevens, en omdat het begrijpen van het gedrag van DISTINCT (vooral op meerdere kolommen) en de alternatieven verwarring en inefficiëntie voorkomen, is het weten hoe je duplicaten met DISTINCT afhandelt nuttige, veel gebruikte kennis voor het werken met echte gegevens die vaak unieke waarden bevatten of nodig hebben.