Utiliser GROUP BY et HAVING en SQL pour détecter les valeurs dupliquées dans les bases de données
Utiliser GROUP BY et HAVING en SQL pour détecter les valeurs dupliquées
Les enregistrements dupliqués font partie des problèmes les plus fréquents dans les bases de données réelles. Que vous travailliez dans la finance, la santé, la logistique, l’éducation, l’analyse de données ou les plateformes SaaS, les employeurs attendent des développeurs juniors et intermédiaires qu’ils sachent identifier, analyser et corriger les données en double de manière efficace.
Il ne s’agit pas simplement d’une compétence syntaxique en SQL. C’est une compétence métier essentielle directement liée à la fiabilité des rapports, à la prévention des fraudes, à la stabilité opérationnelle et à la qualité globale des données.
Lors des entretiens techniques, les candidats sont souvent évalués sur des cas concrets tels que :
- Détection de factures en double
- Réinscriptions multiples d’utilisateurs
- Transactions répétées au même instant
- Incohérences lors des migrations de données
- Anomalies dans les journaux d’événements
- Imports multiples depuis des systèmes externes
Comprendre correctement GROUP BY et HAVING permet de résoudre ces problèmes avec efficacité et de démontrer une vraie maîtrise du développement backend.
Pourquoi les entreprises valorisent la détection des doublons
Beaucoup de développeurs débutants se concentrent uniquement sur les fonctionnalités, tandis que les ingénieurs backend expérimentés se concentrent d’abord sur l’intégrité des données.
Les doublons peuvent provoquer des pertes importantes :
- Tableaux de bord analytiques incorrects
- Paiements en double
- Envoi répété d’e-mails ou de notifications
- Erreurs dans les stocks
- Rapports d’audit trompeurs
- Synchronisation cassée entre systèmes
C’est pourquoi la capacité à détecter et isoler les doublons est un signal fort de maturité technique.
Concepts SQL fondamentaux
1. GROUP BY
La clause GROUP BY regroupe les lignes qui partagent les mêmes valeurs.
SELECT email FROM users GROUP BY email;
Cette requête regroupe tous les emails identiques ensemble.
2. COUNT()
La fonction COUNT() permet de compter le nombre d’occurrences dans chaque groupe.
SELECT email, COUNT(*) FROM users GROUP BY email;
Elle permet de voir combien de fois chaque email apparaît.
3. HAVING
La clause HAVING filtre les résultats après agrégation.
SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1;
Elle retourne uniquement les valeurs dupliquées.
Le modèle fondamental de détection des doublons
La plupart des cas de détection de doublons suivent ce modèle :
SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name HAVING COUNT(*) > 1;
Ce modèle est très fréquent dans les entretiens techniques, les scripts de migration, les audits de données et le débogage en production.
Détection sur plusieurs colonnes
Dans les systèmes réels, une seule colonne ne suffit généralement pas à définir un doublon.
SELECT first_name, last_name, birth_date, COUNT(*) FROM customers GROUP BY first_name, last_name, birth_date HAVING COUNT(*) > 1;
Cette requête identifie les clients ayant la même identité complète.
Les entreprises apprécient les développeurs capables de comprendre ces règles métier complexes.
Gestion des doublons temporels
Les timestamps ajoutent une complexité importante, car deux événements peuvent être séparés de quelques millisecondes tout en représentant la même action logique.
Dans ce cas, il faut normaliser le temps.
Détection à la seconde près
SELECT user_id,
DATE_FORMAT(created_at, '%Y-%m-%d %H:%i:%s') AS second_value,
COUNT(*)
FROM logs
GROUP BY user_id, second_value
HAVING COUNT(*) > 1;
Version PostgreSQL :
SELECT user_id,
DATE_TRUNC('second', created_at) AS second_value,
COUNT(*)
FROM logs
GROUP BY user_id, second_value
HAVING COUNT(*) > 1;
Cette approche illustre la capacité à transformer des règles métier en logique de données.
Détection des événements répétitifs dans le temps
Dans certains systèmes, il est nécessaire d’identifier des actions répétées à la même heure sur plusieurs jours.
SELECT user_id,
TIME(created_at) AS repeated_time,
COUNT(*)
FROM activity_logs
GROUP BY user_id, repeated_time
HAVING COUNT(*) > 1;
Cas d’usage
- Détection de fraude
- Analyse de bots
- Audit de processus répétitifs
- Vérification des planifications système
Patterns avancés
1. Transactions dupliquées
SELECT customer_id,
amount,
transaction_date,
COUNT(*)
FROM payments
GROUP BY customer_id, amount, transaction_date
HAVING COUNT(*) > 1;
2. Fichiers dupliqués
SELECT file_hash, COUNT(*) FROM uploads GROUP BY file_hash HAVING COUNT(*) > 1;
3. Journaux dupliqués
SELECT event_type,
TIME(created_at),
COUNT(*)
FROM system_logs
GROUP BY event_type, TIME(created_at)
HAVING COUNT(*) > 1;
Récupérer les lignes complètes
Une erreur fréquente consiste à ne récupérer que les agrégations sans les données complètes.
SELECT t.*
FROM users t
JOIN (
SELECT email
FROM users
GROUP BY email
HAVING COUNT(*) > 1
) duplicates
ON t.email = duplicates.email;
Projets pratiques
Pour progresser, il est important de construire des projets réels :
- Tableau de nettoyage de données
- Détecteur de factures dupliquées
- Système de validation des utilisateurs
- Analyseur de fraude
- Système de détection d’anomalies
Optimisation des performances
Les requêtes de détection de doublons peuvent devenir coûteuses sur de grandes bases.
Indexation
CREATE INDEX idx_email ON users(email);
Éviter les fonctions sur colonnes indexées
WHERE DATE(created_at) = '2026-01-01'
Préférer :
WHERE created_at >= '2026-01-01 00:00:00' AND created_at < '2026-01-02 00:00:00'
Vision d’un ingénieur senior
Les ingénieurs expérimentés ne voient pas les doublons comme un simple problème SQL.
Ils pensent en termes de :
- Intégrité des données
- Règles métier
- Risques opérationnels
- Fiabilité système
- Auditabilité
Les doublons sont souvent le symptôme de problèmes plus profonds :
- Contraintes de base de données absentes
- Conditions de concurrence
- Mauvaise gestion des files d’attente
- Transactions faibles
- Synchronisation externe défaillante
Les bons ingénieurs ne se limitent pas à la détection, ils analysent aussi la cause.
Conclusion
La maîtrise de GROUP BY et HAVING dépasse largement la simple syntaxe SQL.
Elle développe une mentalité d’ingénieur backend capable de construire des systèmes fiables et des données de qualité.
Progression recommandée :
- Détection simple des doublons
- Règles multi-colonnes
- Normalisation des timestamps
- Analyse temporelle avancée
- Récupération des lignes complètes
Cette compétence est directement liée aux besoins réels des entreprises modernes.