Ricerca di valori duplicati in una tabella SQL

È facile trovare duplicati con un campo:

SELECT name, COUNT(email) 
FROM users
GROUP BY email
HAVING COUNT(email) > 1

Quindi se abbiamo un tavolo

ID   NAME   EMAIL
1    John   asd@asd.com
2    Sam    asd@asd.com
3    Tom    asd@asd.com
4    Bob    bob@asd.com
5    Tom    asd@asd.com

Questa query ci darà John, Sam, Tom, Tom perché hanno tutti lo stesso email.

Tuttavia, quello che voglio è ottenere duplicati con lo stesso email e name .

Cioè, voglio ottenere "Tom", "Tom".

Il motivo per cui ho bisogno di questo: ho fatto un errore e ho permesso di inserire duplicati namee emailvalori. Ora ho bisogno di rimuovere / modificare i duplicati, quindi ho bisogno di trovare loro per primi.

SELECT
    name, email, COUNT(*)
FROM
    users
GROUP BY
    name, email
HAVING 
    COUNT(*) > 1

Raggruppa semplicemente su entrambe le colonne.

Nota: lo standard ANSI più vecchio prevede di avere tutte le colonne non aggregate in GROUP BY ma ciò è cambiato con l'idea di "dipendenza funzionale" :

Nella teoria dei database relazionali, una dipendenza funzionale è un vincolo tra due insiemi di attributi in una relazione da un database. In altre parole, la dipendenza funzionale è un vincolo che descrive la relazione tra attributi in una relazione.

Il supporto non è coerente:

• PostgreSQL recente lo supporta .
• SQL Server (come in SQL Server 2017) richiede ancora tutte le colonne non aggregate in GROUP BY.
• MySQL è imprevedibile ed è necessario sql_mode=only_full_group_by:
  • GROUP BY lname ORDER BY che mostra risultati errati ;
  • Qual è la funzione aggregata meno costosa in assenza di ANY () (vedi commenti nella risposta accettata).
• Oracle non è abbastanza mainstream (attenzione: umorismo, non so di Oracle).

prova questo:

declare @YourTable table (id int, name varchar(10), email varchar(50))

INSERT @YourTable VALUES (1,'John','John-email')
INSERT @YourTable VALUES (2,'John','John-email')
INSERT @YourTable VALUES (3,'fred','John-email')
INSERT @YourTable VALUES (4,'fred','fred-email')
INSERT @YourTable VALUES (5,'sam','sam-email')
INSERT @YourTable VALUES (6,'sam','sam-email')

SELECT
    name,email, COUNT(*) AS CountOf
    FROM @YourTable
    GROUP BY name,email
    HAVING COUNT(*)>1

PRODUZIONE:

name       email       CountOf
---------- ----------- -----------
John       John-email  2
sam        sam-email   2

(2 row(s) affected)

se vuoi gli ID dei dups usa questo:

SELECT
    y.id,y.name,y.email
    FROM @YourTable y
        INNER JOIN (SELECT
                        name,email, COUNT(*) AS CountOf
                        FROM @YourTable
                        GROUP BY name,email
                        HAVING COUNT(*)>1
                    ) dt ON y.name=dt.name AND y.email=dt.email

PRODUZIONE:

id          name       email
----------- ---------- ------------
1           John       John-email
2           John       John-email
5           sam        sam-email
6           sam        sam-email

(4 row(s) affected)

per eliminare i duplicati prova:

DELETE d
    FROM @YourTable d
        INNER JOIN (SELECT
                        y.id,y.name,y.email,ROW_NUMBER() OVER(PARTITION BY y.name,y.email ORDER BY y.name,y.email,y.id) AS RowRank
                        FROM @YourTable y
                            INNER JOIN (SELECT
                                            name,email, COUNT(*) AS CountOf
                                            FROM @YourTable
                                            GROUP BY name,email
                                            HAVING COUNT(*)>1
                                        ) dt ON y.name=dt.name AND y.email=dt.email
                   ) dt2 ON d.id=dt2.id
        WHERE dt2.RowRank!=1
SELECT * FROM @YourTable

PRODUZIONE:

id          name       email
----------- ---------- --------------
1           John       John-email
3           fred       John-email
4           fred       fred-email
5           sam        sam-email

(4 row(s) affected)

Prova questo:

SELECT name, email
FROM users
GROUP BY name, email
HAVING ( COUNT(*) > 1 )

Se vuoi eliminare i duplicati, ecco un modo molto più semplice per farlo che dover trovare righe pari / dispari in una tripla sottoselezione:

SELECT id, name, email 
FROM users u, users u2
WHERE u.name = u2.name AND u.email = u2.email AND u.id > u2.id

E quindi per eliminare:

DELETE FROM users
WHERE id IN (
    SELECT id/*, name, email*/
    FROM users u, users u2
    WHERE u.name = u2.name AND u.email = u2.email AND u.id > u2.id
)

Molto più facile da leggere e comprendere IMHO

Nota: l'unico problema è che è necessario eseguire la richiesta fino a quando non vengono eliminate righe, poiché si elimina solo 1 di ogni duplicato ogni volta

Prova quanto segue:

SELECT * FROM
(
    SELECT Id, Name, Age, Comments, Row_Number() OVER(PARTITION BY Name, Age ORDER By Name)
        AS Rank 
        FROM Customers
) AS B WHERE Rank>1

 SELECT name, email 
    FROM users
    WHERE email in
    (SELECT email FROM users
    GROUP BY email 
    HAVING COUNT(*)>1)

Un po 'tardi alla festa, ma ho trovato una soluzione davvero interessante per trovare tutti gli ID duplicati:

SELECT GROUP_CONCAT( id )
FROM users
GROUP BY email
HAVING ( COUNT(email) > 1 )

prova questo codice

WITH CTE AS

( SELECT Id, Name, Age, Comments, RN = ROW_NUMBER()OVER(PARTITION BY Name,Age ORDER BY ccn)
FROM ccnmaster )
select * from CTE 

Questo seleziona / elimina tutti i record duplicati tranne un record da ciascun gruppo di duplicati. Quindi, l'eliminazione lascia tutti i record univoci + un record da ciascun gruppo di duplicati.

Seleziona duplicati:

SELECT *
FROM table
WHERE
    id NOT IN (
        SELECT MIN(id)
        FROM table
        GROUP BY column1, column2
);

Elimina duplicati:

DELETE FROM table
WHERE
    id NOT IN (
        SELECT MIN(id)
        FROM table
        GROUP BY column1, column2
);

Essere consapevoli di grandi quantità di record, può causare problemi di prestazioni.

Nel caso in cui lavori con Oracle, in questo modo sarebbe preferibile:

create table my_users(id number, name varchar2(100), email varchar2(100));

insert into my_users values (1, 'John', 'asd@asd.com');
insert into my_users values (2, 'Sam', 'asd@asd.com');
insert into my_users values (3, 'Tom', 'asd@asd.com');
insert into my_users values (4, 'Bob', 'bob@asd.com');
insert into my_users values (5, 'Tom', 'asd@asd.com');

commit;

select *
  from my_users
 where rowid not in (select min(rowid) from my_users group by name, email);

select name, email
, case 
when ROW_NUMBER () over (partition by name, email order by name) > 1 then 'Yes'
else 'No'
end "duplicated ?"
from users

Se desideri vedere se ci sono righe duplicate nella tua tabella, ho usato di seguito Query:

create table my_table(id int, name varchar(100), email varchar(100));

insert into my_table values (1, 'shekh', 'shekh@rms.com');
insert into my_table values (1, 'shekh', 'shekh@rms.com');
insert into my_table values (2, 'Aman', 'aman@rms.com');
insert into my_table values (3, 'Tom', 'tom@rms.com');
insert into my_table values (4, 'Raj', 'raj@rms.com');


Select COUNT(1) As Total_Rows from my_table 
Select Count(1) As Distinct_Rows from ( Select Distinct * from my_table) abc 

Questa è la cosa facile che mi è venuta in mente. Utilizza un'espressione di tabella comune (CTE) e una finestra di partizione (penso che queste funzionalità siano in SQL 2008 e versioni successive).

Questo esempio trova tutti gli studenti con nome e dob duplicati. I campi che si desidera controllare per la duplicazione vanno nella clausola OVER. È possibile includere qualsiasi altro campo desiderato nella proiezione.

with cte (StudentId, Fname, LName, DOB, RowCnt)
as (
SELECT StudentId, FirstName, LastName, DateOfBirth as DOB, SUM(1) OVER (Partition By FirstName, LastName, DateOfBirth) as RowCnt
FROM tblStudent
)
SELECT * from CTE where RowCnt > 1
ORDER BY DOB, LName

select id,name,COUNT(*) from user group by Id,Name having COUNT(*)>1

Come possiamo contare i valori duplicati ?? o viene ripetuto 2 volte o più di 2. contali, non in gruppo.

semplice come

select COUNT(distinct col_01) from Table_01

Usando CTE possiamo anche trovare un valore duplicato come questo

with MyCTE
as
(
select Name,EmailId,ROW_NUMBER() over(PARTITION BY EmailId order by id) as Duplicate from [Employees]

)
select * from MyCTE where Duplicate>1

 select emp.ename, emp.empno, dept.loc 
          from emp
 inner join dept 
          on dept.deptno=emp.deptno
 inner join
    (select ename, count(*) from
    emp
    group by ename, deptno
    having count(*) > 1)
 t on emp.ename=t.ename order by emp.ename
/

SELECT id, COUNT(id) FROM table1 GROUP BY id HAVING COUNT(id)>1;

Penso che questo funzionerà correttamente per cercare valori ripetuti in una determinata colonna.

SELECT * FROM users u where rowid = (select max(rowid) from users u1 where
u.email=u1.email);

Anche questo dovrebbe funzionare, magari provalo.

  Select * from Users a
            where EXISTS (Select * from Users b 
                where (     a.name = b.name 
                        OR  a.email = b.email)
                     and a.ID != b.id)

Particolarmente buono nel tuo caso Se cerchi duplicati con qualche tipo di prefisso o cambiamenti generali come ad esempio un nuovo dominio nella posta. quindi puoi usare sostituire () in queste colonne

Se si desidera trovare dati duplicati (secondo uno o più criteri) e selezionare le righe effettive.

with MYCTE as (
    SELECT DuplicateKey1
        ,DuplicateKey2 --optional
        ,count(*) X
    FROM MyTable
    group by DuplicateKey1, DuplicateKey2
    having count(*) > 1
) 
SELECT E.*
FROM MyTable E
JOIN MYCTE cte
ON E.DuplicateKey1=cte.DuplicateKey1
    AND E.DuplicateKey2=cte.DuplicateKey2
ORDER BY E.DuplicateKey1, E.DuplicateKey2, CreatedAt

http://developer.azurewebsites.net/2014/09/better-sql-group-by-find-duplicate-data/

SELECT name, email,COUNT(email) 
FROM users 
WHERE email IN (
    SELECT email 
    FROM users 
    GROUP BY email 
    HAVING COUNT(email) > 1)

Per eliminare i record i cui nomi sono duplicati

;WITH CTE AS    
(

    SELECT ROW_NUMBER() OVER (PARTITION BY name ORDER BY name) AS T FROM     @YourTable    
)

DELETE FROM CTE WHERE T > 1

Per controllare da record duplicati in una tabella.

select * from users s 
where rowid < any 
(select rowid from users k where s.name = k.name and s.email = k.email);

o

select * from users s 
where rowid not in 
(select max(rowid) from users k where s.name = k.name and s.email = k.email);

Per eliminare il record duplicato in una tabella.

delete from users s 
where rowid < any 
(select rowid from users k where s.name = k.name and s.email = k.email);

o

delete from users s 
where rowid not in 
(select max(rowid) from users k where s.name = k.name and s.email = k.email);

SELECT column_name,COUNT(*) FROM TABLE_NAME GROUP BY column1, HAVING COUNT(*) > 1;

Possiamo usare avere qui che funzionano su funzioni aggregate come mostrato di seguito

create table #TableB (id_account int, data int, [date] date)
insert into #TableB values (1 ,-50, '10/20/2018'),
(1, 20, '10/09/2018'),
(2 ,-900, '10/01/2018'),
(1 ,20, '09/25/2018'),
(1 ,-100, '08/01/2018')  

SELECT id_account , data, COUNT(*)
FROM #TableB
GROUP BY id_account , data
HAVING COUNT(id_account) > 1

drop table #TableB

Qui come due campi id_account e dati vengono utilizzati con Count (*). Quindi, fornirà tutti i record che hanno più di una volta gli stessi valori in entrambe le colonne.

Per qualche ragione, abbiamo erroneamente mancato di aggiungere eventuali vincoli nella tabella del server SQL e i record sono stati inseriti duplicati in tutte le colonne con l'applicazione front-end. Quindi possiamo utilizzare la query seguente per eliminare la query duplicata dalla tabella.

SELECT DISTINCT * INTO #TemNewTable FROM #OriginalTable
TRUNCATE TABLE #OriginalTable
INSERT INTO #OriginalTable SELECT * FROM #TemNewTable
DROP TABLE #TemNewTable

Qui abbiamo preso tutti i record distinti della tabella originale e cancellato i record della tabella originale. Ancora una volta abbiamo inserito tutti i valori distinti dalla nuova tabella alla tabella originale e quindi eliminato la nuova tabella.

Potresti provare questo

SELECT NAME, EMAIL, COUNT(*)
FROM USERS
GROUP BY 1,2
HAVING COUNT(*) > 1

La cosa più importante qui è avere la funzione più veloce. Anche gli indici dei duplicati dovrebbero essere identificati. L'unione automatica è una buona opzione, ma per avere una funzione più veloce è meglio prima trovare le righe che hanno duplicati e poi unirsi alla tabella originale per trovare l'id delle righe duplicate. Infine ordina per qualsiasi colonna tranne id per avere righe duplicate l'una vicino all'altra.

SELECT u.*
FROM users AS u
JOIN (SELECT username, email
      FROM users
      GROUP BY username, email
      HAVING COUNT(*)>1) AS w
ON u.username=w.username AND u.email=w.email
ORDER BY u.email;

È possibile utilizzare la parola chiave SELECT DISTINCT per eliminare i duplicati. Puoi anche filtrare per nome e ottenere tutti con quel nome su un tavolo.

Il codice esatto differirebbe a seconda che si desideri trovare anche righe duplicate o solo ID diversi con lo stesso indirizzo e-mail e nome. Se id è una chiave primaria o ha un vincolo univoco, questa distinzione non esiste, ma la domanda non la specifica. Nel primo caso puoi usare il codice fornito in molte altre risposte:

SELECT name, email, COUNT(*)
FROM users
GROUP BY name, email
HAVING COUNT(*) > 1

In quest'ultimo caso useresti:

SELECT name, email, COUNT(DISTINCT id)
FROM users
GROUP BY name, email
HAVING COUNT(DISTINCT id) > 1
ORDER BY COUNT(DISTINCT id) DESC