Why expressions matter in pipelines in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

❓ query_result

intermediate

Output of $project with expression in MongoDB pipeline

Given the collection sales with documents like { item: "apple", price: 10, quantity: 2 }, what is the output of this aggregation pipeline?

[{ $project: { totalCost: { $multiply: ["$price", "$quantity"] } } }]

MongoDB

db.sales.aggregate([{ $project: { totalCost: { $multiply: ["$price", "$quantity"] } } }])

A [{ "totalCost": null }]

B [{ "totalCost": 12 }]

C [{ "totalCost": 10 }]

D [{ "totalCost": 20 }]

💡 Hint

Think about how $multiply works with the fields price and quantity.

The $multiply expression multiplies the values of price (10) and quantity (2), resulting in 20.

🧠 Conceptual

intermediate

Why use expressions in MongoDB pipelines?

Which of the following best explains why expressions are important in MongoDB aggregation pipelines?

A They allow transforming and computing new fields dynamically during data processing.

B They automatically index the collection for faster queries.

C They replace the need for a database schema.

D They encrypt data during aggregation.

💡 Hint

Think about what expressions do inside a pipeline stage.

Expressions let you compute new values or transform existing fields as data flows through the pipeline.

📝 Syntax

advanced

Identify the syntax error in this pipeline expression

What error does this MongoDB aggregation pipeline produce?

[{ $project: { total: { $add: ["$price", "$quantity" } } } }]

MongoDB

db.collection.aggregate([{ $project: { total: { $add: ["$price", "$quantity" } } } }])

A TypeError: Cannot add string and number

B SyntaxError: Missing closing bracket in $add array

C RuntimeError: Field price does not exist

D No error, runs successfully

💡 Hint

Check the brackets around the $add array.

The $add operator expects an array, but the closing bracket is missing, causing a syntax error.

❓ optimization

advanced

Optimizing pipeline expressions for performance

Which pipeline expression is more efficient when calculating a discount price as 90% of the original price in MongoDB?

A { $project: { discountPrice: { $multiply: ["$price", 0.9] } } }

B { $project: { discountPrice: { $subtract: ["$price", { $multiply: ["$price", 0.1] }] } } }

C { $project: { discountPrice: { $add: ["$price", -0.1] } } }

D { $project: { discountPrice: { $divide: ["$price", 1.1] } } }

💡 Hint

Consider the number of operations and clarity.

Multiplying price by 0.9 is a single, clear operation and more efficient than subtracting a computed value or dividing.

🔧 Debug

expert

Why does this pipeline produce unexpected results?

Consider this pipeline:

[{ $project: { total: { $add: ["$price", "$quantity"] } } }, { $match: { total: { $gt: 10 } } }]

Why might the $match stage not filter documents as expected?

A Because $gt operator cannot be used inside $match.

B Because $add cannot add two fields together.

C Because $project creates a new field total but does not persist it for $match to use.

D Because $match must come before $project in the pipeline.

💡 Hint

Think about how fields created in $project are available to later stages.

Fields created in $project are available to subsequent stages, but if the pipeline is run incorrectly or the field is missing, $match may not filter as expected. However, the main issue is that $project replaces the document fields, so if total is the only field projected, $match can use it. If other fields are missing, it might cause confusion.

Practice

1. What is the main reason expressions are important in MongoDB aggregation pipelines?

easy

A. They backup the database during aggregation.

B. They create new collections automatically.

C. They replace the need for indexes.

D. They allow you to calculate and transform data within pipeline stages.

Solution

1. Step 1: Understand the role of expressions in pipelines

   Expressions let you perform calculations and data transformations inside stages like $project and $group.

2. Step 2: Compare other options

   Options A, B, and C describe unrelated features not handled by expressions.

3. Final Answer:

   They allow you to calculate and transform data within pipeline stages. -> Option D

4. Quick Check:

   Expressions = Data transformation [OK]

Hint: Expressions transform data inside stages like $project [OK]

Common Mistakes:

• Thinking expressions create collections
• Confusing expressions with indexing
• Assuming expressions handle backups

2. Which of the following is the correct syntax to use an expression in a $project stage to add two fields price and tax?

easy

A. { $project: { total: { $add: ["$price", "$tax"] } } }

B. { $project: { total: $add(price, tax) } }

C. { $project: { total: { add: [price, tax] } } }

D. { $project: { total: { $sum: "$price" + "$tax" } } }

Solution

1. Step 1: Identify correct expression syntax

   The $add operator requires an array of field references with $ prefix inside an object.

2. Step 2: Check each option

   { $project: { total: { $add: ["$price", "$tax"] } } } correctly uses $add with an array of "$price" and "$tax". Others misuse syntax or operators.

3. Final Answer:

   { $project: { total: { $add: ["$price", "$tax"] } } } -> Option A

4. Quick Check:

   $add needs array with $field names [OK]

Hint: Use $add with array of "$field" names in $project [OK]

Common Mistakes:

• Omitting $ before field names
• Using parentheses instead of array for $add
• Confusing $add with $sum operator

3. Given the pipeline stage:

{ $project: { discountedPrice: { $multiply: ["$price", 0.9] } } }

What will be the output for a document { price: 100 }?

medium

A. { discountedPrice: 10 }

B. { discountedPrice: 90 }

C. { discountedPrice: 100 }

D. { discountedPrice: 0.9 }

Solution

1. Step 1: Understand $multiply expression

   $multiply multiplies the values in the array. Here, price (100) * 0.9 = 90.

2. Step 2: Apply to given document

   Input price is 100, so discountedPrice = 100 * 0.9 = 90.

3. Final Answer:

   { discountedPrice: 90 } -> Option B

4. Quick Check:

   100 * 0.9 = 90 [OK]

Hint: Multiply fields with constants using $multiply [OK]

Common Mistakes:

• Confusing multiplication with subtraction
• Using 0.9 as a field instead of a number
• Expecting original price unchanged

4. Identify the error in this pipeline stage:

{ $project: { total: { $add: "$price", "$tax" } } }

medium

A. The $project stage cannot use $add operator.

B. Field names should not have $ prefix inside $add.

C. The $add operator requires an array of expressions, not separate arguments.

D. The syntax is correct; no error.

Solution

1. Step 1: Review $add operator syntax

   $add expects a single array argument containing expressions, not multiple separate arguments.

2. Step 2: Analyze given code

   The code passes "$price" and "$tax" as separate arguments instead of inside an array.

3. Final Answer:

   The $add operator requires an array of expressions, not separate arguments. -> Option C

4. Quick Check:

   $add needs array input [OK]

Hint: Always pass array to $add, not separate arguments [OK]

Common Mistakes:

• Passing multiple arguments instead of array
• Removing $ from field names inside expressions
• Assuming $project can't use expressions

5. You want to create a pipeline that groups sales by product and calculates the average revenue per sale, but only for sales where quantity is greater than 5. Which expression usage is correct inside the pipeline?

hard

A. { $match: { quantity: { $gt: 5 } } }, { $group: { _id: "$product", avgRevenue: { $avg: { $multiply: ["$price", "$quantity"] } } } }

B. { $group: { _id: "$product", avgRevenue: { $avg: { $multiply: ["$price", "$quantity"] } } } }, { $match: { quantity: { $gt: 5 } } }

C. { $match: { quantity: { $lt: 5 } } }, { $group: { _id: "$product", avgRevenue: { $avg: "$price" } } }

D. { $group: { _id: "$product", avgRevenue: { $sum: "$price" } } }, { $match: { quantity: { $gt: 5 } } }

Solution

1. Step 1: Filter sales with $match before grouping

   To include only sales with quantity > 5, $match must come before $group.

2. Step 2: Use $avg with $multiply expression inside $group

   Calculate revenue per sale as price * quantity, then average it per product.

3. Step 3: Check options

   { $match: { quantity: { $gt: 5 } } }, { $group: { _id: "$product", avgRevenue: { $avg: { $multiply: ["$price", "$quantity"] } } } } correctly orders stages and uses expressions. Others have wrong order or wrong operators.

4. Final Answer:

   { $match: { quantity: { $gt: 5 } } }, { $group: { _id: "$product", avgRevenue: { $avg: { $multiply: ["$price", "$quantity"] } } } } -> Option A

5. Quick Check:

   Filter then group with $avg of $multiply [OK]

Hint: Filter first with $match, then use expressions in $group [OK]

Common Mistakes:

• Placing $match after $group
• Using $sum instead of $avg for average
• Filtering with wrong comparison operator