Sisipkan, pada pembaruan duplikat di PostgreSQL?

Beberapa bulan yang lalu saya belajar dari jawaban di Stack Overflow bagaimana melakukan beberapa pembaruan sekaligus di MySQL menggunakan sintaks berikut:

INSERT INTO table (id, field, field2) VALUES (1, A, X), (2, B, Y), (3, C, Z)
ON DUPLICATE KEY UPDATE field=VALUES(Col1), field2=VALUES(Col2);

Saya sekarang telah beralih ke PostgreSQL dan ternyata ini tidak benar. Ini merujuk pada semua tabel yang benar jadi saya menganggap itu masalah kata kunci yang berbeda yang digunakan, tetapi saya tidak yakin di mana dalam dokumentasi PostgreSQL ini dibahas.

Untuk memperjelas, saya ingin memasukkan beberapa hal dan jika sudah ada untuk memperbaruinya.

PostgreSQL sejak versi 9.5 memiliki sintaks UPSERT , dengan klausa ON CONFLICT . dengan sintaks berikut (mirip dengan MySQL)

INSERT INTO the_table (id, column_1, column_2) 
VALUES (1, 'A', 'X'), (2, 'B', 'Y'), (3, 'C', 'Z')
ON CONFLICT (id) DO UPDATE 
  SET column_1 = excluded.column_1, 
      column_2 = excluded.column_2;

Mencari arsip grup email postgresql untuk "upert" mengarah ke menemukan contoh melakukan apa yang mungkin ingin Anda lakukan, dalam manual :

Contoh 38-2. Pengecualian dengan UPDATE / INSERT

Contoh ini menggunakan penanganan pengecualian untuk melakukan UPDATE atau INSERT, jika perlu:

CREATE TABLE db (a INT PRIMARY KEY, b TEXT);

CREATE FUNCTION merge_db(key INT, data TEXT) RETURNS VOID AS
$$
BEGIN
    LOOP
        -- first try to update the key
        -- note that "a" must be unique
        UPDATE db SET b = data WHERE a = key;
        IF found THEN
            RETURN;
        END IF;
        -- not there, so try to insert the key
        -- if someone else inserts the same key concurrently,
        -- we could get a unique-key failure
        BEGIN
            INSERT INTO db(a,b) VALUES (key, data);
            RETURN;
        EXCEPTION WHEN unique_violation THEN
            -- do nothing, and loop to try the UPDATE again
        END;
    END LOOP;
END;
$$
LANGUAGE plpgsql;

SELECT merge_db(1, 'david');
SELECT merge_db(1, 'dennis');

Mungkin ada contoh bagaimana melakukan ini secara massal, menggunakan CTE di 9.1 dan di atas, di milis peretas :

WITH foos AS (SELECT (UNNEST(%foo[])).*)
updated as (UPDATE foo SET foo.a = foos.a ... RETURNING foo.id)
INSERT INTO foo SELECT foos.* FROM foos LEFT JOIN updated USING(id)
WHERE updated.id IS NULL;

Lihat jawaban a_horse_with_no_name untuk contoh yang lebih jelas.

Peringatan: ini tidak aman jika dijalankan dari beberapa sesi secara bersamaan (lihat peringatan di bawah).

Cara pintar lain untuk melakukan "UPSERT" di postgresql adalah dengan melakukan dua pernyataan UPDATE / INSERT berurutan yang masing-masing dirancang untuk berhasil atau tidak berpengaruh.

UPDATE table SET field='C', field2='Z' WHERE id=3;
INSERT INTO table (id, field, field2)
       SELECT 3, 'C', 'Z'
       WHERE NOT EXISTS (SELECT 1 FROM table WHERE id=3);

UPDATE akan berhasil jika baris dengan "id = 3" sudah ada, jika tidak maka tidak akan berpengaruh.

INSERT hanya akan berhasil jika baris dengan "id = 3" tidak ada.

Anda dapat menggabungkan keduanya menjadi satu string dan menjalankan keduanya dengan mengeksekusi pernyataan SQL tunggal dari aplikasi Anda. Sangat disarankan untuk menjalankannya bersama dalam satu transaksi.

Ini bekerja dengan sangat baik ketika dijalankan dalam isolasi atau di atas meja yang terkunci, tetapi tunduk pada kondisi balapan yang berarti ia mungkin masih gagal dengan kesalahan kunci duplikat jika sebuah baris dimasukkan secara bersamaan, atau mungkin berakhir tanpa baris yang dimasukkan ketika sebuah baris dihapus bersamaan. . SEBUAHSERIALIZABLE transaksi pada PostgreSQL 9.1 atau lebih tinggi akan menanganinya dengan andal dengan biaya tingkat kegagalan serialisasi yang sangat tinggi, artinya Anda harus banyak mencoba. Lihat mengapa begitu rumit , yang membahas kasus ini secara lebih rinci.

Pendekatan ini juga tunduk pada pembaruan yang hilang secara read committedterpisah kecuali jika aplikasi memeriksa jumlah baris yang terpengaruh dan memverifikasi bahwa salah satu insertatau baris yang updateterpengaruh .

Dengan PostgreSQL 9.1 ini dapat dicapai menggunakan CTE yang dapat ditulis ( ekspresi tabel umum ):

WITH new_values (id, field1, field2) as (
  values 
     (1, 'A', 'X'),
     (2, 'B', 'Y'),
     (3, 'C', 'Z')

),
upsert as
( 
    update mytable m 
        set field1 = nv.field1,
            field2 = nv.field2
    FROM new_values nv
    WHERE m.id = nv.id
    RETURNING m.*
)
INSERT INTO mytable (id, field1, field2)
SELECT id, field1, field2
FROM new_values
WHERE NOT EXISTS (SELECT 1 
                  FROM upsert up 
                  WHERE up.id = new_values.id)

Lihat entri blog ini:

• Upserting via CTE yang Dapat Ditulis
• MENUNGGU 9.1 - CTE MENULIS
• MENGAPA UPSERT SANGAT KOMPPLIKASI?

Perhatikan bahwa solusi ini tidak mencegah pelanggaran kunci unik tetapi tidak rentan terhadap pembaruan yang hilang.
Lihat tindak lanjut oleh Craig Ringer di dba.stackexchange.com

Di PostgreSQL 9.5 dan yang lebih baru, Anda dapat menggunakan INSERT ... ON CONFLICT UPDATE .

Lihat dokumentasi .

MySQL INSERT ... ON DUPLICATE KEY UPDATEdapat secara langsung diulang menjadi ON CONFLICT UPDATE. Sintaks standar-SQL juga tidak, keduanya merupakan ekstensi khusus basis data. Ada alasan bagus MERGEyang tidak digunakan untuk ini , sintaks baru tidak dibuat hanya untuk bersenang-senang. (Sintaks MySQL juga memiliki masalah yang berarti tidak diadopsi secara langsung).

mis. pengaturan yang diberikan:

CREATE TABLE tablename (a integer primary key, b integer, c integer);
INSERT INTO tablename (a, b, c) values (1, 2, 3);

permintaan MySQL:

INSERT INTO tablename (a,b,c) VALUES (1,2,3)
  ON DUPLICATE KEY UPDATE c=c+1;

menjadi:

INSERT INTO tablename (a, b, c) values (1, 2, 10)
ON CONFLICT (a) DO UPDATE SET c = tablename.c + 1;

Perbedaan:

• Anda harus menentukan nama kolom (atau nama kendala unik) yang akan digunakan untuk pemeriksaan keunikan. Itu adalahON CONFLICT (columnname) DO

• Kata kunci SETharus digunakan, seolah-olah ini adalah UPDATEpernyataan normal

Ini memiliki beberapa fitur bagus juga:

• Anda dapat memiliki WHEREklausa pada Anda UPDATE(membiarkan Anda secara efektif berubah ON CONFLICT UPDATEmenjadi ON CONFLICT IGNOREuntuk nilai-nilai tertentu)

• Nilai usulan untuk penyisipan tersedia sebagai variabel baris EXCLUDED, yang memiliki struktur yang sama dengan tabel target. Anda bisa mendapatkan nilai asli di tabel dengan menggunakan nama tabel. Jadi dalam hal ini EXCLUDED.cakan 10(karena itulah yang kami coba masukkan) dan "table".cakan 3karena itulah nilai saat ini dalam tabel. Anda dapat menggunakan salah satu atau keduanya dalam SETekspresi dan WHEREklausa.

Untuk latar belakang tentang upsert, lihat Cara UPSERT (MERGE, INSERT ... ON DUPLICATE UPDATE) di PostgreSQL?

Saya sedang mencari hal yang sama ketika saya datang ke sini, tetapi kurangnya fungsi "upsert" generik sedikit mengganggu saya, jadi saya pikir Anda bisa melewati pembaruan dan memasukkan sql sebagai argumen pada fungsi yang membentuk manual

akan terlihat seperti ini:

CREATE FUNCTION upsert (sql_update TEXT, sql_insert TEXT)
    RETURNS VOID
    LANGUAGE plpgsql
AS $$
BEGIN
    LOOP
        -- first try to update
        EXECUTE sql_update;
        -- check if the row is found
        IF FOUND THEN
            RETURN;
        END IF;
        -- not found so insert the row
        BEGIN
            EXECUTE sql_insert;
            RETURN;
            EXCEPTION WHEN unique_violation THEN
                -- do nothing and loop
        END;
    END LOOP;
END;
$$;

dan mungkin untuk melakukan apa yang awalnya ingin Anda lakukan, batch "upsert", Anda bisa menggunakan Tcl untuk membagi sql_update dan loop pembaruan individu, hit dalm kinerja akan sangat kecil lihat http://archives.postgresql.org/pgsql- performance / 2006-04 / msg00557.php

biaya tertinggi adalah mengeksekusi kueri dari kode Anda, di sisi database biaya eksekusi jauh lebih kecil

Tidak ada perintah sederhana untuk melakukannya.

Pendekatan yang paling benar adalah dengan menggunakan fungsi, seperti yang dari dokumen .

Solusi lain (meskipun tidak aman) adalah melakukan pembaruan dengan mengembalikan, memeriksa baris mana yang diperbarui, dan menyisipkan sisanya

Sesuatu di sepanjang garis:

update table
set column = x.column
from (values (1,'aa'),(2,'bb'),(3,'cc')) as x (id, column)
where table.id = x.id
returning id;

dengan asumsi id: 2 dikembalikan:

insert into table (id, column) values (1, 'aa'), (3, 'cc');

Tentu saja itu akan menebus cepat atau lambat (di lingkungan bersamaan), karena ada kondisi balapan yang jelas di sini, tetapi biasanya itu akan berhasil.

Inilah artikel yang lebih panjang dan lebih komprehensif tentang topik ini .

Secara pribadi, saya telah membuat "aturan" yang terlampir pada pernyataan insert. Katakanlah Anda memiliki tabel "dns" yang mencatat hit dns per pelanggan berdasarkan per-waktu:

CREATE TABLE dns (
    "time" timestamp without time zone NOT NULL,
    customer_id integer NOT NULL,
    hits integer
);

Anda ingin dapat memasukkan kembali baris dengan nilai yang diperbarui, atau membuatnya jika belum ada. Mengetik pada customer_id dan waktu. Sesuatu seperti ini:

CREATE RULE replace_dns AS 
    ON INSERT TO dns 
    WHERE (EXISTS (SELECT 1 FROM dns WHERE ((dns."time" = new."time") 
            AND (dns.customer_id = new.customer_id)))) 
    DO INSTEAD UPDATE dns 
        SET hits = new.hits 
        WHERE ((dns."time" = new."time") AND (dns.customer_id = new.customer_id));

Pembaruan: Ini berpotensi gagal jika memasukkan secara bersamaan, karena akan menghasilkan pengecualian unique_violation. Namun, transaksi yang tidak dihentikan akan berlanjut dan berhasil, dan Anda hanya perlu mengulangi transaksi yang dihentikan.

Namun, jika ada banyak sisipan yang terjadi sepanjang waktu, Anda harus meletakkan kunci meja di sekitar pernyataan penyisipan: SHARE ROW EKSKLUSIF mengunci akan mencegah operasi apa pun yang bisa menyisipkan, menghapus atau memperbarui baris di tabel target Anda. Namun, pembaruan yang tidak memperbarui kunci unik aman, jadi jika Anda tidak melakukan operasi akan melakukan ini, gunakan kunci penasihat sebagai gantinya.

Selain itu, perintah COPY tidak menggunakan ATURAN, jadi jika Anda memasukkan dengan COPY, Anda harus menggunakan pemicu.

Saya menggunakan fungsi ini menggabungkan

CREATE OR REPLACE FUNCTION merge_tabla(key INT, data TEXT)
  RETURNS void AS
$BODY$
BEGIN
    IF EXISTS(SELECT a FROM tabla WHERE a = key)
        THEN
            UPDATE tabla SET b = data WHERE a = key;
        RETURN;
    ELSE
        INSERT INTO tabla(a,b) VALUES (key, data);
        RETURN;
    END IF;
END;
$BODY$
LANGUAGE plpgsql

Saya kustom fungsi "upsert" di atas, jika Anda ingin menyisipkan DAN MENGGANTI:

`

 CREATE OR REPLACE FUNCTION upsert(sql_insert text, sql_update text)

 RETURNS void AS
 $BODY$
 BEGIN
    -- first try to insert and after to update. Note : insert has pk and update not...

    EXECUTE sql_insert;
    RETURN;
    EXCEPTION WHEN unique_violation THEN
    EXECUTE sql_update; 
    IF FOUND THEN 
        RETURN; 
    END IF;
 END;
 $BODY$
 LANGUAGE plpgsql VOLATILE
 COST 100;
 ALTER FUNCTION upsert(text, text)
 OWNER TO postgres;`

Dan setelah dieksekusi, lakukan sesuatu seperti ini:

SELECT upsert($$INSERT INTO ...$$,$$UPDATE... $$)

Sangat penting untuk menempatkan koma dolar ganda untuk menghindari kesalahan kompiler

• periksa kecepatan ...

Mirip dengan jawaban yang paling disukai, tetapi bekerja sedikit lebih cepat:

WITH upsert AS (UPDATE spider_count SET tally=1 WHERE date='today' RETURNING *)
INSERT INTO spider_count (spider, tally) SELECT 'Googlebot', 1 WHERE NOT EXISTS (SELECT * FROM upsert)

(sumber: http://www.the-art-of-web.com/sql/upsert/ )

Saya memiliki masalah yang sama untuk mengelola pengaturan akun sebagai pasangan nilai nama. Kriteria desain adalah bahwa klien yang berbeda dapat memiliki set pengaturan yang berbeda.

Solusi saya, mirip dengan JWP adalah menghapus dan mengganti secara massal, menghasilkan catatan gabungan dalam aplikasi Anda.

Ini cukup antipeluru, platform independen dan karena tidak pernah ada lebih dari sekitar 20 pengaturan per klien, ini hanya 3 panggilan db beban yang cukup rendah - mungkin metode tercepat.

Alternatif memperbarui setiap baris - memeriksa pengecualian kemudian memasukkan - atau kombinasi dari kode yang mengerikan, lambat dan sering rusak karena (seperti yang disebutkan di atas) penanganan pengecualian non standar SQL berubah dari db ke db - atau bahkan rilis untuk dirilis.

 #This is pseudo-code - within the application:
 BEGIN TRANSACTION - get transaction lock
 SELECT all current name value pairs where id = $id into a hash record
 create a merge record from the current and update record
  (set intersection where shared keys in new win, and empty values in new are deleted).
 DELETE all name value pairs where id = $id
 COPY/INSERT merged records 
 END TRANSACTION

Menurut dokumentasi INSERTpernyataan PostgreSQL , penanganan ON DUPLICATE KEYkasus tidak didukung. Itu bagian dari sintaks adalah ekstensi MySQL milik.

CREATE OR REPLACE FUNCTION save_user(_id integer, _name character varying)
  RETURNS boolean AS
$BODY$
BEGIN
    UPDATE users SET name = _name WHERE id = _id;
    IF FOUND THEN
        RETURN true;
    END IF;
    BEGIN
        INSERT INTO users (id, name) VALUES (_id, _name);
    EXCEPTION WHEN OTHERS THEN
            UPDATE users SET name = _name WHERE id = _id;
        END;
    RETURN TRUE;
END;

$BODY$
  LANGUAGE plpgsql VOLATILE STRICT

Untuk menggabungkan set kecil, menggunakan fungsi di atas baik-baik saja. Namun, jika Anda menggabungkan data dalam jumlah besar, saya sarankan melihat ke http://mbk.projects.postgresql.org

Praktik terbaik saat ini yang saya ketahui adalah:

1. SALINKAN data baru / diperbarui ke dalam tabel temp (pasti, atau Anda dapat melakukan INSERT jika biayanya ok)
2. Acquire Lock [opsional] (saran lebih baik daripada kunci meja, IMO)
3. Menggabungkan. (bagian yang menyenangkan)

UPDATE akan mengembalikan jumlah baris yang dimodifikasi. Jika Anda menggunakan JDBC (Java), Anda dapat memeriksa nilai ini terhadap 0 dan, jika tidak ada baris yang terpengaruh, jalankan INSERT. Jika Anda menggunakan bahasa pemrograman lain, mungkin jumlah baris yang dimodifikasi masih dapat diperoleh, periksa dokumentasi.

Ini mungkin tidak elegan, tetapi Anda memiliki SQL sederhana yang lebih sepele untuk digunakan dari kode panggilan. Secara berbeda, jika Anda menulis skrip sepuluh baris dalam PL / PSQL, Anda mungkin harus memiliki unit test dari satu atau jenis lain hanya untuk itu saja.

Sunting: Ini tidak berfungsi seperti yang diharapkan. Tidak seperti jawaban yang diterima, ini menghasilkan pelanggaran kunci unik ketika dua proses berulang kali memanggilupsert_foo secara bersamaan.

Eureka! Saya menemukan cara untuk melakukannya dalam satu permintaan: gunakan UPDATE ... RETURNINGuntuk menguji apakah ada baris yang terpengaruh:

CREATE TABLE foo (k INT PRIMARY KEY, v TEXT);

CREATE FUNCTION update_foo(k INT, v TEXT)
RETURNS SETOF INT AS $$
    UPDATE foo SET v = $2 WHERE k = $1 RETURNING $1
$$ LANGUAGE sql;

CREATE FUNCTION upsert_foo(k INT, v TEXT)
RETURNS VOID AS $$
    INSERT INTO foo
        SELECT $1, $2
        WHERE NOT EXISTS (SELECT update_foo($1, $2))
$$ LANGUAGE sql;

The UPDATEharus dilakukan dalam prosedur yang terpisah karena, sayangnya, ini adalah kesalahan sintaks:

... WHERE NOT EXISTS (UPDATE ...)

Sekarang berfungsi sesuai keinginan:

SELECT upsert_foo(1, 'hi');
SELECT upsert_foo(1, 'bye');
SELECT upsert_foo(3, 'hi');
SELECT upsert_foo(3, 'bye');