Menu Docs
Página inicial do Docs
/ / /
Scala
/

Framework de aggregation

Nesta página

  • Pré-requisitos
  • Conecte-se a um MongoDB deployment
  • Fazer aggregation
  • Usar expressões de agregação
  • Explicar uma agregação

O pipeline de agregação é uma estrutura para agregação de dados, modelada sobre o conceito de pipelines de processamento de dados.

Para saber mais sobre agregação, consulte Aggregation Pipeline no manual do servidor.

Você deve configurar os seguintes componentes para executar os exemplos de código neste guia:

  • Uma test.restaurants coleção preenchida com documentos do restaurants.json arquivo nos ativos Github de documentação do .

  • As seguintes declarações de importação:

import org.mongodb.scala._
import org.mongodb.scala.model.Aggregates._
import org.mongodb.scala.model.Accumulators._
import org.mongodb.scala.model.Filters._
import org.mongodb.scala.model.Projections._

Observação

Este guia usa as implicações do Observable como abordadas no Quick Start Primary.

Primeiro, conecte a um MongoDB deployment e, em seguida, declare e defina as instâncias MongoDatabase e MongoCollection .

O código a seguir se conecta a uma MongoDB deployment standalone em execução em localhost na porta 27017. Em seguida, define a variável database para fazer referência ao banco de dados test e a variável collection para fazer referência à coleção restaurants :

val mongoClient: MongoClient = MongoClient()
val database: MongoDatabase = mongoClient.getDatabase("test")
val collection: MongoCollection[Document] = database.getCollection("restaurants")

Para saber mais sobre como se conectar a sistemas do MongoDB, consulte o tutorial Conectar ao MongoDB .

Para executar a agregação, passe uma lista de estágios de agregação para o método MongoCollection.aggregate() . O driver fornece a classe assistente Aggregates que contém construtores para estágios de agregação .

Neste exemplo, o aggregation pipeline executa as seguintes tarefas:

  • Usa um estágio $match para filtrar documentos nos quais o campo de array categories contém o elemento "Bakery". O exemplo utiliza Aggregates.filter() para construir o estágio $match .

  • Utiliza um estágio $group para agrupar os documentos correspondentes pelo campo stars , acumulando uma contagem de documentos para cada valor distinto de stars. O exemplo utiliza Aggregates.group() para construir o estágio $group e Accumulators.sum() para construir a expressão acumulador . Para as expressões acumulador para uso no estágio $group , o driver fornece Accumulators classe assistente .

collection.aggregate(Seq(
Aggregates.filter(Filters.equal("categories", "Bakery")),
Aggregates.group("$stars", Accumulators.sum("count", 1))
)).printResults()

Para expressões de acumulador do $group , o driver fornece a classe assistente do Accumulators . Para outras expressões de agregação , construa manualmente a expressão utilizando a classe Document .

No exemplo a seguir, o aggregation pipeline usa um estágio $project para retornar somente o campo name e o campo calculado firstCategory cujo valor é o primeiro elemento na array categories . O exemplo utiliza Aggregates.project() e vários métodos de classe Projections para construir o estágio $project :

collection.aggregate(
Seq(
Aggregates.project(
Projections.fields(
Projections.excludeId(),
Projections.include("name"),
Projections.computed(
"firstCategory",
Document("$arrayElemAt"-> Seq("$categories", 0))
)
)
)
)
).printResults()

Para $explain um pipeline de agregação , chame o método AggregatePublisher.explain() :

collection.aggregate(
Seq(Aggregates.filter(Filters.eq("categories", "Bakery")),
Aggregates.group("$stars", Accumulators.sum("count", 1)))
).explain().printResults()

Voltar

Operações de gravação em massa