/ /

Transacciones y Sesiones

Overview

En esta guía, aprenderá a usar el controlador Kotlin Sync para realizar transacciones. Las transacciones permiten ejecutar una serie de operaciones que no modifican ningún dato hasta que se confirman. Si alguna operación de la transacción devuelve un error, el controlador la cancela y descarta todos los cambios en los datos antes de que sean visibles.

En MongoDB, las transacciones se ejecutan dentro de sesiones lógicas. Una sesión es una agrupación de operaciones de lectura o escritura relacionadas que se ejecutan secuencialmente. Las sesiones permiten la consistencia causal de un grupo de operaciones y ejecutarlas en una transacción compatible con ACID, que cumple con los requisitos de atomicidad, consistencia, aislamiento y durabilidad. MongoDB garantiza que los datos involucrados en las transacciones se mantengan consistentes, incluso si se producen errores inesperados.

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

Advertencia

Use un ClientSession solo con el MongoClient (o el MongoDatabase o MongoCollection asociado) que lo creó. Usar un ClientSession con un MongoClient diferente genera errores de operación.

Coherencia causal

MongoDB permite la consistencia causal en ciertas sesiones de cliente. El modelo de consistencia causal garantiza que, en un sistema distribuido, las operaciones dentro de una sesión se ejecuten en un orden causal. Los clientes observan resultados consistentes con las relaciones causales o las dependencias entre operaciones. Por ejemplo, si se realiza una serie de operaciones donde una depende lógicamente del resultado de otra, las lecturas posteriores reflejan la 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 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ía	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 anterior.
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 ejecuta primero las operaciones de lectura. Por ejemplo, si llama a `find()` para recuperar un documento y luego llama a `deleteOne()` para eliminar el documento recuperado, el servidor ejecuta primero la operación de búsqueda.

Tip

Para obtener más información sobre los conceptos mencionados en esta sección, consulte las siguientes entradas del manual de MongoDB Server:

Datos de muestra

Los ejemplos de esta guía usan la colección sample_restaurants.restaurants de los conjuntos de datos de muestra de Atlas. Para aprender cómo crear una implementación gratuita de MongoDB y cargar los conjuntos de datos de muestra, consulta la guía MongoDB Comenzar.

Los documentos de esta colección están modelados por la siguiente clase de datos de Kotlin:

data class Restaurant(val name: String, val cuisine: String)

Métodos

Cree una instancia ClientSession con el método startSession() en su instancia MongoClient. A continuación, puede modificar el estado de la sesión con los métodos proporcionados por ClientSession. La siguiente tabla describe los métodos que puede usar para administrar su transacción:

Método	Descripción
`startTransaction()`	Starts a new transaction, configured with the given options, on this session. Returns an error if there is already a transaction in progress for the session. To learn more about this method, see the startTransaction() page in the Server manual. Parameter: `TransactionOptions`
`abortTransaction()`	Ends the active transaction for this session. Returns an error if there is no active transaction for the session or the transaction has been committed or ended. To learn more about this method, see the abortTransaction() page in the Server manual.
`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. To learn more about this method, see the commitTransaction() page in the Server manual.
`withTransaction()`	Starts a transaction on this session and runs the given function within a transaction. Parameters: transaction body function, `TransactionOptions`

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 Sección Transacciones de la guía Limitar el tiempo de ejecución del servidor.

Ejemplo

El siguiente ejemplo demuestra cómo crear una sesión, crear una transacción e insertar documentos en una colección en una transacción a través de los siguientes pasos:

Cree una sesión desde el cliente utilizando el método startSession().
Define el método insertRestaurantsInTransaction() para insertar varios documentos en la colección restaurants.
Utilice el método withTransaction() para iniciar una transacción. El método withTransaction() ejecuta las operaciones de inserción y confirma la transacción. Si alguna operación genera errores, withTransaction() cancela la transacción.
Cierre la conexión al servidor utilizando el método MongoClient.close().

// Creates a new MongoClient to manage your connection
val client = MongoClient.create("<connection string>")
// Gets the database and collection
val database = client.getDatabase("sample_restaurants")
val collection = database.getCollection<Restaurant>("restaurants")
// Inserts restaurants into the collection
fun insertRestaurantsInTransaction(session: ClientSession) {
    // Inserts restaurants within the transaction
    collection.insertOne(
        session,
        Restaurant("Kotlin Sync Pizza", "Pizza")
    )
    collection.insertOne(
        session,
        Restaurant("Kotlin Sync Burger", "Burger")
    )
}
// Starts a client session
client.startSession().use { session ->
    try {
        // Sets transaction options
        val txnOptions = TransactionOptions.builder()
            .readConcern(ReadConcern.LOCAL)
            .writeConcern(WriteConcern.MAJORITY)
            .build()
        // Uses the withTransaction method to start a transaction and run the given function
        session.withTransaction({
            insertRestaurantsInTransaction(session)
            println("Transaction succeeded")
        }, txnOptions)
    } catch (e: Exception) {
        println("Transaction failed: ${e.message}")
    }
}
// Closes the MongoClient
client.close()

Si necesita mayor control sobre sus transacciones, puede usar el método startTransaction(). Puede usar este método junto con los métodos commitTransaction() y abortTransaction() descritos en la sección anterior para administrar manualmente el ciclo de vida de las transacciones.

Nota

Operaciones paralelas no admitidas

El controlador Kotlin Sync no admite la ejecución de operaciones paralelas dentro de una sola transacción.

Si usa MongoDB Server v8.0 o posterior, puede realizar operaciones de escritura en varios espacios de nombres dentro de una sola transacción mediante operaciones de escritura masiva. Para obtener más información, consulte la sección "Escritura masiva del cliente" de la guía "Operaciones de escritura masiva".

Información Adicional

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

Para obtener más información sobre el cumplimiento de ACID, consulte el artículo ¿Qué son las propiedades ACID en los sistemas de administración de bases de datos? en el sitio web de MongoDB.

Documentación de la API

Para aprender más sobre cualquiera de los tipos o métodos discutidos en esta guía, consulta la siguiente documentación de la API:

Volver

Operaciones de escritura masiva

Configurar las operaciones CRUD