Como posso remover linhas duplicadas?

Qual é a melhor maneira de remover linhas duplicadas de uma SQL Servertabela bastante grande (ou seja, mais de 300.000 linhas)?

As linhas, é claro, não serão duplicatas perfeitas devido à existência do RowIDcampo de identidade.

Minha mesa

RowID int not null identity(1,1) primary key,
Col1 varchar(20) not null,
Col2 varchar(2048) not null,
Col3 tinyint not null

Assumindo que não há nulos, GROUP BYas colunas exclusivas e SELECTo MIN (or MAX)RowId são a linha a ser mantida. Em seguida, exclua tudo o que não tinha um ID de linha:

DELETE FROM MyTable
LEFT OUTER JOIN (
   SELECT MIN(RowId) as RowId, Col1, Col2, Col3 
   FROM MyTable 
   GROUP BY Col1, Col2, Col3
) as KeepRows ON
   MyTable.RowId = KeepRows.RowId
WHERE
   KeepRows.RowId IS NULL

Caso você tenha um GUID em vez de um número inteiro, poderá substituir

MIN(RowId)

com

CONVERT(uniqueidentifier, MIN(CONVERT(char(36), MyGuidColumn)))

Outra maneira possível de fazer isso é

; 

--Ensure that any immediately preceding statement is terminated with a semicolon above
WITH cte
     AS (SELECT ROW_NUMBER() OVER (PARTITION BY Col1, Col2, Col3 
                                       ORDER BY ( SELECT 0)) RN
         FROM   #MyTable)
DELETE FROM cte
WHERE  RN > 1;

Estou usando ORDER BY (SELECT 0)acima, pois é arbitrário qual linha preservar em caso de empate.

Para preservar o mais recente RowID, por exemplo, você pode usarORDER BY RowID DESC

Planos de Execução

O plano de execução para isso geralmente é mais simples e mais eficiente do que o da resposta aceita, pois não requer a auto-junção.

Nem sempre é esse o caso. Um local em que a GROUP BYsolução pode ser preferida são as situações em que um agregado de hash seria escolhido em preferência a um agregado de fluxo.

A ROW_NUMBERsolução sempre dará praticamente o mesmo plano, enquanto a GROUP BYestratégia é mais flexível.

Fatores que podem favorecer a abordagem agregada de hash seriam

• Nenhum índice útil nas colunas de particionamento
• relativamente poucos grupos com relativamente mais duplicatas em cada grupo

Nas versões extremas desse segundo caso (se houver muito poucos grupos com muitas duplicatas em cada um), também seria possível inserir simplesmente as linhas para manter em uma nova tabela e, em seguida, inserir TRUNCATEo original e copiá-las para minimizar o registro em comparação com a exclusão de um proporção muito alta das linhas.

Há um bom artigo sobre como remover duplicatas no site de suporte da Microsoft. É bastante conservador - eles fazem tudo em etapas separadas - mas devem funcionar bem em grandes mesas.

Eu usei auto-junções para fazer isso no passado, embora provavelmente possa ser usado com uma cláusula HAVING:

DELETE dupes
FROM MyTable dupes, MyTable fullTable
WHERE dupes.dupField = fullTable.dupField 
AND dupes.secondDupField = fullTable.secondDupField 
AND dupes.uniqueField > fullTable.uniqueField

A consulta a seguir é útil para excluir linhas duplicadas. A tabela neste exemplo tem IDcomo coluna de identidade e as colunas com dados duplicados são Column1, Column2e Column3.

DELETE FROM TableName
WHERE  ID NOT IN (SELECT MAX(ID)
                  FROM   TableName
                  GROUP  BY Column1,
                            Column2,
                            Column3
                  /*Even if ID is not null-able SQL Server treats MAX(ID) as potentially
                    nullable. Because of semantics of NOT IN (NULL) including the clause
                    below can simplify the plan*/
                  HAVING MAX(ID) IS NOT NULL) 

A seguir mostra de script uso GROUP BY, HAVING, ORDER BYem uma consulta, e retorna os resultados com coluna duplicado e sua contagem.

SELECT YourColumnName,
       COUNT(*) TotalCount
FROM   YourTableName
GROUP  BY YourColumnName
HAVING COUNT(*) > 1
ORDER  BY COUNT(*) DESC 

delete t1
from table t1, table t2
where t1.columnA = t2.columnA
and t1.rowid>t2.rowid

Postgres:

delete
from table t1
using table t2
where t1.columnA = t2.columnA
and t1.rowid > t2.rowid

DELETE LU 
FROM   (SELECT *, 
               Row_number() 
                 OVER ( 
                   partition BY col1, col1, col3 
                   ORDER BY rowid DESC) [Row] 
        FROM   mytable) LU 
WHERE  [row] > 1 

Isso excluirá linhas duplicadas, exceto a primeira linha

DELETE
FROM
    Mytable
WHERE
    RowID NOT IN (
        SELECT
            MIN(RowID)
        FROM
            Mytable
        GROUP BY
            Col1,
            Col2,
            Col3
    )

Consulte ( http://www.codeproject.com/Articles/157977/Remove-Duplicate-Rows-from-a-Table-in-SQL-Server )

Eu preferiria o CTE para excluir linhas duplicadas da tabela do servidor sql

é altamente recomendável seguir este artigo :: http://codaffection.com/sql-server-article/delete-duplicate-rows-in-sql-server/

mantendo original

WITH CTE AS
(
SELECT *,ROW_NUMBER() OVER (PARTITION BY col1,col2,col3 ORDER BY col1,col2,col3) AS RN
FROM MyTable
)

DELETE FROM CTE WHERE RN<>1

sem manter o original

WITH CTE AS
(SELECT *,R=RANK() OVER (ORDER BY col1,col2,col3)
FROM MyTable)
 
DELETE CTE
WHERE R IN (SELECT R FROM CTE GROUP BY R HAVING COUNT(*)>1)

Para buscar linhas duplicadas:

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

Para excluir as linhas duplicadas:

DELETE users 
WHERE rowid NOT IN 
(SELECT MIN(rowid)
FROM users
GROUP BY name, email);      

Rápido e Sujo para excluir linhas duplicadas exatas (para tabelas pequenas):

select  distinct * into t2 from t1;
delete from t1;
insert into t1 select *  from t2;
drop table t2;

Prefiro a subconsulta \ tendo a solução count (*)> 1 à junção interna porque achei mais fácil ler e foi muito fácil transformar uma instrução SELECT para verificar o que seria excluído antes da execução.

--DELETE FROM table1 
--WHERE id IN ( 
     SELECT MIN(id) FROM table1 
     GROUP BY col1, col2, col3 
     -- could add a WHERE clause here to further filter
     HAVING count(*) > 1
--)

SELECT  DISTINCT *
      INTO tempdb.dbo.tmpTable
FROM myTable

TRUNCATE TABLE myTable
INSERT INTO myTable SELECT * FROM tempdb.dbo.tmpTable
DROP TABLE tempdb.dbo.tmpTable

Eu pensei em compartilhar minha solução, pois ela funciona em circunstâncias especiais. No meu caso, a tabela com valores duplicados não tinha uma chave estrangeira (porque os valores foram duplicados de outro banco de dados).

begin transaction
-- create temp table with identical structure as source table
Select * Into #temp From tableName Where 1 = 2

-- insert distinct values into temp
insert into #temp 
select distinct * 
from  tableName

-- delete from source
delete from tableName 

-- insert into source from temp
insert into tableName 
select * 
from #temp

rollback transaction
-- if this works, change rollback to commit and execute again to keep you changes!!

PS: ao trabalhar em coisas como essa, eu sempre uso uma transação, isso não apenas garante que tudo seja executado como um todo, mas também me permite testar sem arriscar nada. Mas é claro que você deve fazer um backup de qualquer maneira apenas para ter certeza ...

Esta consulta mostrou um desempenho muito bom para mim:

DELETE tbl
FROM
    MyTable tbl
WHERE
    EXISTS (
        SELECT
            *
        FROM
            MyTable tbl2
        WHERE
            tbl2.SameValue = tbl.SameValue
        AND tbl.IdUniqueValue < tbl2.IdUniqueValue
    )

excluiu 1 milhão de linhas em pouco mais de 30 segundos de uma tabela de 2 milhões (50% de duplicatas)

Usando CTE. A idéia é ingressar em uma ou mais colunas que formam um registro duplicado e remover o que você quiser:

;with cte as (
    select 
        min(PrimaryKey) as PrimaryKey
        UniqueColumn1,
        UniqueColumn2
    from dbo.DuplicatesTable 
    group by
        UniqueColumn1, UniqueColumn1
    having count(*) > 1
)
delete d
from dbo.DuplicatesTable d 
inner join cte on 
    d.PrimaryKey > cte.PrimaryKey and
    d.UniqueColumn1 = cte.UniqueColumn1 and 
    d.UniqueColumn2 = cte.UniqueColumn2;

Ainda outra solução fácil pode ser encontrada no link colado aqui . Este é fácil de entender e parece ser eficaz para a maioria dos problemas semelhantes. É para o SQL Server, mas o conceito usado é mais do que aceitável.

Aqui estão as partes relevantes da página vinculada:

Considere estes dados:

EMPLOYEE_ID ATTENDANCE_DATE
A001    2011-01-01
A001    2011-01-01
A002    2011-01-01
A002    2011-01-01
A002    2011-01-01
A003    2011-01-01

Então, como podemos excluir esses dados duplicados?

Primeiro, insira uma coluna de identidade nessa tabela usando o seguinte código:

ALTER TABLE dbo.ATTENDANCE ADD AUTOID INT IDENTITY(1,1)  

Use o seguinte código para resolvê-lo:

DELETE FROM dbo.ATTENDANCE WHERE AUTOID NOT IN (SELECT MIN(AUTOID) _
    FROM dbo.ATTENDANCE GROUP BY EMPLOYEE_ID,ATTENDANCE_DATE) 

Aqui está outro bom artigo sobre como remover duplicatas .

Ele discute por que é difícil: "O SQL é baseado em álgebra relacional e duplicatas não podem ocorrer na álgebra relacional, porque duplicatas não são permitidas em um conjunto " .

A solução da tabela temporária e dois exemplos de mysql.

No futuro, você evitará isso no nível do banco de dados ou da perspectiva do aplicativo. Eu sugeriria o nível do banco de dados porque seu banco de dados deve ser responsável por manter a integridade referencial; os desenvolvedores apenas causarão problemas;)

Ah com certeza. Use uma tabela temporária. Se você deseja uma declaração única e de baixo desempenho que "funcione", você pode:

DELETE FROM MyTable WHERE NOT RowID IN
    (SELECT 
        (SELECT TOP 1 RowID FROM MyTable mt2 
        WHERE mt2.Col1 = mt.Col1 
        AND mt2.Col2 = mt.Col2 
        AND mt2.Col3 = mt.Col3) 
    FROM MyTable mt)

Basicamente, para cada linha da tabela, a sub-seleção localiza o RowID superior de todas as linhas exatamente iguais à linha em consideração. Então você acaba com uma lista de RowIDs que representam as linhas não duplicadas "originais".

Eu tinha uma tabela em que precisava preservar linhas não duplicadas. Não tenho certeza da velocidade ou eficiência.

DELETE FROM myTable WHERE RowID IN (
  SELECT MIN(RowID) AS IDNo FROM myTable
  GROUP BY Col1, Col2, Col3
  HAVING COUNT(*) = 2 )

Usa isto

WITH tblTemp as
(
SELECT ROW_NUMBER() Over(PARTITION BY Name,Department ORDER BY Name)
   As RowNumber,* FROM <table_name>
)
DELETE FROM tblTemp where RowNumber >1

A outra maneira é criar uma nova tabela com os mesmos campos e com índice exclusivo . Em seguida, mova todos os dados da tabela antiga para a nova tabela . Automaticamente, o SQL SERVER ignora (há também uma opção sobre o que fazer se houver um valor duplicado: ignorar, interromper ou sth) valores duplicados. Portanto, temos a mesma tabela sem linhas duplicadas. Se você não deseja um Índice Único, após a transferência dos dados, você pode soltá-lo .

Especialmente para tabelas maiores, você pode usar o DTS (pacote SSIS para importar / exportar dados) para transferir todos os dados rapidamente para sua nova tabela indexada exclusivamente. Para 7 milhões de linhas, leva apenas alguns minutos.

Usando a consulta abaixo, podemos excluir registros duplicados com base na coluna única ou na coluna múltipla. a consulta abaixo é excluída com base em duas colunas. o nome da tabela é: testinge os nomes das colunasempno,empname

DELETE FROM testing WHERE empno not IN (SELECT empno FROM (SELECT empno, ROW_NUMBER() OVER (PARTITION BY empno ORDER BY empno) 
AS [ItemNumber] FROM testing) a WHERE ItemNumber > 1)
or empname not in
(select empname from (select empname,row_number() over(PARTITION BY empno ORDER BY empno) 
AS [ItemNumber] FROM testing) a WHERE ItemNumber > 1)

1. Criar nova tabela em branco com a mesma estrutura

2. Executar consulta como esta

   INSERT INTO tc_category1
   SELECT *
   FROM tc_category
   GROUP BY category_id, application_id
   HAVING count(*) > 1

3. Em seguida, execute esta consulta

   INSERT INTO tc_category1
   SELECT *
   FROM tc_category
   GROUP BY category_id, application_id
   HAVING count(*) = 1

Esta é a maneira mais fácil de excluir registros duplicados

 DELETE FROM tblemp WHERE id IN 
 (
  SELECT MIN(id) FROM tblemp
   GROUP BY  title HAVING COUNT(id)>1
 )

http://askme.indianyouth.info/details/how-to-dumplicate-record-from-table-in-using-sql-105

Eu mencionaria essa abordagem da melhor maneira possível e funciona em todos os servidores SQL: Muitas vezes, há apenas uma - duas duplicatas, e os IDs e a contagem de duplicatas são conhecidos. Nesse caso:

SET ROWCOUNT 1 -- or set to number of rows to be deleted
delete from myTable where RowId = DuplicatedID
SET ROWCOUNT 0

Do nível do aplicativo (infelizmente). Concordo que a maneira correta de impedir a duplicação é no nível do banco de dados através do uso de um índice exclusivo, mas no SQL Server 2005, um índice tem permissão para ter apenas 900 bytes, e meu campo varchar (2048) deixa isso de lado.

Não sei como seria o desempenho, mas acho que você poderia escrever um gatilho para impor isso, mesmo que não pudesse fazê-lo diretamente com um índice. Algo como:

-- given a table stories(story_id int not null primary key, story varchar(max) not null)
CREATE TRIGGER prevent_plagiarism 
ON stories 
after INSERT, UPDATE 
AS 
    DECLARE @cnt AS INT 

    SELECT @cnt = Count(*) 
    FROM   stories 
           INNER JOIN inserted 
                   ON ( stories.story = inserted.story 
                        AND stories.story_id != inserted.story_id ) 

    IF @cnt > 0 
      BEGIN 
          RAISERROR('plagiarism detected',16,1) 

          ROLLBACK TRANSACTION 
      END 

Além disso, varchar (2048) me parece suspeito (algumas coisas na vida são 2048 bytes, mas é bastante incomum); realmente não deveria ser varchar (max)?

Outra maneira de fazer isso: -

DELETE A
FROM   TABLE A,
       TABLE B
WHERE  A.COL1 = B.COL1
       AND A.COL2 = B.COL2
       AND A.UNIQUEFIELD > B.UNIQUEFIELD 

DELETE
FROM
    table_name T1
WHERE
    rowid > (
        SELECT
            min(rowid)
        FROM
            table_name T2
        WHERE
            T1.column_name = T2.column_name
    );

CREATE TABLE car(Id int identity(1,1), PersonId int, CarId int)

INSERT INTO car(PersonId,CarId)
VALUES(1,2),(1,3),(1,2),(2,4)

--SELECT * FROM car

;WITH CTE as(
SELECT ROW_NUMBER() over (PARTITION BY personid,carid order by personid,carid) as rn,Id,PersonID,CarId from car)

DELETE FROM car where Id in(SELECT Id FROM CTE WHERE rn>1)

Você deseja visualizar as linhas que está prestes a remover e manter o controle sobre quais linhas duplicadas devem ser mantidas. Consulte http://developer.azurewebsites.net/2014/09/better-sql-group-by-find-duplicate-data/

with MYCTE as (
  SELECT ROW_NUMBER() OVER (
    PARTITION BY DuplicateKey1
                ,DuplicateKey2 -- optional
    ORDER BY CreatedAt -- the first row among duplicates will be kept, other rows will be removed
  ) RN
  FROM MyTable
)
DELETE FROM MYCTE
WHERE RN > 1