python - query - SQLAlchemy: ¿Cuál es la diferencia entre flush() y commit()?

sqlalchemy select

Question

¿Cuál es la diferencia entre flush() y commit() en SQLAlchemy?

He leído los documentos, pero no soy el más sabio, parece que suponen una comprensión previa que no tengo.

Estoy particularmente interesado en su impacto en el uso de la memoria. Estoy cargando algunos datos en una base de datos desde una serie de archivos (alrededor de 5 millones de filas en total) y mi sesión ocasionalmente se está cayendo: es una base de datos grande y una máquina con poca memoria.

Me pregunto si estoy usando demasiadas llamadas commit() y no suficientes, flush() pero) sin entender realmente cuál es la diferencia, ¡es difícil decirlo!

Answer 1

Como dice @snapshoe

flush() envía sus sentencias de SQL a la base de datos

commit() comete la transacción.

Cuando session.autocommit == False:

commit () llamará a flush () si su autoflush == True.

Cuando session.autocommit == True:

No puede llamar a commit () si no ha iniciado una transacción (lo cual probablemente no haya hecho ya que probablemente solo usaría este modo para evitar la administración manual de las transacciones).

En este modo, debe llamar a flush () para guardar los cambios de ORM. La descarga efectiva también compromete sus datos.

Answer 2

Un objeto Session es básicamente una transacción en curso de cambios en una base de datos (actualizar, insertar, eliminar). Estas operaciones no se guardan en la base de datos hasta que se confirman (si su programa se cancela por alguna razón en la transacción de mitad de sesión, se pierden los cambios no confirmados).

El objeto de sesión registra las operaciones de transacción con session.add() , pero aún no las comunica a la base de datos hasta que se llama a session.flush() .

session.flush() comunica una serie de operaciones a la base de datos (insertar, actualizar, eliminar). La base de datos los mantiene como operaciones pendientes en una transacción. Los cambios no se guardan permanentemente en el disco, ni son visibles para otras transacciones hasta que la base de datos recibe un COMPROMISO para la transacción actual (que es lo que hace session.commit() ).

session.commit() confirma (persiste) esos cambios en la base de datos.

flush() siempre se llama como parte de una llamada a commit() ( 1 ).

Cuando utiliza un objeto Session para consultar la base de datos, la consulta devolverá resultados tanto de la base de datos como de las partes vaciadas de la transacción no confirmada que contiene. De forma predeterminada, los objetos de sesión autoflush sus operaciones, pero esto se puede desactivar.

Esperemos que este ejemplo aclare esto:

#---
s = Session()

s.add(Foo(''A'')) # The Foo(''A'') object has been added to the session.
                # It has not been committed to the database yet,
                #   but is returned as part of a query.
print 1, s.query(Foo).all()
s.commit()

#---
s2 = Session()
s2.autoflush = False

s2.add(Foo(''B''))
print 2, s2.query(Foo).all() # The Foo(''B'') object is *not* returned
                             #   as part of this query because it hasn''t
                             #   been flushed yet.
s2.flush()                   # Now, Foo(''B'') is in the same state as
                             #   Foo(''A'') was above.
print 3, s2.query(Foo).all() 
s2.rollback()                # Foo(''B'') has not been committed, and rolling
                             #   back the session''s transaction removes it
                             #   from the session.
print 4, s2.query(Foo).all()

#---
Output:
1 [<Foo(''A'')>]
2 [<Foo(''A'')>]
3 [<Foo(''A'')>, <Foo(''B'')>]
4 [<Foo(''A'')>]