psycopg2: Fügen Sie mehrere Zeilen mit einer Abfrage ein

Ich muss mehrere Zeilen mit einer Abfrage einfügen (die Anzahl der Zeilen ist nicht konstant), daher muss ich eine Abfrage wie diese ausführen:

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

Der einzige Weg, den ich kenne, ist

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)

aber ich möchte einen einfacheren Weg.

Ich habe ein Programm erstellt, das mehrere Zeilen in einen Server einfügt, der sich in einer anderen Stadt befindet.

Ich fand heraus, dass die Verwendung dieser Methode etwa zehnmal schneller war als executemany. In meinem Fall tuphandelt es sich um ein Tupel mit etwa 2000 Zeilen. Bei dieser Methode dauerte es ungefähr 10 Sekunden:

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) 

und 2 Minuten bei Verwendung dieser Methode:

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

Neue execute_valuesMethode in 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
)

Die pythonische Methode in 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)

Erläuterung: Wenn die einzufügenden Daten als Liste von Tupeln wie in angegeben sind

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

dann ist es schon im genau gewünschten format als

1. Die valuesSyntax der insertKlausel erwartet eine Liste von Datensätzen wie in

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

2. Psycopgpasst einen Python tuplean einen Postgresql an record.

Die einzige notwendige Arbeit besteht darin, eine Datensatzlistenvorlage bereitzustellen, die von psycopg ausgefüllt werden soll

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

und platzieren Sie es in der insertAbfrage

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

Drucken der insert_queryAusgänge

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

Nun zu den üblichen PsycopgArgumentationsersetzungen

cursor.execute(insert_query, data)

Oder testen Sie einfach, was an den Server gesendet wird

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

Ausgabe:

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

Update mit psycopg2 2.7:

Der Klassiker executemany() ist ungefähr 60-mal langsamer als die Implementierung von @ ant32 ("gefaltet" genannt), wie in diesem Thread erläutert: https://www.postgresql.org/message-id/20170130215151.GA7081%40deb76.aryehleib.com

Diese Implementierung wurde in Version 2.7 zu psycopg2 hinzugefügt und heißt 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)])

Vorherige Antwort:

Das Einfügen mehrerer Zeilen ist mit der Multirow- VALUESSyntax mit execute()etwa 10-mal schneller als mit psycopg2 executemany(). Tatsächlich,executemany() läuft nur viele einzelne INSERTAussagen.

Der Code von @ ant32 funktioniert perfekt in Python 2. In Python 3 werden jedoch cursor.mogrify()Bytes zurückgegeben, cursor.execute()entweder Bytes oder Zeichenfolgen verwendet, und','.join()str Instanz erwartet .

In Python 3 müssen Sie möglicherweise den Code von @ ant32 ändern, indem Sie Folgendes hinzufügen .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)

Oder indem Sie nur Bytes (mit b''oder b"") verwenden:

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) 

cursor.copy_from ist die mit Abstand schnellste Lösung, die ich für Masseneinsätze gefunden habe. Hier ist eine Zusammenfassung, die ich mit einer Klasse namens IteratorFile erstellt habe, mit der ein Iterator, der Zeichenfolgen liefert, wie eine Datei gelesen werden kann. Wir können jeden Eingabedatensatz mithilfe eines Generatorausdrucks in eine Zeichenfolge konvertieren. Die Lösung wäre also

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'))

Für diese triviale Größe von Argumenten macht es keinen großen Geschwindigkeitsunterschied, aber ich sehe große Beschleunigungen, wenn es um Tausende von Zeilen geht. Es ist außerdem speichereffizienter als das Erstellen einer riesigen Abfragezeichenfolge. Ein Iterator würde immer nur einen Eingabedatensatz gleichzeitig im Speicher halten, wobei Ihnen irgendwann der Speicher in Ihrem Python-Prozess oder in Postgres ausgeht, indem Sie die Abfragezeichenfolge erstellen.

Ein Ausschnitt aus der Tutorial-Seite von Psycopg2 auf Postgresql.org (siehe unten) :

Ein letzter Punkt, den ich Ihnen zeigen möchte, ist das Einfügen mehrerer Zeilen mithilfe eines Wörterbuchs. Wenn Sie Folgendes hatten:

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

Sie können ganz einfach alle drei Zeilen in das Wörterbuch einfügen, indem Sie Folgendes verwenden:

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

Es speichert nicht viel Code, sieht aber definitiv besser aus.

Alle diese Techniken werden in der Postgres-Terminologie als "Extended Inserts" bezeichnet. Ab dem 24. November 2016 ist sie immer noch eine Tonne schneller als die Executemany () von psychopg2 () und alle anderen in diesem Thread aufgeführten Methoden (die ich ausprobiert habe, bevor ich dazu gekommen bin) Antworten).

Hier ist ein Code, der cur.mogrify nicht verwendet und nett und einfach ist, um sich zurechtzufinden:

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()

Es sollte jedoch beachtet werden, dass Sie copy_from () verwenden sollten, wenn Sie copy_from () verwenden können;)

Ich benutze die obige Antwort von ant32 seit mehreren Jahren. Ich habe jedoch festgestellt, dass dies ein Fehler in Python 3 ist, da mogrifyeine Byte-Zeichenfolge zurückgegeben wird.

Das explizite Konvertieren in Bytse-Zeichenfolgen ist eine einfache Lösung, um Code Python 3 kompatibel zu machen.

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)

Ein weiterer netter und effizienter Ansatz besteht darin, Zeilen zum Einfügen als 1 Argument zu übergeben, bei dem es sich um ein Array von JSON-Objekten handelt.

ZB Sie übergeben Argument:

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

Es ist ein Array, das eine beliebige Anzahl von Objekten enthalten kann. Dann sieht Ihr SQL so aus:

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

Hinweis: Ihr Postgress muss neu genug sein, um json zu unterstützen

Die Lösung cursor.copyfrom , bereitgestellt von @ jopseph.sheedy ( https://stackoverflow.com/users/958118/joseph-sheedy ) oben ( https://stackoverflow.com/a/30721460/11100064) ) ist in der Tat blitzschnell.

Das Beispiel, das er gibt, ist jedoch nicht generisch für einen Datensatz mit einer beliebigen Anzahl von Feldern verwendbar, und ich habe einige Zeit gebraucht, um herauszufinden, wie man es richtig verwendet.

Die Iterator-Datei muss mit solchen durch Tabulatoren getrennten Feldern instanziiert werden ( rist eine Liste von Diktaten, in denen jedes Diktat ein Datensatz ist):

    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)

Um eine beliebige Anzahl von Feldern zu verallgemeinern, erstellen wir zuerst eine Zeilenzeichenfolge mit der richtigen Anzahl von Registerkarten und Feldplatzhaltern: "{}\t{}\t{}....\t{}"und geben dann .format()die Feldwerte ein *list(r.values())) for r in records::

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

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

vollständige Funktion im Kern hier .

Wenn Sie SQLAlchemy verwenden, müssen Sie sich nicht mit der Handarbeit der Zeichenfolge herumschlagen, da SQLAlchemy das Generieren einer mehrzeiligen VALUESKlausel für eine einzelne INSERTAnweisung unterstützt :

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 wurde zu psycopg2 hinzugefügt, seit diese Frage gestellt wurde.

Es ist langsamer als execute_values, aber einfacher zu verwenden.

Executemany akzeptieren Array von Tupeln

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()

Wenn Sie mehrere Zeilen in eine Einfügestatistik einfügen möchten (vorausgesetzt, Sie verwenden kein ORM), ist es für mich bisher am einfachsten, eine Liste von Wörterbüchern zu verwenden. Hier ist ein Beispiel:

 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)

Wie Sie sehen, wird nur eine Abfrage ausgeführt:

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

Verwenden von Aiopg - Das folgende Snippet funktioniert einwandfrei

    # 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)

Schließlich wird in der SQLalchemy1.2-Version diese neue Implementierung hinzugefügt, um psycopg2.extras.execute_batch () anstelle von executemany zu verwenden, wenn Sie Ihre Engine mit use_batch_mode = True initialisieren, wie:

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

Dann müsste jemand SQLalchmey verwenden, um verschiedene Kombinationen von sqla und psycopg2 auszuprobieren und SQL gemeinsam zu steuern.