Constructores de agregados

Overview

En esta guía, podrá aprender a utilizar el Clase de agregados que proporciona métodos de fábrica estáticos que crean etapas de canalización de agregación en el controlador MongoDB Kotlin.

Para una introducción más completa a la agregación, consulte nuestro Guía de agregación.

Los ejemplos de esta página suponen importaciones para métodos de las siguientes clases:

• Aggregates

• Filters

• Projections

• Sorts

• Accumulators

import com.mongodb.client.model.Aggregates
import com.mongodb.client.model.Filters
import com.mongodb.client.model.Projections
import com.mongodb.client.model.Sorts
import com.mongodb.client.model.Accumulators

Utilice estos métodos para construir etapas de canalización y especificarlas en su agregación como una lista:

val matchStage = Aggregates.match(Filters.eq("someField", "someCriteria"))
val sortByCountStage = Aggregates.sortByCount("\$someField")
val results = collection.aggregate(
    listOf(matchStage, sortByCountStage)).toList()

Muchos Aggregation ejemplos de esta guía utilizan el conjunto de datos Atlas sample_mflix.movies. Los documentos de esta colección se modelan mediante la siguiente Movie clase de datos para su uso con el controlador Kotlin:

data class Movie(
    val title: String,
    val year: Int,
    val genres: List<String>,
    val rated: String,
    val plot: String,
    val runtime: Int,
    val imdb: IMDB,
    val fullplot: String? = "No full plot",
){
    data class IMDB(
        val rating: Double
    )
}

Match

Utilice el match() método para crear una etapa de canalización $match que compare los documentos entrantes con el filtro de consulta especificado y filtre los documentos que no coinciden.

El siguiente ejemplo crea una etapa de canalización que coincide con todos los documentos de la colección movies donde el campo title es igual a "The Shawshank Redemption":

Aggregates.match(Filters.eq(Movie::title.name, "The Shawshank Redemption"))

Proyecto

Utilice el método project() para crear una etapa de pipeline $project que proyecte los campos de documento especificados. La proyección de campos en agregación sigue las mismas reglas que la proyección de campos en las consultas.

El siguiente ejemplo crea una etapa de canalización que incluye los campos title y plot pero excluye el campo _id:

Aggregates.project(
    Projections.fields(
        Projections.include(Movie::title.name, Movie::plot.name),
        Projections.excludeId())
)

Aggregates.project(
    Projections.fields(
        Projections.computed("rating", "\$${Movie::rated.name}"),
        Projections.excludeId()
    )
)

Documentos

Utilice el documents() método para crear una etapa de canalización $documents que devuelva documentos literales a partir de valores de entrada.

El siguiente ejemplo crea una etapa de canalización que crea documentos de muestra en la colección movies con un campo title:

Aggregates.documents(
    listOf(
        Document(Movie::title.name, "Steel Magnolias"),
        Document(Movie::title.name, "Back to the Future"),
        Document(Movie::title.name, "Jurassic Park")
    )
)

val docsStage = database.aggregate<Document>( // ... )

Muestra

Utilice el sample() método para crear una etapa de canalización $sample para seleccionar documentos aleatoriamente de la entrada.

El siguiente ejemplo crea una etapa de canalización que selecciona aleatoriamente 5 documentos de la colección movies:

Aggregates.sample(5)

Sort

Utilice el sort() método para crear una etapa de canalización $sort para ordenar según los criterios especificados.

El siguiente ejemplo crea una etapa de canalización que ordena en orden descendente según el valor del campo year y luego en orden ascendente según el valor del campo title:

Aggregates.sort(
    Sorts.orderBy(
        Sorts.descending(Movie::year.name),
        Sorts.ascending(Movie::title.name)
    )
)

Omitir

Utiliza el método skip() para crear una etapa de pipeline de $skip para omitir la cantidad específica de documentos antes de pasar los documentos a la siguiente etapa.

El siguiente ejemplo crea una etapa de canalización que omite los primeros 5 documentos en la colección movies:

Aggregates.skip(5)

Limit

Utilice la etapa de canalización $limit para limitar la cantidad de documentos que pasan a la siguiente etapa.

El siguiente ejemplo crea una etapa de canalización que limita la cantidad de documentos devueltos desde la colección movies a 4:

Aggregates.limit(4)

Buscar

Utiliza el método lookup() para crear una etapa en la pipeline $lookup y realizar combinaciones y subconsultas no correlacionadas entre dos colecciones.

Aggregates.lookup(
    "comments",
    "_id",
    "movie_id",
    "joined_comments"
)

data class Order(
    @BsonId val id: Int,
    val customerId: Int,
    val item: String,
    val ordered: Int
)
data class Inventory(
    @BsonId val id: Int,
    val stockItem: String,
    val inStock: Int
)

val variables = listOf(
    Variable("order_item", "\$item"),
    Variable("order_qty", "\$ordered")
)
val pipeline = listOf(
    Aggregates.match(
        Filters.expr(
            Document("\$and", listOf(
                Document("\$eq", listOf("$\$order_item", "\$${Inventory::stockItem.name}")),
                Document("\$gte", listOf("\$${Inventory::inStock.name}", "$\$order_qty"))
            ))
        )
    ),
    Aggregates.project(
        Projections.fields(
            Projections.exclude(Order::customerId.name, Inventory::stockItem.name),
            Projections.excludeId()
        )
    )
)
val innerJoinLookup =
    Aggregates.lookup("warehouses", variables, pipeline, "stockData")

group

Utilice el group() método para crear una etapa de canalización $group para agrupar documentos mediante una expresión específica y generar un documento para cada agrupación distinta.

El siguiente ejemplo crea una etapa de canalización que agrupa los documentos de la colección orders según el valor del campo customerId. Cada grupo acumula la suma y el promedio de los valores del campo ordered en los campos totalQuantity y averageQuantity:

Aggregates.group("\$${Order::customerId.name}",
    Accumulators.sum("totalQuantity", "\$${Order::ordered.name}"),
    Accumulators.avg("averageQuantity", "\$${Order::ordered.name}")
)

Obtenga más información sobre los operadores de acumuladores en la sección del manual del servidor sobre Acumuladores.

Acumuladores Pick-N

Los acumuladores pick-n son operadores de acumulación que devuelven los elementos superior e inferior según un orden específico. Utilice uno de los siguientes constructores para crear un operador de acumulación:

• Minnesota()

• máxN()

• firstN()

• lastN()

• arriba()

• topN()

• abajo()

• fondoN()

Conozca en qué etapas del flujo de trabajo de agregación puede usar operadores acumuladores en la sección del manual del servidor sobre Acumuladores.

Los ejemplos del acumulador pick-n utilizan documentos de la colección movies en la base de datos sample-mflix.

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.minN(
        "lowestThreeRatings",
        "\$${Movie::imdb.name}.${Movie.IMDB::rating.name}",
        3
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.maxN(
        "highestTwoRatings",
        "\$${Movie::imdb.name}.${Movie.IMDB::rating.name}",
        2
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.firstN(
        "firstTwoMovies",
        "\$${Movie::title.name}",
        2
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.lastN(
        "lastThreeMovies",
        "\$${Movie::title.name}",
        3
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.top(
        "topRatedMovie",
        Sorts.descending("${Movie::imdb.name}.${Movie.IMDB::rating.name}"),
        listOf("\$${Movie::title.name}", "\$${Movie::imdb.name}.${Movie.IMDB::rating.name}")
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.topN(
        "longestThreeMovies",
        Sorts.descending(Movie::runtime.name),
        listOf("\$${Movie::title.name}", "\$${Movie::runtime.name}"),
        3
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.bottom(
        "shortestMovies",
        Sorts.descending(Movie::runtime.name),
        listOf("\$${Movie::title.name}", "\$${Movie::runtime.name}")
    )
)

Aggregates.group(
    "\$${Movie::year.name}",
    Accumulators.bottom(
        "lowestRatedTwoMovies",
        Sorts.descending("${Movie::imdb.name}.${Movie.IMDB::rating.name}"),
        listOf("\$${Movie::title.name}", "\$${Movie::imdb.name}.${Movie.IMDB::rating.name}"),
    )
)

Unwind

Utilice el unwind() método para crear una etapa de canalización $unwind para deconstruir un campo de matriz a partir de documentos de entrada, creando un documento de salida para cada elemento de la matriz.

El siguiente ejemplo crea un documento para cada elemento de la matriz lowestRatedTwoMovies:

Aggregates.unwind("\$${"lowestRatedTwoMovies"}")

Para conservar documentos que tienen valores faltantes o null para el campo de matriz, o donde la matriz está vacía:

Aggregates.unwind(
    "\$${"lowestRatedTwoMovies"}",
    UnwindOptions().preserveNullAndEmptyArrays(true)
)

Para incluir el índice de la matriz (en este ejemplo, en un campo llamado "position"):

Aggregates.unwind(
    "\$${"lowestRatedTwoMovies"}",
    UnwindOptions().includeArrayIndex("position")
)

Cabo

Utilice el out() método para crear una etapa de canalización $out que escriba todos los documentos en la colección especificada en la misma base de datos.

El siguiente ejemplo escribe los resultados de la canalización en la colección classic_movies:

Aggregates.out("classic_movies")

Combinar

Utilice el merge() método para crear una etapa de canalización $merge que fusione todos los documentos en la colección especificada.

El siguiente ejemplo fusiona la canalización en la colección nineties_movies utilizando las opciones predeterminadas:

Aggregates.merge("nineties_movies")

El siguiente ejemplo fusiona la canalización en la colección movie_ratings en la base de datos aggregation utilizando algunas opciones no predeterminadas que especifican reemplazar el documento si year y title coinciden; de lo contrario, insertar el documento:

Aggregates.merge(
    MongoNamespace("aggregation", "movie_ratings"),
    MergeOptions().uniqueIdentifier(listOf("year", "title"))
            .whenMatched(MergeOptions.WhenMatched.REPLACE)
        .whenNotMatched(MergeOptions.WhenNotMatched.INSERT)
)

GraphLookup

Utilice el graphLookup() método para crear una etapa de canalización $graphLookup que realice una búsqueda recursiva en una colección específica para hacer coincidir un campo específico en un documento con un campo específico de otro documento.

El siguiente ejemplo utiliza la colección contacts. Los datos se modelan con la siguiente clase de datos de Kotlin:

data class Users(
    val name: String,
    val friends: List<String>?,
    val hobbies: List<String>?
)

El ejemplo calcula el gráfico de informes para los usuarios de la colección contact, haciendo coincidir de forma recursiva el valor del campo friends con el campo name:

Aggregates.graphLookup(
    "contacts",
    "\$${Users::friends.name}", Users::friends.name, Users::name.name,
    "socialNetwork"
)

Usando GraphLookupOptions, puede especificar la profundidad de recursión y el nombre del campo de profundidad, si lo desea. En este ejemplo, $graphLookup se recursivamente hasta dos veces y creará un campo llamado degrees con la información de profundidad de recursión para cada documento.

Aggregates.graphLookup(
    "contacts",
    "\$${Users::friends.name}", Users::friends.name, Users::name.name,
    "socialNetwork",
    GraphLookupOptions().maxDepth(2).depthField("degrees")
)

Usando GraphLookupOptions, puede especificar un filtro que los documentos deben cumplir para que MongoDB los incluya en su búsqueda. En este ejemplo, solo se incluirán los enlaces con "golf" en su campo hobbies:

Aggregates.graphLookup(
    "contacts",
    "\$${Users::friends.name}", Users::friends.name, Users::name.name, "socialNetwork",
    GraphLookupOptions().maxDepth(1).restrictSearchWithMatch(
        Filters.eq(Users::hobbies.name, "golf")
    )
)

Ordenar por recuento

Utilice el sortByCount() método para crear una etapa de canalización $sortByCount que agrupe los documentos mediante una expresión determinada y luego ordene estos grupos por conteo en orden descendente.

[
    { "$group": { "_id": <expression to group on>, "count": { "$sum": 1 } } },
    { "$sort": { "count": -1 } }
]

El siguiente ejemplo agrupa los documentos de la colección movies por el campo genres y calcula el recuento de cada valor distinto:

Aggregates.sortByCount("\$${Movie::genres.name}"),

Reemplazar raíz

Utilice el replaceRoot() método para crear una etapa de canalización $replaceRoot que reemplace cada documento de entrada con el documento especificado.

El siguiente ejemplo utiliza una colección books ficticia que contiene datos modelados utilizando la siguiente clase de datos Kotlin:

data class Libro(val titulo: String)
data class Book(val title: String, val spanishTranslation: Libro)

Cada documento de entrada se reemplaza por el documento anidado en el campo spanishTranslation:

Aggregates.replaceRoot("\$${Book::spanishTranslation.name}")

Agregar campos

Utilice el addFields() método para crear una etapa de canalización $addFields que agregue nuevos campos a los documentos.

El siguiente ejemplo añade dos nuevos campos, watched y type, a los documentos de entrada en la colección movie:

Aggregates.addFields(
    Field("watched", false),
    Field("type", "movie")
)

Contar

Utilice el count() método para crear una etapa de canalización $count que cuente el número de documentos que entran en ella y asigne ese valor a un nombre de campo específico. Si no especifica un campo, lo count() define como "count" por defecto.

{ "$group":{ "_id": 0, "count": { "$sum" : 1 } } }

El siguiente ejemplo crea una etapa de canalización que genera el recuento de documentos entrantes en un campo llamado "total":

Aggregates.count("total")

Cubo

Utiliza el método bucket() para crear una etapa de pipeline $bucket que automatiza la agrupación de datos en torno a valores límite predefinidos.

Los siguientes ejemplos utilizan datos modelados con la siguiente clase de datos Kotlin:

data class Screen(
    val id: String,
    val screenSize: Int,
    val manufacturer: String,
    val price: Double
)

Este ejemplo crea una etapa de canalización que agrupa los documentos entrantes en función del valor de su campo screenSize, incluido el límite inferior y excluido el límite superior:

Aggregates.bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70, 1000))

Utilice la clase BucketOptions para especificar un depósito predeterminado para valores fuera de los límites especificados y para especificar acumuladores adicionales.

El siguiente ejemplo crea una etapa de canalización que agrupa los documentos entrantes según el valor de su campo screenSize, contando la cantidad de documentos que caen dentro de cada contenedor, enviando el valor de screenSize a un campo llamado matches y capturando cualquier tamaño de pantalla mayor a "70" en un contenedor llamado "monstruo" para tamaños de pantalla monstruosamente grandes:

Aggregates.bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70),
    BucketOptions()
        .defaultBucket("monster")
        .output(
            Accumulators.sum("count", 1),
            Accumulators.push("matches", "\$${Screen::screenSize.name}")
        )
)

BucketAuto

Utilice el bucketAuto() método para crear una etapa de canalización $bucketAuto que determine automáticamente los límites de cada contenedor en su intento de distribuir los documentos de manera uniforme en una cantidad específica de contenedores.

Los siguientes ejemplos utilizan datos modelados con la siguiente clase de datos Kotlin:

data class Screen(
    val id: String,
    val screenSize: Int,
    val manufacturer: String,
    val price: Double
)

Este ejemplo crea una etapa de pipeline que intentará crear y distribuir de forma uniforme documentos en 5 compartimentos usando el valor de su campo price:

Aggregates.bucketAuto("\$${Screen::screenSize.name}", 5)

Utilice la BucketAutoOptions clase para especificar un esquema basado en números preferido para establecer valores límite y especificar acumuladores adicionales.

El siguiente ejemplo crea una etapa de canalización que intentará crear y distribuir uniformemente documentos en 5 grupos utilizando el valor de su campo price, estableciendo los límites de los grupos en potencias de 2 (2, 4, 8, 16, ...). También cuenta el número de documentos en cada grupo y calcula su promedio price en un nuevo campo llamado avgPrice:

Aggregates.bucketAuto(
    "\$${Screen::price.name}", 5,
    BucketAutoOptions()
        .granularity(BucketGranularity.POWERSOF2)
        .output(Accumulators.sum("count", 1), Accumulators.avg("avgPrice", "\$${Screen::price.name}"))
        )

Facet

Utilice el facet() método para crear una etapa de canalización $facet que permita la definición de canalizaciones paralelas.

Los siguientes ejemplos utilizan datos modelados con la siguiente clase de datos Kotlin:

data class Screen(
    val id: String,
    val screenSize: Int,
    val manufacturer: String,
    val price: Double
)

Este ejemplo crea una etapa de canalización que ejecuta dos agregaciones paralelas:

• La primera agregación distribuye los documentos entrantes en 5 grupos según su campo screenSize.

• La segunda agregación cuenta todos los fabricantes y devuelve su recuento, limitado a los primeros 5.

Aggregates.facet(
    Facet(
        "Screen Sizes",
        Aggregates.bucketAuto(
            "\$${Screen::screenSize.name}",
            5,
            BucketAutoOptions().output(Accumulators.sum("count", 1))
        )
    ),
    Facet(
        "Manufacturer",
        Aggregates.sortByCount("\$${Screen::manufacturer.name}"),
        Aggregates.limit(5)
    )
)

Establecer campos de ventana

Utilice el setWindowFields() método para crear una etapa de canalización $setWindowFields que permita usar operadores de ventana para realizar operaciones en un intervalo específico de documentos en una colección.

El siguiente ejemplo utiliza una colección weather ficticia que utiliza datos modelados con la siguiente clase de datos Kotlin:

data class Weather(
    val localityId: String,
    val measurementDateTime: LocalDateTime,
    val rainfall: Double,
    val temperature: Double
)

El ejemplo crea una etapa de canalización que calcula la precipitación acumulada y la temperatura promedio durante el último mes para cada localidad a partir de mediciones más detalladas presentadas en los campos rainfall y temperature:

val pastMonth = Windows.timeRange(-1, MongoTimeUnit.MONTH, Windows.Bound.CURRENT)
val resultsFlow = weatherCollection.aggregate<Document>(
    listOf(
       Aggregates.setWindowFields("\$${Weather::localityId.name}",
           Sorts.ascending(Weather::measurementDateTime.name),
           WindowOutputFields.sum(
               "monthlyRainfall",
               "\$${Weather::rainfall.name}",
               pastMonth
           ),
           WindowOutputFields.avg(
               "monthlyAvgTemp",
               "\$${Weather::temperature.name}",
               pastMonth
           )
       )
    )

Densificar

Utilice el densify() método para crear una etapa de canalización $densify que genere una secuencia de documentos para abarcar un intervalo específico.

Considere los siguientes documentos recuperados del conjunto de datos meteorológicos de muestra Atlas que contienen mediciones para un position campo similar, con una hora de diferencia:

Document{{ _id=5553a..., position=Document{{type=Point, coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 08:00:00 EST 1984, ... }}
Document{{ _id=5553b..., position=Document{{type=Point, coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 09:00:00 EST 1984, ... }}

Estos documentos se modelan utilizando la siguiente clase de datos de Kotlin:

data class Weather(
    @BsonId val id: ObjectId = ObjectId(),
    val position: Point,
    val ts: LocalDateTime
)

Supongamos que necesita crear una etapa de canalización que realice las siguientes acciones en estos documentos:

• Agregue un documento en cada intervalo de 15minutos para el cual aún no exista un valor ts.

• Agrupe los documentos por el campo position.

La llamada al generador de la etapa de agregación densify() que realiza estas acciones debería parecerse a la siguiente:

Aggregates.densify(
    "ts",
    DensifyRange.partitionRangeWithStep(15, MongoTimeUnit.MINUTE),
    DensifyOptions.densifyOptions().partitionByFields("Position.coordinates")
)

La siguiente salida resalta los documentos generados por la etapa agregada que contienen ts valores cada 15 minutos entre los documentos existentes:

Document{{ _id=5553a..., position=Document{{type=Point, coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 08:00:00 EST 1984, ... }}
Document{{ position=Document{{coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 08:15:00 EST 1984 }}
Document{{ position=Document{{coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 08:30:00 EST 1984 }}
Document{{ position=Document{{coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 08:45:00 EST 1984 }}
Document{{ _id=5553b..., position=Document{{type=Point, coordinates=[-47.9, 47.6]}}, ts=Mon Mar 05 09:00:00 EST 1984, ... }}

Consulte la documentación de la API del paquete densificar para obtener más información.

Fill

Utilice el fill() método para crear una etapa de canalización $fill que complete null y los valores de campo faltantes.

Considere los siguientes documentos que contienen mediciones de temperatura y presión del aire en un intervalo de una hora:

Document{{_id=6308a..., hour=1, temperature=23C, air_pressure=29.74}}
Document{{_id=6308b..., hour=2, temperature=23.5C}}
Document{{_id=6308c..., hour=3, temperature=null, air_pressure=29.76}}

Estos documentos se modelan utilizando la siguiente clase de datos de Kotlin:

data class Weather(
    @BsonId val id: ObjectId = ObjectId(),
    val hour: Int,
    val temperature: String?,
    val air_pressure: Double?
)

Supongamos que necesita completar los puntos de datos de temperatura y presión del aire faltantes en los documentos de la siguiente manera:

• Complete el campo air_pressure para la hora "2" utilizando interpolación lineal para calcular el valor.

• Establezca el valor temperature faltante en "23.6C" para la hora "3".

La llamada al generador de la etapa de agregación fill() que realiza estas acciones se parece a la siguiente:

val resultsFlow = weatherCollection.aggregate<Weather>(
    listOf(
        Aggregates.fill(
            FillOptions.fillOptions().sortBy(Sorts.ascending(Weather::hour.name)),
            FillOutputField.value(Weather::temperature.name, "23.6C"),
            FillOutputField.linear(Weather::air_pressure.name)
        )
    )
)
resultsFlow.collect { println(it) }

Weather(id=6308a..., hour=1, temperature=23C, air_pressure=29.74)
Weather(id=6308b..., hour=2, temperature=23.5C, air_pressure=29.75)
Weather(id=6308b..., hour=3, temperature=23.6C, air_pressure=29.76)

Consulte la documentación de la API del paquete de relleno para obtener más información.

Búsqueda de texto completo en Atlas

Utilice el search() método para crear una etapa de canalización $search que especifique una búsqueda de texto completo de uno o más campos.

El siguiente ejemplo crea una etapa de canalización que busca en el campo title de la colección movies texto que contenga la palabra "Futuro":

Aggregates.search(
    SearchOperator.text(
        SearchPath.fieldPath(Movie::title.name), "Future"
    ),
    SearchOptions.searchOptions().index("title")
)

Obtenga más información sobre los constructores en la documentación de la API del paquete de búsqueda.

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

data class Results(val title: String, val year: Int, val genres: List<String>)
val searchStage = Aggregates.search(
    SearchOperator.compound()
        .filter(
            listOf(
                SearchOperator.`in`(SearchPath.fieldPath(Movie::genres.name), listOf("Comedy")),
                SearchOperator.phrase(SearchPath.fieldPath(Movie::fullplot.name), "new york"),
                SearchOperator.numberRange(SearchPath.fieldPath(Movie::year.name)).gtLt(1950, 2000),
                SearchOperator.wildcard(SearchPath.fieldPath(Movie::title.name), "Love *")
            )
        )
)
val projectStage = Aggregates.project(
    Projections.include(Movie::title.name, Movie::year.name, Movie::genres.name))
val pipeline = listOf(searchStage, projectStage)
val resultsFlow = ftsCollection.aggregate<Results>(pipeline)
resultsFlow.collect { println(it) }

Results(title=Love at First Bite, year=1979, genres=[Comedy, Romance])
Results(title=Love Affair, year=1994, genres=[Comedy, Drama])

Metadatos de búsqueda de MongoDB

Utilice el searchMeta() método para crear una etapa de canalización $searchMeta que devuelva solo la parte de metadatos de los resultados de las consultas de búsqueda de texto completo de Atlas.

El siguiente ejemplo muestra los metadatos count para una etapa de agregación de búsqueda de MongoDB:

Aggregates.searchMeta(
    SearchOperator.near(1985, 2, SearchPath.fieldPath(Movie::year.name)),
    SearchOptions.searchOptions().index("year")
)

Obtenga más información sobre este ayudante en la documentación de la API searchMeta().