comment émuler «insérer ignorer» et «sur la mise à jour de clé en double» (fusion sql) avec postgresql?

Certains serveurs SQL ont une fonctionnalité qui INSERTest ignorée si elle enfreint une contrainte de clé primaire / unique. Par exemple, MySQL a INSERT IGNORE.

Quelle est la meilleure façon d'émuler INSERT IGNOREet ON DUPLICATE KEY UPDATEavec PostgreSQL?

Essayez de faire une MISE À JOUR. S'il ne modifie aucune ligne, cela signifie qu'il n'existe pas, alors faites une insertion. Évidemment, vous faites cela dans une transaction.

Vous pouvez bien sûr envelopper cela dans une fonction si vous ne voulez pas mettre le code supplémentaire côté client. Vous avez également besoin d'une boucle pour la condition de course très rare dans cette réflexion.

Il y a un exemple de cela dans la documentation: http://www.postgresql.org/docs/9.3/static/plpgsql-control-structures.html , exemple 40-2 en bas.

C'est généralement le moyen le plus simple. Vous pouvez faire de la magie avec des règles, mais ce sera probablement beaucoup plus compliqué. Je recommanderais l'approche de la fonction enveloppante à tout moment.

Cela fonctionne pour les valeurs d'une seule ligne ou de quelques lignes. Si vous avez affaire à de grandes quantités de lignes, par exemple à partir d'une sous-requête, il est préférable de la diviser en deux requêtes, une pour INSERT et une pour UPDATE (comme une jointure / sous-sélection appropriée bien sûr - pas besoin d'écrire votre main filtrer deux fois)

Avec PostgreSQL 9.5, il s'agit désormais d' une fonctionnalité native (comme MySQL l'a depuis plusieurs années):

INSÉRER ... EN CAS DE CONFLIT NE RIEN / METTRE À JOUR ("UPSERT")

9.5 apporte un support pour les opérations "UPSERT". INSERT est étendu pour accepter une clause ON CONFLICT DO UPDATE / IGNORE. Cette clause spécifie une autre action à entreprendre en cas de violation potentielle de duplication.

...

Autre exemple de nouvelle syntaxe:

INSERT INTO user_logins (username, logins)
VALUES ('Naomi',1),('James',1) 
ON CONFLICT (username)
DO UPDATE SET logins = user_logins.logins + EXCLUDED.logins;

Edit: au cas où vous auriez manqué la réponse de warren , PG9.5 l'a maintenant nativement; il est temps de mettre à niveau!

S'appuyant sur la réponse de Bill Karwin, pour expliquer à quoi ressemblerait une approche basée sur des règles (transfert d'un autre schéma dans la même base de données et avec une clé primaire à plusieurs colonnes):

CREATE RULE "my_table_on_duplicate_ignore" AS ON INSERT TO "my_table"
  WHERE EXISTS(SELECT 1 FROM my_table 
                WHERE (pk_col_1, pk_col_2)=(NEW.pk_col_1, NEW.pk_col_2))
  DO INSTEAD NOTHING;
INSERT INTO my_table SELECT * FROM another_schema.my_table WHERE some_cond;
DROP RULE "my_table_on_duplicate_ignore" ON "my_table";

Remarque: la règle s'applique à toutes les INSERTopérations jusqu'à ce que la règle soit supprimée, donc pas tout à fait ad hoc.

Pour ceux d'entre vous qui ont Postgres 9.5 ou supérieur, la nouvelle syntaxe ON CONFLICT DO NOTHING devrait fonctionner:

INSERT INTO target_table (field_one, field_two, field_three ) 
SELECT field_one, field_two, field_three
FROM source_table
ON CONFLICT (field_one) DO NOTHING;

Pour ceux d'entre nous qui ont une version antérieure, cette jointure droite fonctionnera à la place:

INSERT INTO target_table (field_one, field_two, field_three )
SELECT source_table.field_one, source_table.field_two, source_table.field_three
FROM source_table 
LEFT JOIN target_table ON source_table.field_one = target_table.field_one
WHERE target_table.field_one IS NULL;

Pour obtenir la logique d' insertion ignorée , vous pouvez faire quelque chose comme ci-dessous. J'ai trouvé que l'insertion à partir d'une instruction de sélection de valeurs littérales fonctionnait mieux, puis vous pouvez masquer les clés en double avec une clause NOT EXISTS. Pour obtenir la mise à jour sur la logique dupliquée, je soupçonne qu'une boucle pl / pgsql serait nécessaire.

INSERT INTO manager.vin_manufacturer
(SELECT * FROM( VALUES
  ('935',' Citroën Brazil','Citroën'),
  ('ABC', 'Toyota', 'Toyota'),
  ('ZOM',' OM','OM')
  ) as tmp (vin_manufacturer_id, manufacturer_desc, make_desc)
  WHERE NOT EXISTS (
    --ignore anything that has already been inserted
    SELECT 1 FROM manager.vin_manufacturer m where m.vin_manufacturer_id = tmp.vin_manufacturer_id)
)

INSERT INTO mytable(col1,col2) 
    SELECT 'val1','val2' 
    WHERE NOT EXISTS (SELECT 1 FROM mytable WHERE col1='val1')

On dirait que PostgreSQL prend en charge un objet de schéma appelé règle .

http://www.postgresql.org/docs/current/static/rules-update.html

Vous pouvez créer une règle ON INSERTpour une table donnée, en la faisant faire NOTHINGsi une ligne existe avec la valeur de clé primaire donnée, ou bien en la faisant faire une UPDATEau lieu de INSERTsi une ligne existe avec la valeur de clé primaire donnée.

Je n'ai pas essayé cela moi-même, donc je ne peux pas parler d'expérience ou donner un exemple.

Comme @hanmari l'a mentionné dans son commentaire. lors de l'insertion dans une table postgres, on conflict (..) do Nothing est le meilleur code à utiliser pour ne pas insérer de données en double:

query = "INSERT INTO db_table_name(column_name)
         VALUES(%s) ON CONFLICT (column_name) DO NOTHING;"

La ligne de code ON CONFLICT permettra à l'instruction d'insertion d'insérer toujours des lignes de données. Le code de requête et de valeurs est un exemple de date insérée depuis un Excel dans une table de base de données postgres. J'ai des contraintes ajoutées à une table postgres que j'utilise pour m'assurer que le champ ID est unique. Au lieu d'exécuter une suppression sur des lignes de données identiques, j'ajoute une ligne de code sql qui renumérote la colonne ID à partir de 1. Exemple:

q = 'ALTER id_column serial RESTART WITH 1'

Si mes données ont un champ ID, je ne l'utilise pas comme ID principal / ID de série, je crée une colonne ID et je la mets en série. J'espère que ces informations seront utiles à tout le monde. * Je n'ai pas de diplôme universitaire en développement / codage de logiciels. Tout ce que je sais en codage, je l'étudie seul.

Cette solution évite d'utiliser des règles:

BEGIN
   INSERT INTO tableA (unique_column,c2,c3) VALUES (1,2,3);
EXCEPTION 
   WHEN unique_violation THEN
     UPDATE tableA SET c2 = 2, c3 = 3 WHERE unique_column = 1;
END;

mais il a un inconvénient en termes de performances (voir PostgreSQL.org ):

Un bloc contenant une clause EXCEPTION est beaucoup plus coûteux à entrer et à sortir qu'un bloc sans clause. Par conséquent, n'utilisez pas EXCEPTION sans besoin.

En bloc, vous pouvez toujours supprimer la ligne avant l'insertion. La suppression d'une ligne qui n'existe pas ne provoque pas d'erreur, elle est donc ignorée en toute sécurité.

Pour les scripts d'importation de données, pour remplacer "IF NOT EXISTS", d'une certaine manière, il existe une formulation un peu maladroite qui fonctionne néanmoins:

DO
$do$
BEGIN
PERFORM id
FROM whatever_table;

IF NOT FOUND THEN
-- INSERT stuff
END IF;
END
$do$;