Why querying is essential in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use queries in databases?

Imagine you have a huge library of books. Why is it important to ask specific questions (queries) to find the books you want?

A Because queries help find only the needed information quickly without looking at everything.

B Because queries make the database slower by searching all data every time.

C Because queries delete all data after searching.

D Because queries are used to add new books to the library.

💡 Hint

Think about how you find a book in a big library without checking every shelf.

Queries let us ask for just the information we want, saving time and effort. Without queries, we would have to look through all data manually.

❓ query_result

intermediate

What does this MongoDB query return?

Given a collection students with documents containing {name, age, grade}, what will this query return?

{ age: { $gt: 18 } }

MongoDB

db.students.find({ age: { $gt: 18 } })

A All students younger than 18 years.

B All students older than 18 years.

C All students exactly 18 years old.

D All students regardless of age.

💡 Hint

The operator $gt means 'greater than'.

The query finds all documents where the age field is greater than 18, so it returns students older than 18.

📝 Syntax

advanced

Identify the syntax error in this MongoDB query

Which option shows a syntax error when trying to find documents where score is at least 70?

MongoDB

db.scores.find({ score: { $gte: 70 } })

A db.scores.find({ score: { $gte: 70 } })

B )} } 07 :etg$ { :erocs {(dnif.serocs.bd

C db.scores.find({ score: { $greaterThanOrEqual: 70 } })

D db.scores.find({ score: { $gte: '70' } })

💡 Hint

Check the operator names carefully.

The correct operator for 'greater than or equal' is $gte. Option C uses $greaterThanOrEqual, which is invalid syntax.

❓ optimization

advanced

Which query is more efficient to find users with age 30?

You want to find users aged exactly 30 in a large collection. Which query is better for performance?

A db.users.find({ age: 30 })

B db.users.find({ age: { $in: [30] } })

C db.users.find({ age: { $gte: 30, $lte: 30 } })

D db.users.find({ age: { $eq: 30 } })

💡 Hint

Simple direct matches are usually faster than complex conditions.

Using { age: 30 } is the simplest and most direct way to match age 30. Other options add unnecessary complexity that can slow down the query.

🔧 Debug

expert

Why does this MongoDB query return no results?

Given a collection products with documents like {name: 'Pen', price: 1.5}, why does this query return an empty list?

db.products.find({ price: { $gt: '1' } })

A Because the query syntax is incorrect.

B Because $gt operator only works with strings, not numbers.

C Because the collection is empty.

D Because the price field is a number but the query compares it to a string '1'.

💡 Hint

Think about data types and how MongoDB compares them.

MongoDB compares values by type. Comparing a number field to a string value causes no matches because types differ.

Practice

1. Why is querying essential when working with a MongoDB database?

easy

A. It automatically fixes errors in the database.

B. It deletes all data from the database.

C. It helps find specific data quickly and efficiently.

D. It creates new databases without user input.

Solution

1. Step 1: Understand the purpose of querying

   Querying is used to search and retrieve specific data from a database.

2. Step 2: Identify the correct benefit of querying

   Querying helps users find data quickly and efficiently, not to delete or fix data automatically.

3. Final Answer:

   It helps find specific data quickly and efficiently. -> Option C

4. Quick Check:

   Querying = Find data fast [OK]

Hint: Queries help you get only the data you want fast [OK]

Common Mistakes:

• Thinking querying fixes database errors automatically
• Confusing querying with deleting data
• Believing querying creates databases

2. Which of the following is the correct MongoDB query syntax to find all documents in a collection named users?

easy

A. db.users.find()

B. db.users.get()

C. db.users.search()

D. db.users.select()

Solution

1. Step 1: Recall MongoDB query syntax for fetching documents

   The correct method to retrieve documents is find().

2. Step 2: Check each option's method name

   Only find() is valid; others like get(), search(), and select() are invalid in MongoDB.

3. Final Answer:

   db.users.find() -> Option A

4. Quick Check:

   Find method = db.collection.find() [OK]

Hint: Use .find() to get documents from a collection [OK]

Common Mistakes:

• Using .get() or .search() instead of .find()
• Forgetting parentheses after find
• Confusing SQL syntax with MongoDB

3. Given the collection products with documents:

{"name": "Pen", "price": 5}

{"name": "Notebook", "price": 15}

{"name": "Eraser", "price": 3}

What will the query db.products.find({ price: { $gt: 4 } }) return?

medium

A. []

B. [{"name": "Eraser", "price": 3}]

C. [{"name": "Notebook", "price": 15}]

D. [{"name": "Pen", "price": 5}, {"name": "Notebook", "price": 15}]

Solution

1. Step 1: Understand the query filter

   The query filters documents where price is greater than 4.

2. Step 2: Check each document's price

   Pen (5) and Notebook (15) have prices > 4; Eraser (3) does not.

3. Final Answer:

   [{"name": "Pen", "price": 5}, {"name": "Notebook", "price": 15}] -> Option D

4. Quick Check:

   Price > 4 returns Pen and Notebook [OK]

Hint: Look for documents matching the filter condition carefully [OK]

Common Mistakes:

• Including documents with price equal to 4
• Selecting documents with price less than 4
• Misunderstanding $gt operator

4. What is wrong with this MongoDB query to find users older than 25?
db.users.find({ age: > 25 })

medium

A. The query is missing a closing parenthesis.

B. The comparison operator > is used incorrectly inside the query object.

C. The find() method cannot filter by age.

D. The collection name should be in quotes.

Solution

1. Step 1: Analyze the query syntax

   The query uses age: > 25, which is invalid syntax in MongoDB.

2. Step 2: Identify correct operator usage

   MongoDB requires operators like $gt inside an object: { age: { $gt: 25 } }.

3. Final Answer:

   The comparison operator > is used incorrectly inside the query object. -> Option B

4. Quick Check:

   Use $gt for greater than in queries [OK]

Hint: Use $gt, not >, inside query objects [OK]

Common Mistakes:

• Using > directly instead of $gt
• Putting collection name in quotes unnecessarily
• Assuming find() can't filter by fields

5. You have a collection orders with documents containing status and total. How would you write a query to find all orders with status "shipped" and total greater than 100?

hard

A. db.orders.find({ status: "shipped", total: { $gt: 100 } })

B. db.orders.find({ status: { $eq: "shipped" }, total: > 100 })

C. db.orders.find({ status == "shipped" && total > 100 })

D. db.orders.find({ status: "shipped" || total: { $gt: 100 } })

Solution

1. Step 1: Understand the query conditions

   We want orders where status equals "shipped" AND total is greater than 100.

2. Step 2: Check correct MongoDB syntax for AND conditions

   MongoDB treats multiple fields in the query object as AND conditions. Use { status: "shipped", total: { $gt: 100 } }.

3. Final Answer:

   db.orders.find({ status: "shipped", total: { $gt: 100 } }) -> Option A

4. Quick Check:

   Multiple fields = AND in MongoDB queries [OK]

Hint: Use multiple fields in find() for AND conditions [OK]

Common Mistakes:

• Using > instead of $gt inside query
• Using == or && which are invalid in MongoDB queries
• Using || which means OR, not AND