Transforme seus dados com agregação

Visão geral

Neste guia, você pode aprender como usar o driver Scala para executar operações de agregação.

Operações de aggregation processam dados em suas collections MongoDB e retornam resultados calculados. A estrutura de agregação MongoDB, que faz parte da API de query, é modelada sobre o conceito de pipelines de processamento de dados. Os documentos entram em um pipeline que contém um ou mais estágios, e esse pipeline transforma os documentos em um resultado agregado.

Dica

Tutoriais completos de agregação

Você pode encontrar tutoriais que fornecem explicações detalhadas de tarefas comuns de agregação na seção Tutoriais completos do aggregation pipeline do manual do servidor. Selecione um tutorial e escolha Scala no menu suspenso Select your language no canto superior direito da página.

Analogia

Uma operação de agregação é semelhante a uma fábrica de carros. Uma fábrica de automóveis tem uma linha de montagem, que contém estações de montagem com ferramentas especializadas para realizar trabalhos específicos, como furadeiras e soldadores. As peças brutas entram na fábrica e, em seguida, a linha de montagem transforma e as monta em um produto acabado.

O pipeline de agregação é a linha de montagem, estágios de agregação são as estações de montagem e expressões do operador são as ferramentas especializadas.

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.

Encontrar operações	Operações de agregação
Select certain documents to return Select which fields to return Sort the results Limit the results Count the results	Select certain documents to return Select which fields to return Sort the results Limit the results Count the results Rename fields Compute new fields Summarize data Connect and merge data sets

Limitações

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

Os documentos devolvidos não podem violar o limite 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.

Executar operações de agregação

Observação

Dados de amostra

Os exemplos neste guia usam a collection restaurants no banco de dados sample_restaurants dos conjuntos de banco de dados de amostra do Atlas. Para saber como criar um cluster MongoDB Atlas gratuito e carregar os conjuntos de dados de amostra, consulte o guia Iniciar com Atlas .

Para executar uma agregação, passe uma lista contendo os estágios do pipeline para o método aggregate(). O driver Scala fornece a classe Aggregates , que inclui métodos de assistente para criar estágios de pipeline.

Para saber mais sobre os estágios do pipeline e seus métodos assistente Aggregates correspondentes, consulte os seguintes recursos:

Estágios de agregação no manual do MongoDB Server
Agregados na documentação da API

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"}},
...}

Executar uma pesquisa de texto completo com o MongoDB Search

Dica

Disponível apenas para coleções com um índice de pesquisa MongoDB

Esse operador de pipeline de agregação só está disponível para coleção com um índice de pesquisa MongoDB.

Para especificar uma pesquisa de texto completo de um ou mais campos, você pode criar um estágio de pipeline $search. O driver Scala fornece o método assistente Aggregates.search() para criar esse estágio. O método search() exige os seguintes argumentos:

SearchOperator instância: especifica o campo e o texto a serem pesquisados.
SearchOptions instância: especifica opções para personalizar a pesquisa de texto completo. Você deve definir a opção index para o nome do índice de pesquisa do MongoDB a ser usado.

Este exemplo cria estágios de pipeline para executar as seguintes ações:

Pesquise no campo name texto que contenha a palavra "Salt"
Projete somente os valores _id e name de documentos correspondentes

val operator = SearchOperator.text(SearchPath.fieldPath("name"), "Salt")
val options = searchOptions().index("<search index name>")
val pipeline = Seq(Aggregates.search(operator, options),
                   Aggregates.project(Projections.include("name")))
collection.aggregate(pipeline)
          .subscribe((doc: Document) => println(doc.toJson()),
                    (e: Throwable) => println(s"There was an error: $e"))

{"_id": {"$oid": "..."}, "name": "Fresh Salt"}
{"_id": {"$oid": "..."}, "name": "Salt & Pepper"}
{"_id": {"$oid": "..."}, "name": "Salt + Charcoal"}
{"_id": {"$oid": "..."}, "name": "A Salt & Battery"}
{"_id": {"$oid": "..."}, "name": "Salt And Fat"}
{"_id": {"$oid": "..."}, "name": "Salt And Pepper Diner"}

Importante

Para executar o exemplo anterior, você deve criar um índice de pesquisa do MongoDB Search na coleção restaurants que cubra o campo name. Em seguida, substitua o espaço reservado "<search index name>" pelo nome do índice. Para saber mais sobre os índices de pesquisa do MongoDB Search, veja o guia Índices de Pesquisa do MongoDB Search.

Informações adicionais

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 obter uma lista completa dos estágios de agregação, consulte Estágios de agregação no manual do MongoDB Server.
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:

Voltar

Monitoramento de clusters

Observables