Transforme seus dados com agregação

Comparar agregação e encontrar operações

Você pode usar encontrar operações para executar as seguintes ações:

• Selecione quais documentos devolver

• Selecione quais campos retornar

• ordenar os resultados

Você pode usar operações de agregação para executar as seguintes ações:

• Execute operações de localização

• Renomear campos

• Calcular campos

• Resumir dados

• Agrupar valores

Limitações

As seguintes limitações se aplicam ao usar operações de agregação :

• Os documentos devolvidos não devem violar o limite de tamanho de 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 este limite utilizando o método allowDiskUse() da classe AggregateIterable .

Criar e Executar um Pipeline de Agregação

Para executar uma agregação nos documentos em uma coleção, passe uma lista de estágios de agregação para o método aggregate() .

Este exemplo gera uma contagem do número de Padarias em cada bairro da cidade de Nova York. O seguinte código cria um pipeline de agregação que contém os seguintes estágios:

• Um estágio $match para filtrar os documentos em que o valor do campo cuisine é "Bakery".

• Um estágio $group para agrupar os documentos correspondentes pelo campo borough , produzindo uma contagem de documentos para cada valor distinto desse campo.

val pipeline = listOf(
    Aggregates.match(Filters.eq(Restaurant::cuisine.name, "Bakery")),
    Aggregates.group("\$borough", Accumulators.sum("count", 1))
)
val results = collection.aggregate<Document>(pipeline)
results.forEach { result ->
    println(result)
}

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

Explicar uma agregação

Para visualizar informações sobre como o MongoDB executa sua operação, você pode incluir o estágio de agregação $explain em seu pipeline. 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 de o MongoDB concluir uma operação. Quando você instrui o MongoDB a explicar uma operação, ele retorna o plano que o MongoDB selecionou para a operação e quaisquer planos de execução rejeitados.

O seguinte exemplo de código executa a mesma agregação mostrada na seção anterior e adiciona o estágio $explain para produzir os detalhes da operação:

print(collection.aggregate(pipeline).explain())

{
  "explainVersion": "2",
  "queryPlanner": {
      "namespace": "sample_restaurants.restaurants"
      "indexFilterSet": false,
      "parsedQuery": {
        "cuisine": {"$eq": "Bakery"}
      },
      "queryHash": "865F14C3",
      "planCacheKey": "0697561B",
      "optimizedPipeline": true,
      "maxIndexedOrSolutionsReached": false,
      "maxIndexedAndSolutionsReached": false,
      "maxScansToExplodeReached": false,
      "winningPlan": { ... }
      ...
  }
  ...
}

Criar um estágio de pesquisa de pipeline

Você pode criar os critérios de pesquisa em seu estágio de pipeline do Atlas Search usando Operadores de pesquisa.

O driver Kotlin Sync fornece métodos 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()
        .filter(
            listOf(
                SearchOperator.`in`(fieldPath("genres"), listOf("Comedy")),
                SearchOperator.phrase(fieldPath("fullplot"), "new york"),
                SearchOperator.numberRange(fieldPath("year")).gtLt(1950, 2000),
                SearchOperator.wildcard(fieldPath("title"), "Love *")
            )
        )
)
val projectStage = Aggregates.project(
    Projections.include("title", "year", "genres"))
val pipeline = listOf(searchStage, projectStage)
val results = collection.aggregate(pipeline)
results.forEach { result -> println(result) }

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

Documentação da API

Para obter mais informações sobre como executar operações de agregação com o driver Kotlin Sync, consulte a seguinte documentação da API:

• Aggregate()

• AggregateIterable

• Agregados

• search()

• projeto()