Localizar vários documentos

Nesta página

Exemplo
Saída

Você pode fazer query de vários documentos em uma coleção chamando o métodofind() em uma Collection instância.

Passe um filtro de query para o método find() para retornar documentos na coleção que correspondam ao filtro. Se você não incluir um filtro, o MongoDB retornará todos os documentos na coleção.

Dica

Para saber mais sobre como recuperar documentos, consulte o guia Recuperar dados e, para saber mais sobre como criar filtros de query, consulte o guia Especificar uma query .

O find() método retorna um cursor tipo, que você pode iterar para recuperar documentos individuais. Para saber mais sobre o uso de cursores, consulte o guia Acessar dados usando um cursor .

Exemplo

Este exemplo recupera documentos que correspondem a um filtro de query da coleção restaurants no banco de dados sample_restaurants . O método find() retorna todos os documentos em que o valor do campo cuisine é "French".

Você pode modelar cada documento recuperado como um tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, substitua o parâmetro de tipo <T> na linha realçada por um dos seguintes valores:

<Document>: Recupera e imprime documentos de coleção como documentos BSON
<Restaurant>: recupera e imprime documentos de coleção como instâncias da estrutura Restaurant, definida na parte superior do código

Selecione a aba Asynchronous ou Synchronous para ver o código correspondente para cada tempo de execução:

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(())
}

Saída

Selecione a aba BSON Document Results ou Restaurant Struct Results para ver a saída de código correspondente com base no parâmetro de tipo da sua coleção:

...
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",
}
...

Voltar

encontrar um

insertOne