Supprimer les enregistrements en double dans SQL Server?

Considérez une colonne nommée EmployeeNametable Employee. Le but est de supprimer les enregistrements répétés, en fonction du EmployeeNamechamp.

EmployeeName
------------
Anand
Anand
Anil
Dipak
Anil
Dipak
Dipak
Anil

En utilisant une requête, je veux supprimer les enregistrements qui sont répétés.

Comment cela peut-il être fait avec TSQL dans SQL Server?

Vous pouvez le faire avec les fonctions de fenêtre. Il ordonnera les dupes par empId et supprimera tout sauf le premier.

delete x from (
  select *, rn=row_number() over (partition by EmployeeName order by empId)
  from Employee 
) x
where rn > 1;

Exécutez-le en tant que sélection pour voir ce qui serait supprimé:

select *
from (
  select *, rn=row_number() over (partition by EmployeeName order by empId)
  from Employee 
) x
where rn > 1;

En supposant que votre table Employee a également une colonne unique ( IDdans l'exemple ci-dessous), ce qui suit fonctionnera:

delete from Employee 
where ID not in
(
    select min(ID)
    from Employee 
    group by EmployeeName 
);

Cela laissera la version avec l'ID le plus bas du tableau.

Modifier
le commentaire de Re McGyver - à partir de SQL 2012

MIN peut être utilisé avec des colonnes numeric, char, varchar, uniqueidentifier ou datetime, mais pas avec des colonnes bit

Pour 2008 R2 et versions antérieures,

MIN peut être utilisé avec des colonnes numériques, char, varchar ou datetime, mais pas avec des colonnes bit (et cela ne fonctionne pas non plus avec les GUID)

Pour 2008R2, vous devrez convertir le GUIDen un type pris en charge par MIN, par exemple

delete from GuidEmployees
where CAST(ID AS binary(16)) not in
(
    select min(CAST(ID AS binary(16)))
    from GuidEmployees
    group by EmployeeName 
);

SqlFiddle pour différents types dans Sql 2008

SqlFiddle pour différents types dans SQL 2012

Vous pouvez essayer quelque chose comme ce qui suit:

delete T1
from MyTable T1, MyTable T2
where T1.dupField = T2.dupField
and T1.uniqueField > T2.uniqueField  

(cela suppose que vous ayez un champ unique basé sur un entier)

Personnellement, je dirais que vous feriez mieux d'essayer de corriger le fait que des entrées en double sont ajoutées à la base de données avant qu'elle ne se produise plutôt que comme une opération de correction postérieure.

DELETE
FROM MyTable
WHERE ID NOT IN (
     SELECT MAX(ID)
     FROM MyTable
     GROUP BY DuplicateColumn1, DuplicateColumn2, DuplicateColumn3)

WITH TempUsers (FirstName, LastName, duplicateRecordCount)
AS
(
    SELECT FirstName, LastName,
    ROW_NUMBER() OVER (PARTITIONBY FirstName, LastName ORDERBY FirstName) AS duplicateRecordCount
    FROM dbo.Users
)
DELETE
FROM TempUsers
WHERE duplicateRecordCount > 1

WITH CTE AS
(
   SELECT EmployeeName, 
          ROW_NUMBER() OVER(PARTITION BY EmployeeName ORDER BY EmployeeName) AS R
   FROM employee_table
)
DELETE CTE WHERE R > 1;

La magie des expressions de table courantes.

Essayer

DELETE
FROM employee
WHERE rowid NOT IN (SELECT MAX(rowid) FROM employee
GROUP BY EmployeeName);

Si vous cherchez un moyen de supprimer les doublons, mais que vous avez une clé étrangère pointant vers la table avec des doublons, vous pouvez adopter l'approche suivante en utilisant un curseur lent mais efficace.

Il déplacera les clés en double sur la table de clé étrangère.

create table #properOlvChangeCodes(
    id int not null,
    name nvarchar(max) not null
)

DECLARE @name VARCHAR(MAX);
DECLARE @id INT;
DECLARE @newid INT;
DECLARE @oldid INT;

DECLARE OLVTRCCursor CURSOR FOR SELECT id, name FROM Sales_OrderLineVersionChangeReasonCode; 
OPEN OLVTRCCursor;
FETCH NEXT FROM OLVTRCCursor INTO @id, @name;
WHILE @@FETCH_STATUS = 0  
BEGIN  
        -- determine if it should be replaced (is already in temptable with name)
        if(exists(select * from #properOlvChangeCodes where Name=@name)) begin
            -- if it is, finds its id
            Select  top 1 @newid = id
            from    Sales_OrderLineVersionChangeReasonCode
            where   Name = @name

            -- replace terminationreasoncodeid in olv for the new terminationreasoncodeid
            update Sales_OrderLineVersion set ChangeReasonCodeId = @newid where ChangeReasonCodeId = @id

            -- delete the record from the terminationreasoncode
            delete from Sales_OrderLineVersionChangeReasonCode where Id = @id
        end else begin
            -- insert into temp table if new
            insert into #properOlvChangeCodes(Id, name)
            values(@id, @name)
        end

        FETCH NEXT FROM OLVTRCCursor INTO @id, @name;
END;
CLOSE OLVTRCCursor;
DEALLOCATE OLVTRCCursor;

drop table #properOlvChangeCodes

delete from person 
where ID not in
(
        select t.id from 
        (select min(ID) as id from person 
         group by email 
        ) as t
);

Veuillez également consulter la méthode de suppression ci-dessous.

Declare @Employee table (EmployeeName varchar(10))

Insert into @Employee values 
('Anand'),('Anand'),('Anil'),('Dipak'),
('Anil'),('Dipak'),('Dipak'),('Anil')

Select * from @Employee

Créé un exemple de table nommé @Employeeet chargé avec des données données.

Delete  aliasName from (
Select  *,
        ROW_NUMBER() over (Partition by EmployeeName order by EmployeeName) as rowNumber
From    @Employee) aliasName 
Where   rowNumber > 1

Select * from @Employee

Résultat:

Je sais, cela a été demandé il y a six ans, poster juste au cas où cela serait utile pour n'importe qui.

Voici un bon moyen de dédupliquer les enregistrements dans une table qui a une colonne d'identité basée sur une clé primaire souhaitée que vous pouvez définir au moment de l'exécution. Avant de commencer, je vais remplir un exemple d'ensemble de données avec lequel travailler à l'aide du code suivant:

if exists (select 1 from sys.all_objects where type='u' and name='_original')
drop table _original

declare @startyear int = 2017
declare @endyear int = 2018
declare @iterator int = 1
declare @income money = cast((SELECT round(RAND()*(5000-4990)+4990 , 2)) as money)
declare @salesrepid int = cast(floor(rand()*(9100-9000)+9000) as varchar(4))
create table #original (rowid int identity, monthyear varchar(max), salesrepid int, sale money)
while @iterator<=50000 begin
insert #original 
select (Select cast(floor(rand()*(@endyear-@startyear)+@startyear) as varchar(4))+'-'+ cast(floor(rand()*(13-1)+1) as varchar(2)) ),  @salesrepid , @income
set  @salesrepid  = cast(floor(rand()*(9100-9000)+9000) as varchar(4))
set @income = cast((SELECT round(RAND()*(5000-4990)+4990 , 2)) as money)
set @iterator=@iterator+1
end  
update #original
set monthyear=replace(monthyear, '-', '-0') where  len(monthyear)=6

select * into _original from #original

Ensuite, je vais créer un type appelé ColumnNames:

create type ColumnNames AS table   
(Columnnames varchar(max))

Enfin, je vais créer un proc stocké avec les 3 mises en garde suivantes: 1. Le proc prendra un paramètre obligatoire @tablename qui définit le nom de la table que vous supprimez de votre base de données. 2. Le proc a un paramètre facultatif @columns que vous pouvez utiliser pour définir les champs qui constituent la clé primaire souhaitée que vous supprimez. Si ce champ est laissé vide, on suppose que tous les champs en dehors de la colonne d'identité constituent la clé primaire souhaitée. 3. Lorsque les enregistrements en double sont supprimés, l'enregistrement avec la valeur la plus basse dans sa colonne d'identité sera conservé.

Voici mon proc stocké delete_dupes:

 create proc delete_dupes (@tablename varchar(max), @columns columnnames readonly) 
 as
 begin

declare @table table (iterator int, name varchar(max), is_identity int)
declare @tablepartition table (idx int identity, type varchar(max), value varchar(max))
declare @partitionby varchar(max)  
declare @iterator int= 1 


if exists (select 1 from @columns)  begin
declare @columns1 table (iterator int, columnnames varchar(max))
insert @columns1
select 1, columnnames from @columns
set @partitionby = (select distinct 
                substring((Select ', '+t1.columnnames 
                From @columns1 t1
                Where T1.iterator = T2.iterator
                ORDER BY T1.iterator
                For XML PATH ('')),2, 1000)  partition
From @columns1 T2 )

end

insert @table 
select 1, a.name, is_identity from sys.all_columns a join sys.all_objects b on a.object_id=b.object_id
where b.name = @tablename  

declare @identity varchar(max)= (select name from @table where is_identity=1)

while @iterator>=0 begin 
insert @tablepartition
Select          distinct case when @iterator=1 then 'order by' else 'over (partition by' end , 
                substring((Select ', '+t1.name 
                From @table t1
                Where T1.iterator = T2.iterator and is_identity=@iterator
                ORDER BY T1.iterator
                For XML PATH ('')),2, 5000)  partition
From @table T2
set @iterator=@iterator-1
end 

declare @originalpartition varchar(max)

if @partitionby is null begin
select @originalpartition  = replace(b.value+','+a.type+a.value ,'over (partition by','')  from @tablepartition a cross join @tablepartition b where a.idx=2 and b.idx=1
select @partitionby = a.type+a.value+' '+b.type+a.value+','+b.value+') rownum' from @tablepartition a cross join @tablepartition b where a.idx=2 and b.idx=1
 end
 else
 begin
 select @originalpartition=b.value +','+ @partitionby from @tablepartition a cross join @tablepartition b where a.idx=2 and b.idx=1
 set @partitionby = (select 'OVER (partition by'+ @partitionby  + ' ORDER BY'+ @partitionby + ','+b.value +') rownum'
 from @tablepartition a cross join @tablepartition b where a.idx=2 and b.idx=1)
 end


exec('select row_number() ' + @partitionby +', '+@originalpartition+' into ##temp from '+ @tablename+'')


exec(
'delete a from _original a 
left join ##temp b on a.'+@identity+'=b.'+@identity+' and rownum=1  
where b.rownum is null')

drop table ##temp

end

Une fois que cela est respecté, vous pouvez supprimer tous vos enregistrements en double en exécutant le processus. Pour supprimer des dupes sans définir une clé primaire souhaitée, utilisez cet appel:

exec delete_dupes '_original'

Pour supprimer les dupes en fonction d'une clé primaire souhaitée définie, utilisez cet appel:

declare @table1 as columnnames
insert @table1
values ('salesrepid'),('sale')
exec delete_dupes '_original' , @table1