Supprimer les enregistrements en double dans PostgreSQL

J'ai une table dans une base de données PostgreSQL 8.3.8, qui n'a aucune clé / contrainte dessus, et a plusieurs lignes avec exactement les mêmes valeurs.

Je souhaite supprimer tous les doublons et ne conserver qu'une seule copie de chaque ligne.

Il y a une colonne en particulier (nommée «clé») qui peut être utilisée pour identifier les doublons (c'est-à-dire qu'il ne devrait exister qu'une seule entrée pour chaque «clé» distincte).

Comment puis-je faire ceci? (idéalement avec une seule commande SQL) La vitesse n'est pas un problème dans ce cas (il n'y a que quelques lignes).

DELETE FROM dupes a
WHERE a.ctid <> (SELECT min(b.ctid)
                 FROM   dupes b
                 WHERE  a.key = b.key);

Une solution plus rapide est

DELETE FROM dups a USING (
      SELECT MIN(ctid) as ctid, key
        FROM dups 
        GROUP BY key HAVING COUNT(*) > 1
      ) b
      WHERE a.key = b.key 
      AND a.ctid <> b.ctid

C'est rapide et concis:

DELETE FROM dupes T1
    USING   dupes T2
WHERE   T1.ctid < T2.ctid  -- delete the older versions
    AND T1.key  = T2.key;  -- add more columns if needed

Voir aussi ma réponse à Comment supprimer les lignes en double sans identifiant unique qui comprend plus d'informations.

J'ai essayé ceci:

DELETE FROM tablename
WHERE id IN (SELECT id
              FROM (SELECT id,
                             ROW_NUMBER() OVER (partition BY column1, column2, column3 ORDER BY id) AS rnum
                     FROM tablename) t
              WHERE t.rnum > 1);

fourni par Postgres wiki:

https://wiki.postgresql.org/wiki/Deleting_duplicates

J'utiliserais une table temporaire:

create table tab_temp as
select distinct f1, f2, f3, fn
  from tab;

Ensuite, supprimez tabet renommez tab_tempen tab.

J'ai dû créer ma propre version. La version écrite par @a_horse_with_no_name est bien trop lente sur ma table (21 millions de lignes). Et @rapimo ne supprime tout simplement pas les doublages.

Voici ce que j'utilise sur PostgreSQL 9.5

DELETE FROM your_table
WHERE ctid IN (
  SELECT unnest(array_remove(all_ctids, actid))
  FROM (
         SELECT
           min(b.ctid)     AS actid,
           array_agg(ctid) AS all_ctids
         FROM your_table b
         GROUP BY key1, key2, key3, key4
         HAVING count(*) > 1) c);

Une autre approche (fonctionne uniquement si vous avez un champ unique comme iddans votre table) pour trouver tous les identifiants uniques par colonnes et supprimer les autres identifiants qui ne sont pas dans la liste unique

DELETE
FROM users
WHERE users.id NOT IN (SELECT DISTINCT ON (username, email) id FROM users);

Que diriez-vous:

AVEC
  u AS (SELECT DISTINCT * FROM your_table),
  x AS (SUPPRIMER DE votre_table)
INSÉRER DANS votre_table SELECT * FROM u;

J'avais été préoccupé par l'ordre d'exécution, est-ce que le DELETE aurait lieu avant le SELECT DISTINCT, mais cela fonctionne bien pour moi. Et a l'avantage supplémentaire de ne pas avoir besoin de connaissances sur la structure de la table.

Cela a bien fonctionné pour moi. J'avais une table, des termes, qui contenait des valeurs en double. Exécuté une requête pour remplir une table temporaire avec toutes les lignes en double. Ensuite, j'ai exécuté l'instruction a delete avec ces identifiants dans la table temporaire. valeur est la colonne contenant les doublons.

        CREATE TEMP TABLE dupids AS
        select id from (
                    select value, id, row_number() 
over (partition by value order by value) 
    as rownum from terms
                  ) tmp
                  where rownum >= 2;

delete from [table] where id in (select id from dupids)

Voici une solution utilisant PARTITION BY:

DELETE FROM dups
USING (
  SELECT
    ctid,
    (ctid != min(ctid) OVER (PARTITION BY key_column1, key_column2 [...])) AS is_duplicate
  FROM dups 
) dups_find_duplicates
WHERE dups.ctid == dups_find_duplicates.ctid
AND dups_find_duplicates.is_duplicate