Suchen Sie doppelte Datensätze in MySQL

Ich möchte doppelte Datensätze in einer MySQL-Datenbank abrufen. Dies kann erfolgen mit:

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

Was in ... resultiert:

100 MAIN ST    2

Ich möchte es so ziehen, dass es jede Zeile zeigt, die ein Duplikat ist. Etwas wie:

JIM    JONES    100 MAIN ST
JOHN   SMITH    100 MAIN ST

Irgendwelche Gedanken darüber, wie das gemacht werden kann? Ich versuche zu vermeiden, den ersten zu machen und dann die Duplikate mit einer zweiten Abfrage im Code nachzuschlagen.

Der Schlüssel besteht darin, diese Abfrage neu zu schreiben, damit sie als Unterabfrage verwendet werden kann.

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

Warum nicht einfach INNER mit sich selbst auf den Tisch treten?

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

Ein DISTINCT wird benötigt, wenn die Adresse mehr als zweimal vorhanden sein könnte.

Ich habe versucht, die beste Antwort für diese Frage zu finden, aber es hat mich etwas verwirrt. Ich brauchte das eigentlich nur auf einem einzigen Feld von meinem Tisch. Das folgende Beispiel von diesem Link hat für mich sehr gut funktioniert:

SELECT COUNT(*) c,title FROM `data` GROUP BY title HAVING c > 1;

select `cityname` from `codcities` group by `cityname` having count(*)>=2

Dies ist die ähnliche Abfrage, nach der Sie gefragt haben, und sie funktioniert zu 200% und ist auch einfach. Genießen!!!

Ist das nicht einfacher:

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

?

Finden Sie mit dieser Abfrage doppelte Benutzer anhand der E-Mail-Adresse ...

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;

Wir können feststellen, dass die Duplikate auch von mehr als einem Feld abhängen. In diesen Fällen können Sie das folgende Format verwenden.

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

Das Auffinden doppelter Adressen ist viel komplexer als es scheint, insbesondere wenn Sie Genauigkeit benötigen. Eine MySQL-Abfrage reicht in diesem Fall nicht aus ...

Ich arbeite bei SmartyStreets , wo wir uns mit Validierung und und anderen befassen, und ich habe viele verschiedene Herausforderungen mit ähnlichen Problemen gesehen.

Es gibt mehrere Dienste von Drittanbietern, die Duplikate in einer Liste für Sie markieren. Wenn Sie dies ausschließlich mit einer MySQL-Unterabfrage tun, werden Unterschiede in den Adressformaten und -standards nicht berücksichtigt. Der USPS (für US-Adresse) hat bestimmte Richtlinien, um diesen Standard festzulegen, aber nur eine Handvoll Anbieter sind für die Durchführung solcher Vorgänge zertifiziert.

Daher würde ich empfehlen, dass die beste Antwort für Sie darin besteht, die Tabelle beispielsweise in eine CSV-Datei zu exportieren und an einen fähigen Listenprozessor zu senden. Eines davon ist das SmartyStreets Bulk Address Validation Tool, das es in wenigen Sekunden bis zu einigen Minuten automatisch für Sie erledigt. Doppelte Zeilen werden mit einem neuen Feld namens "Duplizieren" und einem Wert von gekennzeichnet Y.

Eine andere Lösung wäre die Verwendung von Tabellenaliasnamen wie folgt:

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

Alles , was Sie wirklich in diesem Fall tun wird , um die Original - Aufnahme Liste Tabelle, die Schaffung von zwei p retend Tabellen - p 1 und p 2 - aus , dass, und dann eine Verknüpfung auf der Adress - Spalte (Zeile 3) durchgeführt wird . In der 4. Zeile wird sichergestellt, dass derselbe Datensatz in Ihren Ergebnissen nicht mehrmals angezeigt wird ("doppelte Duplikate").

Nicht sehr effizient, aber es sollte funktionieren:

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

Dadurch werden Duplikate in einem Tabellendurchlauf ausgewählt, keine Unterabfragen.

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

Diese Abfrage emuliert aktiv das ROW_NUMBER()Vorhandensein in OracleundSQL Server

Weitere Informationen finden Sie im Artikel in meinem Blog:

• Analysefunktionen: SUM, AVG, ROW_NUMBER - Emulieren inMySQL.

Dies zeigt Ihnen auch, wie viele Duplikate vorhanden sind, und ordnet die Ergebnisse ohne Verknüpfungen

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

 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 <attribute list> from table_name as temp)t2 where t1.attribute_name = t2.attribute_name

Für Ihren Tisch wäre es so etwas wie

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

Diese Abfrage gibt Ihnen alle eindeutigen Adresseinträge in Ihrer Listentabelle ... Ich bin nicht sicher, wie dies funktionieren wird, wenn Sie Primärschlüsselwerte für Name usw. haben.

Schnellstes Verfahren zum Entfernen von Duplikaten:

/* 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;

Persönlich hat diese Abfrage mein Problem gelöst:

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

In diesem Skript werden alle mehr als einmal vorhandenen Abonnenten-IDs in der Tabelle und die Anzahl der gefundenen Duplikate angezeigt.

Dies sind die Tabellenspalten:

| 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    |                |

Hoffe, es wird auch für Sie hilfreich sein!

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

Ersetzen Sie die Stadt durch Ihren Tisch. Ersetzen Sie den Namen durch Ihren Feldnamen

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

    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 |
+---------------------+------------+---+

Um die doppelten Zeilen schnell zu sehen, können Sie eine einzelne einfache Abfrage ausführen

Hier frage ich die Tabelle ab und liste alle doppelten Zeilen mit derselben Benutzer-ID, demselben Marktplatz und derselben SKU auf:

select user_id, market_place,sku, count(id)as totals from sku_analytics group by user_id, market_place,sku having count(id)>1;

Um die doppelte Zeile zu löschen, müssen Sie entscheiden, welche Zeile Sie löschen möchten. ZB die mit niedrigerer ID (normalerweise älter) oder andere Datumsinformationen. In meinem Fall möchte ich nur die niedrigere ID löschen, da die neuere ID die neuesten Informationen enthält.

Überprüfen Sie zunächst, ob die richtigen Datensätze gelöscht werden. Hier wähle ich den Datensatz unter den Duplikaten aus, die gelöscht werden (nach eindeutiger ID).

select a.user_id, a.market_place,a.sku from sku_analytics a inner join sku_analytics b where a.id< b.id and a.user_id= b.user_id and a.market_place= b.market_place and a.sku = b.sku;

Dann führe ich die Löschabfrage aus, um die Dupes zu löschen:

delete a from sku_analytics a inner join sku_analytics b where a.id< b.id and a.user_id= b.user_id and a.market_place= b.market_place and a.sku = b.sku;

Backup, Double Check, Verify, Verify Backup und dann ausführen.

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

Die innere Unterabfrage gibt Zeilen mit doppelter Adresse zurück, während die äußere Unterabfrage die Adressspalte für Adresse mit doppelten Adressen zurückgibt. Die äußere Unterabfrage darf nur eine Spalte zurückgeben, da sie als Operand für den Operator '= any' verwendet wird.

Die Antwort von Powerlord ist in der Tat die beste und ich würde eine weitere Änderung empfehlen: Verwenden Sie LIMIT, um sicherzustellen, dass db nicht überlastet wird:

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

Es ist eine gute Angewohnheit, LIMIT zu verwenden, wenn es kein WO gibt und wenn Verknüpfungen hergestellt werden. Beginnen Sie mit einem kleinen Wert, überprüfen Sie, wie schwer die Abfrage ist, und erhöhen Sie dann das Limit.