mongodb-querying-and-indexing - mongodb-nosql Interview Questions | Preplance

1. Which operator is used to find documents where a field value is greater than a specified value?

Difficulty: EasyType: MCQTopic: Querying

The dollar gt operator stands for greater than and is used to find documents where a field value is greater than a specified value. For example, to find all users older than 25, you would use age dollar gt 25. MongoDB provides several comparison operators: dollar gt for greater than, dollar gte for greater than or equal to, dollar lt for less than, dollar lte for less than or equal to, dollar eq for equal to, and dollar ne for not equal to. These operators are essential for filtering documents based on numeric or date comparisons.

Example code

// Find users older than 25
db.users.find({ age: { $gt: 25 } })

// Find products with price greater than 100
db.products.find({ price: { $gt: 100 } })

// Combine with other operators
db.users.find({ age: { $gt: 25, $lt: 40 } })

2. What is the default index automatically created by MongoDB for every collection?

Difficulty: MediumType: MCQTopic: Indexing

MongoDB automatically creates a unique index on the underscore id field for every collection. This index ensures that each document has a unique identifier and enables fast lookups by underscore id. You cannot drop this index because it is essential for MongoDB's internal operations. The underscore id index is a single-field index that uses a B-tree data structure for efficient searching. All other indexes must be created manually based on your query patterns.

Example code

// View indexes on a collection
db.users.getIndexes()

// Returns:
[
  {
    "v": 2,
    "key": { "_id": 1 },
    "name": "_id_"
  }
]

3. Which method is used to create an index in MongoDB?

Difficulty: EasyType: MCQTopic: Indexing

The createIndex method is used to create indexes in MongoDB. You specify the field or fields to index and the sort order. A value of 1 creates an ascending index, while negative 1 creates a descending index. Creating indexes is crucial for query performance. Without indexes, MongoDB must scan every document in a collection to find matches, which is slow for large collections. Indexes allow MongoDB to quickly locate documents using a B-tree data structure.

Example code

// Create single-field index
db.users.createIndex({ email: 1 })

// Create descending index
db.products.createIndex({ price: -1 })

// Create compound index
db.orders.createIndex({ userId: 1, orderDate: -1 })

4. What type of index is required to perform text search in MongoDB?

Difficulty: MediumType: MCQTopic: Indexing

A text index is required to perform full-text search in MongoDB. Text indexes tokenize and stem the text content, allowing you to search for words and phrases within string fields. You create a text index using the text keyword instead of 1 or negative 1. MongoDB supports text search queries using the dollar text operator. Text indexes can be created on multiple fields, and you can have only one text index per collection, but it can include multiple fields.

Example code

// Create text index
db.articles.createIndex({ title: "text", body: "text" })

// Perform text search
db.articles.find({
  $text: { $search: "mongodb database" }
})

// Search with exact phrase
db.articles.find({
  $text: { $search: "\"NoSQL database\"" }
})

5. Explain the difference between $in and $or operators in MongoDB queries.

Difficulty: MediumType: SubjectiveTopic: Querying

The dollar in operator is used when you want to match documents where a field's value equals any value in a specified array. It works on a single field and is more concise and efficient for checking multiple possible values. The dollar or operator is used when you need to match documents that satisfy at least one of multiple conditions, which can involve different fields or complex expressions. For example, dollar or can check if age is greater than 30 or city equals New York, involving different fields. Use dollar in when checking if one field matches any of several values. Use dollar or when you have multiple conditions on different fields or need complex logic. The dollar in operator is generally more efficient than dollar or when both can achieve the same result on a single field.

Example code

// $in operator - single field, multiple values
db.users.find({
  status: { $in: ["active", "pending", "verified"] }
})

// $or operator - multiple conditions
db.users.find({
  $or: [
    { age: { $gt: 30 } },
    { city: "New York" },
    { status: "premium" }
  ]
})

6. How do indexes improve query performance in MongoDB and what are the trade-offs?

Difficulty: MediumType: SubjectiveTopic: Indexing

Indexes improve query performance by creating a sorted data structure that allows MongoDB to quickly locate documents without scanning the entire collection. Instead of examining every document, MongoDB can use a B-tree index to jump directly to matching documents. For example, without an index on the age field, finding users with age 30 requires scanning all documents, which is slow for large collections. With an index, MongoDB can find the relevant documents in logarithmic time. The trade-offs are that indexes consume disk space and memory. Each index requires storage for the index data structure. Additionally, indexes slow down write operations because MongoDB must update all relevant indexes whenever you insert, update, or delete documents. Therefore, you should create indexes strategically based on your most common query patterns, not on every field.

Example code

// Without index - scans all documents
db.users.find({ email: "alice@example.com" })
// docsExamined: 100000, executionTimeMillis: 150

// Create index
db.users.createIndex({ email: 1 })

// With index - fast lookup
db.users.find({ email: "alice@example.com" })
// docsExamined: 1, executionTimeMillis: 2

7. How do you query array fields in MongoDB? Explain $elemMatch with an example.

Difficulty: MediumType: SubjectiveTopic: Querying

MongoDB provides several operators for querying array fields. The simplest way is to match an array that contains a specific value. For example, to find users with JavaScript skill, you query skills colon JavaScript. For more complex array queries with multiple conditions on array elements, use the dollar elemMatch operator. This ensures all conditions are met by the same array element, not different elements. For example, if you have an array of grade objects and want to find students who scored above 80 in Math, dollar elemMatch ensures both the subject and score conditions apply to the same grade object. Without dollar elemMatch, MongoDB might match a document where one element has subject Math and a different element has score above 80. Other useful array operators include dollar all to match arrays containing all specified values, dollar size to match arrays of a specific length, and dollar slice for array projections.

Example code

// Simple array match
db.users.find({ skills: "JavaScript" })

// $elemMatch - multiple conditions on same element
db.students.find({
  grades: {
    $elemMatch: {
      subject: "Math",
      score: { $gt: 80 }
    }
  }
})

// Without $elemMatch (may match wrong docs)
db.students.find({
  "grades.subject": "Math",
  "grades.score": { $gt: 80 }
})

8. What is the explain() method in MongoDB and what key metrics should you look for when analyzing query performance?

Difficulty: MediumType: SubjectiveTopic: Querying

The explain method shows how MongoDB executes a query, including which indexes are used, how many documents are scanned, and the execution time. This is crucial for query optimization and identifying performance bottlenecks. You can use different verbosity modes: queryPlanner shows the winning plan, executionStats shows detailed execution statistics, and allPlansExecution shows all considered plans. Key metrics to analyze include: totalDocsExamined which shows how many documents MongoDB scanned, totalDocsReturned which shows how many documents matched your query, executionTimeMillis which shows the query execution time in milliseconds, and indexName which tells you if an index was used. Ideally, totalDocsExamined should be close to totalDocsReturned. If MongoDB scans many more documents than it returns, you need better indexes. A query is efficient when it examines only the documents that match your criteria.

Example code

// Basic explain
db.users.find({ age: 30 }).explain()

// Execution statistics mode
db.users.find({ age: 30 }).explain("executionStats")

// Key output:
{
  executionStats: {
    executionTimeMillis: 2,
    totalDocsExamined: 1,
    totalDocsReturned: 1,
    executionStages: {
      stage: "IXSCAN",  // Index scan
      indexName: "age_1"
    }
  }
}

9. Which operator matches documents where an array field contains all specified elements?

Difficulty: MediumType: MCQTopic: Querying

The dollar all operator matches documents where an array field contains all the specified elements, regardless of order or additional elements. This is useful when you need to ensure an array has multiple specific values. For example, if you want to find users who have both JavaScript and Python skills, you use dollar all. The dollar in operator, in contrast, matches documents where a field equals any value in the specified array. The dollar elemMatch is used for complex array queries with multiple conditions on array elements.

Example code

// Find users with both JavaScript and Python skills
db.users.find({
  skills: { $all: ["JavaScript", "Python"] }
})

// This matches:
{ skills: ["JavaScript", "Python", "Java"] }
{ skills: ["Python", "JavaScript"] }

// But not:
{ skills: ["JavaScript", "Java"] }

10. In MongoDB projections, what does { name: 1, age: 1, _id: 0 } do?

Difficulty: MediumType: MCQTopic: Querying

This projection returns only the name and age fields while explicitly excluding the underscore id field. In MongoDB projections, 1 means include the field and 0 means exclude it. By default, the underscore id field is always included unless you explicitly exclude it with underscore id colon 0. You cannot mix inclusion and exclusion in projections, except for underscore id. Projections improve performance by reducing the amount of data transferred over the network.

Example code

// Return only name and age, exclude _id
db.users.find(
  { age: { $gt: 25 } },
  { name: 1, age: 1, _id: 0 }
)

// Returns:
{ "name": "Alice", "age": 30 }
{ "name": "Bob", "age": 28 }

11. For a compound index { age: 1, city: 1 }, which query can use this index efficiently?

Difficulty: HardType: MCQTopic: Indexing

A compound index on age and city can efficiently support queries on age alone, or on both age and city together, because age is the prefix of the index. However, it cannot efficiently support queries on city alone. This is the index prefix rule. MongoDB can use a compound index for queries on any prefix of the indexed fields. In this case, queries on just age, or on age and city can use the index. But queries on just city cannot use this index efficiently and would need a separate index on city.

Example code

// Compound index
db.users.createIndex({ age: 1, city: 1 })

// Efficient - uses index
db.users.find({ age: 30 })
db.users.find({ age: 30, city: "NYC" })

// Inefficient - cannot use this index
db.users.find({ city: "NYC" })

12. What is a compound index and when should you use it? Explain the index prefix rule.

Difficulty: HardType: SubjectiveTopic: Indexing

A compound index is an index on multiple fields in a specific order. For example, an index on age and city creates a sorted structure first by age, then by city within each age group. This supports queries that filter or sort by these fields. You should use compound indexes when your queries frequently filter or sort by multiple fields together. For example, if you often query users by age and city, a compound index on these fields is more efficient than separate indexes. The index prefix rule states that MongoDB can use a compound index for queries on any prefix of the indexed fields. If you have an index on fields A, B, and C, MongoDB can use it for queries on A alone, A and B together, or A, B, and C together. However, it cannot efficiently use this index for queries on just B, just C, or B and C without A. Field order matters in compound indexes, so place the most selective or frequently queried fields first.

Example code

// Compound index on age, city, status
db.users.createIndex({ age: 1, city: 1, status: 1 })

// Can use index (prefix rule):
db.users.find({ age: 30 })
db.users.find({ age: 30, city: "NYC" })
db.users.find({ age: 30, city: "NYC", status: "active" })

// Cannot use index efficiently:
db.users.find({ city: "NYC" })
db.users.find({ status: "active" })
db.users.find({ city: "NYC", status: "active" })

13. What strategies can you use to optimize slow MongoDB queries?

Difficulty: HardType: SubjectiveTopic: Querying

First, use the explain method with executionStats to identify bottlenecks. Look at totalDocsExamined versus totalDocsReturned. If MongoDB scans many more documents than it returns, you need better indexes. Second, create appropriate indexes based on your query patterns. Index the fields you filter, sort, or use in projections. For queries with multiple conditions, consider compound indexes with the most selective fields first. Third, use projections to return only the fields you need, reducing network transfer and memory usage. Fourth, avoid queries that cannot use indexes efficiently, such as negation operators like dollar ne or regular expressions without anchors. Fifth, for complex queries, restructure them or use the aggregation pipeline with early filtering stages. Sixth, ensure your indexes fit in RAM for best performance. Finally, consider using covered queries where all queried fields are in the index, allowing MongoDB to return results entirely from the index without examining documents.

Example code

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

// Optimize with index
db.users.createIndex({ age: 1 })

// Use projection to reduce data transfer
db.users.find(
  { age: { $gt: 25 } },
  { name: 1, email: 1, _id: 0 }
)

// Covered query (all fields in index)
db.users.createIndex({ age: 1, name: 1 })
db.users.find(
  { age: 30 },
  { name: 1, _id: 0 }
)

Master Interviews
Anywhere, Anytime

MongoDB Querying & Indexing – MongoDB/NoSQL interview questions

Set overview

MongoDB/NoSQL – MongoDB Querying & Indexing questions (13)

1. Which operator is used to find documents where a field value is greater than a specified value?

Continue your preparation

2. What is the default index automatically created by MongoDB for every collection?

3. Which method is used to create an index in MongoDB?

4. What type of index is required to perform text search in MongoDB?

5. Explain the difference between $in and $or operators in MongoDB queries.

6. How do indexes improve query performance in MongoDB and what are the trade-offs?

7. How do you query array fields in MongoDB? Explain $elemMatch with an example.

8. What is the explain() method in MongoDB and what key metrics should you look for when analyzing query performance?

9. Which operator matches documents where an array field contains all specified elements?

10. In MongoDB projections, what does { name: 1, age: 1, _id: 0 } do?

11. For a compound index { age: 1, city: 1 }, which query can use this index efficiently?

12. What is a compound index and when should you use it? Explain the index prefix rule.

13. What strategies can you use to optimize slow MongoDB queries?

More sets in MongoDB/NoSQL

Explore related subjects

Master Interviews Anywhere, Anytime

MongoDB Querying & Indexing – MongoDB/NoSQL interview questions

Set overview

1. Which operator is used to find documents where a field value is greater than a specified value?

Continue your preparation

2. What is the default index automatically created by MongoDB for every collection?

3. Which method is used to create an index in MongoDB?

4. What type of index is required to perform text search in MongoDB?

5. Explain the difference between $in and $or operators in MongoDB queries.

6. How do indexes improve query performance in MongoDB and what are the trade-offs?

7. How do you query array fields in MongoDB? Explain $elemMatch with an example.

8. What is the explain() method in MongoDB and what key metrics should you look for when analyzing query performance?

9. Which operator matches documents where an array field contains all specified elements?

10. In MongoDB projections, what does { name: 1, age: 1, _id: 0 } do?

11. For a compound index { age: 1, city: 1 }, which query can use this index efficiently?

12. What is a compound index and when should you use it? Explain the index prefix rule.

13. What strategies can you use to optimize slow MongoDB queries?

More sets in MongoDB/NoSQL

Explore related subjects

Master Interviews
Anywhere, Anytime