Buscar documentos

Encontrar todos los documentos coincidentes

Para encontrar todos los documentos que coincidan con tus criterios, utiliza el método find(). Este método toma un filtro de query como parámetro. Un filtro de query consta de los campos y valores que forman los criterios para que los documentos coincidan.

El método retorna un tipo Cursor a través del cual puedes iterar para recuperar cualquier documento que coincida con los criterios de filtro.

Para ver un ejemplo que utiliza este método para recuperar datos, consulta el ejemplo de find().

Para obtener más información sobre cómo especificar una query, consulta la guía Especificar una query.

Encuentre un documento

Para encontrar el primer documento que cumpla con tus criterios, usa el método find_one(). Este método toma un filtro de query como parámetro. Un filtro de query consta de los campos y valores que forman los criterios para que los documentos coincidan.

Si un documento coincide con los criterios del filtro, el método devuelve un tipo Result<Option<T>> con un valor de Some. Si ningún documento cumple con los criterios del filtro, find_one() devuelve un tipo Result<Option<T>> con un valor de None.

Para ver un ejemplo que utiliza este método para recuperar datos, consulta el ejemplo de find_one().

Modificar el comportamiento de búsqueda

Puede modificar el comportamiento del método find() encadenando métodos del generador de opciones FindOptions a find(), y puede modificar el comportamiento del método find_one() encadenando métodos del generador de opciones FindOneOptions a find_one().

La siguiente tabla describe los campos de FindOptions y FindOneOptions de uso común que se pueden configurar llamando a sus métodos de construcción correspondientes:

Para una lista completa de ajustes que puede especificar para cada tipo, consulte la documentación de la API para FindOptions y FindOneOptions.

Ejemplo de find()

Este ejemplo realiza las siguientes acciones:

• Llama al método find()

• Pasa un filtro de query a find() que coincide con documentos donde el valor de unit_price es menor que 12.00 y el valor de category no es "kitchen"

• Encadena el método sort() a find() para clasificar los documentos coincidentes por unit_price en orden descendente

let mut cursor = my_coll
    .find(doc! { "$and": vec!
    [
        doc! { "unit_price": doc! { "$lt": 12.00 } },
        doc! { "category": doc! { "$ne": "kitchen" } }
    ] })
    .sort(doc! { "unit_price": -1 })
    .await?;
while let Some(result) = cursor.try_next().await? {
    println!("{:?}", result);
}

Inventory { item: "watering can", category: "garden", unit_price: 11.99 }
Inventory { item: "candle", category: "decor", unit_price: 2.89 }

Ejemplo de archivo completo: Buscar documentos

Este ejemplo recupera los documentos que coinciden con un filtro de query de la colección restaurants en la base de datos sample_restaurants. El método find() devuelve todos los documentos en los que el valor del campo cuisine es "French".

Puedes modelar cada documento recuperado como un tipo Document o un tipo de datos personalizado. Para especificar qué tipo de datos representa los datos de la colección, sustituye el tipo de parámetro <T> en la línea resaltada por uno de los siguientes valores:

• <Document>: Recupera e imprime los documentos de la colección como documentos BSON

• <Restaurant>: Recupera e imprime documentos de la colección como instancias de la estructura Restaurant, definida al inicio del código

Selecciona la pestaña Asynchronous o Synchronous para ver el código correspondiente para cada runtime:

use mongodb::{ 
    bson::doc,
    Client,
    Collection
};
use futures::TryStreamExt;
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: String,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let mut cursor = my_coll.find(
        doc! { "cuisine": "French" }
    ).await?;
    while let Some(doc) = cursor.try_next().await? {
        println!("{:#?}", doc);
    }
    Ok(())
}

use mongodb::{
    bson::doc,
    sync::{Client, Collection}
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: String,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let mut cursor = my_coll.find(
        doc! { "cuisine": "French" }
    ).run()?;
    
    for result in cursor {
        println!("{:#?}", result?);
      }
    Ok(())
}

...
Some(
   Document({
      "_id": ObjectId(
            "...",
      ),
      ...
      "name": String(
            "Cafe Un Deux Trois",
      ),
      ...
   }),
),
Some(
   Document({
      "_id": ObjectId(
            "...",
      ),
      ...
      "name": String(
            "Calliope",
      ),
      ...
   }),
)
...

...
Restaurant {
   name: "Cafe Un Deux Trois",
   cuisine: "French",
}
Restaurant {
   name: "Calliope",
   cuisine: "French",
}
...

Cargar una query desde un archivo: Ejemplo

Puedes almacenar un filtro de query en un archivo JSON y cargarlo en tiempo de ejecución. Este enfoque te permite compartir definiciones de queries entre tu aplicación de Rust y herramientas externas, como el MongoDB Shell (mongosh).

cargo add serde_json

Primero, crea un archivo JSON que contenga tu filtro de query. El siguiente archivo de muestra query.json contiene un filtro de query de comparación que coincide con los documentos en los que el valor del campo category es "kitchen":

{ "category": "kitchen" }

Para cargar este archivo en tu aplicación de Rust, lee el archivo utilizando el método std::fs::read_to_string(). Luego, llama a serde_json::from_str() para analizar el string JSON en una instancia de Document. Debido a que Document implementa el rasgo serde::Deserialize, puedes deserializarlo directamente desde una JSON string.

El siguiente ejemplo lee un filtro de query del archivo query.json y lo pasa al método find():

let json = std::fs::read_to_string("query.json")
    .expect("failed to read query.json");
let filter: Document = serde_json::from_str(&json)
    .expect("query.json contains invalid JSON");
let mut cursor = my_coll.find(filter).await?;
while let Some(doc) = cursor.try_next().await? {
    println!("{:?}", doc);
}

Inventory { item: "blender", category: "kitchen", unit_price: 38.49 }
Inventory { item: "placemat", category: "kitchen", unit_price: 3.19 }

Ejemplo find_one()

Este ejemplo realiza las siguientes acciones:

• Llama al método find_one()

• Pasa un filtro de query a find_one() que coincide con los documentos en los que el valor de unit_price es menor o igual a 20.00

• Encadena el método skip() a find_one() para omitir los primeros dos documentos coincidentes

let result = my_coll
    .find_one(doc! { "unit_price": doc! { "$lte": 20.00 } })
    .skip(2)
    .await?;
println!("{:#?}", result);

Some(
    Inventory {
        item: "watering can",
        category: "garden",
        unit_price: 11.99,
    },
)

Ejemplo de archivo completo: Buscar un documento

Este ejemplo recupera un documento que coincide con un filtro de query de la colección restaurants en la base de datos sample_restaurants. El método find_one() devuelve el primer documento en el que el valor del campo name es "Tompkins Square Bagels".

Puedes modelar el documento recuperado como un tipo Document o un tipo de datos personalizado. Para especificar qué tipo de datos representa los datos de la colección, sustituye el tipo de parámetro <T> en la línea resaltada por uno de los siguientes valores:

• <Document>: Recupera e imprime los documentos de la colección como documentos BSON

• <Restaurant>: Recupera e imprime documentos de la colección como instancias de la estructura Restaurant, definida al inicio del código

Selecciona la pestaña Asynchronous o Synchronous para ver el código correspondiente para cada runtime:

use mongodb::{ 
    bson::doc,
    Client,
    Collection
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: String,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let result = my_coll.find_one(
        doc! { "name": "Tompkins Square Bagels" }
    ).await?;
    println!("{:#?}", result);
    Ok(())
}

use mongodb::{
    bson::doc,
    sync::{Client, Collection}
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: String,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let result = my_coll.find_one(
        doc! { "name": "Tompkins Square Bagels" }
    ).run()?;
    println!("{:#?}", result);
    Ok(())
}

Some(
   Document({
      "_id": ObjectId(
            "...",
      ),
      ...
      "name": String(
            "Tompkins Square Bagels",
      ),
      ...
   }),
)

Some(
   Restaurant {
      name: "Tompkins Square Bagels",
      cuisine: "American",
   },
)

Agrupar datos de documentos

El método aggregate() toma una pipeline de agregación como parámetro. Una pipeline de agregación incluye una o más etapas que especifican cómo transformar los datos. Una etapa incluye un operador de agregación (precedido por un $) y cualquier parámetro requerido para ese operador.

Para obtener más información sobre las agregaciones y ver ejemplos de agregación, consulte la guía de Agregación.

El método devuelve los documentos resultantes en un tipo Cursor. Si tu pipeline de agregación no contiene una etapa $match, el pipeline procesa todos los documentos de la colección.

Modificar el comportamiento de agregación

Puede modificar el comportamiento del método aggregate() encadenando los métodos del generador de opciones AggregateOptions a aggregate().

La siguiente tabla describe los campos de AggregateOptions de uso común que se pueden configurar llamando a los métodos desarrolladores correspondientes:

Para obtener una lista completa de configuraciones, consulta la documentación de la API para AggregateOptions.

Ejemplo

Este ejemplo muestra cómo llamar al método aggregate() con un pipeline que contiene las siguientes etapas:

• $group etapa para calcular el promedio del campo unit_price para cada valor del campo category

• $sort escenario para ordenar los resultados por avg_price en orden ascendente

let pipeline = vec![
    doc! { "$group": doc! { "_id" : doc! {"category": "$category"} ,
    "avg_price" : doc! { "$avg" : "$unit_price" } } },
    doc! { "$sort": { "_id.avg_price" : 1 } },
];
let mut cursor = my_coll.aggregate(pipeline).await?;
while let Some(result) = cursor.try_next().await? {
    println!("{:?}", result);
}

Document({"_id": Document({"category": String("decor")}), "avg_price": Double(2.890000104904175)})
Document({"_id": Document({"category": String("kitchen")}), "avg_price": Double(20.840000867843628)})
Document({"_id": Document({"category": String("garden")}), "avg_price": Double(11.989999771118164)})

Documentación de la API

Para obtener más información sobre los métodos y tipos mencionados en esta guía, vea la siguiente documentación de la API:

• find_one()

• find()

• FindOptions

• FindOneOptions

• Cursor

• aggregate()

• AggregateOptions