executar uma query de pesquisa Atlas

Visão geral

Neste guia, você pode aprender como usar o driver Rust para executar consultas do Atlas Search em uma coleção. O Atlas Search permite realizar pesquisas de texto completo em collections hospedadas no MongoDB Atlas. Os índices do Atlas Search especificam o comportamento da busca 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 Atlas

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

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

Depois de criar um índice do Atlas Search , adicione o estágio $search em sua array de estágios do 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 do Atlas Search

Este exemplo executa uma query do Atlas 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 Atlas 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 Atlas Search

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

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 abaixo mostra como recuperar metadados para um estágio de agregação do Atlas Search :

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 do Atlas Search . Esses ajudantes permitem que você construa consultas de pesquisa complexas usando o sistema de tipos do Rust para melhor segurança em tempo de compilação.

Atlas Search Operators

O driver Rust é compatível com os seguintes operadores do Atlas Search 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 pesquisar 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	Suporta a consulta e pontuação de valores numéricos, de data e de cadeia de caracteres.
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 do Atlas Search na coleção movies que tenha 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 Atlas Search , consulte a seção Índices do Atlas Search e Vector Search do guia Índices.

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

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 do Atlas Search , consulte a documentação dos operadores do Atlas Search .

Informações adicionais

Para saber mais sobre o Atlas Search, consulte Atlas Search 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

Atlas Vector Search