Hvordan håndterer du duplikater med DISTINCT?

Question

Accepted Answer

**`DISTINCT`** fjerner duplikatrader fra et resultat og returnerer bare unike verdier. Det brukes til å få distinkte verdier fra en kolonne (eller kombinasjon av kolonner) — vanlig for å finne unike oppføringer eller bygge nedtrekksmenyer.

## DISTINCT — unike verdier

```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` gjelder for alle valgte kolonner sammen — `DISTINCT country, city` returnerer unike *kombinasjoner*, ikke unike land og unike 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)` teller unike verdier — nyttig for "hvor mange forskjellige X finnes det?"

## Finne faktiske duplikatrader

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

For å *finne* duplikater (ikke bare fjerne dem), bruk `GROUP BY` + `HAVING COUNT(*) > 1` — dette identifiserer hvilke verdier som er duplikert og hvor mange ganger.

## 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 merknad om ytelse

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

`DISTINCT` er en nyttig, ofte nødvendig SQL-funksjon for **håndtering av duplikater** — å få unike verdier er et hyppig behov (unike kategorier for en nedtrekkmeny, distinkte oppføringer, telling av unike elementer), så å forstå det er praktisk hverdagskunnskap.

Å vite hvordan `DISTINCT` fungerer (fjerner duplikatrader, og at på flere kolonner returnerer det unike *kombinasjoner* — et vanlig forvirringspunkt) og hvordan du bruker `COUNT(DISTINCT)` for å telle unike verdier dekker de typiske brukstilfellene.

Like verdifullt er det å vite hvordan du **finner faktiske duplikater** (ved hjelp av `GROUP BY` + `HAVING COUNT(*) > 1`) — en vanlig, viktig oppgave for datarensing og validering (identifisering av duplikate e-poster, poster, osv.).

Å forstå forholdet mellom `DISTINCT` og `GROUP BY` (ofte ekvivalent for deduplisering, med GROUP BY som mer fleksibel) og **ytelsesbemerkingen** (DISTINCT krever sammenligning/sortering og kan være kostbar, og signaliserer noen ganger at en JOIN produserer uønskede duplikater) er også nyttig.

Siden håndtering av duplikater — både fjerning av dem (DISTINCT) og finning av dem (GROUP BY/HAVING) — er et vanlig praktisk behov i spørring og datakvalitetsarbeid, og siden å forstå DISTINCT sin oppførsel (spesielt på flere kolonner) og dens alternativer forhindrer forvirring og ineffektivitet, er det å vite hvordan du håndterer duplikater med DISTINCT nyttig, hyppig brukt kunnskap for å arbeide med virkelige data som ofte inneholder eller krever unike verdier.