Cum gestionezi duplicatele cu DISTINCT?

Question

Accepted Answer

**`DISTINCT`** elimină rândurile duplicate din rezultat, returnând doar valorile unice. Se folosește pentru a obține valori distincte ale unei coloane (sau combinație de coloane) — frecvent pentru a găsi intrări unice sau pentru a construi liste dropdown.

## DISTINCT — valori unice

```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` se aplică tuturor coloanelor selectate împreună — `DISTINCT country, city` returnează combinații *unice*, nu țări unice și orașe unice separat.

## DISTINCT cu 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)` numără valorile unice — util pentru "câte X diferite sunt?".

## Găsirea rândurilor duplicate actuale

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

Pentru a *găsi* duplicate (nu doar pentru a le elimina), folosește `GROUP BY` + `HAVING COUNT(*) > 1` — aceasta identifică ce valori sunt duplicate și de câte ori.

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

## O notă privind performanța

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

## De ce conteaza

`DISTINCT` este o caracteristică SQL utilă și frecvent necesară pentru **gestionarea duplicatelor** — obținerea valorilor unice este o nevoie frecventă (categorii unice pentru o listă dropdown, intrări distincte, numărarea elementelor unice), deci înțelegerea acesteia este cunoaștere practică zilnică.

Cunoscând cum funcționează `DISTINCT` (eliminând rânduri duplicate, și că pe mai multe coloane returnează *combinații* unice — un punct frecvent de confuzie) și cum să folosești `COUNT(DISTINCT)` pentru numărarea valorilor unice, acoperă utilizările tipice.

Egal de valoros este să știi cum să **găsești duplicate actuale** (folosind `GROUP BY` + `HAVING COUNT(*) > 1`) — o sarcină frecventă și importantă pentru curățarea și validarea datelor (identificarea email-urilor duplicate, înregistrărilor, etc.).

Înțelegerea relației dintre `DISTINCT` și `GROUP BY` (adesea echivalente pentru deduplicare, cu GROUP BY fiind mai flexibil) și **nota de performanță** (DISTINCT necesită comparare/sortare și poate fi costisitoare, și uneori semnalează o JOIN producând duplicate nedorite) este de asemenea utilă.

Deoarece gestionarea duplicatelor — atât eliminarea lor (DISTINCT) cât și găsirea lor (GROUP BY/HAVING) — este o nevoie practică frecventă în interogări și lucrul cu calitatea datelor, și deoarece înțelegerea comportamentului DISTINCT (în special pe mai multe coloane) și alternativele sale previne confuzia și ineficiența, știind cum să gestionezi duplicatele cu DISTINCT este cunoaștere utilă și frecvent aplicată pentru lucrul cu date reale care adesea conțin sau necesită valori unice.