Why performance tuning matters in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is performance tuning important in MongoDB?

Imagine you run a busy online store using MongoDB. What is the main reason to focus on performance tuning?

A To increase the size of the database storage automatically

B To change the data format from JSON to XML

C To make queries run faster and reduce waiting time for users

D To add more fields to every document without limit

💡 Hint

Think about what users feel when the website is slow.

Performance tuning helps queries run faster, which means users get their data quickly and have a better experience.

❓ query_result

intermediate

What is the output of this MongoDB query with and without an index?

You have a collection 'orders' with 1 million documents. You run this query:

{ customerId: 12345 }

Without an index on 'customerId', the query takes 10 seconds. With an index, it takes 0.1 seconds.

What is the main reason for this difference?

A The index allows MongoDB to find matching documents quickly without scanning all documents

B The index duplicates all documents making the database bigger and slower

C The query changes the data in the collection when an index is present

D MongoDB ignores the query if an index exists

💡 Hint

Think about how you find a word in a book with or without an index.

An index works like a book's index, letting MongoDB jump directly to matching documents instead of checking every one.

📝 Syntax

advanced

Which MongoDB query syntax correctly uses an index hint to improve performance?

You want to force MongoDB to use the index named 'customerId_1' for this query:

db.orders.find({ customerId: 12345 })

A db.orders.find({ customerId: 12345 }).hint('customerId_1')

B db.orders.find({ customerId: 12345 }).useIndex('customerId_1')

C db.orders.find({ customerId: 12345 }).index('customerId_1')

D db.orders.find({ customerId: 12345 }).forceIndex('customerId_1')

💡 Hint

Check MongoDB documentation for the method to specify an index.

The hint() method tells MongoDB which index to use for the query.

❓ optimization

advanced

Which approach best improves query performance on a large MongoDB collection?

You have a large collection with many fields. You want to speed up queries that only need 'customerId' and 'orderDate'. What should you do?

A Store all data in a single large document

B Add all fields to the index to cover every query

C Remove all indexes to speed up writes

D Create a compound index on 'customerId' and 'orderDate' and use projection to return only those fields

💡 Hint

Think about indexing only what you need and returning less data.

A compound index on the queried fields plus projection reduces data scanned and returned, improving speed.

🔧 Debug

expert

Why does this MongoDB query run slowly despite having an index?

Given the collection 'orders' with an index on 'customerId', this query runs slowly:

db.orders.find({ customerId: { $gt: 1000 } })

What is the most likely reason?

A The index on 'customerId' is ignored because $gt is not supported

B The query uses a range operator ($gt) which causes MongoDB to scan many index entries, slowing performance

C MongoDB does not support queries with $gt on indexed fields

D The query syntax is invalid and causes a runtime error

💡 Hint

Think about how range queries work with indexes.

Range queries like $gt use the index but may scan many entries, so performance depends on data distribution.

Practice

1. Why is performance tuning important in MongoDB databases?

easy

A. It helps queries run faster and reduces resource use.

B. It increases the size of the database automatically.

C. It deletes old data to save space.

D. It changes the database schema without user input.

Solution

1. Step 1: Understand performance tuning purpose

   Performance tuning aims to make database operations faster and more efficient.

2. Step 2: Identify the correct benefit in MongoDB context

   Faster queries and less resource use directly improve application speed and cost.

3. Final Answer:

   It helps queries run faster and reduces resource use. -> Option A

4. Quick Check:

   Performance tuning = faster queries [OK]

Hint: Performance tuning improves speed and resource use [OK]

Common Mistakes:

• Confusing tuning with data deletion
• Thinking tuning changes schema automatically
• Believing tuning increases database size

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

easy

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

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

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

D. db.collection.addIndex(username)

Solution

1. Step 1: Recall MongoDB index creation syntax

   MongoDB uses createIndex with a document specifying fields and sort order (1 for ascending).

2. Step 2: Match syntax with options

   db.collection.createIndex({username: 1}) matches the correct syntax: db.collection.createIndex({username: 1}).

3. Final Answer:

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

4. Quick Check:

   Correct index syntax = db.collection.createIndex({username: 1}) [OK]

Hint: Use createIndex with field and 1 or -1 [OK]

Common Mistakes:

• Using wrong method names like create_index
• Passing field name as string without object
• Using addIndex which does not exist

3. Given the following MongoDB query, what is the expected result?

db.users.find({age: {$gt: 30}}).explain('executionStats')

What does the executionStats output help you understand?

medium

A. It creates an index on the age field automatically.

B. It shows how many documents matched and how long the query took.

C. It changes the age field to greater than 30.

D. It deletes documents older than 30 years.

Solution

1. Step 1: Understand the purpose of explain('executionStats')

   This command returns detailed info about query performance, including matched documents and time taken.

2. Step 2: Identify what the output shows

   The output helps analyze query efficiency, not modify data or create indexes.

3. Final Answer:

   It shows how many documents matched and how long the query took. -> Option B

4. Quick Check:

   Explain executionStats = query performance details [OK]

Hint: Explain shows query stats, not data changes [OK]

Common Mistakes:

• Thinking explain modifies data
• Assuming explain creates indexes
• Confusing query filter with data update

4. You wrote this MongoDB query to find users older than 25:

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

But it runs very slowly. What is the most likely reason?

medium

A. The age field is not indexed.

B. The query syntax is incorrect.

C. MongoDB does not support the $gt operator.

D. The collection name is wrong.

Solution

1. Step 1: Check query syntax correctness

   The syntax is correct; $gt is a valid operator and collection name seems fine.

2. Step 2: Identify performance cause

   Without an index on age, MongoDB must scan all documents, causing slow queries.

3. Final Answer:

   The age field is not indexed. -> Option A

4. Quick Check:

   Missing index = slow query [OK]

Hint: Slow queries often mean missing indexes [OK]

Common Mistakes:

• Blaming syntax when it's correct
• Thinking $gt is unsupported
• Assuming wrong collection name without checking

5. You have a large MongoDB collection with millions of documents. You want to improve query speed for searches on email and status. Which approach best improves performance?

hard

A. Remove all indexes to speed up writes.

B. Create separate indexes on email and status fields.

C. Store email and status in a single string field.

D. Create a compound index on {email: 1, status: 1}.

Solution

1. Step 1: Understand compound vs separate indexes

   A compound index on both fields allows efficient queries filtering on both email and status together.

2. Step 2: Evaluate options for best performance

   Separate indexes help single-field queries but compound index is better for combined filters. Storing combined fields as string or removing indexes harms performance.

3. Final Answer:

   Create a compound index on {email: 1, status: 1}. -> Option D

4. Quick Check:

   Compound index = best multi-field query speed [OK]

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

Common Mistakes:

• Using separate indexes for combined queries
• Combining fields into one string reduces query flexibility
• Removing indexes slows queries