Optimizing MongoDB Queries with `.executionStats`

As developers, we often focus on writing functional queries, but ensuring they run efficiently is just as important. MongoDB provides a powerful tool—.executionStats—that helps analyze query performance and optimize database operations. Let’s explore how it works and why it’s useful in day-to-day development.

What is .executionStats?

In MongoDB, .executionStats is a mode in the explain() method that provides in-depth insights into how a query executes. It helps you understand query performance, index usage, and potential optimizations.

How to Use .executionStats

To analyze a query’s performance, run:

 db.collection.find(query).explain("executionStats")

For example, if you want to check the performance of a query fetching users older than 25:

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

This will return a detailed JSON output containing various execution metrics.

Key Metrics in .executionStats

Here are some critical fields to look at:

1. executionSuccess – Indicates whether the query executed successfully.
2. nReturned – Number of documents returned by the query.
3. executionTimeMillis – Total execution time (in milliseconds).
4. totalKeysExamined – Number of index keys examined.
5. totalDocsExamined – Number of documents scanned in the collection.
6. executionStages – Details about how MongoDB executed the query.

Why is This Useful for Developers?

🔍 Identifying Slow Queries

If executionTimeMillis is high, the query might be inefficient. Identifying slow queries helps in improving performance, especially for large datasets.

📊 Index Optimization

• If totalDocsExamined is much higher than nReturned, MongoDB is scanning too many documents.
• If totalKeysExamined is high, an index might not be working effectively.
• This helps in deciding whether to create, modify, or remove indexes.

🛠 Debugging Execution Plans

If a query isn’t using an index as expected, .executionStats can help diagnose why. This prevents full collection scans and speeds up response times.

🚀 Improving Scalability

Optimizing queries ensures they can handle large traffic loads without causing high CPU or memory usage, making your application more scalable.

🔄 Comparing Query Performance

By testing different queries and comparing their .executionStats, developers can determine the most efficient approach for retrieving data.

Example: Optimizing a Query

Let’s say you run the following query:

 db.orders.find({ status: "shipped" }).explain("executionStats")

If the output shows:

{
  "nReturned": 10,
  "totalDocsExamined": 10000,
  "executionTimeMillis": 120
}

This means MongoDB is scanning 10,000 documents to return just 10! The solution? Add an index:

 db.orders.createIndex({ status: 1 })

After indexing, running .executionStats again might show:

{
  "nReturned": 10,
  "totalDocsExamined": 10,
  "executionTimeMillis": 5
}

This massive improvement makes the database more responsive and efficient.

Conclusion

Using .executionStats regularly helps developers:
✅ Identify slow queries

✅ Optimize indexes

✅ Debug query execution plans

✅ Improve database scalability

✅ Ensure applications run smoothly even under high loads

Next time you write a MongoDB query, don’t just check if it works—check how well it works! 🚀

---

Do you have a query that needs optimization? Share it in the comments! 😃