Why indexes are critical for performance in MongoDB - Performance Analysis

Time Complexity: Why indexes are critical for performance

O(n) without index, O(log n) with index

Understanding Time Complexity

When we search data in MongoDB, how fast it happens depends a lot on indexes.

We want to understand how using indexes changes the work MongoDB does as data grows.

Scenario Under Consideration

Analyze the time complexity of the following MongoDB find query with and without an index.

// Find documents where age is 30
// Without index
db.users.find({ age: 30 })

// With index on age
// Assume index created: db.users.createIndex({ age: 1 })

This code searches for users aged 30, first scanning all documents, then using an index.

Identify Repeating Operations

Look at what repeats as data grows.

• Primary operation: Scanning documents or index entries one by one.
• How many times: Without index, it checks every document; with index, it checks fewer index entries.

How Execution Grows With Input

As the number of users grows, the work changes like this:

Input Size (n)	Approx. Operations Without Index	Approx. Operations With Index
10	10 document checks	About 4 index checks
100	100 document checks	About 7 index checks
1000	1000 document checks	About 10 index checks

Pattern observation: Without index, work grows directly with data size; with index, work grows slowly, like steps up a tree.

Final Time Complexity

Time Complexity: O(n) without index, O(log n) with index

This means searching without an index gets slower directly with more data, but with an index, it grows much slower.

Common Mistake

[X] Wrong: "Adding an index always makes queries instantly fast no matter what."

[OK] Correct: Indexes help most for searches on indexed fields, but if the query is on other fields or returns many results, the speed gain may be less.

Interview Connect

Understanding how indexes change search speed shows you know how databases handle data efficiently, a key skill for real projects.

Self-Check

"What if we added a compound index on age and city? How would that affect the time complexity for queries filtering by both fields?"

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