MySQL supprimer des enregistrements en double, mais gardez dernière

J'ai uniques id et email champs. Les courriers électroniques sont dupliqués. Je veux seulement garder une adresse e-Mail de toutes les doublons mais avec la dernière id (le dernier enregistrement inséré).

Comment puis-je y parvenir?

Avez-vous essayé de faire une recherche? possible en double how-do-i-delete-duplicate-rows-and-keep-the-first-row
pourquoi ne pas simplement éviter les doublons d'être insérées dans la table? faire des e-mail d'un index unique
copain je suis comme 20 threads encore ouvert, mais n'étant pas une base de données pro, tous ceux qui ont certaines conditions qui en font la requête assez difficile à comprendre, donc j'ai fait un nouveau thread avec beaucoup d'excuses @tofutim: Tim, nous avons obtenu ces données à partir d'un tiers afin de cant choisir bien. Donc nettoyage jusqu'à maintenant. 🙂
s'il vous plaît ne pas commencer ou se terminer vos messages avec des excuses, il n'est pas ajouter quoi que ce soit de valeur à la question et souvent il n'y a pas d'excuses nécessaire. Juste obtenir directement au point 🙂 peut-être utiliser un commentaire à la place si vous en ressentez le besoin.

InformationsquelleAutor Khuram | 2011-05-24

duplicates mysql

76

Imaginez votre table test contient les données suivantes:
```
  select id, email
    from test;

ID                     EMAIL                
---------------------- -------------------- 
1                      aaa                  
2                      bbb                  
3                      ccc                  
4                      bbb                  
5                      ddd                  
6                      eee                  
7                      aaa                  
8                      aaa                  
9                      eee 
```
Donc, nous avons besoin de trouver tous répété e-mails et de les supprimer tous d'entre eux, mais le dernier id.

Dans ce cas, aaa, bbb et eee sont répétées, afin que nous voulons supprimer les Id 1, 7, 2 et 6.

Pour ce faire, nous avons d'abord besoin de trouver tous les e-mails répétés:
```
      select email 
        from test
       group by email
      having count(*) > 1;

EMAIL                
-------------------- 
aaa                  
bbb                  
eee  
```
Puis, à partir de ces données, nous avons besoin de trouver la dernière id pour chacun de ces e-mails répétés:
```
  select max(id) as lastId, email
    from test
   where email in (
              select email 
                from test
               group by email
              having count(*) > 1
       )
   group by email;

LASTID                 EMAIL                
---------------------- -------------------- 
8                      aaa                  
4                      bbb                  
9                      eee                                 
```
Enfin, nous pouvons maintenant supprimer tous ces e-mails avec un Id plus petit que LASTID. Donc la solution est:
```
delete test
  from test
 inner join (
  select max(id) as lastId, email
    from test
   where email in (
              select email 
                from test
               group by email
              having count(*) > 1
       )
   group by email
) duplic on duplic.email = test.email
 where test.id < duplic.lastId;
```
Je n'ai pas de mySql installé sur cette machine, mais devrait fonctionner

Mise à jour

Ci-dessus supprimer fonctionne, mais j'ai trouvé un plus version optimisée:
```
 delete test
   from test
  inner join (
     select max(id) as lastId, email
       from test
      group by email
     having count(*) > 1) duplic on duplic.email = test.email
  where test.id < duplic.lastId;
```
Vous pouvez voir qu'il supprime la plus ancienne des doublons, c'est à dire 1, 7, 2, 6:
```
select * from test;
+----+-------+
| id | email |
+----+-------+
|  3 | ccc   |
|  4 | bbb   |
|  5 | ddd   |
|  8 | aaa   |
|  9 | eee   |
+----+-------+
```
Une autre version, c'est la suppression de la provived par René Limon
```
delete from test
 where id not in (
    select max(id)
      from test
     group by email)
```
- +1 pour la patience. 🙂
- Salut José, c'est très éduquer. Je vous remercie. Toutefois, MySQL a jeté une erreur. Il a une certaine erreur de syntaxe près de inner join (2ème ligne). Ne pas faire beaucoup de lumière sur l'erreur, même si.
- +1 moi aussi, même si la mine ne compte pas autant.
- maintenez pendant quelques heures, jusqu'à que je rentre à la maison et vérifier que sur ma machine
- Je ne peux pas encore le tester, mais en attendant j'ai mis à jour la dernière instruction delete. Essayez de nouveau s'il vous plaît
- Cette nouvelle requête est en cours de traitement. Je suis comme 6,00,000 dossiers alors il serait peut exécuter jusqu'à ce que vous arrivez à la maison. Je vous tiendrai au courant. Des acclamations.
- Voir mon jour, il doit courir plus vite
- Votre optimisé requête est exactement ce que je cherchais, sinon il est incroyablement lent, mais, je ne sais pas si il y a toutes les possibilités d'amélioration.
- Très probablement, vous devez créer des index sur les colonnes qui correspondent aux id et email colonnes. Si vous avez déjà ces index créé, assurez-vous que les statistiques sont mises à jour en exécutant ANALYZE TABLE. Vous pouvez exécuter une EXPLAIN SELECT pour inspecter ce qui ne va pas, voir dev.mysql.com/doc/refman/5.0/en/using-explain.html
- Merci pour le commentaire, j'ai déjà l'index mis à jour. Expliquer montre l'utilisation de Using filesort et Using temporary qui provoque un retard. Je sais que la table temporaire est utilisé pour stocker le résultat de la sous-requête et filesort est utilisé par le groupe par. bah..
- Merci, fonctionne brillant
- Cela devrait fonctionner pour un 'Select' instruction aussi, correct?
- Oui, c'est correct. Vous pouvez remplacer le delete test par select * pour avoir un aperçu de ce qui va être supprimé.
- Pourrait être: DELETE FROM test WHERE id NOT IN (SELECT MAX(id) FROM test GROUP BY email)
- C'est tout à fait correcte.
- Je reçois le message d'erreur Table 'test' is specified twice, both as a target for 'DELETE' and as a separate source for data
- Essayez d'utiliser une sous-requête imbriquée pour que mySql se matérialise et n'utilise plus le "même table",par exemple, l'utilisation delete from test where id not in ( SELECT * FROM (select max(id) from test group by email) AS S) (j'ai ajouté les majuscules partie)
- Je veux la même solution, mais ma table n'a pas primaire (id) toute suggestion serait apprécier Merci 🙂
- Korat Il n'est pas littéralement besoin d'être un Id de colonne. Vous avez besoin de remplacer les pièces d'identité quel que soit votre clé primaire, qui peut être une colonne ou un ensemble de colonnes d'identifier de manière univoque une seule ligne.
InformationsquelleAutor Jose Rui Santos

Manière correcte est

DELETE FROM `tablename` 
  WHERE id NOT IN (
    SELECT * FROM (
      SELECT MAX(id) FROM tablename 
        GROUP BY name
    ) 
  )

Ce un a bien fonctionné pour moi, merci @Gaurav!
Quel est le but du caractère x?
merci pour la correction.

InformationsquelleAutor Gaurav Kandpal

4

Essayer cette méthode
```
DELETE t1 FROM test t1, test t2 
WHERE t1.id > t2.id AND t1.email = t2.email
```
- Créer un tableau avec 2 colonnes : id (qui est la clé primaire et les courriels qui contiennent des doublons), puis exécutez cette requête, vous l'obtiendrez. C'est l'auto joindre à partir de la même table, qui est de supprimer les enregistrements en double en gardant une copie
InformationsquelleAutor Pulkit Malhotra

Je dois dire que la version optimisée est un doux, élégant morceau de code, et il fonctionne comme un charme, même lorsque la comparaison est effectuée sur une colonne DATETIME. C'est ce que j'ai utilisé dans mon script, où j'étais à la recherche de la dernière date de fin du contrat pour chaque Employé:

DELETE CurrentContractData
  FROM CurrentContractData
  INNER JOIN (
    SELECT
      EmployeeID,
      PeriodofPerformanceStartDate,
      max(PeriodofPerformanceEndDate) as lastDate,
      ContractID
    FROM CurrentContractData
    GROUP BY EmployeeID
    HAVING COUNT(*) > 1) Duplicate on Duplicate.EmployeeID = CurrentContractData.EmployeeID
    WHERE CurrentContractData.PeriodofPerformanceEndDate < Duplicate.lastDate;

Merci beaucoup!

InformationsquelleAutor Michael Sheaver

Vous devez vous connecter pour publier un commentaire.

Mise à jour