/ /

/ /

Librerías de clientes

Rust

Driver Rust

Operaciones CRUD

Configurar las operaciones CRUD

Overview

En esta guía, aprenderá a configurar las operaciones de lectura y escritura en el controlador de Rust.

Ajustes de lectura y guardar

Puedes controlar cómo el driver direcciona las operaciones de lectura configurando una preferencia de lectura. También puede controlar las opciones de cómo el driver espera la confirmación de las operaciones de lectura y escritura en un set de réplicas configurando un nivel de consistencia de lectura y un nivel de confirmación de escritura (write concern).

De forma predeterminada, las bases de datos heredan estas configuraciones de la Client instancia, y las colecciones las heredan de la base de datos. Sin embargo, puede establecer configuraciones de lectura o escritura personalizadas para una base de datos o colección mediante el uso de base_de_datos_con_opciones()o el método collection_with_options(). Estos métodos crean una nueva instancia Database o Collection con la configuración especificada.

Para configurar los ajustes de lectura o escritura, cree una instancia del tipo ReadConcern, WriteConcern o SelectionCriteria y pásela al generador de opciones.

Tip

Para obtener más información sobre la configuración de lectura y escritura, consulta las siguientes guías en el manual del servidor MongoDB:

Las siguientes secciones muestran cómo configurar los ajustes de lectura y escritura a nivel de cliente, base de datos y colección.

Configuración del cliente

Este ejemplo muestra cómo establecer la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una Client instancia pasando un ClientOptions objeto al método Client::with_options(). El código configura los siguientes ajustes:

Secondary Preferencia de lectura: las operaciones de lectura recuperan datos de los miembros del conjunto de réplicas secundarias
local Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas
Majority nivel de confirmación de escritura (write concern): La mayoría de todos los miembros del conjunto de réplicas deben reconocer la operación de escritura

let read_preference = ReadPreference::Secondary {
    options: Default::default(),
};
let selection_criteria = SelectionCriteria::ReadPreference(read_preference);
let read_concern = ReadConcern::local();
let write_concern = WriteConcern::builder().w(Acknowledgment::Majority).build();
let client_options = ClientOptions::builder()
    .selection_criteria(selection_criteria)
    .read_concern(read_concern)
    .write_concern(write_concern)
    .build();
let client = Client::with_options(client_options)?;

Como alternativa, puede especificar la configuración de lectura y escritura en la URI de conexión y, a continuación, pasar la URI al constructor Client::with_uri_str() como se muestra en el siguiente ejemplo:

let uri = "<connection string>/?readPreference=secondary&readConcernLevel=local&w=majority";
let client = Client::with_uri_str(uri).await?;

Configuración de la base de datos

Este ejemplo muestra cómo establecer la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una base de datos llamada test_database pasando un DatabaseOptions objeto al método database_with_options(). El código configura los siguientes ajustes:

PrimaryPreferred preferencia de lectura: Las operaciones de lectura recuperan datos desde el miembro principal del set de réplicas, o desde miembros secundarios si el principal no está disponible.
available Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas
majority nivel de confirmación de escritura (write concern): La mayoría de todos los miembros del conjunto de réplicas deben reconocer la operación de escritura

let read_preference = ReadPreference::PrimaryPreferred {
    options: Default::default(),
};
let selection_criteria = SelectionCriteria::ReadPreference(read_preference);
let read_concern = ReadConcern::available();
let write_concern = WriteConcern::majority();
let database_options = DatabaseOptions::builder()
    .selection_criteria(selection_criteria)
    .read_concern(read_concern)
    .write_concern(write_concern)
    .build();
let database = client.database_with_options("test_database", database_options);

Configuración de la colección

Este ejemplo muestra cómo establecer la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una colección llamada test_collection pasando un CollectionOptions objeto al método collection_with_options(). El código configura los siguientes ajustes:

SecondaryPreferred Preferencia de lectura: Las operaciones de lectura recuperan datos de los miembros secundarios del conjunto de réplicas, o del miembro principal si no hay secundarios disponibles.
available Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas
w: 0 Problema de escritura: El cliente no solicita confirmación de la operación de escritura.

let read_preference = ReadPreference::SecondaryPreferred {
    options: Default::default(),
};
let selection_criteria = SelectionCriteria::ReadPreference(read_preference);
let read_concern = ReadConcern::available();
let write_concern = WriteConcern::builder().w(0.into()).build();
let collection_options = CollectionOptions::builder()
    .selection_criteria(selection_criteria)
    .read_concern(read_concern)
    .write_concern(write_concern)
    .build();
let collection = database.collection_with_options("test_collection", collection_options);

Lecturas y Guardados Reintentarles

El controlador de Rust reintenta automáticamente ciertas operaciones de lectura y escritura una vez si fallan debido a un error de red o del servidor.

Puede deshabilitar explícitamente las lecturas o escrituras reintentables configurando la opción retry_reads o retry_writes a false al crear una instancia ClientOptions. El siguiente ejemplo deshabilita las lecturas y escrituras reintentables para un cliente:

let client_options = ClientOptions::builder()
    .retry_reads(false)
    .retry_writes(false)
    .build();
let client = Client::with_options(client_options)?;

Para obtener más información sobre las operaciones de lectura repetibles admitidas, consulte Lecturas repetibles en el manual de MongoDB Server. Para obtener más información sobre las operaciones de escritura reintentables admitidas, consulta Escrituras reintentables en el manual del MongoDB Server.

Intercalación

Puedes especificar una intercalación para modificar el comportamiento de las operaciones de lectura y escritura. Una intercalación es un conjunto de reglas específicas de cada lenguaje para la comparación de strings, como las relacionadas con las mayúsculas y los signos diacríticos.

Para obtener más información sobre las intercalaciones y ver ejemplos de código, consulte la Guíade cotejos.

Documentación de la API

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

Volver

Operaciones compuestas

Almacene archivos grandes