Localizando valores duplicados em uma tabela SQL

É fácil encontrar duplicatas com um campo:

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

Então, se tivermos uma mesa

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

Essa consulta nos dará John, Sam, Tom, Tom, porque todos eles têm o mesmo email .

No entanto, o que eu quero é obter duplicatas com o mesmo email e name .

Ou seja, eu quero pegar "Tom", "Tom".

A razão pela qual eu preciso disso: cometi um erro e permiti inserir valores namee duplicados email. Agora eu preciso remover / alterar as duplicatas, então preciso encontrá- las primeiro.

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

Simplesmente agrupe nas duas colunas.

Nota: o padrão ANSI mais antigo é ter todas as colunas não agregadas no GROUP BY, mas isso mudou com a idéia de "dependência funcional" :

Na teoria do banco de dados relacional, uma dependência funcional é uma restrição entre dois conjuntos de atributos em uma relação de um banco de dados. Em outras palavras, dependência funcional é uma restrição que descreve o relacionamento entre atributos em um relacionamento.

O suporte não é consistente:

• O PostgreSQL recente é compatível .
• O SQL Server (como no SQL Server 2017) ainda requer todas as colunas não agregadas no GROUP BY.
• O MySQL é imprevisível e você precisa sql_mode=only_full_group_by:
  • GROUP BY lname ORDER BY mostrando resultados incorretos ;
  • Qual é a função agregada menos dispendiosa na ausência de QUALQUER () (veja os comentários na resposta aceita).
• O Oracle não é suficientemente mainstream (aviso: humor, eu não sei sobre o Oracle).

tente isto:

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

RESULTADO:

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

(2 row(s) affected)

se você quiser os IDs dos dups, use isto:

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

RESULTADO:

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

(4 row(s) affected)

para excluir as duplicatas, tente:

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

RESULTADO:

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

(4 row(s) affected)

Tente o seguinte:

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

Se você deseja excluir as duplicatas, eis uma maneira muito mais simples de fazer isso do que encontrar linhas pares / ímpares em uma sub-seleção tripla:

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 assim, para excluir:

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
)

Muito mais fácil de ler e entender IMHO

Nota: O único problema é que você deve executar a solicitação até que não haja linhas excluídas, pois você exclui apenas 1 de cada duplicado a cada vez

Tente o seguinte:

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)

Um pouco atrasado para a festa, mas achei uma solução muito legal para encontrar todos os IDs duplicados:

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

tente este código

WITH CTE AS

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

Isso seleciona / exclui todos os registros duplicados, exceto um registro de cada grupo de duplicados. Portanto, a exclusão deixa todos os registros exclusivos + um registro de cada grupo de duplicatas.

Selecione duplicatas:

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

Excluir duplicatas:

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

Esteja ciente de quantidades maiores de registros, pois isso pode causar problemas de desempenho.

Caso você trabalhe com a Oracle, é preferível:

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 você deseja ver se há alguma linha duplicada na sua tabela, usei abaixo a Consulta:

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 

Essa é a coisa mais fácil que eu inventei. Ele usa uma expressão de tabela comum (CTE) e uma janela de partição (acho que esses recursos estão no SQL 2008 e posterior).

Este exemplo localiza todos os alunos com nome e data duplicados. Os campos que você deseja verificar a duplicação estão na cláusula OVER. Você pode incluir outros campos que desejar na projeção.

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

Como podemos contar os valores duplicados ?? ou é repetido 2 vezes ou mais que 2. apenas conte-os, não em grupo.

tão simples quanto

select COUNT(distinct col_01) from Table_01

Usando CTE também podemos encontrar valores duplicados como este

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;

Eu acho que isso funcionará corretamente para pesquisar valores repetidos em uma coluna específica.

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

Isso também deve funcionar, talvez tente.

  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)

Especialmente bom no seu caso Se você procurar duplicatas que tenham algum tipo de prefixo ou alteração geral, como, por exemplo, um novo domínio no correio. então você pode usar replace () nessas colunas

Se você deseja encontrar dados duplicados (por um ou vários critérios) e selecione as linhas reais.

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)

Para excluir registros cujos nomes são duplicados

;WITH CTE AS    
(

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

DELETE FROM CTE WHERE T > 1

Para verificar do registro duplicado em uma tabela.

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

ou

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

Para excluir o registro duplicado em uma tabela.

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

ou

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;

Podemos usar aqui que trabalham em funções agregadas, como mostrado abaixo

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

Aqui, como dois campos, id_account e dados são usados ​​com Count (*). Portanto, ele fornecerá todos os registros com mais de uma vez os mesmos valores nas duas colunas.

Por alguma razão, erroneamente, tínhamos perdido a adição de restrições na tabela do servidor SQL e os registros foram inseridos duplicados em todas as colunas com o aplicativo front-end. Em seguida, podemos usar a consulta abaixo para excluir a consulta duplicada da tabela.

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

Aqui, pegamos todos os registros distintos da tabela original e excluímos os registros da tabela original. Novamente, inserimos todos os valores distintos da nova tabela na tabela original e excluímos a nova tabela.

Você pode tentar isso

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

A coisa mais importante aqui é ter a função mais rápida. Também índices de duplicatas devem ser identificados. A junção automática é uma boa opção, mas para ter uma função mais rápida, é melhor encontrar primeiro as linhas que têm duplicatas e depois juntar-se à tabela original para encontrar a identificação das linhas duplicadas. Finalmente, encomende por qualquer coluna, exceto a id, para ter linhas duplicadas próximas uma da outra.

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;

Você pode usar a palavra-chave SELECT DISTINCT para se livrar das duplicatas. Você também pode filtrar por nome e colocar todos com esse nome em uma tabela.

O código exato pode variar dependendo se você deseja encontrar linhas duplicadas ou apenas IDs diferentes com o mesmo email e nome. Se id for uma chave primária ou tiver uma restrição exclusiva, essa distinção não existe, mas a pergunta não especifica isso. No primeiro caso, você pode usar o código fornecido em várias outras respostas:

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

No último caso, você usaria:

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