Uma pergunta muito frequente aqui é como fazer um upsert, que é o que o MySQL chama INSERT ... ON DUPLICATE UPDATEe o padrão suporta como parte da MERGEoperação.

Dado que o PostgreSQL não o suporta diretamente (antes da página 9.5), como você faz isso? Considere o seguinte:

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

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

Agora imagine que você quer "Upsert" as tuplas (2, 'Joe'), (3, 'Alan'), de modo que os novos conteúdos de tabela seria:

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

É disso que as pessoas estão falando quando discutem um upsert. Fundamentalmente, qualquer abordagem deve ser segura na presença de várias transações trabalhando na mesma tabela - usando bloqueio explícito ou defendendo-se contra as condições de corrida resultantes.

Este tópico é discutido extensivamente no Insert, na atualização duplicada no PostgreSQL? , mas trata-se de alternativas à sintaxe do MySQL, e aumentou um pouco de detalhes não relacionados ao longo do tempo. Estou trabalhando em respostas definitivas.

Essas técnicas também são úteis para "inserir se não existir, caso contrário, não faça nada", ou seja, "inserir ... ao ignorar chave duplicada".

9.5 e mais recente:

PostgreSQL 9.5 e suporte mais recente INSERT ... ON CONFLICT UPDATE(e ON CONFLICT DO NOTHING), ou seja, upsert.

Comparação comON DUPLICATE KEY UPDATE .

Explicação rápida .

Para uso, consulte o manual - especificamente a cláusula conflito_ação no diagrama de sintaxe e o texto explicativo .

Ao contrário das soluções para a 9.4 e anteriores fornecidas abaixo, esse recurso funciona com várias linhas conflitantes e não requer bloqueio exclusivo ou loop de repetição.

O commit adicionando o recurso está aqui e a discussão sobre seu desenvolvimento está aqui .

Se você está na versão 9.5 e não precisa ser compatível com versões anteriores, pode parar de ler agora .

9.4 e mais velhos:

O PostgreSQL não tem nenhum built-in UPSERTMERGE recurso interno (ou ) e é muito difícil fazê-lo de maneira eficiente em face do uso simultâneo.

Este artigo discute o problema em detalhes úteis .

Em geral, você deve escolher entre duas opções:

• Operações individuais de inserção / atualização em um loop de repetição; ou
• Bloqueando a tabela e fazendo a mesclagem em lote

Loop de repetição de linha individual

O uso de upserts de linha individuais em um loop de repetição é a opção razoável se você desejar várias conexões simultaneamente tentando executar inserções.

A documentação do PostgreSQL contém um procedimento útil que permite fazer isso em um loop dentro do banco de dados . Ele protege contra atualizações perdidas e insere corridas, ao contrário das soluções mais ingênuas. Funcionará apenas emREAD COMMITTED modo e só será seguro se for a única coisa que você fizer na transação. A função não funcionará corretamente se acionadores ou chaves exclusivas secundárias causarem violações exclusivas.

Essa estratégia é muito ineficiente. Sempre que possível, você deve enfileirar o trabalho e fazer uma upsert em massa, conforme descrito abaixo.

Muitas soluções tentadas para esse problema não consideram reversões, portanto resultam em atualizações incompletas. Duas transações competem entre si; um deles com sucesso INSERTs; o outro recebe um erro de chave duplicada e, em UPDATEvez disso, executa um . Os UPDATEblocos aguardando INSERTa reversão ou confirmação. Quando é revertida, a UPDATEnova verificação da condição corresponde a zero linhas, mesmo que as UPDATEconfirmações não tenham feito o upsert esperado. Você deve verificar as contagens da linha de resultados e tentar novamente quando necessário.

Algumas soluções tentadas também não consideram as corridas SELECT. Se você tentar o óbvio e simples:

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

então, quando dois executam ao mesmo tempo, existem vários modos de falha. Uma é a questão já discutida com uma nova verificação de atualização. Outro é onde ambos UPDATEao mesmo tempo, combinando zero linhas e continuando. Em seguida, ambos fazem o EXISTSteste, o que acontece antes do INSERT. Ambos têm zero linhas, e ambos fazem o INSERT. Um falha com um erro de chave duplicada.

É por isso que você precisa de um loop de repetição. Você pode pensar que pode evitar erros de chave duplicados ou atualizações perdidas com o SQL inteligente, mas não pode. Você precisa verificar a contagem de linhas ou manipular erros de chave duplicados (dependendo da abordagem escolhida) e tentar novamente.

Por favor, não role sua própria solução para isso. Como na fila de mensagens, provavelmente está errado.

Upsert a granel com trava

Às vezes, você deseja fazer uma upsert em massa, em que possui um novo conjunto de dados que deseja mesclar em um conjunto de dados existente mais antigo. Isso é muito mais eficiente do que upserts individuais de linha e deve ser preferido sempre que possível.

Nesse caso, você normalmente segue o seguinte processo:

• CREATEuma TEMPORARYmesa

• COPY ou insira em massa os novos dados na tabela temporária

• LOCKa tabela de destino IN EXCLUSIVE MODE. Isso permite que outras transações SELECT, mas não façam alterações na tabela.

• Faça um UPDATE ... FROMdos registros existentes usando os valores na tabela temporária;

• Faça uma INSERTdas linhas que ainda não existem na tabela de destino;

• COMMIT, liberando a trava.

Por exemplo, para o exemplo fornecido na pergunta, usando valores múltiplos INSERTpara preencher a tabela temporária:

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;

Leitura relacionada

• Página wiki da UPSERT
• UPSERTisms no Postgres
• Inserir, em atualização duplicada no PostgreSQL?
• http://petereisentraut.blogspot.com/2010/05/merge-syntax.html
• Upsert com uma transação
• SELECT ou INSERT em uma função propensa a condições de corrida?
• SQL MERGEno wiki do PostgreSQL
• A maneira mais idiomática de implementar o UPSERT no Postgresql hoje em dia

A respeito MERGE ?

Padrão SQL MERGENa verdade, o possui semânticas de concorrência mal definidas e não é adequado para upserting sem bloquear uma tabela primeiro.

É uma instrução OLAP realmente útil para mesclagem de dados, mas na verdade não é uma solução útil para upsert com segurança de simultaneidade. Há muitos conselhos para as pessoas que usam outros DBMSes para usarMERGE DBMSes para upserts, mas na verdade está errado.

Outros bancos de dados:

• INSERT ... ON DUPLICATE KEY UPDATE no MySQL
• MERGEdo MS SQL Server (mas veja acima sobre MERGEproblemas)
• MERGEda Oracle (mas veja acima sobre MERGEproblemas)

Estou tentando contribuir com outra solução para o problema de inserção única nas versões anteriores ao 9.5 do PostgreSQL. A idéia é simplesmente tentar executar primeiro a inserção e, caso o registro já esteja presente, atualizá-lo:

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

Observe que esta solução pode ser aplicada apenas se não houver exclusões de linhas da tabela .

Eu não sei sobre a eficiência desta solução, mas me parece razoável o suficiente.

Aqui estão alguns exemplos para insert ... on conflict ...(página 9.5+ ):

• Inserir, em conflito - não faça nada .

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

• Inserir, em conflito - atualize , especifique o destino do conflito por meio da coluna .

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

• Inserir, em conflito - atualize , especifique o destino do conflito por meio do nome da restrição .

  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;

SQLAlchemy upsert para Postgres> = 9.5

Como a postagem grande acima cobre muitas abordagens SQL diferentes para as versões do Postgres (não apenas as 9.5 como na pergunta), gostaria de adicionar como fazê-lo no SQLAlchemy se você estiver usando o Postgres 9.5. Em vez de implementar seu próprio upsert, você também pode usar as funções do SQLAlchemy (que foram adicionadas no SQLAlchemy 1.1). Pessoalmente, eu recomendaria usá-los, se possível. Não apenas por conveniência, mas também porque permite ao PostgreSQL lidar com quaisquer condições de corrida que possam ocorrer.

Postagem cruzada de outra resposta que eu dei ontem ( https://stackoverflow.com/a/44395983/2156909 )

O SQLAlchemy suporta ON CONFLICTagora com dois métodos on_conflict_do_update()e on_conflict_do_nothing():

Copiando da documentação:

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

Testado no Postgresql 9.3

Como essa pergunta foi encerrada, estou postando aqui como você faz isso usando SQLAlchemy. Por recursão, ele tenta novamente uma inserção ou atualização em massa para combater condições de corrida e erros de validação.

Primeiro as importações

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

Agora, algumas funções auxiliares

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

E, finalmente, a função 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]))

Veja como você o usa

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

A vantagem disso bulk_save_objectsé que ele pode lidar com relacionamentos, verificação de erros etc. na inserção (ao contrário das operações em massa ).