Pipeline execution order matters in MongoDB - Mini Project: Build & Apply

Pipeline Execution Order Matters in MongoDB Aggregation

📖 Scenario: You are managing a small online bookstore database. You want to analyze book sales data to find the total sales for books priced above a certain amount.

🎯 Goal: Build a MongoDB aggregation pipeline that first filters books priced above 20, then calculates the total sales for each book by multiplying price and quantity sold, and finally sorts the results by total sales in descending order.

📋 What You'll Learn

Create a collection named books with documents containing title, price, and quantity_sold fields.

Add a variable priceThreshold set to 20 to filter books priced above this value.

Write an aggregation pipeline that first filters books with price greater than priceThreshold.

Then add a field totalSales calculated as price * quantity_sold.

Finally, sort the results by totalSales in descending order.

💡 Why This Matters

🌍 Real World

Online stores and inventory systems often need to analyze sales data by filtering, calculating totals, and sorting results to make business decisions.

💼 Career

Understanding MongoDB aggregation pipelines and the importance of stage order is essential for backend developers and data analysts working with NoSQL databases.

1

Create the books collection with sample data

Create a MongoDB collection called books and insert these exact documents: { title: "Book A", price: 15, quantity_sold: 10 }, { title: "Book B", price: 25, quantity_sold: 5 }, { title: "Book C", price: 30, quantity_sold: 7 }.

MongoDB

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

Hint

Use db.books.insertMany() with an array of objects containing the exact fields and values.

2

Set the priceThreshold variable

Create a variable called priceThreshold and set it to 20 to use as the filter value for book prices.

MongoDB

db.books.insertMany([
  { title: "Book A", price: 15, quantity_sold: 10 },
  { title: "Book B", price: 25, quantity_sold: 5 },
  { title: "Book C", price: 30, quantity_sold: 7 }
])

// Create priceThreshold variable and set to 20
// Your code here

Hint

Use const priceThreshold = 20 to create the variable.

3

Build the aggregation pipeline with filtering and adding totalSales

Write an aggregation pipeline on books that first filters documents where price is greater than priceThreshold using $match, then adds a new field totalSales calculated as price * quantity_sold using $addFields.

MongoDB

db.books.insertMany([
  { title: "Book A", price: 15, quantity_sold: 10 },
  { title: "Book B", price: 25, quantity_sold: 5 },
  { title: "Book C", price: 30, quantity_sold: 7 }
])

const priceThreshold = 20;

// Write aggregation pipeline with $match and $addFields
// Your code here

Hint

Use $match first to filter, then $addFields to add totalSales as { $multiply: ["$price", "$quantity_sold"] }.

4

Add sorting stage to the aggregation pipeline

Add a $sort stage to the existing pipeline that sorts documents by totalSales in descending order.

MongoDB

db.books.insertMany([
  { title: "Book A", price: 15, quantity_sold: 10 },
  { title: "Book B", price: 25, quantity_sold: 5 },
  { title: "Book C", price: 30, quantity_sold: 7 }
])

const priceThreshold = 20;

const pipeline = [
  { $match: { price: { $gt: priceThreshold } } },
  { $addFields: { totalSales: { $multiply: ["$price", "$quantity_sold"] } } }
];

// Add $sort stage to pipeline to sort by totalSales descending
// Your code here

Hint

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

Practice

1. In MongoDB aggregation pipelines, why does the order of stages matter?

easy

A. Because stages run in the order they are written, affecting results and performance

B. Because MongoDB runs all stages in parallel regardless of order

C. Because only the last stage affects the output

D. Because stages can be reordered automatically by MongoDB

Solution

1. Step 1: Understand pipeline execution

   MongoDB executes pipeline stages sequentially in the order they appear.

2. Step 2: Impact of order on results and performance

   Changing the order can change the output and how fast the query runs, especially filtering early helps performance.

3. Final Answer:

   Because stages run in the order they are written, affecting results and performance -> Option A

4. Quick Check:

   Pipeline order affects output and speed [OK]

Hint: Remember: pipeline stages run top to bottom [OK]

Common Mistakes:

• Thinking MongoDB runs stages in parallel
• Believing order does not affect output
• Assuming MongoDB reorders stages automatically

2. Which of the following is the correct syntax to start a MongoDB aggregation pipeline with a filter stage?

easy

A. db.collection.aggregate([{ $match: { status: 'A' } }])

B. db.collection.aggregate({ $match: { status: 'A' } })

C. db.collection.find({ $match: { status: 'A' } })

D. db.collection.aggregate([{ match: { status: 'A' } }])

Solution

1. Step 1: Identify correct aggregation syntax

   The aggregate method takes an array of stages, each stage is an object with a stage operator like $match.

2. Step 2: Check each option

   db.collection.aggregate([{ $match: { status: 'A' } }]) correctly uses an array with $match stage. db.collection.aggregate({ $match: { status: 'A' } }) misses array brackets. db.collection.find({ $match: { status: 'A' } }) uses find() which is not aggregation. db.collection.aggregate([{ match: { status: 'A' } }]) misses $ in $match.

3. Final Answer:

   db.collection.aggregate([{ $match: { status: 'A' } }]) -> Option A

4. Quick Check:

   Aggregation stages are in an array [OK]

Hint: Aggregation stages must be in an array [OK]

Common Mistakes:

• Omitting the array brackets around stages
• Using find() instead of aggregate() for pipelines
• Missing $ in stage operators like $match

3. Given this pipeline:

db.orders.aggregate([
  { $sort: { price: -1 } },
  { $match: { status: 'A' } }
])

What is the main issue with this pipeline?

medium

A. It sorts ascending instead of descending

B. It will cause a syntax error due to stage order

C. It will return no results because $match must come first

D. It filters after sorting, which is less efficient

Solution

1. Step 1: Analyze stage order

   The pipeline sorts all documents first, then filters with $match.

2. Step 2: Understand performance impact

   Filtering first reduces documents early, making sorting faster. Sorting before filtering wastes resources.

3. Final Answer:

   It filters after sorting, which is less efficient -> Option D

4. Quick Check:

   Filter early, then sort for best performance [OK]

Hint: Filter before sort to improve speed [OK]

Common Mistakes:

• Thinking stage order causes syntax errors
• Believing $match must always be first to work
• Confusing sort order direction

4. You wrote this pipeline but it returns an error:

db.sales.aggregate([
  { $group: { _id: "$item", total: { $sum: "$amount" } } },
  { $match: { $gt: ["$total", 100] } }
])

What is the likely cause?

medium

A. The $match stage cannot filter on fields created by $group

B. The $match stage should use $expr to filter on computed fields

C. The $match stage must come before $group to filter correctly

D. The $group stage syntax is incorrect

Solution

1. Step 1: Identify the invalid $match syntax

   The $match stage uses aggregation expression syntax { $gt: ["$total", 100] } directly, which is not valid query selector syntax.

2. Step 2: Use $expr for aggregation expressions

   To use expression operators like $gt with field paths and literals in array form, wrap in $expr: { $match: { $expr: { $gt: ["$total", 100] } } }.

3. Final Answer:

   The $match stage should use $expr to filter on computed fields -> Option B

4. Quick Check:

   $expr enables agg expressions in $match [OK]

Hint: Use $expr in $match after $group [OK]

Common Mistakes:

• Trying to filter grouped fields without $expr
• Placing $match before $group expecting same results
• Assuming $group syntax is wrong

5. You want to find the top 3 most expensive products with status 'A'. Which pipeline correctly applies the stages for best performance?

hard

A. db.products.aggregate([
{ $sort: { price: -1 } },
{ $limit: 3 },
{ $match: { status: 'A' } }
])

B. db.products.aggregate([
{ $limit: 3 },
{ $match: { status: 'A' } },
{ $sort: { price: -1 } }
])

C. db.products.aggregate([
{ $match: { status: 'A' } },
{ $sort: { price: -1 } },
{ $limit: 3 }
])

D. db.products.aggregate([
{ $match: { status: 'A' } },
{ $limit: 3 },
{ $sort: { price: -1 } }
])

Solution

1. Step 1: Filter early for performance

   Applying $match first reduces documents to only those with status 'A'.

2. Step 2: Sort and limit after filtering

   Sorting after filtering is faster, then $limit picks top 3.

3. Step 3: Check other options

   db.products.aggregate([ { $sort: { price: -1 } }, { $limit: 3 }, { $match: { status: 'A' } } ]) sorts all documents before filtering, wasting resources. db.products.aggregate([ { $limit: 3 }, { $match: { status: 'A' } }, { $sort: { price: -1 } } ]) limits before filtering, wrong results. db.products.aggregate([ { $match: { status: 'A' } }, { $limit: 3 }, { $sort: { price: -1 } } ]) limits before sorting, wrong order.

4. Final Answer:

   db.products.aggregate([ { $match: { status: 'A' } }, { $sort: { price: -1 } }, { $limit: 3 } ]) -> Option C

5. Quick Check:

   Filter, then sort, then limit [OK]

Hint: Filter first, then sort, then limit [OK]

Common Mistakes:

• Sorting before filtering wastes resources
• Limiting before sorting gives wrong top results
• Filtering after limiting misses correct documents