Why advanced stages matter in MongoDB - See It in Action

Why Advanced Stages Matter in MongoDB Aggregation

📖 Scenario: You are working with a MongoDB database that stores sales data for a retail company. The company wants to analyze their sales to find the total revenue per product category, but only for sales that happened in the last year and where the revenue was above a certain threshold. This requires using advanced aggregation stages to filter, group, and calculate the results efficiently.

🎯 Goal: Build a MongoDB aggregation pipeline that filters sales by date, groups them by product category, calculates total revenue per category, and then filters categories with revenue above a threshold.

📋 What You'll Learn

Create a collection named sales with documents containing product, category, price, quantity, and date fields.

Define a variable minRevenue to set the minimum revenue threshold for filtering categories.

Write an aggregation pipeline that filters sales from the last year, groups by category, calculates total revenue per category, and filters categories with revenue greater than minRevenue.

Add a final stage to sort the results by total revenue in descending order.

💡 Why This Matters

🌍 Real World

Retail companies often analyze sales data to understand which product categories generate the most revenue and to focus marketing or inventory efforts accordingly.

💼 Career

Data analysts and backend developers use MongoDB aggregation pipelines to efficiently process and summarize large datasets for reporting and decision-making.

1

DATA SETUP: Create the sales collection with sample documents

Insert these exact documents into a MongoDB collection called sales: {"product": "Laptop", "category": "Electronics", "price": 1200, "quantity": 5, "date": ISODate("2023-03-15T00:00:00Z")}, {"product": "Headphones", "category": "Electronics", "price": 150, "quantity": 10, "date": ISODate("2023-06-20T00:00:00Z")}, {"product": "Coffee Maker", "category": "Home Appliances", "price": 80, "quantity": 7, "date": ISODate("2022-11-05T00:00:00Z")}, {"product": "Blender", "category": "Home Appliances", "price": 60, "quantity": 3, "date": ISODate("2023-01-10T00:00:00Z")}, {"product": "Notebook", "category": "Stationery", "price": 5, "quantity": 100, "date": ISODate("2023-04-01T00:00:00Z")}

MongoDB

// Insert the exact sales documents into the sales collection
// Your code here

Hint

Use db.sales.insertMany([...]) with the exact documents listed.

2

CONFIGURATION: Define the minimum revenue threshold variable

Create a JavaScript variable called minRevenue and set it to 1000 to use as the minimum revenue filter in the aggregation.

MongoDB

db.sales.insertMany([
  {"product": "Laptop", "category": "Electronics", "price": 1200, "quantity": 5, "date": ISODate("2023-03-15T00:00:00Z")},
  {"product": "Headphones", "category": "Electronics", "price": 150, "quantity": 10, "date": ISODate("2023-06-20T00:00:00Z")},
  {"product": "Coffee Maker", "category": "Home Appliances", "price": 80, "quantity": 7, "date": ISODate("2022-11-05T00:00:00Z")},
  {"product": "Blender", "category": "Home Appliances", "price": 60, "quantity": 3, "date": ISODate("2023-01-10T00:00:00Z")},
  {"product": "Notebook", "category": "Stationery", "price": 5, "quantity": 100, "date": ISODate("2023-04-01T00:00:00Z")}
])

// Define the minimum revenue threshold
// Your code here

Hint

Use const minRevenue = 1000; to set the threshold.

3

CORE LOGIC: Build the aggregation pipeline with filtering and grouping

Write a MongoDB aggregation pipeline called pipeline that does the following: 1) Filters sales with date greater than or equal to ISODate("2023-01-01T00:00:00Z"), 2) Groups documents by category and calculates total revenue as the sum of price * quantity per category, 3) Filters groups where total revenue is greater than minRevenue.

MongoDB

db.sales.insertMany([
  {"product": "Laptop", "category": "Electronics", "price": 1200, "quantity": 5, "date": ISODate("2023-03-15T00:00:00Z")},
  {"product": "Headphones", "category": "Electronics", "price": 150, "quantity": 10, "date": ISODate("2023-06-20T00:00:00Z")},
  {"product": "Coffee Maker", "category": "Home Appliances", "price": 80, "quantity": 7, "date": ISODate("2022-11-05T00:00:00Z")},
  {"product": "Blender", "category": "Home Appliances", "price": 60, "quantity": 3, "date": ISODate("2023-01-10T00:00:00Z")},
  {"product": "Notebook", "category": "Stationery", "price": 5, "quantity": 100, "date": ISODate("2023-04-01T00:00:00Z")}
])

const minRevenue = 1000;

// Create the aggregation pipeline with $match, $group, and $match stages
// Your code here

Hint

Use $match to filter by date, $group to sum revenue, and another $match to filter by minRevenue.

4

COMPLETION: Add sorting stage to the aggregation pipeline

Add a final stage to the pipeline that sorts the results by totalRevenue in descending order.

MongoDB

db.sales.insertMany([
  {"product": "Laptop", "category": "Electronics", "price": 1200, "quantity": 5, "date": ISODate("2023-03-15T00:00:00Z")},
  {"product": "Headphones", "category": "Electronics", "price": 150, "quantity": 10, "date": ISODate("2023-06-20T00:00:00Z")},
  {"product": "Coffee Maker", "category": "Home Appliances", "price": 80, "quantity": 7, "date": ISODate("2022-11-05T00:00:00Z")},
  {"product": "Blender", "category": "Home Appliances", "price": 60, "quantity": 3, "date": ISODate("2023-01-10T00:00:00Z")},
  {"product": "Notebook", "category": "Stationery", "price": 5, "quantity": 100, "date": ISODate("2023-04-01T00:00:00Z")}
])

const minRevenue = 1000;

const pipeline = [
  { $match: { date: { $gte: ISODate("2023-01-01T00:00:00Z") } } },
  { $group: {
      _id: "$category",
      totalRevenue: { $sum: { $multiply: ["$price", "$quantity"] } }
    }
  },
  { $match: { totalRevenue: { $gt: minRevenue } } },
  // Add sorting stage here
  // Your code here
];

Hint

Add { $sort: { totalRevenue: -1 } } as the last stage in the pipeline.

Practice

1. What is the main reason to use advanced stages in MongoDB aggregation pipelines?

easy

A. To process data step-by-step for clearer results

B. To store data in multiple collections

C. To create indexes automatically

D. To backup the database

Solution

1. Step 1: Understand the purpose of advanced stages

   Advanced stages in MongoDB aggregation allow processing data in steps like filtering, grouping, and sorting.

2. Step 2: Identify the benefit of step-by-step processing

   This stepwise processing helps produce clear and useful results from complex data.

3. Final Answer:

   To process data step-by-step for clearer results -> Option A

4. Quick Check:

   Advanced stages = step-by-step processing [OK]

Hint: Think of stages as steps to clean and organize data [OK]

Common Mistakes:

• Confusing aggregation stages with indexing
• Thinking advanced stages create backups
• Believing stages store data in collections

2. Which of the following is the correct syntax to start an aggregation pipeline in MongoDB?

easy

A. db.collection.match([{ age: { $gt: 25 } }])

B. db.collection.find({ $match: { age: { $gt: 25 } } })

C. db.collection.aggregate([{ $match: { age: { $gt: 25 } } }])

D. db.collection.aggregate({ $match: { age: { $gt: 25 } } })

Solution

1. Step 1: Recall the aggregation method syntax

   The aggregation pipeline starts with db.collection.aggregate() and takes an array of stages.

2. Step 2: Check the correct use of $match stage inside an array

   The $match stage must be inside an array as the first element to filter documents.

3. Final Answer:

   db.collection.aggregate([{ $match: { age: { $gt: 25 } } }]) -> Option C

4. Quick Check:

   aggregate() takes an array of stages [OK]

Hint: Remember aggregate() needs an array of stages [OK]

Common Mistakes:

• Using find() instead of aggregate() for pipeline
• Passing object instead of array to aggregate()
• Using non-existent match() method

3. Given the collection 'sales' with documents { item: 'apple', qty: 5 } and { item: 'banana', qty: 10 }, what is the output of this pipeline?

db.sales.aggregate([
  { $match: { qty: { $gt: 5 } } },
  { $project: { item: 1, _id: 0 } }
])

medium

A. [{ item: 'apple' }]

B. [{ item: 'banana' }]

C. [{ item: 'apple' }, { item: 'banana' }]

D. []

Solution

1. Step 1: Apply the $match stage filtering qty > 5

   Only the document with qty 10 (banana) matches the condition.

2. Step 2: Apply the $project stage to include item and exclude _id

   The output will show only the item field for the matched document.

3. Final Answer:

   [{ item: 'banana' }] -> Option B

4. Quick Check:

   Filter qty > 5 then project item only [OK]

Hint: Filter first, then project fields you want [OK]

Common Mistakes:

• Including documents with qty <= 5
• Forgetting to exclude _id field
• Projecting fields before filtering

4. Identify the error in this aggregation pipeline:

db.orders.aggregate([
  { $group: { _id: '$customerId', total: { $sum: '$amount' } } },
  { $sort: { total: -1 } },
  { $match: { total: { $gt: 100 } } }
])

medium

A. The $sort stage cannot be used after $group

B. The $match stage should come before $group

C. The $match stage cannot filter on computed fields after $group

D. No error, pipeline is correct

Solution

1. Step 1: Analyze the $group stage

   It correctly groups by customerId and computes the total sum per customer.

2. Step 2: Verify $sort and $match stages

   $sort by total descending after $group is valid. $match filtering groups with total > 100 after $group is also valid on computed fields.

3. Final Answer:

   No error, pipeline is correct -> Option D

4. Quick Check:

   $match after $group on aggregates is allowed [OK]

Hint: $match can filter aggregates after $group [OK]

Common Mistakes:

• Thinking $match must always precede $group
• Believing $sort cannot follow $group
• Assuming $match cannot filter computed fields

5. You want to find the top 3 products by total sales amount from a 'sales' collection. Which pipeline correctly uses advanced stages to achieve this?

hard

A. [{ $group: { _id: '$product', totalSales: { $sum: '$amount' } } }, { $sort: { totalSales: -1 } }, { $limit: 3 }]

B. [{ $sort: { amount: -1 } }, { $limit: 3 }, { $group: { _id: '$product', totalSales: { $sum: '$amount' } } }]

C. [{ $limit: 3 }, { $group: { _id: '$product', totalSales: { $sum: '$amount' } } }, { $sort: { totalSales: -1 } }]

D. [{ $group: { _id: '$product', totalSales: { $sum: '$amount' } } }, { $limit: 3 }, { $sort: { totalSales: -1 } }]

Solution

1. Step 1: Group sales by product and sum amounts

   The $group stage aggregates total sales per product correctly.

2. Step 2: Sort products by totalSales descending and limit to top 3

   $sort orders by totalSales descending, then $limit picks top 3 products.

3. Final Answer:

   [{ $group: { _id: '$product', totalSales: { $sum: '$amount' } } }, { $sort: { totalSales: -1 } }, { $limit: 3 }] -> Option A

4. Quick Check:

   Group, then sort, then limit for top results [OK]

Hint: Group first, then sort and limit for top results [OK]

Common Mistakes:

• Limiting before grouping loses data
• Sorting before grouping gives wrong totals
• Placing $limit before $sort causes wrong output