Aggregation Pipeline

Calculate Total Order Quantity

The following aggregation pipeline example contains two stages and returns the total order quantity of medium size pizzas grouped by pizza name:

db.orders.aggregate( [
   // Stage 1: Filter pizza order documents by pizza size
   {
      $match: { size: "medium" }
   },
   // Stage 2: Group remaining documents by pizza name and calculate total quantity
   {
      $group: { _id: "$name", totalQuantity: { $sum: "$quantity" } }
   }
] )

The $match stage:

• Filters the pizza order documents to pizzas with a size of medium.

• Passes the remaining documents to the $group stage.

The $group stage:

• Groups the remaining documents by pizza name.

• Uses $sum to calculate the total order quantity for each pizza name. The total is stored in the totalQuantity field returned by the aggregation pipeline.

Example output:

[
   { _id: 'Cheese', totalQuantity: 50 },
   { _id: 'Vegan', totalQuantity: 10 },
   { _id: 'Pepperoni', totalQuantity: 20 }
]

Calculate Total Order Value and Average Order Quantity

The following example calculates the total pizza order value and average order quantity between two dates:

db.orders.aggregate( [
   // Stage 1: Filter pizza order documents by date range
   {
      $match:
      {
         "date": { $gte: new ISODate( "2020-01-30" ), $lt: new ISODate( "2022-01-30" ) }
      }
   },
   // Stage 2: Group remaining documents by date and calculate results
   {
      $group:
      {
         _id: { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
         totalOrderValue: { $sum: { $multiply: [ "$price", "$quantity" ] } },
         averageOrderQuantity: { $avg: "$quantity" }
      }
   },
   // Stage 3: Sort documents by totalOrderValue in descending order
   {
      $sort: { totalOrderValue: -1 }
   }
 ] )

The $match stage:

• Filters the pizza order documents to those in a date range specified using $gte and $lt.

• Passes the remaining documents to the $group stage.

The $group stage:

• Groups the documents by date using $dateToString.

• For each group, calculates:

  • Total order value using $sum and $multiply.

  • Average order quantity using $avg.

• Passes the grouped documents to the $sort stage.

The $sort stage:

• Sorts the documents by the total order value for each group in descending order (-1).

• Returns the sorted documents.

Example output:

[
   { _id: '2022-01-12', totalOrderValue: 790, averageOrderQuantity: 30 },
   { _id: '2021-03-13', totalOrderValue: 770, averageOrderQuantity: 15 },
   { _id: '2021-03-17', totalOrderValue: 630, averageOrderQuantity: 30 },
   { _id: '2021-01-13', totalOrderValue: 350, averageOrderQuantity: 10 }
]

Aggregation Expressions and Operators

Some aggregation pipeline stages accept expressions. Operators calculate values based on input expressions.

In the MongoDB Query Language, you can build expressions from the following components:

For example, { $add: [ 3, "$inventory.total" ] } is an expression consisting of the $add operator and two input expressions:

• The constant 3

• The field path expression "$inventory.total"

The expression returns the result of adding 3 to the value at path inventory.total of the input document.

Field Paths

Field path expressions are used to access fields in input documents. To specify a field path, prefix the field name or the dotted field path (if the field is in an embedded document) with a dollar sign $. For example, "$user" to specify the field path for the user field or "$user.name" to specify the field path to the embedded "user.name" field.

"$<field>" is equivalent to "$$CURRENT.<field>" where the CURRENT is a system variable that defaults to the root of the current object, unless stated otherwise in specific stages.

For more information and examples, see Field Paths.

Aggregation Pipeline Limitations

An aggregation pipeline has limitations on the value types and the result size. See Aggregation Pipeline Limits.

Aggregation Pipelines and Sharded Collections

An aggregation pipeline supports operations on sharded collections. See Aggregation Pipeline and Sharded Collections.

Aggregation Pipelines as an Alternative to Map-Reduce

Starting in MongoDB 5.0, map-reduce is deprecated:

• Instead of map-reduce, you should use an aggregation pipeline. Aggregation pipelines provide better performance and usability than map-reduce.

• You can rewrite map-reduce operations using aggregation pipeline stages, such as $group, $merge, and others.

• For map-reduce operations that require custom functionality, you can use the $accumulator and $function aggregation operators. You can use those operators to define custom aggregation expressions in JavaScript.

For examples of aggregation pipeline alternatives to map-reduce, see:

• Map-Reduce to Aggregation Pipeline

• Map-Reduce Examples