Query patterns that cause collection scans in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Which query causes a collection scan due to missing index?

Given a collection users with an index on age, which query will cause a collection scan?

MongoDB

db.users.find({name: 'Alice'})

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

B db.users.find({age: 30, name: 'Alice'})

C db.users.find({name: 'Alice'})

D db.users.find({age: {$gt: 25}})

💡 Hint

Think about which field has an index and which does not.

Only queries filtering on the indexed field age can use the index. Querying by name without an index causes a collection scan.

❓ query_result

intermediate

Which query pattern causes a collection scan despite an index?

Assuming an index exists on status, which query will still cause a collection scan?

MongoDB

db.orders.find({status: {$ne: 'shipped'}})

A db.orders.find({status: {$in: ['shipped', 'pending']}})

B db.orders.find({status: 'shipped'})

C db.orders.find({status: {$eq: 'shipped'}})

D db.orders.find({status: {$ne: 'shipped'}})

💡 Hint

Think about how negation operators affect index usage.

The $ne operator cannot use indexes efficiently and causes a collection scan even if an index exists on the field.

📝 Syntax

advanced

Which query syntax causes a runtime error due to invalid operator usage?

Identify the query that will cause a runtime error in MongoDB due to incorrect operator usage.

A db.products.find({price: {$between: [50, 100]}})

B db.products.find({$and: [{price: {$gt: 50}}, {price: {$lt: 100}}]})

C db.products.find({price: {$gte: 50, $lte: 100}})

D db.products.find({price: {$lt: 100}})

💡 Hint

Check if the operator is valid in MongoDB query language.

MongoDB does not support the $between operator. Using it causes a runtime error.

❓ optimization

advanced

Which query pattern can be optimized to avoid collection scan?

Given a collection with an index on category, which query can be rewritten to use the index and avoid a collection scan?

A db.items.find({category: {$exists: true}})

B db.items.find({category: {$in: ['books', 'electronics']}})

C db.items.find({category: {$ne: null}})

D db.items.find({category: {$not: {$eq: 'clothing'}}})

💡 Hint

Consider which operators allow index usage.

The $in operator can use indexes efficiently. Other operators like $exists, $ne, and $not often cause collection scans.

🧠 Conceptual

expert

Why does a query with a regex pattern cause a collection scan?

Consider a collection with an index on the username field. Why does the query db.users.find({username: /admin/}) cause a collection scan?

A Because MongoDB can only use indexes for regex queries if the pattern is a prefix without special characters.

B Because the regex pattern is anchored at the start, so index is not used.

C Because regex queries never use indexes in MongoDB.

D Because the index on username is corrupted.

💡 Hint

Think about how MongoDB uses indexes with regex patterns.

MongoDB can use indexes for regex queries only if the pattern is a simple prefix without special regex characters. Complex patterns cause collection scans.