这里一个非常常见的问题是如何进行upsert，这是MySQL调用的内容，INSERT ... ON DUPLICATE UPDATE并且该标准支持该MERGE操作。

鉴于PostgreSQL不直接支持它（在9.5版之前），您该怎么做？考虑以下：

CREATE TABLE testtable (
    id integer PRIMARY KEY,
    somedata text NOT NULL
);

INSERT INTO testtable (id, somedata) VALUES
(1, 'fred'),
(2, 'bob');

现在，假设你想“UPSERT”的元组(2, 'Joe')，(3, 'Alan')，因此新表的内容是：

(1, 'fred'),
(2, 'Joe'),    -- Changed value of existing tuple
(3, 'Alan')    -- Added new tuple

那就是人们在讨论时谈论的话题upsert。至关重要的是，在存在多个事务处理同一个表的情况下，任何方法都必须安全 -通过使用显式锁定或以其他方式抵御由此产生的竞争条件。

在插入中，关于PostgreSQL中的重复更新，对该主题进行了广泛讨论。，但这是关于MySQL语法的替代方法，并且随着时间的推移，它已经发展出了很多无关的细节。我正在努力确定答案。

这些技术还可用于“如果不存在则插入，否则不执行任何操作”，即“在重复键忽略时插入...”。

9.5及更高版本：

PostgreSQL 9.5和更高版本的支持INSERT ... ON CONFLICT UPDATE（和ON CONFLICT DO NOTHING），即upsert。

与的比较ON DUPLICATE KEY UPDATE。

快速解释。

有关用法，请参见手册，特别是语法图中的conflict_action子句和说明性文字。

与下面给出的9.4及更早版本的解决方案不同，此功能可用于多个冲突的行，并且不需要排他锁定或重试循环。

添加功能的提交在这里，关于功能开发的讨论在这里。

如果您使用的是9.5，并且不需要向后兼容，则可以立即停止阅读。

9.4及更高版本：

PostgreSQL没有任何内置UPSERT（或MERGE）功能，面对并发使用要高效地执行它非常困难。

本文详细讨论了该问题。

通常，您必须在两个选项之间进行选择：

• 重试循环中的各个插入/更新操作；要么
• 锁定表并进行批量合并

个别行重试循环

如果您希望多个连接同时尝试执行插入操作，则在重试循环中使用单个行向上插入是合理的选择。

PostgreSQL文档包含一个有用的过程，可让您在数据库内部循环执行此操作。与大多数幼稚的解决方案不同，它可以防止丢失更新和插入竞争。但是，它将仅在READ COMMITTED模式下工作，并且只有在事务中唯一执行时，它才是安全的。如果触发器或辅助唯一键导致唯一违规，则该功能将无法正常工作。

此策略效率很低。只要可行，您都应该将工作排入队列，并按如下所述进行批量追加。

许多尝试解决此问题的方法都没有考虑回滚，因此导致更新不完整。两笔交易相互竞争；他们的成功一个INSERTS; 另一个得到重复的密钥错误，UPDATE而是执行一个。UPDATE等待INSERT回滚或提交的块。当它回滚时，UPDATE条件重新检查匹配零行，因此，即使UPDATE提交实际上并没有完成您期望的更新。您必须检查结果行计数，并在必要时重试。

一些尝试的解决方案也没有考虑SELECT竞争。如果您尝试简单明了的方法：

-- THIS IS WRONG. DO NOT COPY IT. It's an EXAMPLE.

BEGIN;

UPDATE testtable
SET somedata = 'blah'
WHERE id = 2;

-- Remember, this is WRONG. Do NOT COPY IT.

INSERT INTO testtable (id, somedata)
SELECT 2, 'blah'
WHERE NOT EXISTS (SELECT 1 FROM testtable WHERE testtable.id = 2);

COMMIT;

那么当两个同时运行时，会出现几种故障模式。一个问题是已经讨论过的更新重新检查问题。另一个是两个都UPDATE同时匹配零行并继续的地方。然后，他们都做EXISTS测试，这恰好之前的INSERT。两者都获得零行，因此都获得INSERT。一个失败，重复密钥错误。

这就是为什么您需要重试循环的原因。您可能会认为，使用聪明的SQL可以防止重复的键错误或更新丢失，但是您不能这样做。您需要检查行计数或处理重复的键错误（取决于所选方法），然后重试。

请不要为此提出自己的解决方案。像消息队列一样，这可能是错误的。

带锁的批量更新

有时您想做一个批量上载，在这里您有一个新数据集要合并到一个旧的现有数据集中。这大大超过各行upserts更高效，更应是首选，只要实用。

在这种情况下，通常需要执行以下过程：

• CREATE一张TEMPORARY桌子

• COPY 或将新数据批量插入到临时表中

• LOCK目标表IN EXCLUSIVE MODE。这允许其他事务对SELECT表进行更改，但不能对其进行任何更改。

• 做一个UPDATE ... FROM的使用临时表中的值的现有记录;

• 做一个INSERT不已经在目标表中存在的行;

• COMMIT，释放锁。

例如，对于问题中给出的示例，使用多值INSERT填充临时表：

BEGIN;

CREATE TEMPORARY TABLE newvals(id integer, somedata text);

INSERT INTO newvals(id, somedata) VALUES (2, 'Joe'), (3, 'Alan');

LOCK TABLE testtable IN EXCLUSIVE MODE;

UPDATE testtable
SET somedata = newvals.somedata
FROM newvals
WHERE newvals.id = testtable.id;

INSERT INTO testtable
SELECT newvals.id, newvals.somedata
FROM newvals
LEFT OUTER JOIN testtable ON (testtable.id = newvals.id)
WHERE testtable.id IS NULL;

COMMIT;

相关阅读

• UPSERT Wiki页面
• Postgres中的UPSERTisms
• 插入，在PostgreSQL中重复更新吗？
• http://petereisentraut.blogspot.com/2010/05/merge-syntax.html
• 事务更新
• SELECT或INSERT函数是否易于出现竞争状况？
• MERGEPostgreSQL Wiki上的SQL
• 如今在Postgresql中实现UPSERT的最惯用方式

那MERGE呢

SQL标准MERGE实际上具有定义不明确的并发语义，因此不先锁定表就不适合进行上载。

对于数据合并，这是一个非常有用的OLAP语句，但对于并发安全的ups实际上，它并不是有用的解决方案。对于使用其他DBMS进行更新的人们有很多建议MERGE，但这实际上是错误的。

其他数据库：

• INSERT ... ON DUPLICATE KEY UPDATE 在MySQL中
• MERGE从MS SQL Server（但请参阅上面的MERGE问题）
• MERGE来自Oracle（但请参阅上面的MERGE问题）

我正在尝试为9.5之前版本的PostgreSQL的单插入问题提供另一种解决方案。这个想法只是尝试首先执行插入操作，如果记录已经存在，则对其进行更新：

do $$
begin 
  insert into testtable(id, somedata) values(2,'Joe');
exception when unique_violation then
  update testtable set somedata = 'Joe' where id = 2;
end $$;

请注意，只有在不删除表的行的情况下，才可以应用此解决方案。

我不知道这种解决方案的效率，但是在我看来这足够合理。

以下是insert ... on conflict ...（pg 9.5+）的一些示例：

• 发生冲突时插入- 不执行任何操作。

  insert into dummy(id, name, size) values(1, 'new_name', 3)
  on conflict do nothing;`  

• 插入后，在进行冲突更新时，通过column指定冲突目标。

  insert into dummy(id, name, size) values(1, 'new_name', 3)
  on conflict(id)
  do update set name = 'new_name', size = 3;  

• 在执行冲突更新时插入，通过约束名称指定冲突目标。

  insert into dummy(id, name, size) values(1, 'new_name', 3)
  on conflict on constraint dummy_pkey
  do update set name = 'new_name', size = 4;

Postgres> = 9.5的SQLAlchemy更新

由于上面的大篇文章涵盖了Postgres版本的许多不同SQL方法（不仅是非9.5的问题），如果您使用的是Postgres 9.5，我想在SQLAlchemy中添加操作方法。除了实现自己的upsert，您还可以使用SQLAlchemy的函数（已在SQLAlchemy 1.1中添加）。就个人而言，如果可能的话，我建议使用这些。不仅是因为方便，还因为它使PostgreSQL处理可能发生的任何竞争情况。

我昨天给出的另一个答案的交叉发布（https://stackoverflow.com/a/44395983/2156909）

SQLAlchemy的支持ON CONFLICT，现在有两种方法on_conflict_do_update()和on_conflict_do_nothing()：

从文档复制：

from sqlalchemy.dialects.postgresql import insert

stmt = insert(my_table).values(user_email='a@b.com', data='inserted data')
stmt = stmt.on_conflict_do_update(
    index_elements=[my_table.c.user_email],
    index_where=my_table.c.user_email.like('%@gmail.com'),
    set_=dict(data=stmt.excluded.data)
    )
conn.execute(stmt)

http://docs.sqlalchemy.org/en/latest/dialects/postgresql.html?highlight=conflict#insert-on-conflict-upsert

WITH UPD AS (UPDATE TEST_TABLE SET SOME_DATA = 'Joe' WHERE ID = 2 
RETURNING ID),
INS AS (SELECT '2', 'Joe' WHERE NOT EXISTS (SELECT * FROM UPD))
INSERT INTO TEST_TABLE(ID, SOME_DATA) SELECT * FROM INS

在Postgresql 9.3上测试

由于此问题已经关闭，因此我将在此处发布有关如何使用SQLAlchemy进行处理的信息。通过递归，它重试批量插入或更新以适应比赛条件和验证错误。

首先进口

import itertools as it

from functools import partial
from operator import itemgetter

from sqlalchemy.exc import IntegrityError
from app import session
from models import Posts

现在有几个助手功能

def chunk(content, chunksize=None):
    """Groups data into chunks each with (at most) `chunksize` items.
    https://stackoverflow.com/a/22919323/408556
    """
    if chunksize:
        i = iter(content)
        generator = (list(it.islice(i, chunksize)) for _ in it.count())
    else:
        generator = iter([content])

    return it.takewhile(bool, generator)


def gen_resources(records):
    """Yields a dictionary if the record's id already exists, a row object 
    otherwise.
    """
    ids = {item[0] for item in session.query(Posts.id)}

    for record in records:
        is_row = hasattr(record, 'to_dict')

        if is_row and record.id in ids:
            # It's a row but the id already exists, so we need to convert it 
            # to a dict that updates the existing record. Since it is duplicate,
            # also yield True
            yield record.to_dict(), True
        elif is_row:
            # It's a row and the id doesn't exist, so no conversion needed. 
            # Since it's not a duplicate, also yield False
            yield record, False
        elif record['id'] in ids:
            # It's a dict and the id already exists, so no conversion needed. 
            # Since it is duplicate, also yield True
            yield record, True
        else:
            # It's a dict and the id doesn't exist, so we need to convert it. 
            # Since it's not a duplicate, also yield False
            yield Posts(**record), False

最后是upsert功能

def upsert(data, chunksize=None):
    for records in chunk(data, chunksize):
        resources = gen_resources(records)
        sorted_resources = sorted(resources, key=itemgetter(1))

        for dupe, group in it.groupby(sorted_resources, itemgetter(1)):
            items = [g[0] for g in group]

            if dupe:
                _upsert = partial(session.bulk_update_mappings, Posts)
            else:
                _upsert = session.add_all

            try:
                _upsert(items)
                session.commit()
            except IntegrityError:
                # A record was added or deleted after we checked, so retry
                # 
                # modify accordingly by adding additional exceptions, e.g.,
                # except (IntegrityError, ValidationError, ValueError)
                db.session.rollback()
                upsert(items)
            except Exception as e:
                # Some other error occurred so reduce chunksize to isolate the 
                # offending row(s)
                db.session.rollback()
                num_items = len(items)

                if num_items > 1:
                    upsert(items, num_items // 2)
                else:
                    print('Error adding record {}'.format(items[0]))

使用方法如下

>>> data = [
...     {'id': 1, 'text': 'updated post1'}, 
...     {'id': 5, 'text': 'updated post5'}, 
...     {'id': 1000, 'text': 'new post1000'}]
... 
>>> upsert(data)

它具有的优势bulk_save_objects在于，它可以处理插入时的关系，错误检查等（与批量操作不同）。