DISTINCT in SQLite: rimuovere i duplicati dalle query SELECT

DISTINCT rimuove le righe duplicate

Di default, SELECT restituisce ogni riga che corrisponde, duplicati compresi. DISTINCT dice a SQLite di unire le righe identiche nelle colonne che hai selezionato, così ogni combinazione unica compare una sola volta.

CREATE TABLE orders (id INTEGER, customer TEXT, country TEXT);
INSERT INTO orders VALUES
    (1, 'Ada',   'UK'),
    (2, 'Boris', 'FR'),
    (3, 'Ada',   'UK'),
    (4, 'Cleo',  'US'),
    (5, 'Boris', 'FR');

SELECT DISTINCT customer FROM orders;

Entrano cinque righe, ne escono tre. SQLite ha guardato la colonna customer, ha scartato le ripetizioni e ha restituito una riga per ogni valore unico. L'ordine non è garantito: aggiungi ORDER BY se ti interessa.

DISTINCT si applica all'intero elenco della select

Questo confonde molte persone. DISTINCT non sceglie una colonna da deduplicare: deduplica righe intere in base a tutte le colonne che hai selezionato.

CREATE TABLE orders (id INTEGER, customer TEXT, country TEXT);
INSERT INTO orders VALUES
    (1, 'Ada',   'UK'),
    (2, 'Boris', 'FR'),
    (3, 'Ada',   'UK'),
    (4, 'Cleo',  'US'),
    (5, 'Boris', 'FR');

SELECT DISTINCT customer, country FROM orders;

Ogni coppia unica (customer, country) compare una volta. Se lo stesso cliente comparisse con due paesi diversi, vedresti entrambe le righe: per SQLite non sono duplicati.

Non esiste una sintassi DISTINCT(customer) che ignori le altre colonne. Le parentesi sono allettanti, ma SELECT DISTINCT(customer), country viene interpretato esattamente come SELECT DISTINCT customer, country: le parentesi raggruppano solo un'espressione. Se vuoi davvero una riga per cliente con un paese scelto, è un lavoro per GROUP BY più un'aggregazione.

COUNT(DISTINCT col)

Un'esigenza comune: quanti valori unici ci sono in una colonna? COUNT(*) conta le righe, COUNT(col) conta i valori non NULL e COUNT(DISTINCT col) conta i valori unici non NULL.

CREATE TABLE orders (id INTEGER, customer TEXT, country TEXT);
INSERT INTO orders VALUES
    (1, 'Ada',   'UK'),
    (2, 'Boris', 'FR'),
    (3, 'Ada',   'UK'),
    (4, 'Cleo',  'US'),
    (5, 'Boris', 'FR');

SELECT
    COUNT(*)                  AS total_orders,
    COUNT(DISTINCT customer)  AS unique_customers,
    COUNT(DISTINCT country)   AS unique_countries
FROM orders;

Cinque ordini, tre clienti unici, tre paesi unici. COUNT(DISTINCT ...) è la forma aggregata più utile di DISTINCT: la userai ogni volta che vuoi contare "quante cose diverse sono comparse".

Nota che SQLite ammette una sola colonna dentro COUNT(DISTINCT ...). Per contare le combinazioni uniche di più colonne, racchiudile in una subquery: SELECT COUNT(*) FROM (SELECT DISTINCT a, b FROM t).

Come DISTINCT tratta NULL

NULL ha una reputazione strana in SQL perché NULL = NULL dà NULL, non TRUE. Ma DISTINCT fa un'eccezione speciale: ai fini della deduplicazione, tutti i NULL sono considerati uguali tra loro.

CREATE TABLE contacts (name TEXT, email TEXT);
INSERT INTO contacts VALUES
    ('Ada',   'ada@example.com'),
    ('Boris', NULL),
    ('Cleo',  NULL),
    ('Dan',   'dan@example.com'),
    ('Eve',   NULL);

SELECT DISTINCT email FROM contacts;

Tornano tre righe: 'ada@example.com', 'dan@example.com' e un solo NULL. Le tre email NULL si sono unite in una. La stessa regola vale per GROUP BY e per le operazioni sugli insiemi come UNION: utile da ricordare quando ti chiedi "perché quella riga NULL compare una volta invece di tre?"

DISTINCT viene eseguito prima di ORDER BY e LIMIT

Le clausole di una SELECT seguono un ordine logico: FROM → WHERE → GROUP BY → HAVING → SELECT/DISTINCT → ORDER BY → LIMIT. Quindi DISTINCT filtra prima i duplicati, poi ORDER BY ordina ciò che resta, poi LIMIT lo taglia.

CREATE TABLE orders (id INTEGER, customer TEXT, amount REAL);
INSERT INTO orders VALUES
    (1, 'Ada',   12.0),
    (2, 'Boris', 30.0),
    (3, 'Ada',   45.0),
    (4, 'Cleo',  20.0),
    (5, 'Boris', 30.0);

SELECT DISTINCT customer
FROM orders
WHERE amount > 15
ORDER BY customer
LIMIT 2;

WHERE tiene quattro righe, DISTINCT unisce i duplicati di Boris, ORDER BY ordina alfabeticamente, LIMIT restituisce le prime due. Vale la pena seguirlo passo per passo almeno una volta: la confusione sull'ordine dei risultati nasce di solito dal dimenticare quale passaggio avviene quando.

DISTINCT contro GROUP BY

Per la pura deduplicazione, queste due query restituiscono le stesse righe:

CREATE TABLE orders (id INTEGER, customer TEXT, amount REAL);
INSERT INTO orders VALUES
    (1, 'Ada',   12.0),
    (2, 'Boris', 30.0),
    (3, 'Ada',   45.0),
    (4, 'Cleo',  20.0);

SELECT DISTINCT customer FROM orders;
SELECT customer FROM orders GROUP BY customer;

Stesso risultato. La differenza sta in cosa puoi fare dopo:

• DISTINCT serve per "dammi le righe uniche" e nient'altro.
• GROUP BY serve per "dividi le righe in gruppi e calcola qualcosa per ogni gruppo": COUNT(*), SUM(amount), MAX(created_at) e così via.

Se ti ritrovi a usare DISTINCT e poi ti accorgi che vuoi anche un totale per cliente, è il segnale per passare a GROUP BY:

CREATE TABLE orders (id INTEGER, customer TEXT, amount REAL);
INSERT INTO orders VALUES
    (1, 'Ada',   12.0),
    (2, 'Boris', 30.0),
    (3, 'Ada',   45.0),
    (4, 'Cleo',  20.0);

SELECT customer, COUNT(*) AS orders, SUM(amount) AS total
FROM orders
GROUP BY customer
ORDER BY total DESC;

Una riga per cliente, con le aggregazioni che volevi. DISTINCT non poteva farlo: non ha modo di esprimere "una riga per gruppo più una somma".

Alcune cose a cui fare attenzione

• Prestazioni. DISTINCT di solito richiede a SQLite di ordinare o calcolare un hash delle righe per trovare i duplicati. Su risultati grandi, un indice sulle colonne deduplicate aiuta. Se fai SELECT DISTINCT su tutte le colonne di una tabella larga, chiediti se ti servono davvero tutte.
• DISTINCT * è raro. È legale, SELECT DISTINCT * FROM t deduplica righe intere, ma se la tabella ha una chiave primaria ogni riga è già unica, quindi non serve a nulla.
• Non confonderlo con UNIQUE. UNIQUE è un vincolo su una tabella che impedisce fin dall'inizio l'inserimento di valori duplicati. DISTINCT è un filtro applicato durante la query che nasconde i duplicati nel risultato. Strumenti diversi, lavori diversi.

Prossimo passo: le espressioni CASE

Una volta che sai dare forma alle righe del risultato con SELECT, WHERE, ORDER BY e DISTINCT, il passo successivo è la logica condizionale dentro una query. Le espressioni CASE ti permettono di restituire valori diversi in base a delle condizioni: l'equivalente SQL di una catena di if/else, e la prossima pagina le spiega.