Ejecutar una consulta de búsqueda de MongoDB

Datos de muestra

El ejemplo de esta guía utiliza el movies Colección en la sample_mflix base de datos de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulte la guía "Comenzar con Atlas".

Ejemplo de búsqueda en MongoDB

Este ejemplo ejecuta una consulta de búsqueda de MongoDB realizando las siguientes acciones:

• Crea una etapa $search que indica al controlador que consulte documentos en los que el campo title contiene la palabra "Alabama"

• Crea una etapa $project que indica al controlador que incluya el campo title en los resultados de la consulta

• Pasa las etapas de la canalización al método aggregate() e imprime los 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"
}

Operadores de búsqueda de MongoDB

El controlador Rust admite los siguientes operadores de búsqueda de MongoDB a través de la construcción de documentos BSON:

Ejemplo de etapa de búsqueda en el pipeline

Antes de poder ejecutar este ejemplo, debe crear un índice de búsqueda de MongoDB en la colección movies que tenga la siguiente definición:

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

Para obtener más información sobre la creación de índices de búsqueda de MongoDB, consulte la sección Índices de búsqueda de MongoDB y de búsqueda vectorial de la guía Índices.

Puede reemplazar el marcador de posición <search index name> en el código con el nombre de su índice de búsqueda de MongoDB.

El siguiente código crea una etapa $search que tiene las siguientes especificaciones:

• Comprueba que la matriz genres incluye "Comedy"

• Busca en el campo fullplot la frase "new york"

• Coincide con year valores entre 1950 y 2000, inclusive

• Busca title valores que comiencen con el término "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 obtener más información sobre los operadores de búsqueda de MongoDB, consulte la documentación de Operadores de búsqueda de MongoDB.

Construcción de query tipo segura

El controlador de MongoDB para Rust proporciona métodos auxiliares con seguridad de tipos para construir consultas de búsqueda de MongoDB. Estos auxiliares utilizan el sistema de tipos de Rust para proporcionar validación en tiempo de compilación y una mejor compatibilidad con IDE en comparación con la construcción de documentos BSON sin formato.

El siguiente ejemplo crea una consulta de autocompletar con seguridad de tipo utilizando el 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?;

La consulta del ejemplo anterior realiza las siguientes operaciones:

1. Utiliza el método autocomplete() para buscar títulos que comiencen con "pre"

2. Se utiliza el método fuzzy() para añadir tolerancia a errores tipográficos con parámetros específicos:

   • maxEdits:Establece el número máximo de cambios de caracteres permitidos. 1

   • prefixLength:Establece el número de caracteres al principio que deben coincidir exactamente con 1

   • maxExpansions:Establece el número máximo de variaciones a considerar 256

3. Utiliza el método into_stage() para generar el documento BSON $search adecuado

4. Limita la salida a 10 documentos

5. Devuelve solo el campo title, excluyendo _id

Documentación de la API

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

• agregar()

• Cliente

• Colección