Transforme seus dados com agregação

Comparar agregação e encontrar operações

A tabela a seguir lista as diferentes tarefas que as operações de localização podem executar e as compara com o que as operações de agregação podem executar. A framework de agregação oferece funcionalidade expandida que permite transformar e manipular seus dados.

Limitações

Considere as seguintes limitações ao realizar operações de agregação:

• Os documentos devolvidos não podem violar olimite de tamanho do documento BSON de 16 megabytes.

• Os estágios do pipeline têm um limite de memória de 100 megabytes por padrão. Você pode exceder esse limite passando um valor de true para o método allowDiskUse() e vinculando o método a aggregate().

• O operador $graphLookup tem um limite de memória rigoroso de 100 megabytes e ignora o valor passado para o allowDiskUse() método.

Filtrar, agrupar e contar documentos

Este exemplo de código produz uma contagem do número de padarias em cada bairro de Nova York. Para fazer isso, ele chama o método aggregate() e passa um pipeline de agregação como uma lista de estágios. O código cria esses estágios usando os seguintes métodos de assistente Aggregates:

• filter(): cria o estágio $match para filtrar documentos que tenham um cuisine valor de "Bakery"

• group(): Constrói o estágio $group para agrupar os documentos correspondentes pelo borough campo , acumulando uma contagem 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 uma agregação

Para visualizar informações sobre como o MongoDB executa sua operação, você pode instruir o planejador de query do MongoDB a explicá-la. Quando o MongoDB explica uma operação, ele retorna planos de execução e estatísticas de desempenho. Um plano de execução é uma maneira em potencial da qual o MongoDB pode concluir uma operação. Quando você instrui o MongoDB a explicar uma operação, ele retorna o plano executado MongoDB e quaisquer planos de execução rejeitados por padrão.

Para explicar uma operação de agregação , encadeie o método explain() ao método aggregate(). Você pode passar um nível de verbosidade para explain(), que modifica o tipo e a quantidade de informações que o método retorna. Para obter mais informações sobre verbosidade, consulte Modos de verbosidade no manual do MongoDB Server .

O exemplo a seguir instrui o MongoDB a explicar a operação de agregação do exemplo anterior de documentos de filtro, grupo e contagem. O código passa um valor de verbosidade de ExplainVerbosity.EXECUTION_STATS para o método explain(), que configura o método para retornar estatísticas que descrevem a execução do plano vencedor:

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 de auxiliar do operador de pesquisa

O driver Scala fornece métodos de assistente para os seguintes 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 do MongoDB Server

Para saber mais sobre os tópicos discutidos neste guia, consulte as seguintes páginas no manual do MongoDB Server :

• Para ver uma lista completa de operadores de expressão, consulte Operadores de aggregation.

• Para saber mais sobre como montar uma agregação pipeline e ver exemplos, consulte Aggregation Pipeline.

• Para saber mais sobre como criar estágios de pipeline, consulte Estágios de agregação.

• Para saber mais sobre como explicar as operações do MongoDB, consulte Explicar planos de saída e query.

Documentação da API

Para saber mais sobre os métodos e tipos discutidos neste guia, consulte a seguinte documentação da API:

• Aggregate()

• Agregados

• explicar()