psycopg2: inserte varias filas con una consulta

Necesito insertar varias filas con una consulta (el número de filas no es constante), por lo que necesito ejecutar una consulta como esta:

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

La única manera que sé es

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)

Pero quiero una manera más simple.

Creé un programa que inserta varias líneas en un servidor que se encuentra en otra ciudad.

Descubrí que usar este método era aproximadamente 10 veces más rápido que executemany. En mi caso tupes una tupla que contiene aproximadamente 2000 filas. Tomó alrededor de 10 segundos al usar este método:

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) 

y 2 minutos al usar este método:

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

Nuevo execute_valuesmétodo en 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 forma pitónica de hacerlo en 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)

Explicación: Si los datos a insertar se dan como una lista de tuplas como en

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

entonces ya está en el formato exacto requerido como

1. la valuessintaxis de la insertcláusula espera una lista de registros como en

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

2. Psycopgadapta un Python tuplea un Postgresql record.

El único trabajo necesario es proporcionar una plantilla de lista de registros para que sea completada por psycopg

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

y colocarlo en la insertconsulta

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

Imprimir las insert_querysalidas

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

Ahora a la Psycopgsustitución de argumentos habituales

cursor.execute(insert_query, data)

O simplemente probando lo que se enviará al servidor

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

Salida:

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

Actualización con psycopg2 2.7:

El clásico executemany()es aproximadamente 60 veces más lento que la implementación de @ ant32 (llamada "plegada") como se explica en este hilo: https://www.postgresql.org/message-id/20170130215151.GA7081%40deb76.aryehleib.com

Esta implementación se agregó a psycopg2 en la versión 2.7 y se llama 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)])

Respuesta anterior:

Para insertar varias filas, usar la VALUESsintaxis de múltiples filas execute()es aproximadamente 10 veces más rápido que usar psycopg2 executemany(). De hecho, executemany()solo corre muchos individuosINSERT declaraciones .

El código de @ ant32 funciona perfectamente en Python 2. Pero en Python 3, cursor.mogrify()devuelve bytes, cursor.execute()toma bytes o cadenas, y ','.join()esperastr instancia.

Entonces, en Python 3, es posible que deba modificar el código de @ ant32, agregando .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)

O mediante el uso de bytes (con b''o b"") solamente:

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 es la solución más rápida que he encontrado para las inserciones masivas con diferencia. Aquí hay un resumen que hice que contiene una clase llamada IteratorFile que permite que un iterador que produce cadenas se lea como un archivo. Podemos convertir cada registro de entrada en una cadena usando una expresión generadora. Entonces la solución sería

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

Para este tamaño trivial de args, no habrá mucha diferencia de velocidad, pero veo grandes aceleraciones cuando se trata de miles de filas. También será más eficiente en la memoria que construir una cadena de consulta gigante. Un iterador solo mantendría un registro de entrada en la memoria a la vez, donde en algún momento se quedará sin memoria en su proceso de Python o en Postgres al construir la cadena de consulta.

Un fragmento de la página del tutorial de Psycopg2 en Postgresql.org (ver abajo) :

Un último elemento que me gustaría mostrarle es cómo insertar varias filas usando un diccionario. Si tuvieras lo siguiente:

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

Puede insertar fácilmente las tres filas dentro del diccionario utilizando:

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

No guarda mucho código, pero definitivamente se ve mejor.

Todas estas técnicas se llaman 'Inserciones extendidas "en la terminología de Postgres y, a partir del 24 de noviembre de 2016, sigue siendo mucho más rápido que executemany () de psychopg2 y todos los demás métodos enumerados en este hilo (que probé antes de llegar a este responder).

Aquí hay un código que no usa cur.mogrify y es agradable y simplemente para entenderlo:

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

Pero debe tenerse en cuenta que si puede usar copy_from (), debe usar copy_from;)

He estado usando la respuesta de ant32 anterior durante varios años. Sin embargo, he encontrado que hay un error en Python 3 porque mogrifydevuelve una cadena de bytes.

La conversión explícita a cadenas bytse es una solución simple para hacer que el código python 3 sea compatible.

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)

Otro enfoque agradable y eficiente es pasar filas para la inserción como 1 argumento, que es una matriz de objetos json.

Por ejemplo, tu argumento pasajero:

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

Es una matriz, que puede contener cualquier cantidad de objetos en su interior. Entonces su SQL se ve así:

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

Aviso: su postgreso debe ser lo suficientemente nuevo para admitir json

La solución cursor.copyfrom proporcionada por @ jopseph.sheedy ( https://stackoverflow.com/users/958118/joseph-sheedy ) anterior ( https://stackoverflow.com/a/30721460/11100064 ) es realmente muy rápida.

Sin embargo, el ejemplo que da no se puede usar genéricamente para un registro con cualquier número de campos y me tomó un tiempo descubrir cómo usarlo correctamente.

El rarchivo Iterator necesita ser instanciado con campos separados por tabuladores como este ( es una lista de dictados donde cada dict es un registro):

    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)

Para generalizar para un número arbitrario de campos, primero crearemos una cadena de línea con la cantidad correcta de pestañas y marcadores de posición de campo: "{}\t{}\t{}....\t{}"y luego la usaremos .format()para completar los valores de campo *list(r.values())) for r in records:

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

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

Función completa en esencia aquí .

Si está utilizando SQLAlchemy, no necesita meterse a mano en la elaboración de la cadena porque SQLAlchemy admite la generación de una VALUEScláusula de varias filas para una sola INSERTdeclaración :

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)

ejecutar_batch se ha agregado a psycopg2 desde que se publicó esta pregunta.

Es más lento que execute_values pero más simple de usar.

Muchos de ellos aceptan un conjunto de tuplas

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 desea insertar varias filas dentro de un estado de inserción (suponiendo que no esté utilizando ORM), la forma más fácil hasta ahora para mí sería utilizar la lista de diccionarios. Aquí hay un ejemplo:

 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)

Como puede ver, solo se ejecutará una consulta:

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

Usando aiopg : el fragmento a continuación funciona perfectamente bien

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

Finalmente en la versión SQLalchemy1.2, esta nueva implementación se agrega para usar psycopg2.extras.execute_batch () en lugar de executemany cuando inicializa su motor con use_batch_mode = True como:

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

Entonces alguien tendría que usar SQLalchmey no se molestará en probar diferentes combinaciones de sqla y psycopg2 y dirigir SQL juntos.