Hur hanterar du dubbletter med DISTINCT?

Question

Accepted Answer

**`DISTINCT`** tar bort duplicerade rader från ett resultat och returnerar endast unika värden. Det används för att få distinkta värden för en kolumn (eller kombination av kolumner) — vanligt för att hitta unika poster eller bygga listrutorna.

## DISTINCT — unika värden

```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` tillämpas på alla valda kolumner tillsammans — `DISTINCT country, city` returnerar unika *kombinationer*, inte unika länder och unika städer 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)` räknar unika värden — användbart för "hur många olika X finns det?".

## Hitta faktiska duplicerade rader

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

För att *hitta* dubbletter (inte bara ta bort dem), använd `GROUP BY` + `HAVING COUNT(*) > 1` — detta identifierar vilka värden som är duplicerade och hur många gånger.

## 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 anmärkning om prestanda

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

## Varför det spelar roll

`DISTINCT` är en användbar, vanligt behövd SQL-funktion för **hantering av dubbletter** — att få unika värden är ett återkommande behov (unika kategorier för en listruta, distinkta poster, räkning av unika objekt), så att förstå det är praktisk daglig kunskap.

Att veta hur `DISTINCT` fungerar (tar bort duplicerade rader, och att det på flera kolumner returnerar unika *kombinationer* — en vanlig förvirringspunkt) och hur man använder `COUNT(DISTINCT)` för att räkna unika värden täcker de typiska användningsfallen.

Lika värdefull är att veta hur man **hittar faktiska dubbletter** (med `GROUP BY` + `HAVING COUNT(*) > 1`) — en vanlig, viktig uppgift för datarensning och validering (identifiering av duplicerade e-postadresser, poster osv.).

Att förstå relationen mellan `DISTINCT` och `GROUP BY` (ofta ekvivalent för deduplicering, där GROUP BY är mer flexibel) och **prestanda-anmärkningen** (DISTINCT kräver jämförelser/sortering och kan vara kostsamt, och signalerar ofta en JOIN som producerar oönskade dubbletter) är också användbar.

Eftersom hantering av dubbletter — både att ta bort dem (DISTINCT) och hitta dem (GROUP BY/HAVING) — är ett vanligt praktiskt behov vid frågor och datakvalitetsarbete, och eftersom förståelse för DISTINCT:s beteende (särskilt på flera kolumner) och dess alternativ förhindrar förvirring och ineffektivitet, är kunskapen om hur man hanterar dubbletter med DISTINCT användbar, ofta tillämpad kunskap för att arbeta med verklig data som ofta innehåller eller kräver unika värden.