Eliminar registros duplicados en PostgreSQL

Tengo una tabla en una base de datos PostgreSQL 8.3.8, que no tiene claves / restricciones y tiene varias filas con exactamente los mismos valores.

Me gustaría eliminar todos los duplicados y conservar solo 1 copia de cada fila.

Hay una columna en particular (denominada "clave") que se puede utilizar para identificar duplicados (es decir, solo debe existir una entrada para cada "clave" distinta).

¿Cómo puedo hacer esto? (idealmente con un solo comando SQL) La velocidad no es un problema en este caso (solo hay unas pocas filas).

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

Una solución más rápida es

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

Esto es rápido y conciso:

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

Vea también mi respuesta en Cómo eliminar filas duplicadas sin un identificador único que incluye más información.

Probé esto:

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

proporcionado por Postgres wiki:

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

Tuve que crear mi propia versión. La versión escrita por @a_horse_with_no_name es demasiado lenta en mi mesa (21M filas). Y @rapimo simplemente no borra dups.

Esto es lo que uso en 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);

Usaría una tabla temporal:

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

Luego, elimine taby cambie el nombre tab_tempa tab.

Otro enfoque (funciona solo si tiene un campo único como iden su tabla) para encontrar todos los identificadores únicos por columnas y eliminar otros identificadores que no están en la lista única

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

Qué tal si:

CON
  u AS (SELECT DISTINCT * FROM your_table),
  x AS (ELIMINAR DE your_table)
INSERT INTO your_table SELECT * FROM u;

Me había preocupado la orden de ejecución, si el DELETE ocurriría antes del SELECT DISTINCT, pero funciona bien para mí. Y tiene la ventaja adicional de no necesitar ningún conocimiento sobre la estructura de la tabla.

Esto funcionó bien para mí. Tenía una tabla, términos, que contenía valores duplicados. Ejecutó una consulta para completar una tabla temporal con todas las filas duplicadas. Luego ejecuté una declaración de eliminación con esos identificadores en la tabla temporal. valor es la columna que contenía los duplicados.

        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)

Aquí hay una solución usando 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