Comment supprimer les entrées en double?

Je dois ajouter une contrainte unique à une table existante. C'est bien sauf que la table contient déjà des millions de lignes et que de nombreuses lignes violent la contrainte unique que je dois ajouter.

Quelle est l'approche la plus rapide pour supprimer les lignes incriminées? J'ai une instruction SQL qui trouve les doublons et les supprime, mais cela prend une éternité à s'exécuter. Existe-t-il une autre façon de résoudre ce problème? Peut-être sauvegarder la table, puis restaurer après l'ajout de la contrainte?

Par exemple, vous pourriez:

CREATE TABLE tmp ...
INSERT INTO tmp SELECT DISTINCT * FROM t;
DROP TABLE t;
ALTER TABLE tmp RENAME TO t;

Certaines de ces approches semblent un peu compliquées, et je le fais généralement comme:

Compte tenu de la table table, souhaitez l'unifier sur (champ1, champ2) en gardant la ligne avec le champ max3:

DELETE FROM table USING table alias 
  WHERE table.field1 = alias.field1 AND table.field2 = alias.field2 AND
    table.max_field < alias.max_field

Par exemple, j'ai une table, user_accountset je veux ajouter une contrainte unique sur le courrier électronique, mais j'ai quelques doublons. Dites aussi que je veux garder le plus récemment créé (id max parmi les doublons).

DELETE FROM user_accounts USING user_accounts ua2
  WHERE user_accounts.email = ua2.email AND user_account.id < ua2.id;

• Remarque - ce USINGn'est pas du SQL standard, c'est une extension PostgreSQL (mais très utile), mais la question originale mentionne spécifiquement PostgreSQL.

Au lieu de créer une nouvelle table, vous pouvez également réinsérer des lignes uniques dans la même table après l'avoir tronquée. Faites tout cela en une seule transaction . Si vous le souhaitez, vous pouvez supprimer automatiquement la table temporaire à la fin de la transaction avec ON COMMIT DROP. Voir ci-dessous.

Cette approche n'est utile que s'il y a beaucoup de lignes à supprimer de partout dans la table. Pour quelques doublons, utilisez un simple DELETE.

Vous avez mentionné des millions de lignes. Pour accélérer l'opération, vous souhaitez allouer suffisamment de tampons temporaires pour la session. Le paramètre doit être ajusté avant qu'un tampon temporaire ne soit utilisé dans votre session en cours. Découvrez la taille de votre table:

SELECT pg_size_pretty(pg_relation_size('tbl'));

Réglez en temp_buffersconséquence. Arrondissez généreusement car la représentation en mémoire nécessite un peu plus de RAM.

SET temp_buffers = 200MB;    -- example value

BEGIN;

-- CREATE TEMPORARY TABLE t_tmp ON COMMIT DROP AS -- drop temp table at commit
CREATE TEMPORARY TABLE t_tmp AS  -- retain temp table after commit
SELECT DISTINCT * FROM tbl;  -- DISTINCT folds duplicates

TRUNCATE tbl;

INSERT INTO tbl
SELECT * FROM t_tmp;
-- ORDER BY id; -- optionally "cluster" data while being at it.

COMMIT;

Cette méthode peut être supérieure à la création d'une nouvelle table si des objets dépendants existent. Vues, ​​index, clés étrangères ou autres objets référençant la table. TRUNCATEvous permet de commencer avec une ardoise vierge de toute façon (nouveau fichier en arrière-plan) et est beaucoup plus rapide qu'avec DELETE FROM tblde grandes tables ( DELETEpeut en fait être plus rapide avec de petites tables).

Pour les grandes tables, il est régulièrement plus rapide de supprimer les index et les clés étrangères, de remplir la table et de recréer ces objets. En ce qui concerne les contraintes fk, vous devez être certain que les nouvelles données sont bien sûr valides, sinon vous rencontrerez une exception en essayant de créer le fk.

Notez que cela TRUNCATEnécessite un verrouillage plus agressif que DELETE. Cela peut être un problème pour les tables à forte charge simultanée.

Si ce TRUNCATEn'est pas une option ou généralement pour les tables petites à moyennes, il existe une technique similaire avec un CTE de modification des données (Postgres 9.1 +):

WITH del AS (DELETE FROM tbl RETURNING *)
INSERT INTO tbl
SELECT DISTINCT * FROM del;
-- ORDER BY id; -- optionally "cluster" data while being at it.

Plus lent pour les grandes tables, car TRUNCATEc'est plus rapide là-bas. Mais peut-être plus rapide (et plus simple!) Pour les petites tables.

Si vous n'avez aucun objet dépendant du tout, vous pouvez créer une nouvelle table et supprimer l'ancienne, mais vous ne gagnerez pratiquement rien à cette approche universelle.

Pour les très grandes tables qui ne rentreraient pas dans la RAM disponible , la création d'une nouvelle table sera considérablement plus rapide. Vous devrez mettre cela en balance avec d'éventuels problèmes / frais généraux avec des objets dépendants.

Vous pouvez utiliser oid ou ctid, qui sont normalement des colonnes "non visibles" dans le tableau:

DELETE FROM table
 WHERE ctid NOT IN
  (SELECT MAX(s.ctid)
    FROM table s
    GROUP BY s.column_has_be_distinct);

La fonction de fenêtre PostgreSQL est pratique pour ce problème.

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

Voir Suppression des doublons .

À partir d' une ancienne liste de diffusion postgresql.org :

create table test ( a text, b text );

Des valeurs uniques

insert into test values ( 'x', 'y');
insert into test values ( 'x', 'x');
insert into test values ( 'y', 'y' );
insert into test values ( 'y', 'x' );

Dupliquer les valeurs

insert into test values ( 'x', 'y');
insert into test values ( 'x', 'x');
insert into test values ( 'y', 'y' );
insert into test values ( 'y', 'x' );

Encore un double double

insert into test values ( 'x', 'y');

select oid, a, b from test;

Sélectionnez les lignes en double

select o.oid, o.a, o.b from test o
    where exists ( select 'x'
                   from test i
                   where     i.a = o.a
                         and i.b = o.b
                         and i.oid < o.oid
                 );

Supprimer les lignes en double

Remarque: PostgreSQL ne prend pas en charge les alias sur la table mentionnée dans la fromclause de suppression.

delete from test
    where exists ( select 'x'
                   from test i
                   where     i.a = test.a
                         and i.b = test.b
                         and i.oid < test.oid
             );

Requête généralisée pour supprimer les doublons:

DELETE FROM table_name
WHERE ctid NOT IN (
  SELECT max(ctid) FROM table_name
  GROUP BY column1, [column 2, ...]
);

La colonne ctidest une colonne spéciale disponible pour chaque table mais non visible sauf mention contraire. La ctidvaleur de la colonne est considérée comme unique pour chaque ligne d'une table.

Je viens d'utiliser la réponse d'Erwin Brandstetter avec succès pour supprimer les doublons dans une table de jointure (une table ne disposant pas de ses propres ID primaires), mais j'ai trouvé qu'il y avait une mise en garde importante.

Y compris ON COMMIT DROPsignifie que la table temporaire sera supprimée à la fin de la transaction. Pour moi, cela signifiait que la table temporaire n'était plus disponible au moment où je suis allé l'insérer!

Je viens de le faire CREATE TEMPORARY TABLE t_tmp AS SELECT DISTINCT * FROM tbl;et tout a bien fonctionné.

La table temporaire est supprimée à la fin de la session.

Cette fonction supprime les doublons sans supprimer les index et le fait à n'importe quelle table.

Usage: select remove_duplicates('mytable');

---
--- remove_duplicates (nomtable) supprime les enregistrements en double d'une table (conversion d'un ensemble en ensemble unique)
---
FONCTION CRÉER OU REMPLACER remove_duplicates (text) RETURNS void AS $$
DÉCLARER
  nom de table ALIAS FOR $ 1;
COMMENCER
  EXÉCUTER 'CRÉER UNE TABLE TEMPORAIRE _DISTINCT_' || nom_table || 'AS (SELECT DISTINCT * FROM' || nomtable || ');';
  EXÉCUTER «SUPPRIMER DE» || nom_table || ';';
  EXÉCUTER «INSÉRER DANS» || nom_table || '(SELECT * FROM _DISTINCT_' || nomtable || ');';
  EXÉCUTER 'DROP TABLE _DISTINCT_' || nom_table || ';';
  REVENIR;
FIN;
$$ LANGUAGE plpgsql;

DELETE FROM table
  WHERE something NOT IN
    (SELECT     MAX(s.something)
      FROM      table As s
      GROUP BY  s.this_thing, s.that_thing);

Si vous n'avez qu'une ou quelques entrées dupliquées, et qu'elles sont effectivement dupliquées (c'est-à-dire qu'elles apparaissent deux fois), vous pouvez utiliser la ctidcolonne "masquée" , comme proposé ci-dessus, avec LIMIT:

DELETE FROM mytable WHERE ctid=(SELECT ctid FROM mytable WHERE […] LIMIT 1);

Cela supprimera uniquement la première des lignes sélectionnées.

Tout d'abord, vous devez décider lesquels de vos "doublons" vous conserverez. Si toutes les colonnes sont égales, OK, vous pouvez supprimer l'une d'entre elles ... Mais peut-être voulez-vous ne conserver que le plus récent, ou un autre critère?

Le moyen le plus rapide dépend de votre réponse à la question ci-dessus, ainsi que du% de doublons sur la table. Si vous jetez 50% de vos lignes, vous feriez mieux de le faire CREATE TABLE ... AS SELECT DISTINCT ... FROM ... ;, et si vous supprimez 1% des lignes, il est préférable d'utiliser DELETE.

Aussi pour des opérations de maintenance comme celle-ci, il est généralement bon de définir work_memune bonne partie de votre RAM: exécutez EXPLAIN, vérifiez le nombre N de tris / hachages et définissez work_mem sur votre RAM / 2 / N. Utilisez beaucoup de RAM; c'est bon pour la vitesse. Tant que vous n'avez qu'une seule connexion simultanée ...

Je travaille avec PostgreSQL 8.4. Lorsque j'ai exécuté le code proposé, j'ai constaté qu'il ne supprimait pas réellement les doublons. En exécutant certains tests, j'ai trouvé que l'ajout de "DISTINCT ON (duplicate_column_name)" et de "ORDER BY duplicate_column_name" a fait l'affaire. Je ne suis pas un gourou SQL, j'ai trouvé cela dans la doc de PostgreSQL 8.4 SELECT ... DISTINCT.

CREATE OR REPLACE FUNCTION remove_duplicates(text, text) RETURNS void AS $$
DECLARE
  tablename ALIAS FOR $1;
  duplicate_column ALIAS FOR $2;
BEGIN
  EXECUTE 'CREATE TEMPORARY TABLE _DISTINCT_' || tablename || ' AS (SELECT DISTINCT ON (' || duplicate_column || ') * FROM ' || tablename || ' ORDER BY ' || duplicate_column || ' ASC);';
  EXECUTE 'DELETE FROM ' || tablename || ';';
  EXECUTE 'INSERT INTO ' || tablename || ' (SELECT * FROM _DISTINCT_' || tablename || ');';
  EXECUTE 'DROP TABLE _DISTINCT_' || tablename || ';';
  RETURN;
END;
$$ LANGUAGE plpgsql;

Cela fonctionne très bien et est très rapide:

CREATE INDEX otherTable_idx ON otherTable( colName );
CREATE TABLE newTable AS select DISTINCT ON (colName) col1,colName,col2 FROM otherTable;

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

Supprimez les doublons par colonne (s) et conservez la ligne avec l'ID le plus bas. Le motif est tiré du wiki postgres

En utilisant les CTE, vous pouvez obtenir une version plus lisible de ce qui précède grâce à ce

WITH duplicate_ids as (
    SELECT id, rnum 
    FROM num_of_rows
    WHERE rnum > 1
),
num_of_rows as (
    SELECT id, 
        ROW_NUMBER() over (partition BY column1, 
                                        column2, 
                                        column3 ORDER BY id) AS rnum
        FROM tablename
)
DELETE FROM tablename 
WHERE id IN (SELECT id from duplicate_ids)

CREATE TABLE test (col text);
INSERT INTO test VALUES
 ('1'),
 ('2'), ('2'),
 ('3'),
 ('4'), ('4'),
 ('5'),
 ('6'), ('6');
DELETE FROM test
 WHERE ctid in (
   SELECT t.ctid FROM (
     SELECT row_number() over (
               partition BY col
               ORDER BY col
               ) AS rnum,
            ctid FROM test
       ORDER BY col
     ) t
    WHERE t.rnum >1);