Localizando linhas duplicadas no SQL Server

Eu tenho um banco de dados de organizações do SQL Server e há muitas linhas duplicadas. Desejo executar uma instrução select para capturar tudo isso e a quantidade de enganos, mas também retornar os IDs associados a cada organização.

Uma declaração como:

SELECT     orgName, COUNT(*) AS dupes  
FROM         organizations  
GROUP BY orgName  
HAVING      (COUNT(*) > 1)

Retornará algo como

orgName        | dupes  
ABC Corp       | 7  
Foo Federation | 5  
Widget Company | 2 

Mas eu também gostaria de pegar os IDs deles. Há alguma maneira de fazer isso? Talvez como um

orgName        | dupeCount | id  
ABC Corp       | 1         | 34  
ABC Corp       | 2         | 5  
...  
Widget Company | 1         | 10  
Widget Company | 2         | 2  

O motivo é que também há uma tabela separada de usuários vinculados a essas organizações, e eu gostaria de unificá-los (portanto, remova os dupes para que os usuários se vinculem à mesma organização em vez de dupe orgs). Mas gostaria de fazer parte manualmente para não estragar nada, mas ainda assim precisaria de uma declaração retornando os IDs de todas as organizações duplas para que eu possa percorrer a lista de usuários.

select o.orgName, oc.dupeCount, o.id
from organizations o
inner join (
    SELECT orgName, COUNT(*) AS dupeCount
    FROM organizations
    GROUP BY orgName
    HAVING COUNT(*) > 1
) oc on o.orgName = oc.orgName

Você pode executar a seguinte consulta e encontrar as duplicatas com max(id)e excluir essas linhas.

SELECT orgName, COUNT(*), Max(ID) AS dupes 
FROM organizations 
GROUP BY orgName 
HAVING (COUNT(*) > 1)

Mas você precisará executar essa consulta algumas vezes.

Você pode fazer assim:

SELECT
    o.id, o.orgName, d.intCount
FROM (
     SELECT orgName, COUNT(*) as intCount
     FROM organizations
     GROUP BY orgName
     HAVING COUNT(*) > 1
) AS d
    INNER JOIN organizations o ON o.orgName = d.orgName

Se você deseja retornar apenas os registros que podem ser excluídos (deixando um de cada), você pode usar:

SELECT
    id, orgName
FROM (
     SELECT 
         orgName, id,
         ROW_NUMBER() OVER (PARTITION BY orgName ORDER BY id) AS intRow
     FROM organizations
) AS d
WHERE intRow != 1

Editar: o SQL Server 2000 não possui a função ROW_NUMBER (). Em vez disso, você pode usar:

SELECT
    o.id, o.orgName, d.intCount
FROM (
     SELECT orgName, COUNT(*) as intCount, MIN(id) AS minId
     FROM organizations
     GROUP BY orgName
     HAVING COUNT(*) > 1
) AS d
    INNER JOIN organizations o ON o.orgName = d.orgName
WHERE d.minId != o.id

A solução marcada como correta não funcionou para mim, mas achei esta resposta que funcionou muito bem: Obtenha uma lista de linhas duplicadas no MySql

SELECT n1.* 
FROM myTable n1
INNER JOIN myTable n2 
ON n2.repeatedCol = n1.repeatedCol
WHERE n1.id <> n2.id

Você pode tentar isso, é melhor para você

 WITH CTE AS
    (
    SELECT *,RN=ROW_NUMBER() OVER (PARTITION BY orgName ORDER BY orgName DESC) FROM organizations 
    )
    select * from CTE where RN>1
    go

Se você deseja excluir duplicatas:

WITH CTE AS(
   SELECT orgName,id,
       RN = ROW_NUMBER()OVER(PARTITION BY orgName ORDER BY Id)
   FROM organizations
)
DELETE FROM CTE WHERE RN > 1

select * from [Employees]

Para encontrar o Registro 1 duplicado) Usando CTE

with mycte
as
(
select Name,EmailId,ROW_NUMBER() over(partition by Name,EmailId order by id) as Duplicate from [Employees]
)
select * from mycte

2) Usando GroupBy

select Name,EmailId,COUNT(name) as Duplicate from  [Employees] group by Name,EmailId 

Select * from (Select orgName,id,
ROW_NUMBER() OVER(Partition By OrgName ORDER by id DESC) Rownum
From organizations )tbl Where Rownum>1

Portanto, os registros com rowum> 1 serão os registros duplicados na sua tabela. Primeiro, agrupe pelos registros e os serialize, dando-lhes os números de série. Portanto, rownum> 1 serão os registros duplicados que podem ser excluídos como tais.

select column_name, count(column_name)
from table_name
group by column_name
having count (column_name) > 1;

Src: https://stackoverflow.com/a/59242/1465252

select a.orgName,b.duplicate, a.id
from organizations a
inner join (
    SELECT orgName, COUNT(*) AS duplicate
    FROM organizations
    GROUP BY orgName
    HAVING COUNT(*) > 1
) b on o.orgName = oc.orgName
group by a.orgName,a.id

select orgname, count(*) as dupes, id 
from organizations
where orgname in (
    select orgname
    from organizations
    group by orgname
    having (count(*) > 1)
)
group by orgname, id

Você tem várias maneiras de selecionar duplicate rows.

para minhas soluções, primeiro considere esta tabela, por exemplo

CREATE TABLE #Employee
(
ID          INT,
FIRST_NAME  NVARCHAR(100),
LAST_NAME   NVARCHAR(300)
)

INSERT INTO #Employee VALUES ( 1, 'Ardalan', 'Shahgholi' );
INSERT INTO #Employee VALUES ( 2, 'name1', 'lname1' );
INSERT INTO #Employee VALUES ( 3, 'name2', 'lname2' );
INSERT INTO #Employee VALUES ( 2, 'name1', 'lname1' );
INSERT INTO #Employee VALUES ( 3, 'name2', 'lname2' );
INSERT INTO #Employee VALUES ( 4, 'name3', 'lname3' );

Primeira solução:

SELECT DISTINCT *
FROM   #Employee;

WITH #DeleteEmployee AS (
                     SELECT ROW_NUMBER()
                            OVER(PARTITION BY ID, First_Name, Last_Name ORDER BY ID) AS
                            RNUM
                     FROM   #Employee
                 )

SELECT *
FROM   #DeleteEmployee
WHERE  RNUM > 1

SELECT DISTINCT *
FROM   #Employee

Solução completa: identitycampo de uso

SELECT DISTINCT *
FROM   #Employee;

ALTER TABLE #Employee ADD UNIQ_ID INT IDENTITY(1, 1)

SELECT *
FROM   #Employee
WHERE  UNIQ_ID < (
    SELECT MAX(UNIQ_ID)
    FROM   #Employee a2
    WHERE  #Employee.ID = a2.ID
           AND #Employee.FIRST_NAME = a2.FIRST_NAME
           AND #Employee.LAST_NAME = a2.LAST_NAME
)

ALTER TABLE #Employee DROP COLUMN UNIQ_ID

SELECT DISTINCT *
FROM   #Employee

e final de toda solução, use este comando

DROP TABLE #Employee

Eu acho que sei o que você precisa, eu precisava misturar as respostas e acho que consegui a solução que ele queria:

select o.id,o.orgName, oc.dupeCount, oc.id,oc.orgName
from organizations o
inner join (
    SELECT MAX(id) as id, orgName, COUNT(*) AS dupeCount
    FROM organizations
    GROUP BY orgName
    HAVING COUNT(*) > 1
) oc on o.orgName = oc.orgName

ter o ID máximo fornecerá o ID do publicador e o do original, que ele solicitou:

id org name , dublicate count (missing out in this case) 
id doublicate org name , doub count (missing out again because does not help in this case)

única coisa triste que você colocá-lo nesta forma

id , name , dubid , name

espero que ainda ajude

Suponha que tenhamos a tabela 'Student' com 2 colunas:

• student_id int

• student_name varchar

  Records:
  +------------+---------------------+
  | student_id | student_name        |
  +------------+---------------------+
  |        101 | usman               |
  |        101 | usman               |
  |        101 | usman               |
  |        102 | usmanyaqoob         |
  |        103 | muhammadusmanyaqoob |
  |        103 | muhammadusmanyaqoob |
  +------------+---------------------+

Agora queremos ver registros duplicados Use esta consulta:

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

Eu tenho uma opção melhor para obter os registros duplicados em uma tabela

SELECT x.studid, y.stdname, y.dupecount
FROM student AS x INNER JOIN
(SELECT a.stdname, COUNT(*) AS dupecount
FROM student AS a INNER JOIN
studmisc AS b ON a.studid = b.studid
WHERE (a.studid LIKE '2018%') AND (b.studstatus = 4)
GROUP BY a.stdname
HAVING (COUNT(*) > 1)) AS y ON x.stdname = y.stdname INNER JOIN
studmisc AS z ON x.studid = z.studid
WHERE (x.studid LIKE '2018%') AND (z.studstatus = 4)
ORDER BY x.stdname

O resultado da consulta acima mostra todos os nomes duplicados com IDs de alunos exclusivos e número de ocorrências duplicadas

Clique aqui para ver o resultado do sql

 /*To get duplicate data in table */

 SELECT COUNT(EmpCode),EmpCode FROM tbl_Employees WHERE Status=1 
  GROUP BY EmpCode HAVING COUNT(EmpCode) > 1

Eu uso dois métodos para encontrar linhas duplicadas. O primeiro método é o mais famoso usando grupo por e tendo. O segundo método está usando CTE - Common Table Expression .

Conforme mencionado pelo @RedFilter, esse caminho também é correto. Muitas vezes acho que o método CTE também é útil para mim.

WITH TempOrg (orgName,RepeatCount)
AS
(
SELECT orgName,ROW_NUMBER() OVER(PARTITION by orgName ORDER BY orgName) 
AS RepeatCount
FROM dbo.organizations
)
select t.*,e.id from organizations   e
inner join TempOrg t on t.orgName= e.orgName
where t.RepeatCount>1

No exemplo acima, coletamos o resultado localizando ocorrência repetida usando ROW_NUMBER e PARTITION BY. Em seguida, aplicamos a cláusula where para selecionar apenas as linhas que estão na contagem de repetição superior a 1. Todo o resultado é coletado na tabela CTE e associado à tabela Organizações.

Fonte: CodoBee

Experimentar

SELECT orgName, id, count(*) as dupes
FROM organizations
GROUP BY orgName, id
HAVING count(*) > 1;