Rechercher des doublons dans MySQL

Je veux extraire des enregistrements en double dans une firebase database MySQL. Cela peut être fait avec:

SELECT address, count(id) as cnt FROM list GROUP BY address HAVING cnt > 1 

Qui aboutit à:

 100 MAIN ST 2 

Je voudrais le tirer pour qu’il affiche chaque ligne qui est un doublon. Quelque chose comme:

 JIM JONES 100 MAIN ST JOHN SMITH 100 MAIN ST 

Des idées sur la façon dont cela peut être fait? J’essaie d’éviter de faire le premier puis de rechercher les doublons avec une seconde requête dans le code.

La clé est de réécrire cette requête afin qu’elle puisse être utilisée en tant que sous-requête.

 SELECT firstname, lastname, list.address FROM list INNER JOIN (SELECT address FROM list GROUP BY address HAVING COUNT(id) > 1) dup ON list.address = dup.address; 
 SELECT date FROM logs group by date having count(*) >= 2 

Pourquoi pas juste INNER REJOIGNEZ-vous la table avec lui-même?

 SELECT a.firstname, a.lastname, a.address FROM list a INNER JOIN list b ON a.address = b.address WHERE a.id <> b.id 

Un DISTINCT est nécessaire si l’adresse peut exister plus de deux fois.

J’ai essayé la meilleure réponse choisie pour cette question, mais cela m’a un peu troublé. J’avais en fait besoin de ça sur un seul champ de ma table. L’exemple suivant de ce lien a très bien fonctionné pour moi:

 SELECT COUNT(*) c,title FROM `data` GROUP BY title HAVING c > 1; 
 select `cityname` from `codcities` group by `cityname` having count(*)>=2 

C’est la requête similaire que vous avez demandée et son fonctionnement à 200% et facile aussi. Prendre plaisir!!!

Trouver des utilisateurs en double par adresse email avec cette requête …

 SELECT users.name, users.uid, users.mail, from_unixtime(created) FROM users INNER JOIN ( SELECT mail FROM users GROUP BY mail HAVING count(mail) > 1 ) dupes ON users.mail = dupes.mail ORDER BY users.mail; 

Nous pouvons trouver que les doublons dépendent de plusieurs champs. Pour ces cas, vous pouvez utiliser le format ci-dessous.

 SELECT COUNT(*), column1, column2 FROM tablename GROUP BY column1, column2 HAVING COUNT(*)>1; 

Une autre solution consisterait à utiliser des alias de table, comme ceci:

 SELECT p1.id, p2.id, p1.address FROM list AS p1, list AS p2 WHERE p1.address = p2.address AND p1.id != p2.id 

Tout ce que vous faites dans ce cas, c’est prendre le tableau de liste d’ origine, en créant deux tables de restitution – p 1 et p 2 – et en effectuant une jointure sur la colonne d’adresse (ligne 3). La 4ème ligne s’assure que le même enregistrement ne s’affiche pas plusieurs fois dans votre ensemble de résultats (“doublons en double”).

Trouver des adresses en double est beaucoup plus complexe qu’il n’y paraît, surtout si vous avez besoin de précision. Une requête MySQL ne suffit pas dans ce cas …

Je travaille chez SmartyStreets , où nous traitons de la validation et de la déduplication et d’autres choses, et j’ai vu beaucoup de problèmes divers avec des problèmes similaires.

Plusieurs services tiers signaleront les doublons dans une liste. Faire cela uniquement avec une sous-requête MySQL ne tiendra pas compte des différences de formats d’adresse et de normes. L’USPS (pour les adresses aux États-Unis) a certaines directives pour rendre ces normes, mais seule une poignée de fournisseurs sont certifiés pour effectuer de telles opérations.

Donc, je vous recommande la meilleure réponse: exporter la table dans un fichier CSV, par exemple, et la soumettre à un processeur de liste capable. LiveAddress, par exemple, le fera automatiquement dans quelques secondes à quelques minutes. Il marquera les lignes dupliquées avec un nouveau champ appelé “Duplicate” et une valeur de Y dans celui-ci.

Cela sélectionnera les doublons dans un passage de table, pas de sous-requêtes.

 SELECT * FROM ( SELECT ao.*, (@r := @r + 1) AS rn FROM ( SELECT @_address := 'N' ) vars, ( SELECT * FROM list a ORDER BY address, id ) ao WHERE CASE WHEN @_address <> address THEN @r := 0 ELSE 0 END IS NOT NULL AND (@_address := address ) IS NOT NULL ) aoo WHERE rn > 1 

Cette requête émule de manière ROW_NUMBER() présent dans Oracle et SQL Server

Voir l’article sur mon blog pour plus de détails:

  • Fonctions analytiques: SUM, AVG, ROW_NUMBER – émulant dans MySQL .

Ne va pas être très efficace, mais ça devrait marcher:

 SELECT * FROM list AS outer WHERE (SELECT COUNT(*) FROM list AS inner WHERE inner.address = outer.address) > 1; 

Cela vous montrera également combien de doublons ont et commandera les résultats sans jointures

 SELECT `Language` , id, COUNT( id ) AS how_many FROM `languages` GROUP BY `Language` HAVING how_many >=2 ORDER BY how_many DESC 

N’est-ce pas plus facile:

 SELECT * FROM tc_tariff_groups GROUP BY group_id HAVING COUNT(group_id) >1 

?

  SELECT firstname, lastname, address FROM list WHERE Address in (SELECT address FROM list GROUP BY address HAVING count(*) > 1) 
 select * from table_name t1 inner join (select distinct  from table_name as temp)t2 where t1.atsortingbute_name = t2.atsortingbute_name 

Pour votre table ce serait quelque chose comme

 select * from list l1 inner join (select distinct address from list as list2)l2 where l1.address=l2.address 

Cette requête vous donnera toutes les entrées d’adresse distinctes dans votre tableau de liste … Je ne sais pas comment cela fonctionnera si vous avez des valeurs de clé primaire pour le nom, etc.

Procédure de suppression des doublons les plus rapides:

 /* create temp table with one primary column id */ INSERT INTO temp(id) SELECT MIN(id) FROM list GROUP BY (isbn) HAVING COUNT(*)>1; DELETE FROM list WHERE id IN (SELECT id FROM temp); DELETE FROM temp; 

Personnellement cette requête a résolu mon problème:

 SELECT `SUB_ID`, COUNT(SRV_KW_ID) as subscriptions FROM `SUB_SUBSCR` group by SUB_ID, SRV_KW_ID HAVING subscriptions > 1; 

Ce que fait ce script affiche tous les ID d’abonné qui existent plus d’une fois dans la table et le nombre de doublons trouvés.

Ce sont les colonnes de la table:

 | SUB_SUBSCR_ID | int(11) | NO | PRI | NULL | auto_increment | | MSI_ALIAS | varchar(64) | YES | UNI | NULL | | | SUB_ID | int(11) | NO | MUL | NULL | | | SRV_KW_ID | int(11) | NO | MUL | NULL | | 

J’espère que ce sera utile pour vous non plus!

 SELECT t.*,(select count(*) from city as tt where tt.name=t.name) as count FROM `city` as t where (select count(*) from city as tt where tt.name=t.name) > 1 order by count desc 

Remplacez la ville par votre table. Remplacez le nom par le nom de votre champ

  SELECT * FROM (SELECT address, COUNT(id) AS cnt FROM list GROUP BY address HAVING ( COUNT(id) > 1 )) 

La réponse de Powerlord est en effet la meilleure et je recommanderais un autre changement: utilisez LIMIT pour vous assurer que db ne sera pas surchargé:

 SELECT firstname, lastname, list.address FROM list INNER JOIN (SELECT address FROM list GROUP BY address HAVING count(id) > 1) dup ON list.address = dup.address LIMIT 10 

C’est une bonne habitude d’utiliser LIMIT s’il n’y a pas WHERE et quand on fait des jointures. Commencez avec une petite valeur, vérifiez le poids de la requête, puis augmentez la limite.

  Find duplicate Records: Suppose we have table : Student student_id int student_name varchar Records: +------------+---------------------+ | student_id | student_name | +------------+---------------------+ | 101 | usman | | 101 | usman | | 101 | usman | | 102 | usmanyaqoob | | 103 | muhammadusmanyaqoob | | 103 | muhammadusmanyaqoob | +------------+---------------------+ Now we want to see duplicate records Use this query: select student_name,student_id ,count(*) c from student group by student_id,student_name having c>1; +--------------------+------------+---+ | student_name | student_id | c | +---------------------+------------+---+ | usman | 101 | 3 | | muhammadusmanyaqoob | 103 | 2 | +---------------------+------------+---+ 

select address from list where address = any (select address from (select address, count(id) cnt from list group by address having cnt > 1 ) as t1) order by address

la sous-requête interne renvoie des lignes avec une adresse en double, alors la sous-requête externe renvoie la colonne d’adresse pour l’adresse avec les doublons. la sous-requête externe doit renvoyer une seule colonne car elle a été utilisée comme opérande pour l’opérateur ‘= any’