MongoDB búsqueda

Overview

En esta guía, puedes aprender a usar el controlador de Java para ejecutar consultas de Búsqueda de MongoDB en una colección. MongoDB Search permite realizar búsquedas de texto completo en colecciones alojadas en MongoDB Atlas. Los índices de búsqueda de MongoDB Search especifican el comportamiento de la búsqueda y los campos que se deben indexar.

Ejecuta una MongoDB Search query

Esta sección muestra cómo crear una pipeline de agregación para ejecutar una consulta de MongoDB Search en una colección. Puedes utilizar el método builder Aggregates.search() para crear una etapa $search en la pipeline que especifique los criterios de búsqueda. Luego, llama al método aggregate() y pasa tu pipeline como parámetro.

Antes de ejecutar una MongoDB Search query, debes crear un MongoDB Search índice en tu colección. Para aprender a crear un índice de búsqueda de MongoDB programáticamente, consulta la sección Índices de Búsqueda y Búsqueda Vectorial de MongoDB en la guía de índices.

collection.aggregate(
    Arrays.asList(
    	Aggregates.search(SearchOperator.text(
                      SearchPath.fieldPath("title"), "Alabama")),
        Aggregates.project(Projections.include("title"))
    )
).forEach(doc -> System.out.println(doc.toJson()));

{"_id": {"$oid": "..."}, "title": "Alabama Moon"}
{"_id": {"$oid": "..."}, "title": "Crazy in Alabama"}
{"_id": {"$oid": "..."}, "title": "Sweet Home Alabama"}

MongoDB Search metadatos

Utilice el método searchMeta() para crear una etapa de pipeline de $searchMeta, que solo devuelve los metadatos de los resultados de MongoDB Search.

El siguiente ejemplo muestra los metadatos near para una etapa de agregación MongoDB Search:

Aggregates.searchMeta(
        SearchOperator.near(2010, 1, fieldPath("year")));

Para aprender más sobre este método asistente, consultar la documentación de la API searchMeta().

Crear etapas de búsqueda en pipeline

El driver Java proporciona métodos asistentes para los siguientes operadores:

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

List<Bson> pipeline = new ArrayList<>();
pipeline.add(Aggregates.search(
        SearchOperator.compound()
                .filter(
                        List.of(
                                SearchOperator.in(fieldPath("genres"), "Comedy"),
                                SearchOperator.phrase(fieldPath("fullplot"), "new york"),
                                SearchOperator.numberRange(fieldPath("year")).gtLt(1950, 2000),
                                SearchOperator.wildcard(fieldPath("title"), "Love *")
                        ))));
pipeline.add(Aggregates.project(
        Projections.include("title", "year", "genres")
));
AggregateIterable<Document> results = collection.aggregate(pipeline);
results.forEach(doc -> System.out.println(doc.toJson()));

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

Operadores de búsqueda vectorial de MongoDB

Utiliza los métodos estáticos vectorSearch() o vectorSearchExact() en la clase SearchOperator para realizar una búsqueda vectorial dentro de una etapas del pipeline de agregación $search. Estos métodos te permiten combinar la búsqueda por similitud vectorial con otros operadores de búsqueda de MongoDB Search, incluidos operadores que utilizan prefiltros de texto analizados.

Utiliza el método vectorSearch() para realizar una búsqueda aproximada de vecinos más cercanos (ANN). Utilice el método vectorSearchExact() para realizar una búsqueda exacta del vecino más cercano (ENN). Ambos métodos aceptan los siguientes parámetros:

Ambos métodos devuelven una instancia de VectorSearchOperator. Puedes encadenar los siguientes métodos en la instancia devuelta:

List<Double> queryVector = List.of(
    -0.014, -0.055, 0.047, -0.041, 0.027);
Bson searchStage = Aggregates.search(
    SearchOperator.vectorSearch(
        fieldPath("plot_embedding"),
        queryVector,
        10,
        20
    ).filter(SearchOperator.text(
        fieldPath("genres"), "Drama")));
collection.aggregate(List.of(searchStage))
    .forEach(result -> System.out.println(result));

List<Double> queryVector = List.of(
    -0.014, -0.055, 0.047, -0.041, 0.027);
Bson searchStage = Aggregates.search(
    SearchOperator.vectorSearchExact(
        fieldPath("plot_embedding"),
        queryVector,
        5));
collection.aggregate(List.of(searchStage))
    .forEach(result -> System.out.println(result));

Información Adicional

Para obtener más información sobre MongoDB Search, consulte la MongoDB Search en la documentación de Atlas.