Transforma tus datos con agregación

Analogía

Una operación de agregación se asemeja a una fábrica de automóviles. Una fábrica de automóviles tiene 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 ingresan a la fábrica y luego la línea de montaje las transforma y ensambla en un producto terminado.

La pipeline de agregación es la cadena de ensamblaje, las etapas de agregación son las estaciones de ensamblaje y las expresiones de operadores son las herramientas especializadas.

Comparar las operaciones de agregación y búsqueda

La siguiente tabla muestra las diferentes tareas que pueden realizar las operaciones de búsqueda y las compara con lo que las operaciones de agregación pueden realizar. El marco de agregación proporciona funcionalidades ampliadas que permiten transformar y manipular tus 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 del pipeline tienen un límite de memoria de 100 megabytes por defecto. Puede sobrepasar este límite pasando un valor de true al método allowDiskUse() y encadenar el método con aggregate().

• La $graphLookup operadora tiene un límite estricto de memoria de 100 megabytes y omite el valor pasado al método allowDiskUse().

Filtrar, agrupar y contar documentos

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

• filter(): Compila la fase $match para filtrar documentos que tienen un valor de cuisine de "Bakery"

• group(): Construye la etapa $group para agrupar los documentos coincidentes por el campo borough, 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}

Explica una agregación

Para ver información sobre cómo MongoDB ejecuta tu operación, puedes indicarle al planificador de consultas de MongoDB que la explique. Cuando MongoDB explica una operación, devuelve los planes de ejecución y las estadísticas de rendimiento. Un plan de ejecución es una forma potencial en la que MongoDB puede completar una operación. Cuando indicas a MongoDB que explique una operación, por defecto te devuelve tanto el plan que ejecutó como los planes de ejecución rechazados.

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

El siguiente ejemplo instruye a MongoDB para que explique la operación de agregación a partir del ejemplo anterior Filtrar, agrupar y contar documentos. El código pasa un valor de nivel de verbosidad de ExplainVerbosity.EXECUTION_STATS al método explain(), que configura el método 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 asistentes del operador de búsqueda

El driver Scala proporciona métodos asistentes 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 de MongoDB

Para aprender más sobre los temas tratados en esta guía, consulta las siguientes páginas del manual del servidor MongoDB:

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

• Para aprender sobre cómo armar un pipeline de agregación y para ver ejemplos, consulta pipeline de agregación.

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

• Para obtener más información sobre cómo explicar las operaciones de MongoDB, consulta Resultado de explicación y Planes de consultas.

Documentación de la API

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

• aggregate()

• Agregados

• explain()