/ /

Transacciones

Overview

En esta guía, puedes aprender a utilizar el controlador de Ruby para realizar transacciones. Las transacciones te permiten realizar una serie de operaciones que cambian los datos solo si toda la transacción se completa. Si alguna operación en la transacción no tuvo éxito, el controlador detiene la transacción y descarta todos los cambios de datos antes de que lleguen a ser visibles. Esta funcionalidad se llama atomicidad.

En MongoDB, las transacciones se ejecutan dentro de sesiones lógicas. Una sesión es un agrupamiento de operaciones de lectura o guardado relacionadas que desea ejecutar en forma secuencial. Las sesiones permiten la coherencia causal para un grupo de operaciones y permiten ejecutar operaciones en una transacción compatible con ACID, que es una transacción que cumple una expectativa de atomicidad, consistencia, aislamiento y durabilidad. MongoDB garantiza que los datos involucrados en las operaciones de transacción se mantengan coherentes, incluso si las operaciones encuentran errores inesperados.

Cuando se usa el driver de Ruby, puedes iniciar una sesión llamando al método start_session en tu cliente. Luego, puedes realizar transacciones dentro de la sesión.

Advertencia

Utilice una sesión solo en operaciones que se ejecutan en el Mongo::Client que la creó. Utilizar una sesión con un Mongo::Client diferente resulta en errores de operación.

Coherencia causal

MongoDB habilita la coherencia causal en ciertas sesiones de clientes. El modelo de coherencia causal garantiza que en un sistema distribuido, las operaciones dentro de una sesión se ejecuten en un orden causal. Los clientes observan resultados que son coherentes con las relaciones causales, o las dependencias entre las operaciones. Por ejemplo, si realizas una serie de operaciones donde una depende lógicamente del resultado de otra, las lecturas subsecuentes reflejarán esa relación de dependencia.

Para garantizar la coherencia causal, las sesiones de los clientes deben cumplir los siguientes requisitos:

Al iniciar una sesión, el driver debe habilitar la opción de coherencia causal. Esta opción está habilitada por defecto.
Las operaciones deben ejecutarse en una sola sesión en un solo hilo. De lo contrario, las sesiones o hilos deben comunicarse entre sí los valores de operation time y tiempo de clúster. Para ver un ejemplo de dos sesiones que comunican estos valores, consulte los Ejemplos de coherencia causal en el manual del servidor de MongoDB.
Debes usar un :majority nivel de consistencia de lectura.
Debe usar un :majority nivel de confirmación de escritura (write concern). Este es el valor predeterminado de nivel de confirmación de escritura (write concern).

La siguiente tabla describe las garantías que ofrecen las sesiones coherentes causales:

garantías	Descripción
Leer las escrituras	Las operaciones de lectura reflejan los resultados de las operaciones de escritura anteriores.
Lecturas monotónicas	Las operaciones de lectura no devuelven resultados que reflejen un estado de datos anterior al de una operación de lectura previa.
Escrituras monotónicas	Si una operación de escritura debe preceder a otras operaciones de escritura, el servidor ejecutará primero esta operación de escritura. Por ejemplo, si llamas a `insert_one()` para insertar un documento y luego llamas a `update_one()` para modificar el documento insertado, el servidor ejecutará primero la operación de inserción.
Las escrituras siguen a las lecturas	Si una operación de escritura debe seguir a otras operaciones de lectura, el servidor primero ejecuta las operaciones de lectura. Por ejemplo, si llamas a `find()` para recuperar un documento y luego llamas a `delete_one()` para borrar el documento recuperado, el servidor ejecutará primero la operación find.

Tip

Para aprender más sobre los conceptos mencionados en esta sección, consulta las siguientes entradas del manual del servidor MongoDB:

Métodos

Después de llamar al método start_session para iniciar una sesión, utilice los métodos de la clase Mongo::Session para gestionar el estado de la sesión. La siguiente tabla describe los métodos que puedes usar para administrar una transacción:

Método	Descripción
`start_transaction`	Inicia una nueva transacción en esta sesión. No se puede iniciar una transacción si ya hay una transacción activa en ejecución en la sesión. Se pueden configurar las opciones de transacción, como la prioridad de lectura, la prioridad de escritura y la preferencia de lectura, pasando un `Hash` valor como parámetro.
`commit_transaction`	Confirma la transacción activa de esta sesión. Este método devuelve un error si no hay una transacción activa para la sesión, la transacción finalizó anteriormente o si hay un conflicto de escritura.
`abort_transaction`	Termina la transacción activa para esta sesión. Este método devuelve un error si no hay una transacción activa para la sesión o si la transacción fue confirmada o finalizada.
`with_transaction`	Inicia una transacción antes de ejecutar el bloque proporcionado y la confirma cuando el bloque finaliza. Si alguna de las operaciones del bloque, o la operación de confirmación, produce un error transitorio en la transacción, el bloque y/o la confirmación se ejecutarán de nuevo.

Ejemplo de transacción

Este ejemplo define un método run_transaction que modifica datos en las colecciones de la base de datos sample_mflix. El código realiza las siguientes acciones:

Crea Mongo::Collection instancias para acceder a las colecciones movies y users.
Especifica las preocupaciones de lectura y el nivel de confirmación de escritura (write concern) para la transacción.
Inicia la transacción.
Inserta un documento en la colección movies e imprime los resultados.
Actualiza un documento en la colección users e imprime los resultados.

database = client.use('sample_mflix')
movies_collection = database[:movies]
users_collection = database[:users]
def run_transaction(session, movies_collection, users_collection)
  transaction_options = {
    read_concern: { level: "snapshot" },
    write_concern: { w: "majority" }
  }
session.with_transaction(transaction_options) do
  # Inserts document into the "movies" collection
  insert_result = movies_collection.insert_one({ name: 'The Menu', runtime: 107 }, session: session)
  puts "Insert completed: #{insert_result.inspect}"
  # Updates document in the "users" collection
  update_result = users_collection.update_one({ name: 'Amy Phillips'}, { "$set" => { name: 'Amy Ryan' }}, session: session)
  puts "Update completed: #{update_result.inspect}"
  end
end
# Starts a session
session = client.start_session
begin
  # Runs the transaction
  run_transaction(session, movies_collection, users_collection)
  puts "Transaction committed successfully."
rescue Mongo::Error::OperationFailure => e
  puts "Transaction failed and was aborted. Error: #{e.message}"
ensure
  session.end_session
end

Nota

Operaciones paralelas no admitidas

El driver Ruby no soporta la ejecución de operaciones paralelas dentro de una sola transacción.

Si usas MongoDB Server v8.0 o posterior, puedes realizar operaciones de escritura en varios espacios de nombres dentro de una sola transacción utilizando el método bulk_write. Para obtener más información, consulta la Guía de operaciones de escritura masiva.

Información Adicional

Para obtener más información sobre los conceptos mencionados en esta guía, consulta las siguientes páginas del manual de MongoDB Server:

Para aprender más sobre ACID compliance, consulte el articulo Una guía sobre las propiedades ACID en los sistemas de gestión de bases de datos en el sitio web de MongoDB.

Para obtener más información sobre las operaciones de inserción, consulte la Guía de Inserción de Documentos.

Documentación de la API

Para obtener más información sobre los métodos y tipos mencionados en esta guía, vea la siguiente documentación de la API:

Volver

Operaciones de escritura masiva

Configurar las operaciones CRUD