Transacciones

Overview

En esta guía, aprenderás a usar el MongoDB Go Driver para realizar transacciones. Transacciones que te permiten ejecutar una serie de operaciones que no cambian ningún dato hasta que la transacción se confirme. Si alguna operación en la transacción devuelve un error, el controlador cancela la transacción y descarta todos los cambios de datos antes de que lleguen a ser 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 usar el controlador de Go, puedes crear una nueva sesión desde una instancia Client como un tipo Session. Recomendamos reutilizar su cliente para múltiples sesiones y transacciones en lugar de crear una nueva instancia de cliente cada vez.

Métodos de sesión

Una vez que inicies una sesión utilizando el método StartSession() en tu cliente, podrás modificar el estado de la sesión usando el método set proporcionado por el Session retornado. La siguiente tabla describe estos métodos:

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

txnOpts := options.Transaction().SetReadConcern(readconcern.Majority())
sessOpts := options.Session().SetDefaultTransactionOptions(txnOpts)
session, err := client.StartSession(sessOpts)
if err != nil {
	return err
}

Ejemplo

Los ejemplos de esta sección usan la siguiente estructura de Book como el modelo de datos para los documentos que se insertarían en una colección:

type Book struct {
	Title  string `bson:"title"`
	Author string `bson:"author"`
}

El siguiente ejemplo muestra cómo puedes crear una sesión, crear una transacción y confirmar una operación de inserción de varios documentos mediante los siguientes pasos:

1. Cree una sesión desde el cliente usando el método StartSession().

2. Utiliza el método WithTransaction() para iniciar una transacción.

3. Inserte varios documentos. El método WithTransaction() ejecuta la inserción y confirma la transacción. Si alguna operación resulta en errores, WithTransaction() gestiona la cancelación de la transacción.

4. Cierra la transacción y la sesión utilizando el método EndSession().

wc := writeconcern.Majority()
txnOptions := options.Transaction().SetWriteConcern(wc)
// Starts a session on the client
session, err := client.StartSession()
if err != nil {
	panic(err)
}
// Defers ending the session after the transaction is committed or ended
defer session.EndSession(context.TODO())
// Inserts multiple documents into a collection within a transaction,
// then commits or ends the transaction
result, err := session.WithTransaction(context.TODO(), func(ctx context.Context) (any, error) {
	result, err := coll.InsertMany(ctx, []any{
		Book{Title: "The Bluest Eye", Author: "Toni Morrison"},
		Book{Title: "Sula", Author: "Toni Morrison"},
		Book{Title: "Song of Solomon", Author: "Toni Morrison"},
	})
	return result, err
}, txnOptions)

wc := writeconcern.Majority()
txnOptions := options.Transaction().SetWriteConcern(wc)
// Starts a session on the client
session, err := client.StartSession()
if err != nil {
	panic(err)
}
// Defers ending the session after the transaction is committed or ended
defer session.EndSession(context.TODO())
err = mongo.WithSession(context.TODO(), session, func(ctx context.Context) error {
	if err = session.StartTransaction(txnOptions); err != nil {
		return err
	}
	docs := []any{
		Book{Title: "The Year of Magical Thinking", Author: "Joan Didion"},
		Book{Title: "Play It As It Lays", Author: "Joan Didion"},
		Book{Title: "The White Album", Author: "Joan Didion"},
	}
	result, err := coll.InsertMany(ctx, docs)
	if err != nil {
		return err
	}
	if err = session.CommitTransaction(ctx); err != nil {
		return err
	}
	fmt.Println(result.InsertedIDs)
	return nil
})
if err != nil {
	if err := session.AbortTransaction(context.TODO()); err != nil {
		panic(err)
	}
	panic(err)
}

Información Adicional

Para obtener más información sobre las operaciones de inserción, consulta la página de conceptos básicos Insertar documentos.

Para obtener más información sobre cómo especificar write concerns en el driver de Go, consulta Nivel de confirmación de escritura (write concern).

Para un ejemplo adicional utilizando sesiones y transacciones con el controlador Go, consulta la entrada de blog para desarrollador sobre Transacciones ACID Multidocumento.