psycopg2: insérer plusieurs lignes avec une seule requête

J'ai besoin d'insérer plusieurs lignes avec une requête (le nombre de lignes n'est pas constant), je dois donc exécuter une requête comme celle-ci:

INSERT INTO t (a, b) VALUES (1, 2), (3, 4), (5, 6);

La seule façon dont je sais est

args = [(1,2), (3,4), (5,6)]
args_str = ','.join(cursor.mogrify("%s", (x, )) for x in args)
cursor.execute("INSERT INTO t (a, b) VALUES "+args_str)

mais je veux un moyen plus simple.

J'ai construit un programme qui insère plusieurs lignes sur un serveur situé dans une autre ville.

J'ai découvert que l'utilisation de cette méthode était environ 10 fois plus rapide que executemany. Dans mon cas, il tups'agit d'un tuple contenant environ 2000 lignes. Cela a pris environ 10 secondes lors de l'utilisation de cette méthode:

args_str = ','.join(cur.mogrify("(%s,%s,%s,%s,%s,%s,%s,%s,%s)", x) for x in tup)
cur.execute("INSERT INTO table VALUES " + args_str) 

et 2 minutes avec cette méthode:

cur.executemany("INSERT INTO table VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s)", tup)

Nouvelle execute_valuesméthode dans Psycopg 2.7:

data = [(1,'x'), (2,'y')]
insert_query = 'insert into t (a, b) values %s'
psycopg2.extras.execute_values (
    cursor, insert_query, data, template=None, page_size=100
)

La manière pythonique de le faire dans Psycopg 2.6:

data = [(1,'x'), (2,'y')]
records_list_template = ','.join(['%s'] * len(data))
insert_query = 'insert into t (a, b) values {}'.format(records_list_template)
cursor.execute(insert_query, data)

Explication: Si les données à insérer sont données sous forme de liste de tuples comme dans

data = [(1,'x'), (2,'y')]

alors il est déjà dans le format exact requis comme

1. la valuessyntaxe de la insertclause attend une liste d'enregistrements comme dans

   insert into t (a, b) values (1, 'x'),(2, 'y')

2. Psycopgadapte un Python tupleà un Postgresql record.

Le seul travail nécessaire est de fournir un modèle de liste d'enregistrements à remplir par psycopg

# We use the data list to be sure of the template length
records_list_template = ','.join(['%s'] * len(data))

et placez-le dans la insertrequête

insert_query = 'insert into t (a, b) values {}'.format(records_list_template)

Impression des insert_querysorties

insert into t (a, b) values %s,%s

Passons maintenant à la Psycopgsubstitution d'arguments habituelle

cursor.execute(insert_query, data)

Ou simplement tester ce qui sera envoyé au serveur

print (cursor.mogrify(insert_query, data).decode('utf8'))

Production:

insert into t (a, b) values (1, 'x'),(2, 'y')

Mise à jour avec psycopg2 2.7:

Le classique executemany()est environ 60 fois plus lent que l'implémentation de @ ant32 (appelée "pliée") comme expliqué dans ce fil: https://www.postgresql.org/message-id/20170130215151.GA7081%40deb76.aryehleib.com

Cette implémentation a été ajoutée à psycopg2 dans la version 2.7 et s'appelle execute_values():

from psycopg2.extras import execute_values
execute_values(cur,
    "INSERT INTO test (id, v1, v2) VALUES %s",
    [(1, 2, 3), (4, 5, 6), (7, 8, 9)])

Réponse précédente:

Pour insérer plusieurs lignes, l'utilisation de la VALUESsyntaxe multirow avec execute()est environ 10 fois plus rapide que l'utilisation de psycopg2 executemany(). En effet, executemany()exécute juste de nombreuses INSERTdéclarations individuelles .

Le code de @ ant32 fonctionne parfaitement en Python 2. Mais en Python 3, cursor.mogrify()retourne des octets, cursor.execute()prend des octets ou des chaînes et ','.join()attend une strinstance.

Donc, dans Python 3, vous devrez peut-être modifier le code de @ ant32, en ajoutant .decode('utf-8'):

args_str = ','.join(cur.mogrify("(%s,%s,%s,%s,%s,%s,%s,%s,%s)", x).decode('utf-8') for x in tup)
cur.execute("INSERT INTO table VALUES " + args_str)

Ou en utilisant uniquement des octets (avec b''ou b""):

args_bytes = b','.join(cur.mogrify("(%s,%s,%s,%s,%s,%s,%s,%s,%s)", x) for x in tup)
cur.execute(b"INSERT INTO table VALUES " + args_bytes) 

curseur.copy_from est de loin la solution la plus rapide que j'ai trouvée pour les insertions en vrac. Voici l'essentiel que j'ai créé contenant une classe nommée IteratorFile qui permet à un itérateur produisant des chaînes d'être lu comme un fichier. Nous pouvons convertir chaque enregistrement d'entrée en une chaîne à l'aide d'une expression de générateur. Donc la solution serait

args = [(1,2), (3,4), (5,6)]
f = IteratorFile(("{}\t{}".format(x[0], x[1]) for x in args))
cursor.copy_from(f, 'table_name', columns=('a', 'b'))

Pour cette taille triviale d'arguments, cela ne fera pas beaucoup de différence de vitesse, mais je vois de grandes accélérations lorsque l'on traite des milliers + de lignes. Il sera également plus efficace en termes de mémoire que de créer une chaîne de requête géante. Un itérateur ne conserverait jamais qu'un seul enregistrement d'entrée en mémoire à la fois, où à un moment donné vous manquerez de mémoire dans votre processus Python ou dans Postgres en construisant la chaîne de requête.

Un extrait de la page de tutoriel de Psycopg2 sur Postgresql.org (voir en bas) :

Un dernier élément que je voudrais vous montrer est comment insérer plusieurs lignes à l'aide d'un dictionnaire. Si vous aviez ce qui suit:

namedict = ({"first_name":"Joshua", "last_name":"Drake"},
            {"first_name":"Steven", "last_name":"Foo"},
            {"first_name":"David", "last_name":"Bar"})

Vous pouvez facilement insérer les trois lignes dans le dictionnaire en utilisant:

cur = conn.cursor()
cur.executemany("""INSERT INTO bar(first_name,last_name) VALUES (%(first_name)s, %(last_name)s)""", namedict)

Cela n'économise pas beaucoup de code, mais il est définitivement meilleur.

Toutes ces techniques sont appelées «insertions étendues» dans la terminologie Postgres, et à partir du 24 novembre 2016, c'est toujours une tonne plus rapide que l'executemany () de psychopg2 et toutes les autres méthodes répertoriées dans ce fil (que j'ai essayé avant d'en venir à cela) répondre).

Voici un code qui n'utilise pas cur.mogrify et qui est agréable et simple à comprendre:

valueSQL = [ '%s', '%s', '%s', ... ] # as many as you have columns.
sqlrows = []
rowsPerInsert = 3 # more means faster, but with diminishing returns..
for row in getSomeData:
        # row == [1, 'a', 'yolo', ... ]
        sqlrows += row
        if ( len(sqlrows)/len(valueSQL) ) % rowsPerInsert == 0:
                # sqlrows == [ 1, 'a', 'yolo', 2, 'b', 'swag', 3, 'c', 'selfie' ]
                insertSQL = 'INSERT INTO "twitter" VALUES ' + ','.join(['(' + ','.join(valueSQL) + ')']*rowsPerInsert)
                cur.execute(insertSQL, sqlrows)
                con.commit()
                sqlrows = []
insertSQL = 'INSERT INTO "twitter" VALUES ' + ','.join(['(' + ','.join(valueSQL) + ')']*len(sqlrows))
cur.execute(insertSQL, sqlrows)
con.commit()

Mais il faut noter que si vous pouvez utiliser copy_from (), vous devez utiliser copy_from;)

J'utilise la réponse de ant32 ci-dessus depuis plusieurs années. Cependant, j'ai trouvé que c'est une erreur dans python 3 car mogrifyrenvoie une chaîne d'octets.

La conversion explicite en chaînes bytse est une solution simple pour rendre le code compatible python 3.

args_str = b','.join(cur.mogrify("(%s,%s,%s,%s,%s,%s,%s,%s,%s)", x) for x in tup) 
cur.execute(b"INSERT INTO table VALUES " + args_str)

Une autre approche agréable et efficace consiste à passer des lignes à insérer en tant qu'argument 1, qui est un tableau d'objets json.

Par exemple, vous passez un argument:

[ {id: 18, score: 1}, { id: 19, score: 5} ]

C'est un tableau, qui peut contenir n'importe quelle quantité d'objets à l'intérieur. Ensuite, votre SQL ressemble à:

INSERT INTO links (parent_id, child_id, score) 
SELECT 123, (r->>'id')::int, (r->>'score')::int 
FROM unnest($1::json[]) as r 

Remarque: votre postgress doit être suffisamment nouveau pour prendre en charge json

La solution cursor.copyfrom fournie par @ jopseph.sheedy ( https://stackoverflow.com/users/958118/joseph-sheedy ) ci-dessus ( https://stackoverflow.com/a/30721460/11100064 ) est en effet ultra-rapide.

Cependant, les exemples qu'il donne ne sont pas utilisables de manière générique pour un enregistrement avec un nombre quelconque de champs et il m'a fallu du temps pour comprendre comment l'utiliser correctement.

Le IteratorFile doit être instancié avec des champs séparés par des tabulations comme celui-ci ( rest une liste de dictionnaires où chaque dict est un enregistrement):

    f = IteratorFile("{0}\t{1}\t{2}\t{3}\t{4}".format(r["id"],
        r["type"],
        r["item"],
        r["month"],
        r["revenue"]) for r in records)

Pour généraliser pour un nombre arbitraire de champs, nous allons d'abord créer une chaîne de ligne avec le nombre correct d'onglets et d'espaces réservés de champ: "{}\t{}\t{}....\t{}"puis utiliser .format()pour remplir les valeurs de champ *list(r.values())) for r in records::

        line = "\t".join(["{}"] * len(records[0]))

        f = IteratorFile(line.format(*list(r.values())) for r in records)

fonction complète dans essentiel ici .

Si vous utilisez SQLAlchemy, vous n'avez pas besoin de jouer avec la création manuelle de la chaîne, car SQLAlchemy prend en charge la génération d'une VALUESclause à plusieurs lignes pour une seule INSERTinstruction :

rows = []
for i, name in enumerate(rawdata):
    row = {
        'id': i,
        'name': name,
        'valid': True,
    }
    rows.append(row)
if len(rows) > 0:  # INSERT fails if no rows
    insert_query = SQLAlchemyModelName.__table__.insert().values(rows)
    session.execute(insert_query)

execute_batch a été ajouté à psycopg2 depuis que cette question a été publiée.

Il est plus lent que execute_values mais plus simple à utiliser.

executemany accepte un tableau de tuples

https://www.postgresqltutorial.com/postgresql-python/insert/

    """ array of tuples """
    vendor_list = [(value1,)]

    """ insert multiple vendors into the vendors table  """
    sql = "INSERT INTO vendors(vendor_name) VALUES(%s)"
    conn = None
    try:
        # read database configuration
        params = config()
        # connect to the PostgreSQL database
        conn = psycopg2.connect(**params)
        # create a new cursor
        cur = conn.cursor()
        # execute the INSERT statement
        cur.executemany(sql,vendor_list)
        # commit the changes to the database
        conn.commit()
        # close communication with the database
        cur.close()
    except (Exception, psycopg2.DatabaseError) as error:
        print(error)
    finally:
        if conn is not None:
            conn.close()

Si vous souhaitez insérer plusieurs lignes dans un même état d'insertion (en supposant que vous n'utilisez pas ORM), le moyen le plus simple jusqu'à présent pour moi serait d'utiliser une liste de dictionnaires. Voici un exemple:

 t = [{'id':1, 'start_date': '2015-07-19 00:00:00', 'end_date': '2015-07-20 00:00:00', 'campaignid': 6},
      {'id':2, 'start_date': '2015-07-19 00:00:00', 'end_date': '2015-07-20 00:00:00', 'campaignid': 7},
      {'id':3, 'start_date': '2015-07-19 00:00:00', 'end_date': '2015-07-20 00:00:00', 'campaignid': 8}]

conn.execute("insert into campaign_dates
             (id, start_date, end_date, campaignid) 
              values (%(id)s, %(start_date)s, %(end_date)s, %(campaignid)s);",
             t)

Comme vous pouvez le voir, une seule requête sera exécutée:

INFO sqlalchemy.engine.base.Engine insert into campaign_dates (id, start_date, end_date, campaignid) values (%(id)s, %(start_date)s, %(end_date)s, %(campaignid)s);
INFO sqlalchemy.engine.base.Engine [{'campaignid': 6, 'id': 1, 'end_date': '2015-07-20 00:00:00', 'start_date': '2015-07-19 00:00:00'}, {'campaignid': 7, 'id': 2, 'end_date': '2015-07-20 00:00:00', 'start_date': '2015-07-19 00:00:00'}, {'campaignid': 8, 'id': 3, 'end_date': '2015-07-20 00:00:00', 'start_date': '2015-07-19 00:00:00'}]
INFO sqlalchemy.engine.base.Engine COMMIT

Utilisation de aiopg - L'extrait ci-dessous fonctionne parfaitement

    # items = [10, 11, 12, 13]
    # group = 1
    tup = [(gid, pid) for pid in items]
    args_str = ",".join([str(s) for s in tup])
    # insert into group values (1, 10), (1, 11), (1, 12), (1, 13)
    yield from cur.execute("INSERT INTO group VALUES " + args_str)

Enfin dans la version SQLalchemy1.2, cette nouvelle implémentation est ajoutée pour utiliser psycopg2.extras.execute_batch () au lieu d'executemany lorsque vous initialisez votre moteur avec use_batch_mode = True comme:

engine = create_engine(
    "postgresql+psycopg2://scott:tiger@host/dbname",
    use_batch_mode=True)

http://docs.sqlalchemy.org/en/latest/changelog/migration_12.html#change-4109

Ensuite, quelqu'un devrait utiliser SQLalchmey ne prend pas la peine d'essayer différentes combinaisons de sqla et psycopg2 et de SQL direct ensemble.