How MongoDB indexes work (B-tree mental model) - Practice Exercises

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does a B-tree index improve query speed in MongoDB?

Imagine you have a phone book sorted by last names. How does MongoDB's B-tree index help find a specific last name faster compared to scanning every entry?

A It organizes data in a tree structure allowing quick jumps to the right section instead of checking every entry.

B It stores all data in a single list and searches linearly from start to end.

C It duplicates the entire collection to speed up queries.

D It randomly picks entries until it finds the match.

💡 Hint

Think about how a dictionary helps you find words quickly by jumping to the right letter section.

A B-tree index splits data into sorted blocks, allowing MongoDB to jump directly to the block containing the searched value, avoiding scanning all entries.

❓ query_result

intermediate

What is the output count of documents matched using an indexed field?

Given a MongoDB collection users with an index on age, what will be the count result of this query?

db.users.find({ age: { $gt: 30 } }).count()

Assume the collection has 100 documents with ages ranging from 1 to 100.

A 30

B 0

C 100

D 70

💡 Hint

Count how many ages are greater than 30 in the range 1 to 100.

Ages from 31 to 100 inclusive are 70 numbers, so 70 documents match.

📝 Syntax

advanced

Which MongoDB index creation command is syntactically correct for a compound B-tree index?

Choose the correct command to create a compound index on lastName ascending and age descending fields.

A db.collection.createIndex([lastName: 1, age: -1])

B db.collection.createIndex({ lastName: 1, age: -1 })

C db.collection.createIndex({ lastName => 1, age => -1 })

D db.collection.createIndex({ lastName: 'asc', age: 'desc' })

💡 Hint

Remember MongoDB uses JSON-like objects with field names and 1 or -1 for ascending/descending.

The correct syntax uses an object with field names as keys and 1 or -1 as values to specify ascending or descending order.

❓ optimization

advanced

Which index choice optimizes queries filtering by both category and price fields?

You often query a products collection filtering by category and price. Which index will speed up these queries best?

A A text index on category and price

B Separate single-field indexes on category and price

C A compound index on { category: 1, price: 1 }

D No index, just scan the collection

💡 Hint

Think about how a single index can cover multiple fields in order.

A compound index on both fields allows MongoDB to efficiently filter by category first, then price, improving query speed compared to separate indexes.

🔧 Debug

expert

Why does this MongoDB query not use the index as expected?

Given an index on username, why does this query not use the index?

db.users.find({ username: { $regex: 'admin' } })

A Because the regex is a string pattern and MongoDB cannot use indexes with regex queries unless they are simple prefixes.

B Because regex queries with anchors (^) always ignore indexes in MongoDB.

C Because the regex is case sensitive and the index is case insensitive.

D Because regex with ^ can use the index, so this query should use it.

💡 Hint

Consider how MongoDB uses indexes with regex patterns.

MongoDB can use indexes for regex queries only if the regex is a simple prefix expression like /^prefix/. The pattern 'admin' matches anywhere in the field value and cannot use the index.

Practice

1. What is the main purpose of an index in MongoDB using a B-tree structure?

easy

A. To encrypt data for security

B. To store data in a compressed format

C. To speed up search and sort operations on data

D. To backup the database automatically

Solution

1. Step 1: Understand what a B-tree index does

   A B-tree index organizes data so that searching and sorting can happen quickly.

2. Step 2: Identify the main benefit of indexing

   Indexes help queries find data faster by avoiding full collection scans.

3. Final Answer:

   To speed up search and sort operations on data -> Option C

4. Quick Check:

   Index = Faster search and sort [OK]

Hint: Indexes speed up queries by organizing data [OK]

Common Mistakes:

• Thinking indexes compress data
• Confusing indexes with backups
• Assuming indexes encrypt data

2. Which of the following is the correct syntax to create an ascending index on the field age in MongoDB?

easy

A. db.collection.createIndex({age: 1})

B. db.collection.createIndex(age: ascending)

C. db.collection.index({age: 'asc'})

D. db.collection.addIndex({age: 1})

Solution

1. Step 1: Recall MongoDB index creation syntax

   The correct method is createIndex with a document specifying field and order.

2. Step 2: Check the correct format for ascending order

   Ascending order is represented by 1, so {age: 1} is correct.

3. Final Answer:

   db.collection.createIndex({age: 1}) -> Option A

4. Quick Check:

   createIndex + {field: 1} = correct syntax [OK]

Hint: Use createIndex({field: 1}) for ascending index [OK]

Common Mistakes:

• Using addIndex instead of createIndex
• Passing string 'asc' instead of 1
• Omitting curly braces around field

3. Given a collection with an index on score, what will be the order of documents returned by this query?
db.collection.find().sort({score: 1})

medium

A. Documents sorted by score in descending order

B. Documents sorted by insertion order

C. Documents in random order

D. Documents sorted by score in ascending order

Solution

1. Step 1: Understand the sort parameter

   The sort({score: 1}) means sort by score ascending (lowest to highest).

2. Step 2: Recognize index usage

   Since there is an index on score, MongoDB uses it to return documents in ascending order efficiently.

3. Final Answer:

   Documents sorted by score in ascending order -> Option D

4. Quick Check:

   sort({score: 1}) = ascending order [OK]

Hint: sort({field: 1}) means ascending order [OK]

Common Mistakes:

• Confusing 1 with descending order
• Assuming no order without explicit index
• Thinking insertion order is default

4. You created a unique index on the field email but still see duplicate emails in your collection. What is the likely cause?

medium

A. The index was created with ascending order instead of unique

B. The unique index was created after duplicates existed

C. MongoDB does not enforce uniqueness on indexes

D. The field email is missing in some documents

Solution

1. Step 1: Understand unique index behavior

   Unique indexes prevent duplicates only for new inserts after index creation.

2. Step 2: Consider existing duplicates

   If duplicates existed before creating the unique index, MongoDB allows them unless you drop or clean data first.

3. Final Answer:

   The unique index was created after duplicates existed -> Option B

4. Quick Check:

   Unique index blocks new duplicates, not old ones [OK]

Hint: Unique index blocks new duplicates, not existing ones [OK]

Common Mistakes:

• Thinking ascending order affects uniqueness
• Believing MongoDB ignores unique constraints
• Assuming missing fields cause duplicates

5. You want to optimize queries filtering by category and sorting by price. Which index is best to improve performance?

hard

A. A compound index on {category: 1, price: 1}

B. Two separate indexes: one on category, one on price

C. A unique index on price

D. No index needed if collection is small

Solution

1. Step 1: Understand compound index benefits

   A compound index on {category: 1, price: 1} supports queries filtering by category and sorting by price efficiently.

2. Step 2: Compare with separate indexes

   Separate indexes cannot optimize combined filter and sort as well as a compound index.

3. Step 3: Consider uniqueness and collection size

   Unique index on price is irrelevant here; small collections may not need indexes but that is not optimization.

4. Final Answer:

   A compound index on {category: 1, price: 1} -> Option A

5. Quick Check:

   Compound index = best for filter + sort [OK]

Hint: Use compound index for filter and sort fields together [OK]

Common Mistakes:

• Using separate indexes instead of compound
• Confusing unique index with performance index
• Ignoring index for small collections