MongoDB Aggregation Operations

Note: this page has been created with the use of AI. Please take caution, and note that the content of this page does not necessarily reflect the opinion of Cratecode.

MongoDB, the popular NoSQL database, offers powerful tools to process and transform your data. One such tool is the aggregation framework, which allows you to perform complex data manipulation tasks in an efficient and straightforward manner. By combining various aggregation operations, you can create pipelines to transform your data into the desired format or perform calculations on it.

Aggregation Basics

Aggregation in MongoDB works by processing data records and returning computed results. Aggregation operations group values from multiple documents together and perform a variety of operations on the grouped data to return a single result.

Aggregation Pipeline

The aggregation pipeline is a powerful feature of MongoDB that allows you to perform complex data manipulation in a sequence of stages. Each stage in the pipeline processes the data and passes the transformed data to the next stage.

To create an aggregation pipeline, you use the aggregate() method on a MongoDB collection. Here's a simple example:

db.sales.aggregate([
    { $match: { status: "A" } },
    { $group: { _id: "$customer_id", total: { $sum: "$amount" } } },
    { $sort: { total: -1 } }
]);

This pipeline consists of three stages:

1. $match filters the documents with the status field equal to "A."
2. $group groups the documents by customer_id and calculates the total amount for each group.
3. $sort sorts the results in descending order by the total field.

Aggregation Operations

MongoDB provides a rich set of aggregation operations that you can use in your pipelines. Some of the most common operations include:

• $match: Filters the documents to pass only those that match the specified condition.
• $group: Groups documents by a specified expression and applies an accumulator to each group.
• $project: Reshapes the documents by adding or removing fields, renaming fields, or creating new fields from existing ones.
• $sort: Sorts the documents by one or more fields.
• $limit: Limits the number of documents passed to the next stage in the pipeline.
• $skip: Skips a specified number of documents before passing the remaining documents to the next stage.

Example: Aggregating Sales Data

Let's walk through a practical example of using MongoDB aggregation operations to process sales data. Consider a sales collection with documents that have the following structure:

{
    "_id": ObjectId("..."),
    "date": ISODate("2021-01-01"),
    "product_id": 1,
    "customer_id": 123,
    "quantity": 5,
    "price": 10.99
}

Let's say we want to calculate the total sales for each product for the year 2021. We can create an aggregation pipeline with the following stages:

1. $match to filter documents with a date within the year 2021.
2. $group to group documents by product_id and calculate the total sales using $sum.
3. $sort to sort the results by total sales in descending order.

Here's the code for this pipeline:

db.sales.aggregate([
    {
        $match: {
            date: {
                $gte: ISODate("2021-01-01"),
                $lt: ISODate("2022-01-01")
            }
        }
    },
    {
        $group: {
            _id: "$product_id",
            total_sales: { $sum: { $multiply: ["$quantity", "$price"] } }
        }
    },
    { $sort: { total_sales: -1 } }
]);

This example demonstrates how you can use MongoDB's aggregation framework to perform complex data processing tasks with just a few lines of code. By chaining aggregation operations in a pipeline, you can efficiently transform and analyze your data to meet your specific needs.

FAQ

db.collection("orders").aggregate([
    { $match: { status: "completed" } },
    { $group: { _id: "$customerID", total: { $sum: "$amount" } } },
    { $sort: { total: -1 } }
])

db.collection("orders").aggregate([
    { $match: { status: "completed" } },
    {
        $lookup: {
            from: "customers",
            localField: "customerID",
            foreignField: "_id",
            as: "customerDetails"
        }
    }
])