FAQ

¿Por qué obtengo errores al conectarme a MongoDB?

Si tienes problemas para conectarte a una implementación de MongoDB, consulta la guía de resolución de problemas de conexión para posibles soluciones.

¿Cómo funciona la agrupación de conexiones en el controlador Rust?

Cada servidor en su clúster de MongoDB mantiene un pool de conexiones. Puedes acceder o gestionar el comportamiento del pool de conexiones utilizando una instancia de un ClienteLos grupos de conexiones abren sockets a pedido para admitir operaciones simultáneas en su aplicación multiproceso.

Se puede configurar el siguiente pool de conexiones:

• Tamaño máximo y mínimo, establecido por el max_pool_size y min_pool_size opciones

• Número máximo de conexiones que el pool crea en paralelo, establecido por la opción max_connecting

• Tiempo máx. inactivo, configurado mediante la opción max_idle_time

Para obtener más información sobre la agrupación de conexiones, consulte la sección Grupo de conexiones de la guía Consideraciones de rendimiento.

¿Cómo convierto entre BSON y tipos de Rust?

El driver de Rust y la librería BSON utilizan el framework Serde para realizar conversiones entre tipos personalizados de Rust y BSON. Puedes añadir la caja serde a tu archivo Cargo.toml para acceder a la funcionalidad del framework Serde. Para obtener instrucciones sobre cómo añadir esta caja, consulta serde en el registro de cajas.

Después de agregar la caja a tu aplicación, puedes modelar los documentos en una colección utilizando un tipo personalizado en lugar de un documento BSON. El siguiente ejemplo incluye el atributo derive antes de la definición de estructura Vegetable, lo que indica al driver que realice las siguientes acciones cuando sea necesario:

• Serializar la estructura, que convierte la estructura a BSON

• Deserializar BSON, que convierte los datos BSON en tu struct

#[derive(Serialize, Deserialize)]
struct Vegetable {
   // Add struct fields here
}

A continuación, puedes crear una instancia de Collection con tu propio tipo struct personalizado como parámetro de tipo genérico. En el siguiente ejemplo, se asigna una instancia de Collection parametrizada con el tipo Vegetable a la variable my_coll:

let my_coll: Collection<Vegetable> = client.database("db").collection("vegetables");

Para obtener más información sobre la conversión entre tipos BSON y Rust, consulte la guía Modelado y serialización de datos y el artículo Estructuración de datos con Serde en Rust MongoDB Developer Center.

¿Cómo puedo solucionar los errores de límites de características insatisfechos?

Los límites de atributos permiten a los métodos restringir los tipos que aceptan como parámetros y la funcionalidad que deben implementar. Por ejemplo, si define un método que acepta un parámetro de tipo genérico e imprime su valor, el parámetro debe implementar el atributo Display para la impresión. El siguiente ejemplo define el método printer() y especifica que su parámetro debe implementar Display:

fn printer<T: Display>(t: T) {
   println!("{}", t);
}

Al llamar a un método en un tipo de dato, puede que encuentres un error que indique que los límites del rasgo del método no se cumplen. Por ejemplo, el controlador puede generar el siguiente mensaje de error cuando se llama al método try_next() en una instancia Cursor:

error[E0599]: the method `try_next` exists for struct `mongodb::Cursor<T>`,
but its trait bounds were not satisfied

El Cursor<T> tipo solo implementa el Stream atributo, necesario para acceder al try_next() método, si se cumplen los límites del T atributo. Es decir, T debe implementar el DeserializeOwned atributo, como se especifica en la documentación de la API Cursor. El siguiente ejemplo replica el mensaje de error anterior definiendo una estructura personalizada Actor para modelar los documentos de la actors colección. Sin embargo, esta estructura no implementa el DeserializeOwned atributo, y usar el try_next() método para iterar sobre las Actor instancias genera un error:

struct Actor {
   name: String,
}
// Add setup code here
let my_coll: Collection<Actor> = client.database("db").collection("actors");
let mut cursor = my_coll.find(doc! {}).await?;
while let Some(result) = cursor.try_next().await? {
     println!("{:?}", result);
 };

Para resolver el error de límites de rasgo, identifique el tipo de dato sobre el que itera el cursor y asegúrese de que este tipo de dato implemente el rasgo DeserializeOwned. Puede usar el atributo derive para aplicar el límite de rasgo requerido.

El siguiente ejemplo ajusta la definición de la estructura Actor para implementar Deserialize:

#[derive(Deserialize)]
struct Actor {
   name: String,
}

Para obtener más información sobre los límites de rasgos, consulte los siguientes recursos:

• Límites en la documentación del lenguaje Rust

• Derive en la documentación del lenguaje Rust

¿Cómo proceso un valor envuelto en un Enum Result u Option?

Rust proporciona los enumerados Result y Option como salvaguardias para el código de tu aplicación. Muchos métodos ofrecidos por el controlador Rust devuelven valores encapsulados en uno de estos dos tipos.

La enumeración Result puede devolver las siguientes variantes:

• Ok(T): envuelve el valor del resultado de la operación

• Err(E): envuelve un valor de error si la operación no tiene éxito

Por ejemplo, el método insert_one() devuelve un tipo Result para envolver una respuesta exitosa o un error.

Para acceder al resultado sin envolver de insert_one(), utiliza el operador ?. Si la operación es exitosa, el método retorna la variante Ok(InsertOneResult) del enum Result. En este caso, el operador ? desempaqueta el valor InsertOneResult y lo asigna a la variable insert_one_result. Si la operación no tiene éxito, el método retorna la variante Err(E) del enum, y el operador ? desempaqueta y retorna el valor del error. El siguiente código muestra la sintaxis para usar el operador ? al manejar el resultado de una operación de inserción:

let insert_one_result = my_coll.insert_one(doc).await?;

Alternativamente, puede crear una condicional para gestionar los valores desenvueltos de InsertOneResult. El siguiente código utiliza la palabra clave match para procesar el resultado insert_one():

let insert_one_result = my_coll.insert_one(doc).await;
match insert_one_result {
   Ok(val) => {
     println!("Document inserted with ID: {}", val.inserted_id);
   },
   Err(err) => {
     println!("Operation not successful");
   }
}

La enumeración Option puede devolver las siguientes variantes:

• None: representa un valor vacío devuelto por una operación

• Some(T): envuelve un valor de retorno no vacío

Algunos métodos de los drivers de Rust devuelven un tipo Option, como el método read_concern(). Este método retorna un Option que contiene un valor vacío, si no existe un nivel de consistencia de lectura, o un valor ReadConcern.

Para acceder al resultado de read_concern(), puede usar la misma sintaxis match que se muestra en el ejemplo anterior para procesar las variantes None y Some(T). Alternativamente, puede usar la sintaxis if let para procesar solo la variante Some(T). El siguiente código desempaqueta e imprime el valor de retorno read_concern() no vacío, si existe:

if let Some(rc) = my_coll.read_concern() {
   println!("Read concern: {:?}", rc);
}

Para obtener más información sobre los enums Result y Option, consulta los siguientes recursos en la documentación del lenguaje Rust:

• Resultado

• Opción

• ? operador

• Flujo de control conciso con if let