Postgres: INSERT se já não existir

Estou usando o Python para escrever em um banco de dados postgres:

sql_string = "INSERT INTO hundred (name,name_slug,status) VALUES ("
sql_string += hundred + ", '" + hundred_slug + "', " + status + ");"
cursor.execute(sql_string)

Mas como algumas das minhas linhas são idênticas, recebo o seguinte erro:

psycopg2.IntegrityError: duplicate key value  
  violates unique constraint "hundred_pkey"

Como posso escrever uma instrução SQL 'INSERT, a menos que essa linha já exista'?

Eu já vi declarações complexas como esta recomendadas:

IF EXISTS (SELECT * FROM invoices WHERE invoiceid = '12345')
UPDATE invoices SET billed = 'TRUE' WHERE invoiceid = '12345'
ELSE
INSERT INTO invoices (invoiceid, billed) VALUES ('12345', 'TRUE')
END IF

Mas, em primeiro lugar, é um exagero para o que eu preciso e, em segundo lugar, como posso executar um deles como uma sequência simples?

O Postgres 9.5 (lançado desde 07-01-2016) oferece um comando "upsert" , também conhecido como cláusula ON CONFLICT, para INSERT :

INSERT ... ON CONFLICT DO NOTHING/UPDATE

Ele resolve muitos dos problemas sutis que você pode encontrar ao usar a operação simultânea, que algumas outras respostas propõem.

Como posso escrever uma instrução SQL 'INSERT, a menos que essa linha já exista'?

Existe uma boa maneira de fazer INSERT condicional no PostgreSQL:

INSERT INTO example_table
    (id, name)
SELECT 1, 'John'
WHERE
    NOT EXISTS (
        SELECT id FROM example_table WHERE id = 1
    );

CAVEAT Essa abordagem não é 100% confiável para operações de gravação simultâneas . Existe uma condição de raça muito pequena entre SELECTo NOT EXISTSanti-semi-join e o INSERTpróprio. Ele pode falhar sob tais condições.

Uma abordagem seria criar uma tabela não restrita (sem índices exclusivos) para inserir todos os seus dados e fazer uma seleção distinta daquela para fazer sua inserção na sua tabela de cem.

Tão alto nível seria. Suponho que todas as três colunas sejam distintas no meu exemplo, portanto, para a etapa 3, altere a junção NOT EXITS para ingressar apenas nas colunas exclusivas da tabela de cem.

1. Crie tabela temporária. Veja os documentos aqui .

   CREATE TEMPORARY TABLE temp_data(name, name_slug, status);

2. INSERIR Dados na tabela temporária.

   INSERT INTO temp_data(name, name_slug, status); 

3. Adicione quaisquer índices à tabela temporária.

4. Faça a inserção da tabela principal.

   INSERT INTO hundred(name, name_slug, status) 
       SELECT DISTINCT name, name_slug, status
       FROM hundred
       WHERE NOT EXISTS (
           SELECT 'X' 
           FROM temp_data
           WHERE 
               temp_data.name          = hundred.name
               AND temp_data.name_slug = hundred.name_slug
               AND temp_data.status    = status
       );

Infelizmente, PostgreSQLnão suporta nem MERGEnem ON DUPLICATE KEY UPDATE, então você terá que fazer isso em duas instruções:

UPDATE  invoices
SET     billed = 'TRUE'
WHERE   invoices = '12345'

INSERT
INTO    invoices (invoiceid, billed)
SELECT  '12345', 'TRUE'
WHERE   '12345' NOT IN
        (
        SELECT  invoiceid
        FROM    invoices
        )

Você pode envolvê-lo em uma função:

CREATE OR REPLACE FUNCTION fn_upd_invoices(id VARCHAR(32), billed VARCHAR(32))
RETURNS VOID
AS
$$
        UPDATE  invoices
        SET     billed = $2
        WHERE   invoices = $1;

        INSERT
        INTO    invoices (invoiceid, billed)
        SELECT  $1, $2
        WHERE   $1 NOT IN
                (
                SELECT  invoiceid
                FROM    invoices
                );
$$
LANGUAGE 'sql';

e apenas chame:

SELECT  fn_upd_invoices('12345', 'TRUE')

Você pode usar VALUES - disponível no Postgres:

INSERT INTO person (name)
    SELECT name FROM person
    UNION 
    VALUES ('Bob')
    EXCEPT
    SELECT name FROM person;

Eu sei que essa pergunta é de um tempo atrás, mas achei que isso poderia ajudar alguém. Eu acho que a maneira mais fácil de fazer isso é através de um gatilho. Por exemplo:

Create Function ignore_dups() Returns Trigger
As $$
Begin
    If Exists (
        Select
            *
        From
            hundred h
        Where
            -- Assuming all three fields are primary key
            h.name = NEW.name
            And h.hundred_slug = NEW.hundred_slug
            And h.status = NEW.status
    ) Then
        Return NULL;
    End If;
    Return NEW;
End;
$$ Language plpgsql;

Create Trigger ignore_dups
    Before Insert On hundred
    For Each Row
    Execute Procedure ignore_dups();

Execute esse código em um prompt do psql (ou como você deseja executar consultas diretamente no banco de dados). Então você pode inserir normalmente do Python. Por exemplo:

sql = "Insert Into hundreds (name, name_slug, status) Values (%s, %s, %s)"
cursor.execute(sql, (hundred, hundred_slug, status))

Observe que, como o @Thomas_Wouters já mencionado, o código acima aproveita os parâmetros em vez de concatenar a string.

Existe uma boa maneira de fazer INSERT condicional no PostgreSQL usando a consulta WITH:

WITH a as(
select 
 id 
from 
 schema.table_name 
where 
 column_name = your_identical_column_value
)
INSERT into 
 schema.table_name
(col_name1, col_name2)
SELECT
    (col_name1, col_name2)
WHERE NOT EXISTS (
     SELECT
         id
     FROM
         a
        )
  RETURNING id 

Este é exatamente o problema que enfrento e minha versão é 9.5

E eu resolvo isso com a consulta SQL abaixo.

INSERT INTO example_table (id, name)
SELECT 1 AS id, 'John' AS name FROM example_table
WHERE NOT EXISTS(
            SELECT id FROM example_table WHERE id = 1
    )
LIMIT 1;

Espero que ajude alguém que tenha o mesmo problema com a versão> = 9.5.

Obrigado pela leitura.

INSERIR .. ONDE NÃO EXISTE é uma boa abordagem. E as condições de corrida podem ser evitadas pela transação "envelope":

BEGIN;
LOCK TABLE hundred IN SHARE ROW EXCLUSIVE MODE;
INSERT ... ;
COMMIT;

É fácil com as regras:

CREATE RULE file_insert_defer AS ON INSERT TO file
WHERE (EXISTS ( SELECT * FROM file WHERE file.id = new.id)) DO INSTEAD NOTHING

Mas falha com gravações simultâneas ...

A abordagem com os mais votados (de John Doe) funciona de alguma forma para mim, mas, no meu caso, das 422 linhas esperadas, recebo apenas 180. Não consegui encontrar nada errado e não há erros, por isso procurei uma solução diferente. abordagem simples.

Usar IF NOT FOUND THENdepois de SELECTapenas funciona perfeitamente para mim.

(descrito na documentação do PostgreSQL )

Exemplo da documentação:

SELECT * INTO myrec FROM emp WHERE empname = myname;
IF NOT FOUND THEN
  RAISE EXCEPTION 'employee % not found', myname;
END IF;

A classe de cursor psycopgs possui o atributo rowcount .

Esse atributo somente leitura especifica o número de linhas que a última execução * () produziu (para instruções DQL como SELECT) ou afetou (para instruções DML como UPDATE ou INSERT).

Portanto, você pode tentar UPDATE primeiro e INSERT apenas se o número de linhas for 0.

Mas, dependendo dos níveis de atividade em seu banco de dados, você pode atingir uma condição de corrida entre UPDATE e INSERT, onde outro processo pode criar esse registro nesse ínterim.

Sua coluna "cem" parece ser definida como chave primária e, portanto, deve ser única, o que não é o caso. O problema não é com os seus dados.

Sugiro que você insira um ID como tipo de série para manusear a chave primária

Se você disser que muitas de suas linhas são idênticas, você terminará a verificação várias vezes. Você pode enviá-los e o banco de dados determinará se o inserirá ou não com a cláusula ON CONFLICT da seguinte maneira

  INSERT INTO Hundred (name,name_slug,status) VALUES ("sql_string += hundred  
  +",'" + hundred_slug + "', " + status + ") ON CONFLICT ON CONSTRAINT
  hundred_pkey DO NOTHING;" cursor.execute(sql_string);

Eu estava procurando uma solução semelhante, tentando encontrar SQL que funcionasse no PostgreSQL e no HSQLDB. (Foi o HSQLDB que tornou isso difícil.) Usando o seu exemplo como base, este é o formato que encontrei em outro lugar.

sql = "INSERT INTO hundred (name,name_slug,status)"
sql += " ( SELECT " + hundred + ", '" + hundred_slug + "', " + status
sql += " FROM hundred"
sql += " WHERE name = " + hundred + " AND name_slug = '" + hundred_slug + "' AND status = " + status
sql += " HAVING COUNT(*) = 0 );"

Aqui está uma função python genérica que, com um nome de tabela, colunas e valores, gera o equivalente de upsert para o postgresql.

json de importação

def upsert(table_name, id_column, other_columns, values_hash):

    template = """
    WITH new_values ($$ALL_COLUMNS$$) as (
      values
         ($$VALUES_LIST$$)
    ),
    upsert as
    (
        update $$TABLE_NAME$$ m
            set
                $$SET_MAPPINGS$$
        FROM new_values nv
        WHERE m.$$ID_COLUMN$$ = nv.$$ID_COLUMN$$
        RETURNING m.*
    )
    INSERT INTO $$TABLE_NAME$$ ($$ALL_COLUMNS$$)
    SELECT $$ALL_COLUMNS$$
    FROM new_values
    WHERE NOT EXISTS (SELECT 1
                      FROM upsert up
                      WHERE up.$$ID_COLUMN$$ = new_values.$$ID_COLUMN$$)
    """

    all_columns = [id_column] + other_columns
    all_columns_csv = ",".join(all_columns)
    all_values_csv = ','.join([query_value(values_hash[column_name]) for column_name in all_columns])
    set_mappings = ",".join([ c+ " = nv." +c for c in other_columns])

    q = template
    q = q.replace("$$TABLE_NAME$$", table_name)
    q = q.replace("$$ID_COLUMN$$", id_column)
    q = q.replace("$$ALL_COLUMNS$$", all_columns_csv)
    q = q.replace("$$VALUES_LIST$$", all_values_csv)
    q = q.replace("$$SET_MAPPINGS$$", set_mappings)

    return q


def query_value(value):
    if value is None:
        return "NULL"
    if type(value) in [str, unicode]:
        return "'%s'" % value.replace("'", "''")
    if type(value) == dict:
        return "'%s'" % json.dumps(value).replace("'", "''")
    if type(value) == bool:
        return "%s" % value
    if type(value) == int:
        return "%s" % value
    return value


if __name__ == "__main__":

    my_table_name = 'mytable'
    my_id_column = 'id'
    my_other_columns = ['field1', 'field2']
    my_values_hash = {
        'id': 123,
        'field1': "john",
        'field2': "doe"
    }
    print upsert(my_table_name, my_id_column, my_other_columns, my_values_hash)

A solução é simples, mas não imediata.
Se você quiser usar esta instrução, faça uma alteração no db:

ALTER USER user SET search_path to 'name_of_schema';

após essas alterações, "INSERIR" funcionará corretamente.