Executar uma query de pesquisa do MongoDB

Visão geral

Neste guia, você pode aprender como usar o driver Rust para executar queries de pesquisa do MongoDB Search em uma coleção. O MongoDB Search permite realizar pesquisas de texto completo em coleções hospedadas no MongoDB Atlas. Os índices de pesquisa do MongoDB especificam o comportamento da pesquisa e quais campos indexar.

Dados de amostra

O exemplo neste guia usa a coleção movies no banco de dados sample_mflix dos conjuntos de dados de amostra do Atlas. Para aprender como criar um cluster do MongoDB Atlas gratuito e carregar os conjuntos de dados de amostra, consulte o guia Introdução ao Atlas.

Executar uma query de pesquisa do MongoDB

Esta seção mostra como criar um pipeline de agregação para executar uma query de pesquisa do MongoDB Search em uma coleção.

Para executar uma query de pesquisa do MongoDB Search, você deve criar um índice de pesquisa do MongoDB Search em sua coleção. Para saber como criar programaticamente um índice de pesquisa do MongoDB, consulte a seção Índices de Pesquisa do MongoDB Search e Vector Search do guia Índices. Você pode substituir o espaço reservado <search index name> nos exemplos de código deste guia pelo nome do seu índice de pesquisa do MongoDB.

Depois de criar um índice de pesquisa MongoDB, adicione o estágio $search em sua array de estágios de pipeline para especificar os critérios de pesquisa. Em seguida, chame o método aggregate() e passe sua array de pipeline como parâmetro.

Dica

Para saber mais sobre as operações de agregação, consulte o Guia de agregação.

Exemplo de pesquisa do MongoDB

Este exemplo executa uma query de pesquisa do MongoDB Search executando as seguintes ações:

Cria um estágio $search que instrui o driver a fazer query de documentos nos quais o campo title contém a palavra "Alabama"
Cria uma etapa $project que instrui o driver a incluir o campo title nos resultados da consulta
Passa as fases do pipeline para o método aggregate() e imprime os resultados

use mongodb::{
       bson::{doc, Document},
       Client, Collection,
   };
use futures::stream::TryStreamExt;
#[tokio::main]
  async fn main() -> mongodb::error::Result<()> {
    // Replace the uri string with your connection string
    let uri = "<connection string uri>";
    let client = Client::with_uri_str(uri).await?;
    let my_coll: Collection<Document> = client
        .database("sample_mflix")
        .collection("movies");
    // Defines the MongoDB Search query
    let pipeline = vec![
        doc! {
          "$search": {
            "index": "<search index name>",
              "text": {
                "query": "Alabama",
                "path": "title"
              }
          }
        },
        doc! {
          "$project": {
            "title": 1,
            "_id": 1
            }
        }
    ];
    // Runs the aggregation pipeline
    let mut cursor = my_coll.aggregate(pipeline).await?;
    // Prints the results
    while let Some(doc) = cursor.try_next().await? {
      println!("{}", doc);
    }
    Ok(())
  }

{
  "_id": ObjectId("..."),
  "title": "Alabama Moon"
}
{
  "_id": ObjectId("..."),
  "title": "Crazy in Alabama"
}
{
  "_id": ObjectId("..."),
  "title": "Sweet Home Alabama"
}

Metadados de pesquisa do MongoDB

Use o estágio de pipeline $searchMeta para criar um estágio de agregação $searchMeta, que retorna somente os metadados dos resultados do MongoDB pesquisa.

Dica

Disponível apenas no Atlas para MongoDB v4,4,11 e posterior

Este operador de pipeline de agregação está disponível somente em clusters do MongoDB Atlas executando a versão v4.4.11 ou posterior.

O exemplo a seguir mostra como recuperar metadados para um estágio de agregação do MongoDB pesquisa:

use mongodb::{
    bson::{doc, Document, DateTime},
    Client, Collection,
};
use futures::stream::TryStreamExt;
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    // Replace the uri string with your connection string
    let uri = "<connection string uri>";
    let client = Client::with_uri_str(uri).await?;
    let my_coll: Collection<Document> = client
        .database("sample_mflix")
        .collection("movies");
    // Defines the $searchMeta pipeline stage
    let pipeline = vec![
        doc! {
            "$searchMeta": {
                "index": "<search index name>",
                "near": {
                    "path": "released",
                    "origin": DateTime::parse_rfc3339_str("2011-09-01T00:00:00.000Z")
                        .unwrap(),
                    "pivot": 7776000000i64
                }
            }
        }
    ];
    let mut cursor = my_coll.aggregate(pipeline).await?;
    while let Some(doc) = cursor.try_next().await? {
        println!("{}", doc);
    }
    Ok(())
}

{
  "count": 3,
  "hits": [
    {
      "id": ObjectId("..."),
      "score": 1.0
    },
    {
      "id": ObjectId("..."),
      "score": 1.0
    },
    {
      "id": ObjectId("..."),
      "score": 1.0
    }
  ]
}

Criar estágios de pesquisa de pipeline

O driver MongoDB Rust fornece métodos assistente e construtores para criar estágios de pipeline da MongoDB pesquisa. Esses assistentes permitem que você construa querys de pesquisa complexas usando o sistema de tipos do Rust para melhor segurança em tempo de compilação.

Operadores de pesquisa do MongoDB

O driver Rust oferece suporte aos seguintes operadores da pesquisa MongoDB por meio da construção de documento BSON:

Operador	Descrição
autocompletar	Executa uma pesquisa por uma palavra ou frase que contém uma sequência de caracteres de uma string de entrada incompleta.
composto	Combina dois ou mais operadores em uma única query.
é igual a	Verifica se um campo corresponde a um valor que você especificou.
existe	Testa se existe um caminho para um nome de campo indexado especificado em um documento.
geo	Para queries geográficas que permitem pesquisa por localização.
realçar	Para retornar os trechos de texto que correspondem aos critérios de pesquisa, útil para interfaces de usuário que precisam destacar termos de pesquisa.
Em	Executa uma pesquisa por uma array de valores de número BSON, data, boolean, ObjectId, uuid ou string no caminho fornecido e retorna documentos em que o valor do campo é igual a qualquer valor na array especificada.
moreLikeThis	Retorna documentos semelhantes aos documentos de entrada.
perto	Suporta a consulta e pontuação de valores numéricos, de data e de ponto GeoJSON .
frase	Executa uma pesquisa de documentos contendo uma sequência ordenada de termos usando o analisador especificado na configuração do índice.
String de query	Suporta a realização de query de uma combinação de campos e valores indexados.
faixa	Suporte para consulta e pontuação de valores numéricos, de data e de string.
regex	Interpreta o campo de query como uma expressão regular.
text	Executa uma pesquisa de texto completo usando o analisador especificado na configuração do índice.
curinga	Habilita queries que usam caracteres especiais na string de pesquisa que podem corresponder a qualquer caractere.

Exemplo de estágio de pesquisa de pipeline

Observação

Conjunto de Dados de Amostra do Atlas

Este exemplo utiliza a collection sample_mflix.movies a partir do conjunto de dados de amostra do Atlas . Para saber como configurar um Atlas cluster de camada grátis e carregar o conjunto de dados de amostra, consulte o tutorial Introdução ao Atlas na documentação do Atlas.

Antes de executar este exemplo, você deve criar um índice de pesquisa MongoDB na coleção movies que tem a seguinte definição:

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "title": {
        "analyzer": "lucene.keyword",
        "type": "string"
      },
      "genres": {
        "normalizer": "lowercase",
        "type": "token"
      }
    }
  }
}

Para saber mais sobre como criar índices do MongoDB Search, consulte a seção Índices do MongoDB Search e Vector Search do guia de Índices.

Você pode substituir o espaço reservado <search index name> no código pelo nome do seu índice de pesquisa MongoDB.

O seguinte código cria um estágio $search que tem as seguintes especificações:

Verifica se a array genres inclui "Comedy"
Pesquisa no campo fullplot a frase "new york"
Corresponde a year valores entre 1950 e 2000, inclusive
Pesquisa valores title que começam com o termo "Love"

use mongodb::{
    bson::{doc, Document},
    Client, Collection,
};
use futures::stream::TryStreamExt;
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    // Replace the uri string with your connection string
    let uri = "<connection string uri>";
    let client = Client::with_uri_str(uri).await?;
    let my_coll: Collection<Document> = client
        .database("sample_mflix")
        .collection("movies");
    // Creates a complex search using multiple operators
    let search_stage = doc! {
        "$search": {
            "index": "<search index name>",
            "compound": {
                "must": [
                    {
                        "equals": {
                            "path": "genres",
                            "value": "Comedy"
                        }
                    },
                    {
                        "phrase": {
                            "path": "fullplot",
                            "query": "new york"
                        }
                    },
                    {
                        "range": {
                            "path": "year",
                            "gte": 1950,
                            "lte": 2000
                        }
                    },
                    {
                        "wildcard": {
                            "path": "title",
                            "query": "Love*"
                        }
                    }
                ]
            }
        }
    };
    let project_stage = doc! {
        "$project": {
            "title": 1,
            "year": 1,
            "genres": 1,
            "_id": 1
        }
    };
    let pipeline = vec![search_stage, project_stage];
    let mut cursor = my_coll.aggregate(pipeline).await?;
    while let Some(doc) = cursor.try_next().await? {
        println!("{}", doc);
    }
    Ok(())
}

{
  "_id": ObjectId("..."),
  "genres": ["Comedy", "Romance"],
  "title": "Love at First Bite",
  "year": 1979
}
{
  "_id": ObjectId("..."),
  "genres": ["Comedy", "Drama"],
  "title": "Love Affair",
  "year": 1994
}

Para saber mais sobre os operadores de pesquisa do MongoDB, consulte a documentação Operadores de pesquisa do MongoDB.

Construção de query segura por tipo

O MongoDB Rust driver fornece métodos assistente seguros por tipo para construir queries de pesquisa do MongoDB. Esses assistentes usam o sistema de tipos do Rust para fornecer validação em tempo de compilação e melhor suporte a IDE em comparação com a construção de documento BSON bruto.

O exemplo a seguir cria uma query de preenchimento automático com segurança de tipo usando o módulo atlas_search:

use mongodb::atlas_search;
let cursor = collection.aggregate(vec![
    atlas_search::autocomplete("title", "pre")
        .fuzzy(doc! { "maxEdits": 1, "prefixLength": 1, "maxExpansions": 256 })
        .into_stage(),
    doc! {
        "$limit": 10,
    },
    doc! {
        "$project": {
            "_id": 0,
            "title": 1,
        }
    },
]).await?;

A query no exemplo anterior executa as seguintes operações:

Utiliza o método autocomplete() para realizar a pesquisa de títulos que começam com "pre"
Usa o método fuzzy() para adicionar tolerância para erros de digitação com parâmetros específicos:
- maxEdits: define o número máximo de alterações de caracteres permitidas para 1
- prefixLength: define o número de caracteres no início que devem corresponder exatamente a 1
- maxExpansions: define o número máximo de variações a considerar para 256
Usa o método into_stage() para gerar o documento BSON $search adequado
Limita a saída a 10 documentos
Retorna somente o campo title, excluindo _id

Informações adicionais

Para aprender mais sobre o MongoDB pesquisa, consulte MongoDB pesquisa na documentação do Atlas.

Documentação da API

Para saber mais sobre os métodos mencionados neste guia, consulte a seguinte documentação da API:

Voltar

Indexes

MongoDB Vector Search