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.