Ejecuta una MongoDB Search query

Datos de muestra

El ejemplo de esta guía utiliza la colección movies en la base de datos sample_mflix de los Conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los datasets de muestra, consulta la guía Primeros Pasos con Atlas.

MongoDB Search Ejemplo

Este ejemplo ejecuta una MongoDB Search al realizar las siguientes acciones:

• Crea una etapa $search que indica al driver que haga queries para documentos en los que el campo title contenga la palabra "Alabama"

• Crea una etapa $project que instruya al driver para incluir el campo title en los resultados de la query.

• Pasa las etapas de la pipeline 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"
}

MongoDB Search Operadores

El controlador de Rust admite los siguientes operadores de búsqueda de MongoDB mediante la construcción de documentos BSON:

Ejemplo de etapa de búsqueda en el pipeline

Antes de poder ejecutar este ejemplo, debes 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 cómo crear índices de MongoDB Search, consulte la sección Índices de MongoDB Search y Vector Search de la guía Índices.

Puedes reemplazar el marcador de posición <search index name> en el código con el nombre de tu MongoDB Search índice.

El siguiente código crea un escenario $search que tiene las siguientes especificaciones:

• Comprueba que el arreglo genres incluya "Comedy"

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

• Coincide con year valores entre 1950 y 2000, ambos inclusive

• Busca valores de title 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 saber más sobre los operadores de MongoDB Search, consulta la documentación de Operadores de MongoDB Search.

Construcción de query tipo segura

El MongoDB Rust Driver proporciona métodos auxiliares type-safe para crear consultas de MongoDB Search. Estos asistentes utilizan el sistema de tipos de Rust para proporcionar validación en tiempo de compilación y un mejor soporte para el IDE en comparación con la construcción de documentos BSON en bruto.

El siguiente ejemplo construye 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 query en el 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:

   • maxEditsEstablece el número máximo de cambios de caracteres permitidos en 1

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

   • maxExpansionsEstablece el número máximo de variaciones a considerar para 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, consulta la siguiente documentación de la API:

• aggregate()

• Cliente

• Colección