Transforme seus dados com agregação

Visão geral

Neste guia, você pode aprender como usar Mongoid para realizar 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.

As operações de agregação funcionam de forma semelhante às fábricas de automóveis com linhas de montagem. As linhas de montagem têm estações com ferramentas especializadas para executar tarefas específicas. Por exemplo, ao construir um carro, a linha de montagem começa com o estrutura. Em seguida, à medida que a estrutura do carro se move pela linha de montagem, cada estação monta uma peça separada. O resultado é um produto final transformado, o carro acabado.

A linha de montagem representa o aggregation pipeline, as estações individuais representam os estágios de aggregation, as ferramentas especializadas representam os operadores de expressão, e o produto finalizado representa o resultado agregado.

Comparar agregação e encontrar operações

A tabela a seguir lista as diferentes tarefas que você pode executar com operações de localização, em comparação com o que você pode obter com operações de agregação. A estrutura de agregação fornece 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

Mongoid Builders

Você pode construir um pipeline de agregação usando a linguagem específica de domínio (DSL) de alto nível da Mongoid. O DSL é compatível com os seguintes operadores de agregação pipeline:

Operador	Nome do método
$group	`group`
$project	`project`
$unwind	`unwind`

Para criar um agregação pipeline usando um dos operadores anteriores, chame o método correspondente em uma instância do Criteria. A chamada do método adiciona a operação de agregação ao atrritbure pipeline da instância Criteria. Para executar o pipeline de agregação , passe o valor de atributo pipeline para o método Collection#aggregate.

Exemplo

Considere um banco de dados que contenha uma collection com documentos modelados pelas seguintes classes:

class Tour
  include Mongoid::Document
  embeds_many :participants
  field :name, type: String
  field :states, type: Array
end
class Participant
  include Mongoid::Document
  embedded_in :tour
  field :name, type: String
end

Neste exemplo, o modelo Tour representa o nome de um roteiro e os estados pelos quais ele passa, e o modelo Participant representa o nome de uma pessoa que participa do roteiro.

O exemplo a seguir cria um pipeline de agregação que produz os estados que um participante visitou usando as seguintes operações de agregação :

match, que encontram documentos nos quais o valor do campo participants.name é "Serenity"
unwind, que desconstrói o campo da array states e gera um documento para cada elemento da array
group, que agrupa os documentos pelo valor de seu campo states
project, que solicita que o pipeline retorne somente os campos _id e states

criteria = Tour.where('participant.name' => 'Serenity').
    unwind(:states).
    group(_id: 'states', :states.add_to_set => '$states').
    project(_id: 0, states: 1)
@states = Tour.collection.aggregate(criteria.pipeline).to_json

[{"states":["OR","WA","CA"]}]

Agregação sem construtores

Você pode utilizar o método Collection#aggregate para executar operações de agregação que não têm métodos de construtor correspondentes passando uma array de operações de agregação . O uso desse método para executar a agregação retorna objetos BSON::Document brutos em vez de instâncias de modelo Mongoid::Document.

Exemplo

Considere um banco de dados que contenha uma collection com documentos modelados pelas seguintes classes:

class Band
  include Mongoid::Document
  has_many :tours
  has_many :awards
  field :name, type: String
end
class Tour
  include Mongoid::Document
  belongs_to :band
  field :year, type: Integer
end
class Award
  include Mongoid::Document
  belongs_to :band
  field :name, type: String
end

O exemplo a seguir cria um pipeline de agregação para recuperar todas as bandas que fizeram turnês desde 2000 e têm pelo menos 1 prêmios:

band_ids = Band.collection.aggregate([
  { '$lookup' => {
    from: 'tours',
    localField: '_id',
    foreignField: 'band_id',
    as: 'tours',
  } },
  { '$lookup' => {
    from: 'awards',
    localField: '_id',
    foreignField: 'band_id',
    as: 'awards',
  } },
  { '$match' => {
    'tours.year' => {'$gte' => 2000},
    'awards._id' => {'$exists' => true},
  } },
  {'$project' => {_id: 1}},
])
bands = Band.find(band_ids.to_a)

[
 {"_id": "...", "name": "Deftones" },
 {"_id": "...", "name": "Tool"},
 ...
]

Dica

O exemplo anterior projeta somente o campo _id dos documentos de saída. Em seguida, ele usa os resultados projetados para localizar os documentos e devolvê-los como Mongoid::Document instâncias de modelo. Esta etapa opcional não é necessária para executar um pipeline de agregação .

Informações adicionais

Para ver uma lista completa de operadores de agregação , consulte Operadores de aggregation.

Para saber mais sobre como montar um aggregation pipeline e ver exemplos, consulte Aggregation Pipeline.

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

Documentação da API

Para saber mais sobre qualquer um dos métodos discutidos nesta guia, consulte a seguinte documentação da API:

Voltar

Modificar Resultados da Query

Texto de pesquisa