Transacciones

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 controlador debe habilitar la opción de consistencia 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 utilizar 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 brindan las sesiones causalmente consistentes:

Core API

La API central proporciona los siguientes métodos para implementar transacciones:

• startSession(): crea una nueva instancia de ClientSession

• startTransaction(): inicia una nueva transacción

• commitTransaction(): confirma la transacción activa en la sesión en la que fue creada

• abortTransaction(): finaliza la transacción activa en la sesión en la que fue creada.

• endSession(): finaliza la sesión activa

Debes realizar los siguientes pasos cuando uses esta API:

• Pasa la instancia de la sesión a cada operación que desees ejecutar en esa sesión.

• Implemente un bloque catch en el que identifique los errores de transacción del servidor y la lógica de control de errores implementada.

El siguiente código demuestra cómo realizar una transacción utilizando la Core API:

async function coreTest(client) {
  const session = client.startSession();
  try {
    session.startTransaction();
    const savingsColl = client.db("bank").collection("savings_accounts");
    await savingsColl.findOneAndUpdate(
      {account_id: "9876"}, 
      {$inc: {amount: -100 }}, 
      { session });
    const checkingColl = client.db("bank").collection("checking_accounts");
    await checkingColl.findOneAndUpdate(
      {account_id: "9876"}, 
      {$inc: {amount: 100 }}, 
      { session });
    // ... perform other operations
    await session.commitTransaction();
    console.log("Transaction committed.");
  } catch (error) {
    console.log("An error occurred during the transaction:" + error);
    await session.abortTransaction();
  } finally {
    await session.endSession();
  }
}

const session = client1.startSession();
client2.db('myDB').collection('myColl').insertOne({ name: 'Jane Eyre' }, { session });

Para ver un ejemplo completamente ejecutable que utiliza esta API, consulte Utilice el ejemplo de usode la API principal.

API de transacciones convenientes

La API de Transacciones Convenientes ofrece los siguientes métodos para implementar transacciones:

• withSession(): ejecuta la función de retorno que recibe dentro de una sesión. La API gestiona automáticamente la creación y finalización de la sesión.

• withTransaction(): ejecuta la devolución de llamada que se le pasa dentro de una transacción y llama al commitTransaction() método cuando la devolución de llamada regresa.

Estos métodos devuelven el valor que devuelve la devolución de llamada. Por ejemplo, si una devolución de llamada que se pasa al método withTransaction() devuelve el documento { hello: "world" }, el método withTransaction() también lo devuelve.

Cuando uses la API de Transacciones Convenientes, puedes propagar valores de retorno desde la función de retorno como los valores de retorno de los métodos withTransaction() y withSession() para trabajar con ellos en otras partes de tu código.

Debes realizar los siguientes pasos cuando uses esta API:

• Pasa la instancia de la sesión a cada operación que desees ejecutar en esa sesión.

• Implemente la sintaxis async await para cada operación en la sesión.

• Evitar el paralelismo, como llamar al método Promise.all(). Utilizar sesiones en paralelo suele conducir a errores en el servidor.

El siguiente código demuestra cómo realizar una transacción utilizando la API de Transacciones Convenientes:

async function convTest(client) {
  let txnRes = await client.withSession(async (session) =>
    session.withTransaction(async (session) => {
      const savingsColl = client.db("bank").collection("savings_accounts");
      await savingsColl.findOneAndUpdate(
        {account_id: "9876"}, 
        {$inc: {amount: -100 }}, 
        { session });
  
      const checkingColl = client.db("bank").collection("checking_accounts");
      await checkingColl.findOneAndUpdate(
        {account_id: "9876"}, 
        {$inc: {amount: 100 }}, 
        { session });
      // ... perform other operations
      return "Transaction committed.";
    }, null)
  );
  console.log(txnRes);
}

Para ver un ejemplo completamente ejecutable que utiliza esta API, consulte el ejemplo de uso de la API de transacciones convenientes.

Manejo conveniente de errores de API de transacciones

La API de transacciones convenientes incorpora lógica de reintento para estos tipos de errores. El controlador reintenta automáticamente la transacción hasta que se produzca una confirmación exitosa.

Manejo de errores de Core API

Si está usando la Core API para realizar una transacción, debe añadir las siguientes funciones de gestión de errores a su aplicación:

• Una función que vuelve a intentar toda la transacción cuando el conductor encuentra un TransientTransactionError

• Una función que reintenta la operación de confirmación cuando el controlador encuentra un UnknownTransactionCommitResult

Estas funciones deben ejecutarse hasta que se realice un compromiso exitoso o se produzca un error diferente. Para un ejemplo de esta lógica de reintentos, consulta la sección de la Core API en la página de la API de controladores del manual del servidor.