Comment trouver des enregistrements en double dans PostgreSQL

J'ai une table de base de données PostgreSQL appelée "user_links" qui autorise actuellement les champs en double suivants:

year, user_id, sid, cid

La contrainte unique est actuellement le premier champ « id », mais je suis maintenant d'ajouter une contrainte pour vous assurer que la year, user_id, sidetcid sont tous uniques , mais je ne peux pas appliquer la contrainte parce que les valeurs en double existent déjà qui violent cette contrainte.

Existe-t-il un moyen de trouver tous les doublons?

L'idée de base sera d'utiliser une requête imbriquée avec une agrégation de comptage:

select * from yourTable ou
where (select count(*) from yourTable inr
where inr.sid = ou.sid) > 1

Vous pouvez ajuster la clause where dans la requête interne pour restreindre la recherche.

Il existe une autre bonne solution pour ce qui est mentionné dans les commentaires (mais tout le monde ne les lit pas):

select Column1, Column2, count(*)
from yourTable
group by Column1, Column2
HAVING count(*) > 1

Ou plus court:

SELECT (yourTable.*)::text, count(*)
FROM yourTable
GROUP BY yourTable.*
HAVING count(*) > 1

De " Rechercher les lignes en double avec PostgreSQL ", voici la solution intelligente:

select * from (
  SELECT id,
  ROW_NUMBER() OVER(PARTITION BY column1, column2 ORDER BY id asc) AS Row
  FROM tbl
) dups
where 
dups.Row > 1

Vous pouvez rejoindre la même table sur les champs qui seraient dupliqués puis anti-jointure sur le champ id. Sélectionnez le champ id du premier alias de table (tn1), puis utilisez la fonction array_agg sur le champ id du second alias de table. Enfin, pour que la fonction array_agg fonctionne correctement, vous regrouperez les résultats par le champ tn1.id. Cela produira un jeu de résultats contenant l'identifiant d'un enregistrement et un tableau de tous les identifiants correspondant aux conditions de jointure.

select tn1.id,
       array_agg(tn2.id) as duplicate_entries, 
from table_name tn1 join table_name tn2 on 
    tn1.year = tn2.year 
    and tn1.sid = tn2.sid 
    and tn1.user_id = tn2.user_id 
    and tn1.cid = tn2.cid
    and tn1.id <> tn2.id
group by tn1.id;

De toute évidence, les identifiants qui seront dans le tableau duplicate_entries pour un identifiant auront également leurs propres entrées dans le jeu de résultats. Vous devrez utiliser cet ensemble de résultats pour décider quel identifiant vous voulez devenir la source de la «vérité». Le seul enregistrement qui ne devrait pas être supprimé. Vous pourriez peut-être faire quelque chose comme ceci:

with dupe_set as (
select tn1.id,
       array_agg(tn2.id) as duplicate_entries, 
from table_name tn1 join table_name tn2 on 
    tn1.year = tn2.year 
    and tn1.sid = tn2.sid 
    and tn1.user_id = tn2.user_id 
    and tn1.cid = tn2.cid
    and tn1.id <> tn2.id
group by tn1.id
order by tn1.id asc)
select ds.id from dupe_set ds where not exists 
 (select de from unnest(ds.duplicate_entries) as de where de < ds.id)

Sélectionne le plus petit nombre d'ID ayant des doublons (en supposant que l'ID augmente int PK). Ce seraient les pièces d'identité que vous conserveriez.

Afin de faciliter les choses, je suppose que vous souhaitez appliquer une contrainte unique uniquement pour l'année de la colonne et la clé primaire est une colonne nommée id.

Afin de trouver des valeurs en double, vous devez exécuter,

SELECT year, COUNT(id)
FROM YOUR_TABLE
GROUP BY year
HAVING COUNT(id) > 1
ORDER BY COUNT(id);

En utilisant l'instruction sql ci-dessus, vous obtenez une table qui contient toutes les années en double dans votre table. Afin de supprimer tous les doublons à l'exception de la dernière entrée en double, vous devez utiliser l'instruction sql ci-dessus.

DELETE
FROM YOUR_TABLE A USING YOUR_TABLE_AGAIN B
WHERE A.year=B.year AND A.id<B.id;