Why indexes are critical for performance in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How do indexes improve query speed in MongoDB?

Imagine you have a huge phone book and you want to find a person's phone number. Without an index, you might have to look at every page. How does an index help MongoDB find data faster?

A Indexes compress data to make it smaller and faster to read.

B Indexes store all data in memory so queries never access the disk.

C Indexes let MongoDB jump directly to the data location without scanning all documents.

D Indexes duplicate all data to speed up queries.

💡 Hint

Think about how a book's index helps you find a topic quickly.

Indexes create a fast lookup structure that points to the exact location of data, avoiding full collection scans.

❓ query_result

intermediate

What is the output count of a query with and without an index?

Given a collection users with 100,000 documents, 10,000 have age: 30. You run this query:

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

What will be the count returned?

A 10000

B 0

C 100000

D Error: no index found

💡 Hint

The count is about how many documents match, not how fast the query runs.

The query counts all documents where age is 30, which is 10,000 regardless of indexing.

📝 Syntax

advanced

Which index creation command is correct for fast queries on 'email' field?

You want to create an index on the email field in the users collection. Which command is correct?

A db.users.createIndex({email})

B db.users.createIndex(email)

C db.users.createIndex(['email'])

D db.users.createIndex({email: 1})

💡 Hint

Indexes need a field name and sort order inside an object.

The correct syntax uses an object with the field name as key and 1 for ascending order.

❓ optimization

advanced

Which index type is best for queries filtering on multiple fields?

You often query orders collection filtering by customerId and status. Which index improves performance best?

A A text index on customerId and status

B A compound index on {customerId: 1, status: 1}

C Separate single-field indexes on customerId and status

D No index, just scan all documents

💡 Hint

Think about how combining fields in one index helps multi-field queries.

A compound index on both fields lets MongoDB efficiently filter by both at once.

🔧 Debug

expert

Why does this query run slowly despite an index on 'username'?

Collection users has an index on username. This query is slow:

db.users.find({username: /john/i})

Why?

A Regex with case-insensitive flag prevents index use

B Index on username is corrupted

C Query syntax is invalid

D MongoDB does not support indexes on strings

💡 Hint

Think about how indexes work with regular expressions.

Case-insensitive regex disables index use because it can't match index order efficiently.

Practice

1. Why are indexes important in MongoDB for query performance?

easy

A. They speed up data retrieval by avoiding scanning the entire collection.

B. They increase the storage size without any performance benefit.

C. They automatically backup the database.

D. They encrypt the data for security.

Solution

1. Step 1: Understand what happens without indexes

   Without indexes, MongoDB must scan every document in the collection to find matches, which is slow.

2. Step 2: Role of indexes in query speed

   Indexes allow MongoDB to quickly locate documents by using a data structure, avoiding full scans.

3. Final Answer:

   They speed up data retrieval by avoiding scanning the entire collection. -> Option A

4. Quick Check:

   Indexes improve query speed = C [OK]

Hint: Indexes avoid full scans, making queries faster [OK]

Common Mistakes:

• Thinking indexes backup data
• Believing indexes encrypt data
• Assuming indexes only increase storage without benefit

2. Which of the following is the correct way to create an index on the field username in MongoDB?

easy

A. db.collection.addIndex({username: true})

B. db.collection.createIndex('username')

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

D. db.collection.createIndex({username: 1})

Solution

1. Step 1: Recall MongoDB index creation syntax

   The correct method is createIndex with a document specifying field and order (1 for ascending).

2. Step 2: Check each option

   db.collection.createIndex({username: 1}) uses correct syntax: createIndex({username: 1}). Others are invalid or incorrect method names.

3. Final Answer:

   db.collection.createIndex({username: 1}) -> Option D

4. Quick Check:

   Correct index syntax = A [OK]

Hint: Use createIndex with field: 1 or -1 for ascending/descending [OK]

Common Mistakes:

• Using wrong method names like addIndex
• Passing field name as string instead of object
• Using incorrect field order values

3. Given a collection users with an index on email, what will be the output of the following explain query?

db.users.find({email: '[e-mail]'}).explain('executionStats')

Which statement is true about the executionStats output?

medium

A. The query will show a COLLSCAN stage indicating a full collection scan.

B. The query will show an IXSCAN stage indicating an index scan on email.

C. The query will fail because explain cannot be used with find.

D. The query will show no stages because indexes are ignored.

Solution

1. Step 1: Understand explain with executionStats

   Explain with 'executionStats' shows how MongoDB executes the query, including index usage.

2. Step 2: Effect of index on email field

   Since there is an index on email, MongoDB uses an index scan (IXSCAN) instead of a full collection scan (COLLSCAN).

3. Final Answer:

   The query will show an IXSCAN stage indicating an index scan on email. -> Option B

4. Quick Check:

   Index present means IXSCAN used = D [OK]

Hint: Explain shows IXSCAN if index used, COLLSCAN if not [OK]

Common Mistakes:

• Confusing COLLSCAN with IXSCAN
• Thinking explain causes query failure
• Assuming indexes are ignored in explain

4. You created an index on age field but your queries still perform full collection scans. What is the most likely reason?

medium

A. MongoDB does not support indexes on numeric fields.

B. Indexes slow down queries intentionally.

C. The index was created with the wrong field name or syntax error.

D. You must restart MongoDB to activate indexes.

Solution

1. Step 1: Check index creation correctness

   If the index was created with a wrong field name or syntax error, it won't be used by queries.

2. Step 2: Eliminate other options

   MongoDB supports numeric indexes, does not require restart, and indexes speed up queries, not slow them.

3. Final Answer:

   The index was created with the wrong field name or syntax error. -> Option C

4. Quick Check:

   Incorrect index creation causes no index use = B [OK]

Hint: Check index field names and syntax if queries ignore indexes [OK]

Common Mistakes:

• Believing MongoDB needs restart for indexes
• Thinking numeric fields can't be indexed
• Assuming indexes slow queries

5. You have a large collection with frequent writes and queries on status and createdAt. How should you design indexes to balance read speed and write performance?

hard

A. Create a compound index on {status: 1, createdAt: -1} and avoid extra indexes.

B. Create separate indexes on status and createdAt and many others for all queries.

C. Create no indexes to keep writes fast.

D. Create an index on a non-used field to reduce write load.

Solution

1. Step 1: Understand compound indexes for multiple query fields

   A compound index on {status: 1, createdAt: -1} supports queries filtering by status and sorting by createdAt efficiently.

2. Step 2: Balance index count for write performance

   Too many indexes slow writes. Using one compound index reduces overhead while improving read speed.

3. Final Answer:

   Create a compound index on {status: 1, createdAt: -1} and avoid extra indexes. -> Option A

4. Quick Check:

   Compound index balances reads and writes = A [OK]

Hint: Use compound indexes for multi-field queries, limit total indexes [OK]

Common Mistakes:

• Creating too many indexes hurting write speed
• Not using compound indexes for related fields
• Avoiding indexes completely hurting read speed