Extraction des valeurs uniques avec DISTINCT

Parfois, les bases de données, c'est un peu comme un pote qui a la mémoire courte : il note tout, mais oublie ce qu'il a déjà noté. Résultat, tu ouvres une table avec les villes des clients, et là tu vois dix "Berlin", cinq "Seattle" et plein d'autres doublons. Ça arrive quand plusieurs clients viennent de la même ville. Mais bon, tu veux pas faire une campagne de pub pour dix "Berlin" alors que c'est juste une seule ville, non ?

Pour choper uniquement les valeurs uniques — sans doublons — il y a la commande DISTINCT. C'est un peu comme une baguette magique : d'un coup, elle vire toutes les lignes en double et te laisse que ce qui est vraiment différent.

DISTINCT te permet de sortir uniquement les lignes uniques du résultat de ta requête. C'est super utile quand tu veux te débarrasser des données qui se répètent, genre :

• Les produits uniques dans les commandes.
• Les prénoms de clients uniques.
• Les combinaisons uniques de données, genre "ville + pays".

Comment marche DISTINCT ?

La syntaxe de DISTINCT est simple et claire, comme souvent avec SQL :

SELECT DISTINCT colonne1, colonne2, ...
FROM table;

Quand tu ajoutes DISTINCT dans ta requête, la base de données te garantit que chaque ligne du résultat sera unique.

Exemples d'utilisation de DISTINCT

On commence avec des exemples classiques pour piger comment DISTINCT fonctionne.

Exemple 1 : Valeurs uniques d'une seule colonne

Imaginons qu'on a une table students avec des infos sur les étudiants :

-- Table students

On veut savoir de quelles villes viennent les étudiants. On écrit la requête

SELECT city
FROM students;

et voilà le résultat :

C'est pas vraiment ce qu'on voulait :(

Pour virer les doublons, il faut utiliser DISTINCT :

SELECT DISTINCT city
FROM students;

Résultat :

Sans DISTINCT, on aurait vu "Seattle" trois fois, alors qu'on voulait juste une fois chaque ville.

Exemple 2 : Valeurs uniques de plusieurs colonnes

Maintenant, imaginons qu'on veut choper les combinaisons uniques "prénom + nom", parce qu'il peut y avoir des gens avec le même prénom ou le même nom.

On a toujours la même table students :

-- Table students

La requête :

SELECT DISTINCT first_name, last_name
FROM students;

Résultat :

Donc, DISTINCT agit comme un filtre : il regarde toutes les colonnes que t'as indiquées et enlève les doublons seulement pour les lignes où toutes ces colonnes sont identiques.

Exemple 3 : Combinaisons uniques et tri

Maintenant, on combine DISTINCT avec le tri ORDER BY, pour avoir les valeurs uniques, triées par nom de famille dans l'ordre alphabétique.

On a la table students :

-- Table students

La requête :

SELECT DISTINCT first_name, last_name
FROM students
ORDER BY last_name ASC;

Résultat :

Les lignes en double sont parties, et les noms de famille sont triés par ordre alphabétique.

Exemple 4 : Utilisation avec les agrégations

Et si on essayait d'utiliser DISTINCT avec une fonction, genre COUNT ?

SELECT COUNT(DISTINCT city) AS unique_city_count
FROM students;

Résultat :

Cette requête te donne le nombre de villes uniques. Pratique, non ?

Particularités de DISTINCT

Quand tu utilises DISTINCT, faut bien piger qu'il bosse sur toutes les colonnes que t'as mises. Si tu ajoutes plus de colonnes dans la requête, le résultat peut changer.

Exemple 5 : Pourquoi c'est important de comprendre le contexte ?

Si tu ajoutes des champs en plus dans la requête, ça peut changer l'unicité des lignes.

SELECT DISTINCT first_name, city
FROM students;

Table students :

Résultat :

Chaque combinaison "prénom + ville" est maintenant unique. Donc retiens bien : l'unicité dépend de toutes les colonnes indiquées, pas de chaque colonne séparément.

Erreurs classiques avec DISTINCT

Une des erreurs les plus courantes avec DISTINCT, c'est de mal piger ce que fait vraiment la requête. Par exemple, si tu mets trop de colonnes dans la requête, tu risques d'avoir un résultat qui n'a rien à voir avec ce que tu voulais, parce que l'unicité sera calculée sur toutes les colonnes.

Par exemple :

SELECT DISTINCT *
FROM students;

Là, chaque ligne sera considérée comme unique, parce que toutes les colonnes sont prises en compte.

Une autre erreur — utiliser DISTINCT là où t'en as pas besoin. Si tu sais que les données sont déjà uniques (genre une colonne qui est une clé primaire), alors DISTINCT va juste rajouter de la charge inutile sur la base de données.