Comparison expressions ($eq, $gt in aggregation) in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find documents where age equals 30

Given a collection users with documents containing an age field, which aggregation pipeline stage will return only documents where age is exactly 30?

MongoDB

db.users.aggregate([
  { $match: { $expr: { $eq: ["$age", 30] } } }
])

A db.users.aggregate([{ $match: { $expr: { $gt: ["$age", 30] } } }])

B db.users.aggregate([{ $match: { age: { $gt: 30 } } }])

C db.users.aggregate([{ $match: { $expr: { $eq: ["$age", 30] } } }])

D db.users.aggregate([{ $match: { age: 30 } }])

💡 Hint

Use $expr with $eq to compare fields inside aggregation.

Option C uses $expr with $eq to compare the age field to 30 inside the aggregation pipeline using an aggregation expression, which matches the topic.

Option C filters for ages greater than 30, not equal.

Option C filters for ages greater than 30 using $expr, not equal.

Option C matches documents where age is 30 using standard query syntax, which also works inside aggregation $match stages.

❓ query_result

intermediate

Filter documents with score greater than 80

Which aggregation pipeline stage filters documents where the score field is greater than 80?

MongoDB

db.scores.aggregate([
  { $match: { $expr: { $gt: ["$score", 80] } } }
])

A db.scores.aggregate([{ $match: { score: { $gt: 80 } } }])

B db.scores.aggregate([{ $match: { score: 80 } }])

C db.scores.aggregate([{ $match: { $expr: { $eq: ["$score", 80] } } }])

D db.scores.aggregate([{ $match: { $expr: { $gt: ["$score", 80] } } }])

💡 Hint

Use $expr with $gt to compare field values inside aggregation.

Option D correctly uses $expr with $gt to filter documents where score is greater than 80 using an aggregation expression.

Option D uses a direct query filter with $gt, which also works inside aggregation $match stages.

Option D filters for score equal to 80, not greater.

Option D filters for score exactly 80, not greater.

📝 Syntax

advanced

Identify the syntax error in this aggregation filter

Which option contains a syntax error in the aggregation pipeline that filters documents where price is greater than 100?

MongoDB

db.products.aggregate([
  { $match: { $expr: { $gt: ["$price", 100] } } }
])

A )]} } } ]001 ,"ecirp$"[ :tg$ { :rpxe$ { :hctam$ {[(etagergga.stcudorp.bd

B db.products.aggregate([{ $match: { $expr: { $gt: ["$price", 100] } } }])

C db.products.aggregate([{ $match: { price: { $gt: 100 } } }])

D b.products.aggregate([{ $match: { $expr: { $gt: ["$price", 100] } } }])

💡 Hint

Check the syntax of $gt operator arguments inside $expr.

Option B is invalid because $gt expects an array of two elements inside $expr, but here it is given as two separate arguments without array brackets, causing a syntax error.

Options A, C, and D are syntactically correct.

❓ optimization

advanced

Optimize filtering for equality in aggregation

Which option is the most efficient way to filter documents where status equals "active" in an aggregation pipeline?

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

B db.collection.aggregate([{ $match: { $expr: { $eq: ["$status", "active"] } } }])

C db.collection.aggregate([{ $match: { $expr: { $gt: ["$status", "active"] } } }])

D db.collection.aggregate([{ $match: { status: { $eq: "active" } } }])

💡 Hint

Simple equality filters can be done directly without $expr for better performance.

Option A uses a direct match on the status field, which is more efficient because it can use indexes directly.

Option A uses $expr with $eq, which is more flexible but less efficient.

Option A uses $gt which is incorrect for equality.

Option A uses $eq as a query operator inside a field filter, which is valid but redundant syntax equivalent to simple equality.

🧠 Conceptual

expert

Understanding $expr with $eq and $gt in aggregation

Consider the aggregation pipeline stage: { $match: { $expr: { $and: [ { $eq: ["$type", "A"] }, { $gt: ["$value", 10] } ] } } }. What does this stage do?

A Filters documents where type is "A" and value is greater than 10

B Filters documents where type is "A" or value is greater than 10

C Filters documents where type is not "A" and value is less than or equal to 10

D Filters documents where type is "A" and value is less than 10

💡 Hint

Look at the logical operator $and combining $eq and $gt conditions.

The $match stage uses $expr with $and to require both conditions: type equals "A" and value is greater than 10.

Option A correctly describes this.

Option A incorrectly uses OR logic.

Option A and D describe opposite or incorrect conditions.