Multikey indexes for arrays in MongoDB - Step-by-Step Execution

Concept Flow - Multikey indexes for arrays

Start: Document with array field

↓

Create index on array field

↓

MongoDB extracts each array element

↓

Index stores each element as separate key

↓

Query uses index to find matching elements

↓

Return documents matching any array element

MongoDB creates a multikey index by indexing each element of an array field separately, allowing efficient queries on any array element.

Execution Sample

MongoDB

db.products.createIndex({ tags: 1 })
db.products.insertMany([
  { _id: 1, tags: ["red", "blue"] },
  { _id: 2, tags: ["blue", "green"] }
])
db.products.find({ tags: "blue" })

Create a multikey index on 'tags' array, insert documents with arrays, then query documents containing 'blue' in tags.

Execution Table

Step	Action	Index Keys Created	Query Condition	Documents Matched
1	Create index on 'tags' array field	empty
2	Insert document {_id:1, tags:["red","blue"]}	Index keys updated with 'red', 'blue'
3	Insert document {_id:2, tags:["blue","green"]}	Index keys updated with 'blue', 'green'
4	Query for tags: 'blue'		tags = 'blue'	Documents with _id 1 and 2
5	Query for tags: 'red'		tags = 'red'	Document with _id 1
6	Query for tags: 'green'		tags = 'green'	Document with _id 2
7	Query for tags: 'yellow'		tags = 'yellow'	No documents matched

💡 Queries stop after matching all documents with the requested array element or none if no match.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
Index keys	empty	['red', 'blue']	['red', 'blue', 'blue', 'green']	['red', 'blue', 'blue', 'green']
Documents	empty	[{_id:1, tags:['red','blue']}]	[{_id:1, tags:['red','blue']}, {_id:2, tags:['blue','green']}]	[{_id:1, tags:['red','blue']}, {_id:2, tags:['blue','green']}]

Key Moments - 3 Insights

Why does the index have duplicate keys like 'blue' twice?

Because each array element is indexed separately, and multiple documents or the same document can have the same element, so 'blue' appears multiple times in the index as shown in execution_table rows 2-3.

Does the multikey index store the whole array or each element separately?

It stores each element separately as individual keys, not the whole array as one key. This is why queries can match any element efficiently, as shown in execution_table step 4.

What happens if we query for an element not in any array?

No documents are matched because the index has no keys for that element, as shown in execution_table step 7.

Visual Quiz - 3 Questions

Look at the execution_table, at which step are the index keys first created?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Check the 'Index Keys Created' column in execution_table row for Step 2.

According to variable_tracker, what is the state of 'Index keys' after Step 3?

A ['red', 'blue']

B ['blue', 'green']

C ['red', 'blue', 'blue', 'green']

D empty

💡 Hint

Look at the 'Index keys' row under 'After Step 3' in variable_tracker.

From execution_table, which query returns no documents?

A tags = 'yellow'

B tags = 'red'

C tags = 'green'

D tags = 'blue'

💡 Hint

Check the 'Documents Matched' column for queries in execution_table.

Concept Snapshot

Multikey indexes in MongoDB index each element of an array field separately.
This allows queries to efficiently find documents matching any array element.
Duplicates appear in the index if elements repeat across documents.
Queries use these keys to quickly locate matching documents.
If no element matches, no documents are returned.
Create with createIndex({ arrayField: 1 }).

Full Transcript

This visual execution trace shows how MongoDB creates and uses multikey indexes for array fields. First, an index is created on the array field. MongoDB extracts each element from arrays in documents and stores them as separate keys in the index. When documents are inserted, their array elements are added to the index keys. Queries on the array field use these keys to find documents containing the queried element. If the element exists in any document's array, those documents are returned. If not, no documents match. The index can have duplicate keys if multiple documents or arrays contain the same element. This process allows efficient querying of array contents in MongoDB.

Practice

1. What is the main purpose of a multikey index in MongoDB when applied to an array field?

easy

A. To index each element inside the array separately for faster queries

B. To store the entire array as a single indexed value

C. To prevent duplicate values inside the array

D. To convert arrays into strings before indexing

Solution

1. Step 1: Understand what a multikey index does

   A multikey index indexes each element of an array field separately, allowing efficient queries on any element inside the array.

2. Step 2: Compare options with this behavior

   Only To index each element inside the array separately for faster queries describes indexing each element separately. Other options describe incorrect behaviors.

3. Final Answer:

   To index each element inside the array separately for faster queries -> Option A

4. Quick Check:

   Multikey index = indexes array elements separately [OK]

Hint: Multikey indexes each array element, not the whole array [OK]

Common Mistakes:

• Thinking multikey indexes the whole array as one value
• Confusing multikey with unique constraints
• Assuming arrays are converted to strings before indexing

2. Which of the following is the correct syntax to create a multikey index on the tags array field in a MongoDB collection named posts?

easy

A. db.posts.createIndex({ tags: [1] })

B. db.posts.createIndex({ tags: 1 })

C. db.posts.createIndex({ tags: 'multikey' })

D. db.posts.createIndex({ tags: { $each: 1 } })

Solution

1. Step 1: Recall MongoDB index creation syntax

   To create an index on a field, use createIndex({ field: 1 }) for ascending order.

2. Step 2: Understand multikey index creation

   MongoDB automatically creates a multikey index if the field is an array. No special keyword is needed.

3. Final Answer:

   db.posts.createIndex({ tags: 1 }) -> Option B

4. Quick Check:

   Index array field normally = multikey index [OK]

Hint: Just index the array field normally; MongoDB handles multikey [OK]

Common Mistakes:

• Using special keywords like 'multikey' in index definition
• Trying to pass array syntax in index keys
• Misusing MongoDB operators inside createIndex

3. Given the collection products with documents like { _id: 1, categories: ["electronics", "gadgets"] }, what will be the result of the query db.products.find({ categories: "gadgets" }) if a multikey index exists on categories?

medium

A. [{ _id: 1, categories: ["electronics"] }]

B. [] (empty array)

C. Error: Cannot query array field

D. [{ _id: 1, categories: ["electronics", "gadgets"] }]

Solution

1. Step 1: Understand query on array field with multikey index

   The query searches for documents where the array contains "gadgets". The multikey index allows fast lookup of such elements.

2. Step 2: Check the document matching the query

   The document with _id 1 has "gadgets" in its categories array, so it matches and will be returned.

3. Final Answer:

   [{ _id: 1, categories: ["electronics", "gadgets"] }] -> Option D

4. Quick Check:

   Query array element with multikey index returns matching docs [OK]

Hint: Query matches docs with array containing the value [OK]

Common Mistakes:

• Expecting empty result because array is indexed
• Thinking query errors on array fields
• Confusing partial array matches with exact matches

4. You created a multikey index on the tags array field, but your query db.articles.find({ tags: "news" }) is slow. What is a likely reason?

medium

A. The index was created on a different field, not tags

B. Multikey indexes do not support queries on array elements

C. You must use $elemMatch to query array fields

D. MongoDB does not index array fields automatically

Solution

1. Step 1: Check index field correctness

   If the index is on a different field, queries on tags won't use the index, causing slowness.

2. Step 2: Verify multikey index behavior

   Multikey indexes do support queries on array elements without special operators like $elemMatch.

3. Final Answer:

   The index was created on a different field, not tags -> Option A

4. Quick Check:

   Index on correct field = fast query [OK]

Hint: Ensure index is on the queried array field [OK]

Common Mistakes:

• Believing multikey indexes don't support element queries
• Thinking $elemMatch is always required
• Assuming MongoDB indexes arrays automatically without createIndex

5. You have a collection users with documents containing an array field roles. You want to create a multikey index on roles but only for users who are active (active: true). Which is the correct way to create a partial multikey index for this?

hard

A. db.users.createIndex({ roles: 1 }, { condition: { active: true } })

B. db.users.createIndex({ roles: 1, active: true })

C. db.users.createIndex({ roles: 1 }, { partialFilterExpression: { active: true } })

D. db.users.createIndex({ roles: 1 }, { filter: { active: true } })

Solution

1. Step 1: Understand partial indexes in MongoDB

   Partial indexes use partialFilterExpression to index only documents matching a filter.

2. Step 2: Apply partialFilterExpression with multikey index

   Creating an index on roles with partialFilterExpression: { active: true } indexes only active users' roles.

3. Final Answer:

   db.users.createIndex({ roles: 1 }, { partialFilterExpression: { active: true } }) -> Option C

4. Quick Check:

   Use partialFilterExpression for conditional multikey index [OK]

Hint: Use partialFilterExpression option for conditional indexes [OK]

Common Mistakes:

• Using invalid options like filter or condition
• Trying to include filter in index key object
• Not knowing partialFilterExpression syntax