MongoDB Aggregation - Basics
The find() command is frequently used for a variety of queries when we first begin using MongoDB. But as your queries become more complex, you'll need to know more about MongoDB aggregation.
In this article, I will explain the principles of building aggregate queries in MongoDB and some important stages of the aggregation pipeline with short examples using each one, and how to apply them to the pipeline.
What is MongoDB Aggregation?
Aggregation is a MongoDB way of managing complex algorithms which revolve around your data. Filtering, sorting, grouping, reshaping, and altering documents as they move through a pipeline are all possible. It also gives you procedural capabilities that do not by default exist inside your normal query framework. Here, we have a pipeline. A pipeline is made up of several stages inside an array that will do something to your data depending on what stage it is.
Calculating aggregate values for collections of documents is one of Aggregation's most often used use cases. Rather than only selecting and sorting your documents, you can also summarize them, group them, change the structure of your documents, relate different collections together, and join two collections. It starts processing the data as it comes.
Why MongoDB aggregation?
Aggregation Syntax
Find the name of the eldest host in Canada.
db.person.find({ "address.country": "Canada” '}, { “_id”: 0, “age’: 1, "name":1}) .sort({ "age": -1}).limit(1)
db.persons.aggregate ([
{ $match: { "address.country": "Canada" } },
{ $sort: { "age": -1},
{ $limit: 1},
{ $project: { "_id": 0, "age“: 1, “name”: 1 }
])
The above two methods would yield the same output. However, the order is very important. Because the order of the stage will decide the order in which that object gets processed. If the match stage is last in the pipeline: First, all the data will be fetched and sorted, and then it will be filtered. So execution will happen in the exact order of the stages that are written in the application to avoid processing unnecessary data.
Aggregation Syntax - Dollar Overloading:
{ $match: { a: 5 } } - Dollar on left means a stage name - in this case a $match stage.
{ $set: { b: "$a" } } - Dollar on right of colon "$a" refers to the value of field a.
{ $set: { area: { $multiply: [5,10] } } - $multiply is an expression name left of colon.
{ $set: { priceswithtax: { $map: {
input: "$prices",
as: “p”,
$in: {$multiply: ["$$p”, 1.08] }
} } } }
$$p refers to the temporary loop variable "p" declared in $map.
Pipeline Stages:
1. $match Stage:
Similar to the find() function is the $match stage. It is generally the initial stage in the pipeline because if the $match stage comes last, all the data will first be fetched, sorted, and then filtered. Hence, more documents would be evaluated for stages before this one. An aggregate pipeline with a $match stage is illustrated by the following example.
Recommended by LinkedIn
db.person.aggregate([{$match:{age:20, gender:“female”}}])
The above example will return all the documents where the age is 20 and the gender is female.
2. $project Stage:
In order to avoid processing more data than necessary, it is best practice to only return the fields you require. To achieve this and add any necessary computed fields, use the $project stage.
Please note:
In the example, we only need the fields name, age, and country:
db.person.aggregate([{$project:{_id:0, name: 1, age: 1, country: 1}}])
3. $group Stage:
It is essentially the group by clusters that you have in your app. The $group stage is used to group the input documents by the specified _id expression and return a single document containing the accumulated values for each distinct group. (GROUP BY in SQL is the closest equivalent).
_id is what MongoDB uses as a unique field. Each unique value represents one ‘group’.
{ $group: { _id: <expression>,
field1: { <$accum>: <expression> },
…} }
In the given example, we want to know the total population per country:
db.person.aggregate([
{$group:{_id: ”country”,
population: {$sum: “city_populaation”}}])
Common $group accumulators:
$avg: Displays the average value of a document’s field in the collection.
$min/$max: Displays the maximum/minimum value of a document’s field in the collection.
$sum: Sums up the specified values of all documents in the collection.
$push: Adds extra values into the array of the resulting document.
$count: Calculates the number of documents in the given group.
PERFORMANCE
The query is automatically reshaped by the aggregation pipeline in an effort to enhance performance. If you have both $sort and $match stages, it is always better to use the $match before the $sort in order to minimize the number of documents that the $sort stage has to deal with.
CONCLUSION
In the above article, I have introduced you to the MongoDB aggregation pipeline like what it is, and what are the stages, and demonstrated with examples how to use only some stages.
The aggregation pipeline becomes increasingly crucial as you use MongoDB because it enables you to perform all of the crucial database developer jobs including reporting, converting, and querying. You can also check and debug the input and output of every stage.
REFERENCES: