Why logical operators matter in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

❓ query_result

intermediate

Find documents with age greater than 25 and city 'New York'

Given a collection users with documents containing age and city, which query returns users older than 25 who live in New York?

MongoDB

db.users.find({$and: [{age: {$gt: 25}}, {city: 'New York'}]})

A db.users.find({age: {$gt: 25}, city: 'New York'})

B db.users.find({$or: [{age: {$gt: 25}}, {city: 'New York'}]})

C db.users.find({$and: [{age: {$gt: 25}}, {city: 'New York'}]})

D db.users.find({age: {$gt: 25}}).find({city: 'New York'})

💡 Hint

Use $and to combine conditions that both must be true.

Option C uses $and to ensure both conditions are met: age > 25 and city is 'New York'. Option C works too because MongoDB implicitly ANDs conditions, but the question expects explicit use of logical operators. Option C uses $or, which returns documents matching either condition, not both. Option C is invalid because chaining find() like that does not work.

❓ query_result

intermediate

Find documents where status is 'active' or score is above 80

Which MongoDB query returns documents where status is 'active' or score is greater than 80?

MongoDB

db.records.find({$or: [{status: 'active'}, {score: {$gt: 80}}]})

A db.records.find({status: 'active', score: {$gt: 80}})

B db.records.find({$or: [{status: 'active'}, {score: {$gt: 80}}]})

C db.records.find({$and: [{status: 'active'}, {score: {$gt: 80}}]})

D db.records.find({status: {$in: ['active', {$gt: 80}]}})

💡 Hint

Use $or to match either condition.

Option B correctly uses $or to find documents where either condition is true. Option B implicitly ANDs conditions, so it only returns documents where both are true. Option B explicitly ANDs conditions, same as A but more verbose. Option B is invalid because $in cannot mix values and operators like {$gt: 80}.

📝 Syntax

advanced

Identify the syntax error in this MongoDB query

Which option contains a syntax error in the MongoDB query to find documents where type is 'admin' and active is true?

A db.users.find({$and: [{type: 'admin'}, {active: true}]})

B b.users.find({$and: [{type: 'admin'}, {active: true}]})

C )}]}eurt :evitca{ ,}'nimda' :epyt{[ :dna${(dnif.sresu.bd

D db.users.find({type: 'admin', active: true})

💡 Hint

Check for matching brackets and commas.

Option A has a syntax error: the first object in the $and array is missing a closing brace before the comma. This causes a syntax error. Options A, B, and C are syntactically correct.

🧠 Conceptual

advanced

Why use $nor instead of $not with $or?

Which statement best explains why $nor is preferred over using $not with $or in MongoDB queries?

A <code>$not</code> can only negate single conditions, so it cannot negate an <code>$or</code> with multiple conditions, but <code>$nor</code> can.

B <code>$nor</code> returns documents where none of the conditions are true, while <code>$not</code> cannot be applied to <code>$or</code> directly.

C <code>$nor</code> is deprecated and should be replaced with <code>$not</code> and <code>$or</code>.

D <code>$not</code> with <code>$or</code> is faster than <code>$nor</code> but less readable.

💡 Hint

Think about what each operator can negate.

Option A is correct because $not negates only single expressions, so it cannot negate an entire $or with multiple conditions. $nor negates an array of conditions, returning documents where none match. Option A is incorrect because $not can be applied but only to single expressions, not to $or directly. Option A is false about performance and readability. Option A is false; $nor is not deprecated.

❓ optimization

expert

Optimize query to find users not in city 'Boston' and age less than 30

Which MongoDB query is the most efficient and correct way to find users who are NOT in 'Boston' and have age less than 30?

A db.users.find({$and: [{city: {$nin: ['Boston']}}, {age: {$lt: 30}}]})

B db.users.find({city: {$not: {$eq: 'Boston'}}, age: {$lt: 30}})

C db.users.find({$nor: [{city: 'Boston'}], age: {$lt: 30}})

D db.users.find({$and: [{city: {$ne: 'Boston'}}, {age: {$lt: 30}}]})

💡 Hint

Use operators that clearly express negation and combine conditions properly.

Option D uses $ne to exclude 'Boston' and $and to combine with age condition, which is clear and efficient. Option D misuses $not with $eq inside an object, which is valid but less readable and can be slower. Option D uses $nor incorrectly combined with age condition outside the array, which may cause unexpected results. Option D uses $nin with a single value array, which works but is less direct than $ne.

Practice

1. Which logical operator in MongoDB requires all conditions to be true for a document to match?

easy

A. $and

B. $or

C. $not

D. $nor

Solution

1. Step 1: Recall MongoDB logical operators

   $and combines multiple conditions and only matches documents where every condition is true. $or matches if any condition is true, $not excludes matches, and $nor matches if none are true.

2. Final Answer:

   $and -> Option A

3. Quick Check:

   $and requires all true [OK]

Hint: Remember $and means all conditions must be true [OK]

Common Mistakes:

• Confusing $and with $or
• Thinking $not means all true
• Mixing $nor with $and

2. Which of the following is the correct syntax to find documents where age is greater than 25 or status is "active" in MongoDB?

easy

A. { $and: [ { age: { $gt: 25 } }, { status: "active" } ] }

B. { $nor: [ { age: { $gt: 25 } }, { status: "active" } ] }

C. { $not: [ { age: { $gt: 25 } }, { status: "active" } ] }

D. { $or: [ { age: { $gt: 25 } }, { status: "active" } ] }

Solution

1. Step 1: Identify $or operator and verify syntax

   $or matches documents where at least one condition is true, perfect for age > 25 or status = "active". The syntax with $or and array of conditions is correct; $and requires both true, $not and $nor have different meanings.

2. Final Answer:

   { $or: [ { age: { $gt: 25 } }, { status: "active" } ] } -> Option D

3. Quick Check:

   $or for either condition true = { $or: [ { age: { $gt: 25 } }, { status: "active" } ] } [OK]

Hint: Use $or for any condition true, syntax needs array [OK]

Common Mistakes:

• Using $and instead of $or
• Wrong array brackets
• Using $not with array incorrectly

3. Given the collection documents:
{ name: "Alice", age: 30, status: "active" }
{ name: "Bob", age: 20, status: "inactive" }
{ name: "Carol", age: 25, status: "active" }
What will the query { $and: [ { age: { $gt: 20 } }, { status: "active" } ] } return?

medium

A. [{ name: "Bob", age: 20, status: "inactive" }]

B. [{ name: "Alice", age: 30, status: "active" }, { name: "Carol", age: 25, status: "active" }]

C. [{ name: "Alice", age: 30, status: "active" }]

D. []

Solution

1. Step 1: Evaluate documents against $and conditions

   age > 20 and status = "active": Alice (30, active) matches, Carol (25, active) matches, Bob (20, inactive) does not. Both Alice and Carol returned.

2. Final Answer:

   [{ name: "Alice", age: 30, status: "active" }, { name: "Carol", age: 25, status: "active" }] -> Option B

3. Quick Check:

   Both age > 20 and active status = [{ name: "Alice", age: 30, status: "active" }, { name: "Carol", age: 25, status: "active" }] [OK]

Hint: Check each condition carefully for all documents [OK]

Common Mistakes:

• Including Bob who fails conditions
• Returning only one document
• Confusing $and with $or results

4. You wrote this query to exclude documents where status is "inactive":
{ $not: { status: "inactive" } }
But it returns an error. What is the problem?

medium

A. $not must be inside $and

B. $not cannot be used with strings

C. $not requires a condition operator like $eq, not a direct value

D. $not only works with numeric fields

Solution

1. Step 1: Identify $not syntax error

   $not expects a condition operator like { status: { $not: { $eq: "inactive" } } }, not { $not: { status: "inactive" } } with direct value.

2. Final Answer:

   $not requires a condition operator like $eq, not a direct value -> Option C

3. Quick Check:

   $not needs operator condition [OK]

Hint: Use $not with operators like $eq, not direct values [OK]

Common Mistakes:

• Passing direct values to $not
• Assuming $not works alone
• Using $not with arrays incorrectly

5. You want to find documents where age is greater than 20 but NOT with status equal to "inactive". Which query correctly uses logical operators to achieve this?

hard

A. { $and: [ { age: { $gt: 20 } }, { status: { $ne: "inactive" } } ] }

B. { $and: [ { age: { $gt: 20 } }, { $not: { status: { $eq: "inactive" } } } ] }

C. { $or: [ { age: { $gt: 20 } }, { $not: { status: { $eq: "inactive" } } } ] }

D. { $and: [ { age: { $gt: 20 } }, { $not: { status: "inactive" } } ] }

Solution

1. Step 1: Analyze requirement and options

   Need age > 20 AND status != "inactive". A: $not with direct value (invalid). B: $not wrongly placed at top-level; must be { status: { $not: { $eq: "inactive" } } } (but $ne simpler). C: $or allows documents failing one condition. D: Correctly uses $and with $gt and $ne.

2. Final Answer:

   { $and: [ { age: { $gt: 20 } }, { status: { $ne: "inactive" } } ] } -> Option A

3. Quick Check:

   Use $ne for NOT equal, combine with $and = { $and: [ { age: { $gt: 20 } }, { status: { $ne: "inactive" } } ] } [OK]

Hint: Use $ne for NOT equal, combine with $and for all true [OK]

Common Mistakes:

• Using $not with direct value
• Using $or instead of $and
• Overcomplicating with $not and $eq