Recherche de valeurs en double dans une table SQL

Il est facile de trouver des doublons avec un seul champ:

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

Donc, si nous avons une table

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

Cette requête nous donnera John, Sam, Tom, Tom parce qu'ils ont tous la même chose email.

Cependant, ce que je veux, c'est obtenir des doublons avec les mêmes email et name .

Autrement dit, je veux obtenir "Tom", "Tom".

La raison pour laquelle j'en ai besoin: j'ai fait une erreur et j'ai autorisé l'insertion de doublons nameet de emailvaleurs. Maintenant, je dois supprimer / modifier les doublons, donc je dois d' abord les trouver .

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

Regroupez simplement les deux colonnes.

Remarque: l'ancienne norme ANSI consiste à avoir toutes les colonnes non agrégées dans le GROUP BY, mais cela a changé avec l'idée de "dépendance fonctionnelle" :

Dans la théorie des bases de données relationnelles, une dépendance fonctionnelle est une contrainte entre deux ensembles d'attributs dans une relation à partir d'une base de données. En d'autres termes, la dépendance fonctionnelle est une contrainte qui décrit la relation entre les attributs d'une relation.

Le support n'est pas cohérent:

• PostgreSQL récent le supporte .
• SQL Server (comme dans SQL Server 2017) nécessite toujours toutes les colonnes non agrégées dans GROUP BY.
• MySQL est imprévisible et vous avez besoin de sql_mode=only_full_group_by:
  • GROUP BY lname ORDER BY montrant des résultats erronés ;
  • Quelle est la fonction d'agrégation la moins chère en l'absence de ANY () (voir les commentaires dans la réponse acceptée).
• Oracle n'est pas assez courant (avertissement: humour, je ne connais pas Oracle).

essaye ça:

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

PRODUCTION:

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

(2 row(s) affected)

si vous voulez que les ID des dups utilisent ceci:

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

PRODUCTION:

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

(4 row(s) affected)

pour supprimer les doublons, essayez:

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

PRODUCTION:

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

(4 row(s) affected)

Essaye ça:

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

Si vous souhaitez supprimer les doublons, voici une façon beaucoup plus simple de le faire que de trouver des lignes paires / impaires dans une triple sous-sélection:

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

Et ainsi supprimer:

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
)

Beaucoup plus facile à lire et à comprendre à mon humble avis

Remarque: le seul problème est que vous devez exécuter la demande jusqu'à ce qu'aucune ligne ne soit supprimée, car vous ne supprimez qu'un seul de chaque doublon à chaque fois

Essayez ce qui suit:

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 peu tard pour la fête, mais j'ai trouvé une solution de contournement vraiment cool pour trouver tous les ID en double:

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

essayez ce code

WITH CTE AS

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

Cela sélectionne / supprime tous les enregistrements en double, sauf un enregistrement de chaque groupe de doublons. Ainsi, la suppression laisse tous les enregistrements uniques + un enregistrement de chaque groupe de doublons.

Sélectionnez les doublons:

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

Supprimer les doublons:

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

Soyez conscient des quantités plus importantes d'enregistrements, cela peut entraîner des problèmes de performances.

Dans le cas où vous travaillez avec Oracle, cette méthode serait préférable:

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

Si vous souhaitez voir s'il y a des lignes en double dans votre tableau, j'ai utilisé ci-dessous la requête:

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 

C'est la chose la plus simple que j'ai trouvée. Il utilise une expression de table commune (CTE) et une fenêtre de partition (je pense que ces fonctionnalités sont dans SQL 2008 et versions ultérieures).

Cet exemple recherche tous les élèves avec un nom et un ddb en double. Les champs dont vous souhaitez vérifier la duplication se trouvent dans la clause OVER. Vous pouvez inclure tout autre champ souhaité dans la projection.

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

Comment pouvons-nous compter les valeurs dupliquées ?? soit il est répété 2 fois ou supérieur à 2. il suffit de les compter, pas en groupe.

aussi simple que

select COUNT(distinct col_01) from Table_01

En utilisant CTE, nous pouvons également trouver une valeur en double comme celle-ci

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;

Je pense que cela fonctionnera correctement pour rechercher des valeurs répétées dans une colonne particulière.

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

Cela devrait également fonctionner, peut-être essayer.

  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)

Particulièrement bon dans votre cas Si vous recherchez des doublons qui ont une sorte de préfixe ou un changement général comme par exemple un nouveau domaine dans la messagerie. alors vous pouvez utiliser replace () dans ces colonnes

Si vous souhaitez rechercher des données en double (selon un ou plusieurs critères) et sélectionner les lignes réelles.

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)

Pour supprimer des enregistrements dont les noms sont en double

;WITH CTE AS    
(

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

DELETE FROM CTE WHERE T > 1

Pour vérifier à partir d'un enregistrement en double dans un tableau.

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);

Pour supprimer l'enregistrement en double dans une table.

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;

Nous pouvons utiliser avoir ici qui fonctionnent sur des fonctions d'agrégation comme indiqué ci-dessous

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

Ici, deux champs id_account et data sont utilisés avec Count (*). Ainsi, il donnera à tous les enregistrements qui ont plus d'une fois les mêmes valeurs dans les deux colonnes.

Nous avons une raison erronée d'avoir manqué d'ajouter des contraintes dans la table SQL Server et les enregistrements ont été insérés en double dans toutes les colonnes avec l'application frontale. Ensuite, nous pouvons utiliser la requête ci-dessous pour supprimer la requête en double de la table.

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

Ici, nous avons pris tous les enregistrements distincts de la table d'origine et supprimé les enregistrements de la table d'origine. Encore une fois, nous avons inséré toutes les valeurs distinctes de la nouvelle table dans la table d'origine, puis supprimé la nouvelle table.

Vous voudrez peut-être essayer ceci

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

La chose la plus importante ici est d'avoir la fonction la plus rapide. Les indices des doublons doivent également être identifiés. L'auto-jointure est une bonne option mais pour avoir une fonction plus rapide, il est préférable de trouver d'abord les lignes qui ont des doublons, puis de se joindre à la table d'origine pour trouver l'id des lignes dupliquées. Enfin, triez par colonne, sauf id, pour avoir des lignes en double les unes à côté des autres.

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;

Vous pouvez utiliser le mot clé SELECT DISTINCT pour supprimer les doublons. Vous pouvez également filtrer par nom et placer tout le monde avec ce nom sur une table.

Le code exact diffère selon que vous souhaitez également rechercher des lignes en double ou uniquement des identifiants différents avec le même e-mail et le même nom. Si id est une clé primaire ou a une contrainte unique, cette distinction n'existe pas, mais la question ne le précise pas. Dans le premier cas, vous pouvez utiliser le code donné dans plusieurs autres réponses:

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

Dans ce dernier cas, vous utiliseriez:

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