Why query operators are needed in MongoDB - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find documents where age is greater than 25.

MongoDB

db.users.find({ age: { [1]: 25 } })

Drag options to blanks, or click blank then click option'

A$gt

B$lt

C$eq

D$ne

Attempts:

3 left

💡 Hint

Common Mistakes

Using $lt instead of $gt will find ages less than 25.

Using $eq will find ages exactly 25, not greater.

The $gt operator means 'greater than'. It finds documents where the age is more than 25.

2fill in blank

medium

Complete the code to find documents where the status is either 'A' or 'B'.

MongoDB

db.orders.find({ status: { [1]: ["A", "B"] } })

Drag options to blanks, or click blank then click option'

A$and

B$in

C$or

D$nin

Attempts:

3 left

💡 Hint

Common Mistakes

Using $or requires multiple conditions, not an array.

Using $nin finds documents NOT in the list.

The $in operator matches any value in the given array. It finds documents where status is 'A' or 'B'.

3fill in blank

hard

Fix the error in the query to find documents where score is less than or equal to 80.

MongoDB

db.scores.find({ score: { [1]: 80 } })

Drag options to blanks, or click blank then click option'

A$gte

B$lt

C$lte

D$eq

Attempts:

3 left

💡 Hint

Common Mistakes

Using $lt finds scores strictly less than 80, excluding 80.

Using $gte finds scores greater than or equal to 80.

The $lte operator means 'less than or equal to'. It finds scores 80 or below.

4fill in blank

hard

Fill both blanks to find documents where price is greater than 50 and less than 100.

MongoDB

db.products.find({ price: { [1]: 50, [2]: 100 } })

Drag options to blanks, or click blank then click option'

A$gt

B$lt

C$gte

D$lte

Attempts:

3 left

💡 Hint

Common Mistakes

Using $gte or $lte changes the range to include 50 or 100.

Swapping the operators will cause wrong results.

Use $gt for 'greater than 50' and $lt for 'less than 100' to find prices between 50 and 100.

5fill in blank

hard

Fill all three blanks to find documents where age is at least 18, less than 65, and status is 'active'.

MongoDB

db.users.find({ age: { [1]: 18, [2]: 65 }, status: [3] })

Drag options to blanks, or click blank then click option'

A$gte

B$lt

C"active"

D"inactive"

Attempts:

3 left

💡 Hint

Common Mistakes

Using $gt instead of $gte excludes age 18.

Using $lte includes age 65, which is not wanted.

Setting status to 'inactive' returns wrong documents.

Use $gte for 'age at least 18', $lt for 'age less than 65', and set status to the string 'active'.

Practice

1. Why do we need query operators like $gt or $lt in MongoDB queries?

easy

A. To find documents where a field meets a condition other than simple equality

B. To create new collections in the database

C. To update documents automatically without specifying fields

D. To delete all documents in a collection

Solution

1. Step 1: Understand basic query needs

   Simple queries check if a field equals a value, but often we want to find values greater or less than something.

2. Step 2: Role of query operators

   Operators like $gt (greater than) and $lt (less than) let us specify these conditions inside queries.

3. Final Answer:

   To find documents where a field meets a condition other than simple equality -> Option A

4. Quick Check:

   Query operators enable conditional searches = D [OK]

Hint: Operators add conditions beyond equals, always start with $ [OK]

Common Mistakes:

• Thinking operators create or delete collections
• Confusing query operators with update commands
• Assuming operators are optional for all queries

2. Which of the following is the correct syntax to find documents where the age is greater than 30 in MongoDB?

easy

A. { age: > 30 }

B. { age: gt: 30 }

C. { age: { $gt: 30 } }

D. { $age: { $gt: 30 } }

Solution

1. Step 1: Identify correct operator usage

   MongoDB query operators start with a $ and are placed inside the field object.

2. Step 2: Check syntax correctness

   { age: { $gt: 30 } } uses { age: { $gt: 30 } } which is the correct syntax for 'age greater than 30'. Others miss the $ or use invalid syntax.

3. Final Answer:

   { age: { $gt: 30 } } -> Option C

4. Quick Check:

   Correct operator syntax uses $ inside field = A [OK]

Hint: Operators always start with $ inside the field object [OK]

Common Mistakes:

• Omitting the $ sign before operator
• Using comparison symbols like > directly
• Placing $ before field name instead of operator

3. Given the collection users with documents:
{ name: "Alice", age: 25 }, { name: "Bob", age: 35 }, { name: "Carol", age: 30 }
What will the query db.users.find({ age: { $gt: 28 } }) return?

medium

A. [{ name: "Alice", age: 25 }]

B. [{ name: "Bob", age: 35 }]

C. [] (empty array)

D. [{ name: "Bob", age: 35 }, { name: "Carol", age: 30 }]

Solution

1. Step 1: Understand the query condition

   The query looks for documents where age is greater than 28.

2. Step 2: Check each document against condition

   Alice has age 25 (not > 28), Bob has 35 (> 28), Carol has 30 (> 28). So Bob and Carol match.

3. Final Answer:

   [{ name: "Bob", age: 35 }, { name: "Carol", age: 30 }] -> Option D

4. Quick Check:

   age > 28 matches Bob and Carol = C [OK]

Hint: Check each document's field against operator condition [OK]

Common Mistakes:

• Including documents that do not meet the condition
• Confusing $gt with $lt
• Assuming all documents are returned

4. What is wrong with this MongoDB query to find users younger than 40?

db.users.find({ age: $lt: 40 })

medium

A. The $lt operator should be replaced with $gt

B. The operator $lt should be inside curly braces after the field name

C. The query should use parentheses instead of curly braces

D. The field name should be prefixed with $

Solution

1. Step 1: Analyze operator placement

   The operator $lt must be inside an object as the value of the field key.

2. Step 2: Correct syntax structure

   The correct syntax is { age: { $lt: 40 } }. The given query misses the curly braces around the operator.

3. Final Answer:

   The operator $lt should be inside curly braces after the field name -> Option B

4. Quick Check:

   Operators need braces inside field object = A [OK]

Hint: Always wrap operators in braces inside the field object [OK]

Common Mistakes:

• Writing operator outside braces
• Using wrong operator for condition
• Misplacing $ before field name

5. You want to find all products priced between 50 and 100 inclusive in a MongoDB collection. Which query correctly uses query operators to achieve this?

hard

A. { price: { $gte: 50, $lte: 100 } }

B. { price: { $gt: 50, $lt: 100 } }

C. { price: { $gte: 50 }, { $lte: 100 } }

D. { price: { $between: [50, 100] } }

Solution

1. Step 1: Understand inclusive range operators

   To include 50 and 100, use $gte (greater or equal) and $lte (less or equal).

2. Step 2: Check correct syntax for multiple operators

   Both operators must be inside the same object for the field: { price: { $gte: 50, $lte: 100 } }.

3. Final Answer:

   { price: { $gte: 50, $lte: 100 } } -> Option A

4. Quick Check:

   Inclusive range uses $gte and $lte together = B [OK]

Hint: Use $gte and $lte inside one object for inclusive ranges [OK]

Common Mistakes:

• Using $gt and $lt for inclusive range
• Separating operators into different objects
• Using non-existent $between operator