How the engine optimizes pipelines in MongoDB - Practice Exercises

Challenge - 5 Problems

❓ query_result

intermediate

Pipeline Stage Reordering Effect

Consider a MongoDB aggregation pipeline on a collection with 1 million documents. The pipeline is:

[{ $project: { name: 1, age: 1 } }, { $match: { age: { $gt: 30 } } }]

What is the main effect of reordering the stages to put $match before $project?

MongoDB

[{ $project: { name: 1, age: 1 } }, { $match: { age: { $gt: 30 } } }]

A There is no difference in performance because MongoDB executes stages in parallel.

B The pipeline will run slower because projecting first reduces fields needed for matching.

C The pipeline will run faster because filtering happens before projecting, reducing data early.

D The pipeline will fail because $match cannot come after $project.

💡 Hint

Think about filtering data early to reduce workload.

Putting $match before $project allows MongoDB to filter documents early, reducing the number of documents processed in later stages, which improves performance.

🧠 Conceptual

intermediate

Understanding Pipeline Optimization

Which of the following best describes how MongoDB optimizes aggregation pipelines internally?

A It automatically reorders stages to filter and reduce data as early as possible.

B It executes all stages in the order written without any changes.

C It converts all stages into a single map-reduce operation.

D It duplicates data to speed up parallel processing of stages.

💡 Hint

Think about how to reduce data early in a pipeline.

MongoDB's aggregation engine tries to reorder stages like $match and $project to filter and reduce data early, improving efficiency.

📝 Syntax

advanced

Identify the Invalid Pipeline Stage

Which of the following pipeline stages will cause a syntax error when used in a MongoDB aggregation pipeline?

A { $filter: { input: "$items", as: "item", cond: { $gt: ["$$item.price", 100] } } }

B { $group: { _id: "$city", total: { $sum: 1 } } }

C { $match: { age: { $gte: 18 } } }

D { $sort: { name: 1 } }

💡 Hint

Check if the stage is a valid aggregation pipeline stage operator.

The $filter operator is not a pipeline stage but an expression used inside stages like $project. Using it as a stage causes a syntax error.

❓ optimization

advanced

Optimizing Pipeline with Indexes

Given a collection with an index on the field status, which pipeline will best utilize the index to optimize performance?

A [{ $sort: { status: 1 } }, { $match: { status: "active" } }]

B [{ $group: { _id: "$category", count: { $sum: 1 } } }, { $match: { status: "active" } }]

C [{ $project: { status: 1, category: 1 } }, { $match: { status: "active" } }]

D [{ $match: { status: "active" } }, { $group: { _id: "$category", count: { $sum: 1 } } }]

💡 Hint

Indexes help when filtering happens early.

Placing $match first allows MongoDB to use the index on status to quickly filter documents before grouping, improving performance.

🔧 Debug

expert

Diagnose Pipeline Performance Issue

A developer notices their aggregation pipeline is slow. The pipeline is:

[{ $project: { name: 1, age: 1, status: 1 } }, { $match: { status: "active" } }, { $group: { _id: "$age", count: { $sum: 1 } } }]

What is the main reason for the slow performance?

A The $group stage is missing an index, causing slow grouping.

B The $match stage comes after $project, so filtering happens late, processing more data than needed.

C The $project stage removes the status field needed for $match, causing an error.

D The pipeline uses $sum incorrectly, causing a runtime error.

💡 Hint

Consider the order of filtering and projecting.

Filtering with $match after $project means MongoDB processes all documents with extra fields before filtering, which is inefficient.

Practice

1. What is the main reason MongoDB's aggregation engine reorders pipeline stages?

easy

A. To change the output format of the data

B. To add more fields to each document

C. To improve query performance by filtering data early

D. To sort the data alphabetically

Solution

1. Step 1: Understand pipeline stage purpose

   MongoDB pipelines process data step-by-step. Filtering early reduces data size quickly.

2. Step 2: Recognize optimization goal

   Reordering stages to filter first means less data passes through later stages, speeding up processing.

3. Final Answer:

   To improve query performance by filtering data early -> Option C

4. Quick Check:

   Filtering early = better performance [OK]

Hint: Filter data early in pipeline for faster queries [OK]

Common Mistakes:

• Thinking reordering changes output format
• Believing it adds fields automatically
• Assuming sorting is the main reason

2. Which of the following is the correct syntax to add a $match stage at the start of a MongoDB aggregation pipeline?

easy

A. [{$match: {status: "active"}}, {$group: {_id: "$category"}}]

B. [{$group: {_id: "$category"}}, {$match: {status: "active"}}]

C. [{$sort: {date: -1}}, {$match: {status: "active"}}]

D. [{$project: {name: 1}}, {$match: {status: "active"}}]

Solution

1. Step 1: Identify correct $match placement

   $match should come first to filter documents before grouping or sorting.

2. Step 2: Check syntax order

   [{$match: {status: "active"}}, {$group: {_id: "$category"}}] places $match first, then $group, which is correct syntax and optimization practice.

3. Final Answer:

   [{$match: {status: "active"}}, {$group: {_id: "$category"}}] -> Option A

4. Quick Check:

   $match first in pipeline = correct syntax [OK]

Hint: Place $match before $group to filter early [OK]

Common Mistakes:

• Putting $match after $group or $sort
• Using $match inside $group stage
• Incorrect array order of stages

3. Given the pipeline [{$project: {name: 1, age: 1}}, {$match: {age: {$gt: 30}}}], what will MongoDB do to optimize it?

medium

A. It will reorder to apply $match before $project

B. It will keep the stages as is, projecting before matching

C. It will remove the $project stage

D. It will combine $project and $match into one stage

Solution

1. Step 1: Analyze pipeline stages

   $project limits fields, $match filters documents. Filtering first reduces data early.

2. Step 2: Understand optimization behavior

   MongoDB reorders pipeline to apply $match before $project to reduce documents processed.

3. Final Answer:

   It will reorder to apply $match before $project -> Option A

4. Quick Check:

   Filter before project = better optimization [OK]

Hint: MongoDB moves $match before $project to filter early [OK]

Common Mistakes:

• Assuming stages stay in original order
• Thinking $project is removed
• Believing stages combine automatically

4. You wrote this pipeline: [{$group: {_id: "$category", total: {$sum: "$amount"}}}, {$match: {total: {$gt: 100}}}]. It runs slowly. What is the main issue?

medium

A. You cannot use $sum inside $group

B. The $group stage syntax is incorrect

C. The pipeline is missing a $sort stage

D. The $match stage should come before $group to filter documents early

Solution

1. Step 1: Understand pipeline order impact

   $group aggregates all documents first, then $match filters groups, causing more work.

2. Step 2: Identify optimization fix

   Filtering documents before grouping reduces data size and speeds up aggregation.

3. Final Answer:

   The $match stage should come before $group to filter documents early -> Option D

4. Quick Check:

   Filter before group = faster pipeline [OK]

Hint: Place $match before $group to reduce data early [OK]

Common Mistakes:

• Thinking $group syntax is wrong
• Believing $sum can't be used in $group
• Assuming $sort affects speed here

5. You want to optimize this pipeline for a large collection:
[{$lookup: {from: "orders", localField: "_id", foreignField: "userId", as: "orders"}}, {$unwind: "$orders"}, {$match: {"orders.status": "shipped"}}, {$group: {_id: "$_id", total: {$sum: "$orders.amount"}}}]
What is the best optimization to improve performance?

hard

A. Replace $lookup with $project

B. Move the $match stage before $lookup using a $match on the local collection

C. Remove the $unwind stage

D. Add a $sort stage before $group

Solution

1. Step 1: Analyze pipeline stages

   $lookup joins data, $unwind expands arrays, $match filters joined data, $group aggregates.

2. Step 2: Identify optimization strategy

   Filtering local documents before $lookup reduces join size, improving performance.

3. Step 3: Understand why other options fail

   $sort doesn't reduce data size, removing $unwind breaks structure, $project can't replace $lookup.

4. Final Answer:

   Move the $match stage before $lookup using a $match on the local collection -> Option B

5. Quick Check:

   Filter early before $lookup = best optimization [OK]

Hint: Filter local data before $lookup to speed joins [OK]

Common Mistakes:

• Adding $sort expecting speedup
• Removing $unwind breaks data structure
• Replacing $lookup with $project is invalid