Bagaimana cara menghapus entri duplikat?

Saya harus menambahkan batasan unik ke tabel yang ada. Ini bagus kecuali bahwa tabel sudah memiliki jutaan baris, dan banyak baris yang melanggar batasan unik yang perlu saya tambahkan.

Apa pendekatan tercepat untuk menghilangkan baris yang melanggar? Saya memiliki pernyataan SQL yang menemukan duplikat dan menghapusnya, tetapi butuh waktu lama untuk dijalankan. Apakah ada cara lain untuk mengatasi masalah ini? Mungkin mencadangkan tabel, lalu memulihkan setelah batasan ditambahkan?

Misalnya Anda bisa:

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

Beberapa dari pendekatan ini tampak sedikit rumit, dan saya biasanya melakukan ini sebagai:

Tabel yang diberikan table, ingin membuatnya unik di (bidang1, bidang2) menjaga baris dengan bidang3 maks:

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

Misalnya, saya memiliki tabel, user_accountsdan saya ingin menambahkan batasan unik pada email, tetapi saya memiliki beberapa duplikat. Katakan juga bahwa saya ingin menyimpan yang paling baru dibuat (id maks di antara duplikat).

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

• Catatan - USINGbukan SQL standar, ini adalah ekstensi PostgreSQL (tetapi sangat berguna), tetapi pertanyaan asli secara khusus menyebutkan PostgreSQL.

Alih-alih membuat tabel baru, Anda juga dapat memasukkan kembali baris unik ke dalam tabel yang sama setelah memotongnya. Lakukan semuanya dalam satu transaksi . Secara opsional, Anda dapat menghapus tabel sementara di akhir transaksi secara otomatis dengan ON COMMIT DROP. Lihat di bawah.

Pendekatan ini hanya berguna jika ada banyak baris yang harus dihapus dari seluruh tabel. Untuk beberapa duplikat, gunakan polos DELETE.

Anda menyebutkan jutaan baris. Untuk membuat operasi cepat, Anda ingin mengalokasikan buffer sementara yang cukup untuk sesi tersebut. Pengaturan harus disesuaikan sebelum buffer sementara apa pun digunakan dalam sesi Anda saat ini. Cari tahu ukuran meja Anda:

SELECT pg_size_pretty(pg_relation_size('tbl'));

Atur temp_bufferssesuai. Kumpulkan dengan murah hati karena representasi dalam memori membutuhkan lebih banyak 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;

Metode ini bisa lebih baik daripada membuat tabel baru jika tergantung objek yang ada. Tampilan, indeks, kunci asing, atau objek lain yang mereferensikan tabel. TRUNCATEmembuat Anda tetap memulai dengan papan tulis yang bersih (file baru di latar belakang) dan jauh lebih cepat dibandingkan DELETE FROM tbldengan tabel besar ( DELETEsebenarnya bisa lebih cepat dengan tabel kecil).

Untuk tabel besar, biasanya lebih cepat untuk menghapus indeks dan kunci asing, mengisi ulang tabel, dan membuat ulang objek ini. Sejauh menyangkut kendala fk, Anda harus yakin bahwa data baru tentu saja valid atau Anda akan mengalami pengecualian saat mencoba membuat fk.

Perhatikan bahwa TRUNCATEmembutuhkan penguncian yang lebih agresif daripada DELETE. Ini mungkin menjadi masalah untuk tabel dengan beban yang berat dan bersamaan.

Jika TRUNCATEbukan merupakan pilihan atau umumnya untuk tabel kecil hingga menengah, ada teknik serupa dengan CTE pemodifikasi data (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.

Lebih lambat untuk tabel besar, karena TRUNCATElebih cepat ke sana. Tetapi mungkin lebih cepat (dan lebih sederhana!) Untuk tabel kecil.

Jika Anda tidak memiliki objek bergantung sama sekali, Anda dapat membuat tabel baru dan menghapus yang lama, tetapi Anda hampir tidak mendapatkan apa-apa dari pendekatan universal ini.

Untuk tabel yang sangat besar yang tidak sesuai dengan RAM yang tersedia , membuat tabel baru akan jauh lebih cepat. Anda harus mempertimbangkan ini terhadap kemungkinan masalah / overhead dengan objek yang bergantung.

Anda dapat menggunakan oid atau ctid, yang biasanya merupakan kolom "tidak terlihat" di tabel:

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

Fungsi jendela PostgreSQL berguna untuk masalah ini.

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

Lihat Menghapus duplikat .

Dari milis postgresql.org lama :

create table test ( a text, b text );

Nilai-nilai unik

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

Nilai duplikat

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

Satu lagi duplikat ganda

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

select oid, a, b from test;

Pilih baris duplikat

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

Hapus baris duplikat

Catatan: PostgreSQL tidak mendukung alias di tabel yang disebutkan di fromklausul penghapusan.

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

Kueri umum untuk menghapus duplikat:

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

Kolom ctidadalah kolom khusus yang tersedia untuk setiap tabel tetapi tidak terlihat kecuali disebutkan secara khusus. Nilai ctidkolom dianggap unik untuk setiap baris dalam tabel.

Saya baru saja menggunakan jawaban Erwin Brandstetter berhasil menghapus duplikat dalam tabel gabungan (tabel yang tidak memiliki ID utamanya sendiri), tetapi menemukan bahwa ada satu peringatan penting.

Termasuk ON COMMIT DROPberarti tabel sementara akan dijatuhkan di akhir transaksi. Bagi saya, itu berarti tabel sementara tidak lagi tersedia pada saat saya memasukkannya!

Saya baru saja melakukannya CREATE TEMPORARY TABLE t_tmp AS SELECT DISTINCT * FROM tbl;dan semuanya bekerja dengan baik.

Tabel sementara tidak dihilangkan di akhir sesi.

Fungsi ini menghapus duplikat tanpa menghapus indeks dan melakukannya ke tabel mana pun.

Pemakaian: select remove_duplicates('mytable');

---
--- remove_duplicates (tablename) menghapus catatan duplikat dari tabel (ubah dari set ke set unik)
---
BUAT ATAU GANTI FUNGSI remove_duplicates (teks) KEMBALI batal AS $$
MENYATAKAN
  tablename ALIAS UNTUK $ 1;
MULAI
  Jalankan 'BUAT TABEL TEMPORER _DISTINCT_' || tablename || 'AS (SELECT DISTINCT * FROM' || tablename || ');';
  Jalankan 'DELETE FROM' || tablename || ';';
  Jalankan 'INSERT INTO' || tablename || '(SELECT * FROM _DISTINCT_' || tablename || ');';
  LAKUKAN 'DROP TABLE _DISTINCT_' || tablename || ';';
  KEMBALI;
AKHIR;
$$ 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);

Jika Anda hanya memiliki satu atau beberapa entri duplikat, dan mereka memang duplikat (yaitu, muncul dua kali), Anda dapat menggunakan kolom "tersembunyi" ctid, seperti yang diusulkan di atas, bersama dengan LIMIT:

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

Ini hanya akan menghapus baris pertama yang dipilih.

Pertama, Anda perlu memutuskan "duplikat" mana yang akan Anda simpan. Jika semua kolom sama, OK, Anda dapat menghapus salah satu dari mereka ... Tetapi mungkin Anda hanya ingin menyimpan yang terbaru, atau beberapa kriteria lain?

Cara tercepat bergantung pada jawaban Anda atas pertanyaan di atas, dan juga pada% duplikat di tabel. Jika Anda membuang 50% baris Anda, lebih baik Anda melakukannya CREATE TABLE ... AS SELECT DISTINCT ... FROM ... ;, dan jika Anda menghapus 1% baris, menggunakan DELETE lebih baik.

Juga untuk operasi pemeliharaan seperti ini, umumnya baik untuk mengatur work_memsebagian besar RAM Anda: jalankan JELASKAN, periksa nomor N jenis / hash, dan setel work_mem ke RAM / 2 / N. Gunakan banyak RAM; itu bagus untuk kecepatan. Selama Anda hanya memiliki satu koneksi bersamaan ...

Saya bekerja dengan PostgreSQL 8.4. Ketika saya menjalankan kode yang diusulkan, saya menemukan bahwa itu tidak benar-benar menghapus duplikat. Dalam menjalankan beberapa tes, saya menemukan bahwa menambahkan "DISTINCT ON (duplikat_kolom_namaku)" dan "ORDER BY duplikat_kolom_namaku" berhasil. Saya bukan ahli SQL, saya menemukan ini di dokumen 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;

Ini bekerja dengan sangat baik dan sangat cepat:

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

Hapus duplikat menurut kolom dan pertahankan baris dengan id terendah. Polanya diambil dari wiki postgres

Dengan menggunakan CTE Anda dapat mencapai versi yang lebih mudah dibaca di atas melalui ini

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