Pipeline execution order matters in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this aggregation pipeline?

Consider a MongoDB collection sales with documents like:

{ "item": "apple", "price": 10, "quantity": 5 }

What will be the output of this pipeline?

db.sales.aggregate([
  { $match: { price: { $gt: 5 } } },
  { $group: { _id: "$item", totalQuantity: { $sum: "$quantity" } } }
])

MongoDB

db.sales.aggregate([
  { $match: { price: { $gt: 5 } } },
  { $group: { _id: "$item", totalQuantity: { $sum: "$quantity" } } }
])

A []

B [ { _id: "apple", totalQuantity: 0 } ]

C [ { _id: null, totalQuantity: 5 } ]

D [ { _id: "apple", totalQuantity: 5 } ]

💡 Hint

Remember that $match filters documents before grouping.

The $match stage filters documents where price is greater than 5. Then $group sums the quantity for each item. Since the example document has price 10 and quantity 5, it is included and summed.

❓ query_result

intermediate

How does changing the order of $group and $match affect output?

Given the same sales collection, what is the output of this pipeline?

db.sales.aggregate([
  { $group: { _id: "$item", totalQuantity: { $sum: "$quantity" }, avgPrice: { $avg: "$price" } } },
  { $match: { avgPrice: { $gt: 5 } } }
])

MongoDB

db.sales.aggregate([
  { $group: { _id: "$item", totalQuantity: { $sum: "$quantity" }, avgPrice: { $avg: "$price" } } },
  { $match: { avgPrice: { $gt: 5 } } }
])

A [ { _id: "apple", totalQuantity: 5 } ]

B [ { _id: "apple", totalQuantity: 5, avgPrice: 10 } ]

C []

D [ { _id: null, totalQuantity: 5, avgPrice: 10 } ]

💡 Hint

Think about when filtering happens: before or after grouping.

This pipeline groups all documents first, calculating total quantity and average price per item. Then it filters groups where average price is greater than 5. Since the average price for "apple" is 10, it passes the filter.

🧠 Conceptual

advanced

Which pipeline is inefficient due to stage order?

Which of these MongoDB aggregation pipelines is inefficient because it processes more data than necessary?

A db.collection.aggregate([{ $sort: { price: 1 } }, { $match: { price: { $gt: 10 } } }])

B db.collection.aggregate([{ $match: { price: { $gt: 10 } } }, { $sort: { price: 1 } }])

C db.collection.aggregate([{ $group: { _id: "$category", total: { $sum: "$amount" } } }, { $sort: { total: -1 } }])

D db.collection.aggregate([{ $project: { price: 1, category: 1, amount: 1 } }, { $group: { _id: "$category", total: { $sum: "$amount" } } }])

💡 Hint

Place $match before $sort to reduce the dataset early.

Option A sorts all documents by price before filtering with $match, processing unnecessary documents in the $sort stage. Option A filters first, making $sort more efficient. Options C and D use appropriate orders: grouping before sorting derived fields, and projecting before grouping is fine here.

🔧 Debug

advanced

Why does this pipeline return no results?

Given this pipeline:

db.orders.aggregate([
  { $group: { _id: "$customer", totalSpent: { $sum: "$amount" } } },
  { $match: { amount: { $gt: 100 } } }
])

Why does it return no results?

MongoDB

db.orders.aggregate([
  { $group: { _id: "$customer", totalSpent: { $sum: "$amount" } } },
  { $match: { amount: { $gt: 100 } } }
])

A Because $match must come before $group

B Because $group removes all documents

C Because $match filters on a field 'amount' that does not exist after $group

D Because $sum operator is used incorrectly

💡 Hint

Check the fields available after the $group stage.

After grouping, the documents have fields '_id' and 'totalSpent'. The field 'amount' no longer exists. So filtering on 'amount' in $match matches nothing, returning no results.

🧠 Conceptual

expert

Why does pipeline order affect performance and results?

Which statement best explains why the order of stages in a MongoDB aggregation pipeline matters?

A Because stages are executed in sequence, changing order can change which documents are processed and how much data flows through the pipeline

B Because MongoDB automatically reorders stages for best performance, order does not matter

C Because only the first stage affects the output, later stages are ignored

D Because the order only affects the output format, not the data processed

💡 Hint

Think about filtering early vs late in the pipeline.

MongoDB runs pipeline stages in the order written. Early filtering reduces data for later stages, improving performance and changing results. The order affects both what data is processed and the final output.