MongoDB Aggregate Pipeline

Main Page >> MongoDB >>MongoDB Workbook >> Aggregation Pipeline

Aggregation Pipeline

So far find() either returns all the elements of an array, if one element matches the search criteria, or $elematch returns the first one found only. The latter is fine if there is only one to be found, but not so good if several items in the array should match the search criteria.

The aggregation pipeline is a framework for data aggregation modelled on the concept of data processing pipelines. What this means, is documents enter a multi-stage pipeline that transforms the documents into aggregated results.

This is similar to using GROUP BY in SQL, where you might aggregate the average grades of all students taking a module.

The MongoDB aggregation pipeline consists of stages and each stage transforms the documents as they pass through the pipeline. A stage can generate new documents or filter out documents. A stage can also appear several times in the pipeline.

The syntax is:

db.collectionName.aggregate( [ { <stage> }, ... ] )

The pipeline for instance, could:

• project out certain details from each document, such as the employees;
• group the projected details by a certain fields and then using an aggregate function, such as group by the deptno and then counting the number of occurrences;
• sorting the results in order;
• limiting the results to a certain number, such as the first 10;

These are represented by the following operators: $project,$group, $sort or $limit.

A number of operations exist for the aggregation pipeline, details of which can be found in the MongoDB manual:

https://docs.mongodb.com/manual/reference/operator/aggregation/

$filter

In the aggregation pipeline, array has various operators and the one we are interested in is $filter

This returns a subset of the array with only the elements that match the filter condition.

$filter has the following syntax:

{ $filter: {
	input: <array>,    /* expression for the array */
	as: <string>, 	   /* variable name for the element */   
	cond: <expression> /* filter condition */
} }

$filter is one of the stages of the pipeline and can not be used by itself. It is used with an aggregation framework operator, such as $project.

We can use the pipeline to gather elements of our employees array to get the employees matching the query criteria only, rather than one, or everyone. This example has only one stage:

db.deptCollection.aggregate([ {
     $project: {
        empSet: {
           $filter: {
              input: "$employees",
              as: "employee",
              cond: { $gte: [ "$$employee.sal", 2000 ] }
           }
        }
     }
  }
]).pretty()

Now the system should only retrieve the employees with salary > 2000.

Count

The power of the aggregation pipeline is to do processing on the data.

Lets count how many employees each department has:

db.deptCollection.aggregate({ 
 "$project": {
    "deptno": 1,
    "Count": { "$size": { "$ifNull": [ "$employees", [] ] }
     }
   }})

The $ifNull operator is needed, since department 40 has no employees - you will get an error message if left out!

Next Step

Updating the collection