Elimina i record duplicati in PostgreSQL

Ho una tabella in un database PostgreSQL 8.3.8, che non ha chiavi / vincoli su di esso e ha più righe con esattamente gli stessi valori.

Vorrei rimuovere tutti i duplicati e conservare solo 1 copia di ogni riga.

C'è una colonna in particolare (chiamata "chiave") che può essere usata per identificare i duplicati (cioè dovrebbe esistere solo una voce per ogni "chiave" distinta).

Come posso fare questo? (idealmente con un singolo comando SQL) La velocità non è un problema in questo caso (ci sono solo poche righe).

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

Una soluzione più veloce è

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

Questo è veloce e 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

Vedi anche la mia risposta su Come eliminare le righe duplicate senza identificatore univoco che include ulteriori informazioni.

Ho provato questo:

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

fornito da Postgres wiki:

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

Ho dovuto creare la mia versione. La versione scritta da @a_horse_with_no_name è troppo lenta sulla mia tabella (21 milioni di righe). E @rapimo semplicemente non elimina i duplicati.

Ecco cosa utilizzo su 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);

Userei una tabella temporanea:

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

Quindi, elimina tabe rinomina tab_tempin tab.

Un altro approccio (funziona solo se hai un campo univoco come idnella tua tabella) per trovare tutti gli ID univoci per colonne e rimuovere altri ID che non sono nell'elenco univoco

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

Che ne dite di:

CON
  u AS (SELECT DISTINCT * FROM your_table),
  x AS (DELETE FROM your_table)
INSERISCI NELLA tua_tabella SELEZIONA * DA u;

Ero preoccupato per l'ordine di esecuzione, l'eliminazione sarebbe avvenuta prima di SELECT DISTINCT, ma per me funziona bene. E ha il vantaggio di non aver bisogno di alcuna conoscenza della struttura del tavolo.

Questo ha funzionato bene per me. Avevo una tabella, termini, che conteneva valori duplicati. Ha eseguito una query per popolare una tabella temporanea con tutte le righe duplicate. Quindi ho eseguito l'istruzione a delete con quegli ID nella tabella temporanea. valore è la colonna che conteneva i duplicati.

        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)

Ecco una soluzione che utilizza 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