Znajdź duplikaty rekordów w MySQL

SELECT date FROM logs group by date having count(*) >= 2

Dlaczego po prostu nie połączyć tabeli z samym sobą?

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

DISTINCT jest potrzebny, jeśli adres może istnieć więcej niż dwa razy.

Próbowałem najlepszej odpowiedzi wybranej na to pytanie, ale trochę mnie to zdezorientowało. Potrzebowałem tego tylko na jednym polu z mojego stołu. Poniższy przykład z TEN link zadziałał dla mnie bardzo dobrze:

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

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

To jest podobne Zapytanie, o które prosiłeś, a jego 200% działa i jest łatwe. Smacznego!!!

Czy to nie jest łatwiejsze:

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

?

Znajdź zduplikowanych użytkowników przez adres e-mail z tym zapytaniem...

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;

Możemy znaleźć duplikaty również na więcej niż jednym polu.W takich przypadkach możesz użyć poniższego formatu.

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

Innym rozwiązaniem byłoby użycie aliasów tabel, w ten sposób:

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

Wszystko, co naprawdę robisz w tym przypadku, to pobranie oryginalnejlisty tabeli, utworzenie dwóchp retend tabel -- p1 oraz p2 -- z tego, a następnie wykonanie join w kolumnie adresu(linia 3). 4. linia zapewnia, że ten sam rekord nie pojawia się wiele razy w zestawie wyników ("duplicate duplicates").

Znajdowanie duplikatów adresów jest znacznie bardziej skomplikowane, niż się wydaje, zwłaszcza jeśli wymaga się dokładności. Zapytanie MySQL nie wystarczy w tym przypadku...

Pracuję w SmartyStreets , gdzie zajmujemy się walidacją, duplikacją i innymi rzeczami, i widziałem wiele różnych wyzwań z podobnymi problemami.

Istnieje kilka usług stron trzecich, które oznaczą duplikaty na liście dla Ciebie. Robienie tego wyłącznie z subquery MySQL nie będzie rozliczać różnice w formatach adresów i standardach. USPS (dla adresu USA) ma pewne wytyczne, aby wprowadzić te standardy, ale tylko garstka dostawców jest certyfikowana do wykonywania takich operacji.

Zalecałbym więc, aby najlepszą odpowiedzią było wyeksportowanie tabeli do pliku CSV i przesłanie jej do zdolnego procesora list. Jednym z nich jest LiveAddress , który automatycznie zrobi to za Ciebie w ciągu kilku sekund do kilku minut. Będzie oznaczał zduplikowane wiersze nowym pole o nazwie "Duplicate" i w nim wartość Y.

Nie będzie zbyt wydajny, ale powinien działać:

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

Spowoduje wybranie duplikatów w jednym przejściu tabeli, bez zapytań podrzędnych.

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

To zapytanie emuluje ROW_NUMBER() obecne w Oracle i SQL Server

Zobacz artykuł na moim blogu po szczegóły:

• funkcje analityczne: SUM, AVG, ROW_NUMBER - emulacja w MySQL.

To również pokaże Ci, ile duplikatów ma i uporządkuje wyniki bez łączenia

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

Dla Twojego stołu byłoby to coś w stylu

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

To zapytanie wyświetli wszystkie odrębne wpisy adresowe w tabeli listy... Nie jestem pewien, jak to będzie działać, jeśli masz jakieś podstawowe wartości klucza dla name, itp..

Najszybsza procedura usuwania duplikatów:

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

Osobiście to zapytanie rozwiązało mój problem:

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

Skrypt pokazuje wszystkie identyfikatory Abonenta, które istnieją więcej niż jeden raz w tabeli oraz liczbę znalezionych duplikatów.

Oto kolumny tabeli:

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

Nadzieję, że będzie to pomocne dla ciebie albo!

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

Zastąp Miasto swoją tabelą. Zastąp nazwę nazwą pola

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

Aby szybko zobaczyć zduplikowane wiersze, możesz uruchomić jedno proste zapytanie

Tutaj sprawdzam tabelę i wypisuję wszystkie zduplikowane wiersze z tym samym user_id, market_place i sku:

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

Aby usunąć zduplikowany wiersz, musisz zdecydować, który wiersz chcesz usunąć. Np. ten z niższym id (Zwykle starszy) lub może jakieś inne informacje o dacie. W moim przypadku chcę tylko usunąć niższy identyfikator, ponieważ nowszy IDENTYFIKATOR to najnowsze informacje.

Najpierw sprawdź, czy prawo zapisy zostaną usunięte. Tutaj wybieram rekord wśród duplikatów, który zostanie usunięty (przez unikalny identyfikator).

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;

Następnie uruchamiam zapytanie delete, aby usunąć dupki:

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 then execute.

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

Wewnętrzne zapytanie podrzędne zwraca wiersze o zduplikowanym adresie, a następnie zewnętrzne zapytanie podrzędne zwraca kolumnę address dla adresu z duplikatami. zewnętrzne zapytanie podrzędne musi zwracać tylko jedną kolumnę, ponieważ używane jest jako operand dla operatora "= any "

Odpowiedź Powerlord jest rzeczywiście najlepsza i polecam jeszcze jedną zmianę: użyj LIMIT, aby upewnić się, że db nie zostanie przeciążony:

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

Dobrym nawykiem jest używanie LIMIT, jeśli nie ma miejsca i podczas wykonywania połączeń. Zacznij od małej wartości, sprawdź, jak ciężkie jest zapytanie, a następnie zwiększ limit.