Aggregation

Overview

In this guide, you can learn how to use the MongoDB .NET/C# Driver to perform aggregation operations.

Aggregation operations process data in your MongoDB collections and return computed results. The MongoDB Aggregation framework is modeled on the concept of data processing pipelines. Documents enter a pipeline comprised of one or more stages, and this pipeline transforms the documents into an aggregated result.

Compare Aggregation and Find Operations

The following table lists the different tasks you can perform with find operations, compared to what you can achieve with aggregation operations. The aggregation framework provides expanded functionality that allows you to transform and manipulate your data.

Server Limitations

Consider the following limitations when performing aggregation operations:

• Returned documents must not violate the BSON document size limit of 16 megabytes.

• Pipeline stages have a memory limit of 100 megabytes by default. If required, you can exceed this limit by setting the AllowDiskUse property of the AggregateOptions object that you pass to the Aggregate() method.

• The $graphLookup stage has a strict memory limit of 100 megabytes and ignores the AllowDiskUse property.

Aggregation Example

To perform an aggregation, pass a list of aggregation stages to the IMongoCollection<TDocument>.Aggregate() method.

The following code example produces a count of the number of bakeries in each borough of New York City. To do so, it uses an aggregation pipeline that contains the following stages:

• A $match stage to filter for documents whose cuisine field contains the value "Bakery".

• A $group stage to group the matching documents by the borough field, accumulating a count of documents for each distinct value of that field.

The following sections implement this example by using LINQ, Builders, and BsonDocument approaches to create and combine the aggregation stages used in the example pipeline.

// 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);
}

Additional Information