Agregação

Visão geral

Neste guia, você pode aprender como usar o driver MongoDB .NET/C# para realizar operações de agregação.

Operações de agregação processam dados em suas coleções MongoDB e retornam resultados calculados. A estrutura de agregação MongoDB é modelada sobre o conceito de pipelines de processamento de dados. Os documentos entram em um pipeline composto por um ou mais estágios, e esse pipeline transforma os documentos em um 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.

Limitações do servidor

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

• Os documentos retornados não devem 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. Se necessário, você pode exceder esse limite definindo a propriedadeAllowDiskUse do objeto AggregateOptions que você passa para o método Aggregate() .

• O estágio $graphLookup tem um limite estrito de memória de 100 megabytes e ignora a propriedade AllowDiskUse.

Exemplo de agregação

Para executar uma agregação, passe uma lista de estágios de agregação para o método IMongoCollection<TDocument>.Aggregate().

O exemplo de código a seguir produz uma contagem do número de padarias em cada distrito da cidade de Nova York. Para fazer isso, ele usa um pipeline de agregação que contém os seguintes estágios:

• Um estágio $match para filtrar os documentos cujo campo cuisine contém o valor "Bakery".

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

As seções a seguir implementam esse exemplo usando as abordagens LINQ, Builders e BSONDocument para criar e combinar os estágios de agregação usados no pipeline de exemplo.

// Defines a queryable collection object as a prerequisite to using LINQ
var queryableCollection = collection.AsQueryable();
// Defines the query with $match and $group stages
var query = queryableCollection
    .Where(r => r.Cuisine == "Bakery")
    .GroupBy(r => r.Borough)
    .Select(g => new { _id = g.Key, Count = g.Count() });
// Executes the query and prints the aggregated results
foreach (var result in query.ToList())
{
    Console.WriteLine(result);
}

// Defines the $match aggregation stage  
var matchFilter = Builders<Restaurant>.Filter.Eq(r => r.Cuisine, "Bakery");
// Defines the aggregation pipeline with the $match and $group aggregation stages
var pipeline = new EmptyPipelineDefinition<Restaurant>()
    .Match(matchFilter)
    .Group(r => r.Borough,
        g => new
            {
                _id = g.Key,
                Count = g.Count()
            }
    );
// Executes the aggregation pipeline
var results = collection.Aggregate(pipeline).ToList();
// Prints the aggregated results
foreach (var result in results)
{
    Console.WriteLine(result);
}

// Defines the $match and $group aggregation stages
var matchStage = new BsonDocument
{
    {
        "$match",
        new BsonDocument
        {
            { "cuisine", "Bakery" }
        }
    }
};
var groupStage = new BsonDocument
{
    {
        "$group",
        new BsonDocument
        {
            { "_id", "$borough" },
            { "count", new BsonDocument("$sum", 1) }
        }
    }
};
// Executes the aggregation pipeline
var pipeline = new[] { matchStage, groupStage };
var results = collection.Aggregate<BsonDocument>(pipeline).ToList();
// Prints the aggregated results
foreach (BsonDocument result in results)
{
    Console.WriteLine(result);
}

Informações adicionais