Transforma tus datos con agregación

Analogía

Una operación de agregación es similar a una fábrica de automóviles. Una fábrica de automóviles cuenta con una línea de ensamblaje, que contiene estaciones de ensamblaje con herramientas especializadas para realizar tareas específicas, como taladros y soldadores. Las piezas en bruto entran en la fábrica y luego la línea de ensamblaje las transforma y ensambla en un producto terminado.

La tubería de agregación es la línea de ensamblaje, las etapas de agregación son las estaciones de ensamblaje y las expresiones del operador son las herramientas especializadas.

Comparar las operaciones de agregación y búsqueda

La siguiente tabla enumera las diferentes tareas que pueden realizar las operaciones de búsqueda y las compara con las de agregación. El marco de agregación ofrece una funcionalidad ampliada que permite transformar y manipular los datos.

Limitaciones

Considera las siguientes limitaciones al realizar operaciones de agregación:

• Los documentos devueltos no pueden violar el límite de tamaño de documento BSON de 16 megabytes.

• Las etapas de la canalización tienen un límite de memoria de 100 megabytes por defecto. Puedes superar este límite pasando un valor de true al método allowDiskUse() y encadenando el método a aggregate().

• El operador $graphLookup tiene un límite de memoria estricto de 100 megabytes e ignora el valor pasado al allowDiskUse() método.

Filtrar, agrupar y contar documentos

Este ejemplo de código genera un recuento del número de panaderías en cada distrito de Nueva York. Para ello, llama al método aggregate() y pasa una canalización de agregación como una lista de etapas. El código construye estas etapas mediante los siguientes métodos auxiliares Aggregates:

• filter(): Construye la etapa $match para filtrar los documentos que tienen un cuisine valor de "Bakery"

• group(): Construye la etapa $group para agrupar los documentos coincidentes por el borough campo, acumulando un recuento de documentos para cada valor distinto

val pipeline = Seq(Aggregates.filter(Filters.equal("cuisine", "Bakery")),
                   Aggregates.group("$borough", Accumulators.sum("count", 1))
)
collection.aggregate(pipeline)
          .subscribe((doc: Document) => println(doc.toJson()),
                    (e: Throwable) => println(s"There was an error: $e"))

{"_id": "Brooklyn", "count": 173}
{"_id": "Queens", "count": 204}
{"_id": "Bronx", "count": 71}
{"_id": "Staten Island", "count": 20}
{"_id": "Missing", "count": 2}
{"_id": "Manhattan", "count": 221}

Explicar una agregación

Para ver información sobre cómo MongoDB ejecuta su operación, puede indicarle al planificador de consultas de MongoDB que la explique. Cuando MongoDB explica una operación, devuelve planes de ejecución y estadísticas de rendimiento. Un plan de ejecución es una forma en que MongoDB puede completar una operación. Al indicarle a MongoDB que explique una operación, devuelve tanto el plan ejecutado como cualquier plan de ejecución rechazado por defecto.

Para explicar una operación de agregación, encadene el explain() método al aggregate() método. Puede pasar un nivel de verbosidad a,explain() lo que modifica el tipo y la cantidad de información que devuelve el método. Para más información sobre el nivel de verbosidad, consulte "Modos de verbosidad" en el manual de MongoDB Server.

El siguiente ejemplo indica a MongoDB que explique la operación de agregación del ejemplo anterior de Filtrar, Agrupar y Contar Documentos. El código pasa un valor de verbosidad de ExplainVerbosity.EXECUTION_STATS al explain() método, que lo configura para devolver estadísticas que describen la ejecución del plan ganador:

val pipelineToExplain = Seq(Aggregates.filter(Filters.equal("cuisine", "Bakery")),
                   Aggregates.group("$borough", Accumulators.sum("count", 1))
)
collection.aggregate(pipelineToExplain)
          .explain(ExplainVerbosity.EXECUTION_STATS)
          .subscribe((doc: Document) => println(doc.toJson()),
                    (e: Throwable) => println(s"There was an error: $e"))

{"explainVersion": "2", "queryPlanner": {"namespace": "sample_restaurants.restaurants",
"indexFilterSet": false, "parsedQuery": {"cuisine": {"$eq": "Bakery"}}, "queryHash": "865F14C3",
"planCacheKey": "0FC225DA", "optimizedPipeline": true, "maxIndexedOrSolutionsReached": false,
"maxIndexedAndSolutionsReached": false, "maxScansToExplodeReached": false, "winningPlan":
{"queryPlan": {"stage": "GROUP", "planNodeId": 3, "inputStage": {"stage": "COLLSCAN",
"planNodeId": 1, "filter": {"cuisine": {"$eq": "Bakery"}}, "direction": "forward"}},
...}

Métodos auxiliares del operador de búsqueda

El controlador Scala proporciona métodos auxiliares para los siguientes operadores:

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

val searchStage = Aggregates.search(
  SearchOperator.compound()
    .must(
      Iterable(
        SearchOperator.in(fieldPath("genres"), List("Comedy")),
        SearchOperator.phrase(fieldPath("fullplot"), "new york"),
        SearchOperator.numberRange(fieldPath("year")).gtLt(1950, 2000),
        SearchOperator.wildcard("Love *", fieldPath("title")),
      ).asJava
    )
)
val projectStage = Aggregates.project(
  Projections.include("title", "year", "genres"))
val aggregatePipelineStages = Seq(searchStage, projectStage)
collection.aggregate(aggregatePipelineStages)
  .subscribe((doc: Document) => println(doc.toJson()),
    (e: Throwable) => println(s"There was an error: $e"))

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

Manual del servidor MongoDB

Para obtener más información sobre los temas tratados en esta guía, consulte las siguientes páginas del manual de MongoDB Server:

• Para obtener una lista completa de las etapas de agregación, consulta Etapas de agregación en el manual de MongoDB Server.

• Para obtener más información sobre cómo ensamblar una canalización de agregación y ver ejemplos, consulte Canalización de agregación.

• Para obtener más información sobre cómo crear etapas de canalización, consulte Etapas de agregación.

• Para obtener más información sobre cómo explicar las operaciones de MongoDB, consulte Explicar los planesde salida y consulta.

Documentación de la API

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

• agregar()

• Agregados

• explicar()