FAQ

¿Por qué obtengo errores al conectarme a MongoDB?

Si tiene problemas para conectarse a una implementación de MongoDB, consulte la guía de solución de problemas de conexión para obtener posibles soluciones.

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

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

Puede configurar las siguientes funciones del grupo 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 grupo crea en paralelo, establecido por la opción max_connecting

• Tiempo máximo de inactividad, establecido por 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 tipos BSON y Rust?

El controlador de Rust y la biblioteca BSON utilizan el framework Serde para realizar conversiones entre tipos personalizados de Rust y BSON. Puede agregar el serde paquete a su Cargo.toml archivo para acceder a la funcionalidad del framework Serde. Para obtener instrucciones sobre cómo agregar este paquete,consulte serde en el registro de paquetes.

Tras añadir el contenedor a la aplicación, puede modelar los documentos de 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 la estructura Vegetable, que indica al controlador que realice las siguientes acciones cuando sea necesario:

• Serializar la estructura, que convierte la estructura a BSON

• Deserializar BSON, que convierte los datos BSON a su estructura

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

Luego, puede crear una instancia Collection con su tipo de estructura personalizado como parámetro de tipo genérico. El siguiente ejemplo asigna una instancia 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 corregir errores de límites de rasgos no satisfechos?

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

• Derivar en la documentación del lenguaje Rust

¿Cómo proceso un valor incluido en una enumeración de resultados u opciones?

Rust proporciona las enumeraciones Result y Option como protección para el código de su aplicación. Muchos métodos del controlador de 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 es exitosa

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

Para acceder al resultado desempaquetado de insert_one(), utilice el operador ?. Si la operación se realiza correctamente, el método devuelve la variante Ok(InsertOneResult) de la enumeración Result. En este caso, el operador ? desempaqueta el valor InsertOneResult y lo asigna a la variable insert_one_result. Si la operación no se realiza correctamente, el método devuelve la variante Err(E) de la enumeración y el operador ? desempaqueta y devuelve el valor de error. El siguiente código muestra la sintaxis para usar el operador ? al gestionar el resultado de una operación de inserción:

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

Como alternativa, puede crear una condición para gestionar los valores desempaquetados de InsertOneResult. El siguiente código usa 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 del controlador de Rust devuelven un tipo Option, como el método read_concern(). Este método devuelve un Option que encapsula un valor vacío (si no existe un problema 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 las enumeraciones Result y Option, consulte los siguientes recursos en la documentación del lenguaje Rust:

• Resultado

• Opción

• ¿Operador?

• Flujo de control conciso con if let