/ /

driver de Kotlin corrutina

Docs Home

Librerías de clientes

Kotlin

driver de Kotlin corrutina

Docs Home

Librerías de clientes

Kotlin

driver de Kotlin corrutina

Transacciones

Overview

En esta guía, puedes aprender cómo utilizar el controlador de Kotlin para realizar transacciones. Transacciones le permiten ejecutar una serie de operaciones que no cambian ningún dato hasta que la transacción es confirmada. Si alguna operación en la transacción devuelve un error, el driver cancela la transacción y descarta todos los cambios de datos antes de que sean visibles.

En MongoDB, las transacciones se ejecutan dentro de sesiones lógicas. Una sesión es un agrupamiento de operaciones de lectura o escritura relacionadas que usted planea ejecutar secuencialmente. Las sesiones habilitan la coherencia causal para un conjunto de operaciones o te permiten ejecutar operaciones en una ACID transaction. MongoDB garantiza que los datos involucrados en sus operaciones de transacción permanezcan coherentes, incluso si las operaciones encuentran errores inesperados.

Al utilizar el controlador Kotlin, puede crear una nueva sesión desde un MongoClient instancia como ClientSession. Recomendamos reutilizar tu cliente para múltiples sesiones y transacciones en lugar de instanciar un nuevo cliente cada vez.

Advertencia

Utiliza un ClientSession solo con el MongoClient (o el MongoDatabase o MongoCollection asociados) que lo creaste. El uso de un ClientSession con un MongoClient 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 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 subproceso. De lo contrario, las sesiones o subprocesos deben comunicarse entre sí los valores de tiempo de la operación y del clúster. Para ver un ejemplo de dos sesiones que comunican estos valores, consulte los ejemplos de consistencia causal en el manual del servidor MongoDB.
Debes utilizar una preocupación de lectura ReadConcern.MAJORITY.
Debe usar un WriteConcern.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:

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 ejecuta esta operación de escritura primero. Por ejemplo, si llama a `insertOne()` para insertar un documento y luego llama a `updateOne()` para modificar el documento insertado, el servidor ejecuta 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 `deleteOne()` 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 de MongoDB:

Métodos

Crea ClientSession utilizando el método startSession() en tu instancia Client. Luego se puede modificar el estado de la sesión utilizando los siguientes métodos:

Método	Descripción
`startTransaction()`	Starts a new transaction for this session with the default transaction options. You cannot start a transaction if there's already an active transaction on the session. To set transaction options, use `startTransaction(transactionOptions: TransactionOptions)`.
`abortTransaction()`	Ends the active transaction for this session. Returns an error if there is no active transaction for the session or the transaction was previously ended.
`commitTransaction()`	Commits the active transaction for this session. Returns an error if there is no active transaction for the session or if the transaction was ended.

Tip

Tiempo de espera de transacción

Puede establecer un límite de tiempo para completar las operaciones de sus transacciones. Para obtener más información, consulte Transactions sección de la guía sobre Límite de Tiempo de Ejecución del Servidor.

Un ClientSession también tiene métodos para recuperar propiedades de sesión y modificar propiedades de sesión modificables. Consulta la documentación de la API para aprender más sobre estos métodos.

Ejemplo

Este ejemplo utiliza la siguiente clase de datos Kotlin para modelar sus documentos:

data class Account(
    val accountId: String,
    val amount: Int
)

El siguiente ejemplo demuestra cómo puedes crear una sesión, iniciar una transacción y guardar cambios en documentos existentes:

Cree una sesión desde el cliente utilizando el método startSession().
Utilice el método startTransaction() para iniciar una transacción.
Actualiza los documentos especificados y después utiliza el método commitTransaction() si todas las operaciones tienen éxito, o abortTransaction() si alguna operación falla.

// Set up the session
val session = client.startSession()
try {
    session.startTransaction()
    val savingsColl = database
        .getCollection<Account>("savings_accounts")
    val checkingColl = database
        .getCollection<Account>("checking_accounts")
    savingsColl.findOneAndUpdate(
        session,
        eq(Account::accountId.name, "9876"),
        inc(Account::amount.name, -100),
    )
    checkingColl.findOneAndUpdate(
        session,
        eq(Account::accountId.name, "9876"),
        inc(Account::amount.name, 100)
    )
    // Commit the transaction
    val result = session.commitTransaction()
    println("Transaction committed.")
} catch (error: Exception) {
    println("An error occurred during the transaction: ${error.message}")
    // Abort the transaction
    session.abortTransaction()
}

Nota

Operaciones paralelas no admitidas

El driver de Kotlin no admite la ejecución de operaciones en paralelo dentro de una sola transacción.

Si estás usando MongoDB server v8.0 o posterior, puedes realizar operaciones de escritura en varios espacios de nombres dentro de una sola transacción mediante el uso de operaciones de escritura masiva. Para aprender más, consulta la guía de Operaciones en masa.

Información Adicional

Para **aprender** más sobre los conceptos mencionados en esta **guía**, consulta las siguientes páginas en el manual del **servidor**:

Para aprender más sobre ACID compliance, consulte el ¿Cuáles son las propiedades ACID en los sistemas de gestión de bases de datos? artículo en el sitio web de MongoDB.

Documentación de la API

Para obtener más información sobre cualquiera de los tipos o métodos analizados en esta guía, consulte la siguiente documentación de API:

Volver

Operaciones compuestas

Configurar las operaciones CRUD