Hvordan håndterer du duplikater med DISTINCT?

Question

Accepted Answer

**`DISTINCT`** fjerner duplikerede rækker fra et resultat og returnerer kun unikke værdier. Det bruges til at få distincte værdier af en kolonne (eller kombination af kolonner) — almindeligt til at finde unikke indgange eller bygge dropdown-lister.

## DISTINCT — unikke værdier

```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` gælder for alle de valgte kolonner sammen — `DISTINCT country, city` returnerer unikke *kombinationer*, ikke unikke lande og unikke byer separat.

## DISTINCT med 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)` tæller unikke værdier — nyttigt til "hvor mange forskellige X findes der?"

## Find faktiske duplikerede rækker

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

Til at *finde* duplikater (ikke bare fjerne dem), skal du bruge `GROUP BY` + `HAVING COUNT(*) > 1` — dette identificerer hvilke værdier der duplikeres og hvor mange gange.

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

## En note om ydeevne

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

## Hvorfor det betyder noget

`DISTINCT` er en brugbar, almindeligt benyttet SQL-funktion til **håndtering af duplikater** — at få unikke værdier er et hyppigt behov (unikke kategorier til en dropdown, distincte indgange, tælling af unikke elementer), så det er praktisk hverdagsviden at forstå det.

At vide, hvordan `DISTINCT` virker (fjerner duplikerede rækker, og at det på flere kolonner returnerer unikke *kombinationer* — et almindeligt forvirringspoint) og hvordan man bruger `COUNT(DISTINCT)` til at tælle unikke værdier dækker de typiske anvendelser.

Et ligeværdigt værdifuldt område er at vide, hvordan man **finder faktiske duplikater** (ved brug af `GROUP BY` + `HAVING COUNT(*) > 1`) — en almindelig, vigtig opgave for datarensning og validering (identificering af duplikerede e-mails, poster osv.).

At forstå forholdet mellem `DISTINCT` og `GROUP BY` (ofte ækvivalente til deduplicering, hvor GROUP BY er mere fleksibel) og **ydelsesbemærkningen** (DISTINCT kræver sammenligning/sortering og kan være kostbart, og signalerer nogle gange en JOIN der producerer uønskede duplikater) er også nyttigt.

Da håndtering af duplikater — både at fjerne dem (DISTINCT) og at finde dem (GROUP BY/HAVING) — er et almindeligt praktisk behov i forespørgsler og datakvalitetsarbejde, og da forståelse af DISTINCT's adfærd (især på flere kolonner) og dens alternativer forhindrer forvirring og ineffektivitet, er det nyttigt og hyppigt anvendt viden at vide, hvordan man håndterer duplikater med DISTINCT når man arbejder med rigtige data, som ofte indeholder eller kræver unikke værdier.