Single field index in MongoDB - Step-by-Step Execution

Concept Flow - Single field index

Create collection

↓

Define index on one field

↓

Insert documents

↓

Query uses index

↓

Faster search on that field

↓

Return matching documents

This flow shows how creating an index on a single field helps MongoDB find documents faster when querying that field.

Execution Sample

MongoDB

db.users.createIndex({ age: 1 })
db.users.insertMany([
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Carol", age: 25 }
])
db.users.find({ age: 25 })

Create an index on the 'age' field, insert documents, then query documents where age is 25.

Execution Table

Step	Action	Details	Result
1	Create index	Index on field 'age' ascending	Index created on 'age'
2	Insert documents	Insert Alice (25), Bob (30), Carol (25)	3 documents added
3	Query documents	Find documents where age = 25	Uses index to find Alice and Carol
4	Return results	Documents matching age=25	[{name: 'Alice', age: 25}, {name: 'Carol', age: 25}]
5	End	No more steps	Query complete

💡 Query completes after returning all documents with age 25 using the index

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Index on age	None	Created	Created	Used in query	Used
Documents in collection	Empty	Empty	3 documents	3 documents	3 documents
Query result	None	None	None	2 documents found	2 documents returned

Key Moments - 2 Insights

Why does the query run faster after creating the index?

Because the index on 'age' lets MongoDB quickly locate documents with age 25 without scanning all documents, as shown in execution_table step 3.

Does the index store the whole document?

No, the index stores the values of the 'age' field and pointers to documents, so it is smaller and faster to search, as implied in step 1 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 3?

A Index is created

B Documents are inserted

C Documents with age 25 are found

D Query ends

💡 Hint

Check the 'Result' column in row with Step 3 in execution_table

At which step are documents added to the collection?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for document insertion

If we did not create the index, how would the query step change?

A Query would scan all documents (slower)

B Query would use the index anyway

C Query would fail

D Query would return no results

💡 Hint

Indexes speed up queries by avoiding full scans, see key_moments explanation

Concept Snapshot

Single field index in MongoDB:
- Created with createIndex({field: 1})
- Speeds up queries filtering on that field
- Index stores field values + pointers
- Query uses index to find matches fast
- Improves read performance without changing data

Full Transcript

This visual execution shows how creating a single field index in MongoDB works. First, an index is created on the 'age' field. Then, documents are inserted into the collection. When a query searches for documents where age equals 25, MongoDB uses the index to quickly find matching documents instead of scanning all documents. The result is faster query performance. The index stores only the 'age' values and pointers to documents, not the whole documents. This example helps beginners see how indexes improve search speed step-by-step.

Practice

1. What is the main purpose of creating a single field index in MongoDB?

easy

A. To backup the database automatically

B. To speed up queries that filter or sort by one specific field

C. To store multiple fields in a single document

D. To create relationships between collections

Solution

1. Step 1: Understand what single field index does

   A single field index helps MongoDB find documents faster when searching or sorting by that one field.

2. Step 2: Compare options with this purpose

   Only To speed up queries that filter or sort by one specific field describes speeding up queries on one field, which matches the purpose of a single field index.

3. Final Answer:

   To speed up queries that filter or sort by one specific field -> Option B

4. Quick Check:

   Single field index = speed up queries on one field [OK]

Hint: Indexes speed up queries on the indexed field [OK]

Common Mistakes:

• Thinking indexes store multiple fields
• Confusing indexes with backups
• Believing indexes create relationships

2. Which of the following is the correct syntax to create a single field ascending index on the field age in MongoDB?

easy

A. db.collection.createIndex({ 'age' => 1 })

B. db.collection.createIndex(age: 1)

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

D. db.collection.createIndex({ age: 'asc' })

Solution

1. Step 1: Recall correct syntax for createIndex

   The correct syntax uses an object with the field name as key and 1 for ascending order: createIndex({ field: 1 }).

2. Step 2: Check each option

   db.collection.createIndex({ age: 1 }) matches the correct syntax exactly. The other options use invalid syntax or wrong symbols.

3. Final Answer:

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

4. Quick Check:

   Correct syntax = createIndex({ field: 1 }) [OK]

Hint: Use curly braces and 1 for ascending index [OK]

Common Mistakes:

• Missing curly braces around the field
• Using wrong symbols like =>
• Using string 'asc' instead of 1

3. Given the following commands run on a MongoDB collection:

db.users.createIndex({ username: 1 })
db.users.find({ username: 'alice' })

What is the effect of the index on the find query?

medium

A. The query will use the index to find documents faster

B. The query will cause an error due to index usage

C. The query will ignore the index and scan all documents

D. The query will run slower because of the index

Solution

1. Step 1: Understand index effect on find queries

   Creating an index on 'username' helps MongoDB quickly locate documents matching that field.

2. Step 2: Analyze the find query

   The find query filters by username 'alice', so it will use the index to speed up the search.

3. Final Answer:

   The query will use the index to find documents faster -> Option A

4. Quick Check:

   Index on field = faster find queries on that field [OK]

Hint: Find queries on indexed field run faster [OK]

Common Mistakes:

• Assuming indexes slow down queries
• Thinking queries ignore indexes
• Believing index causes errors

4. You tried to create a single field index on email using this command:

db.users.createIndex(email: 1)

What is the problem with this command?

medium

A. Indexes cannot be created on the email field

B. Using 1 instead of 'asc' for ascending order

C. The field name should be a string in quotes

D. Missing curly braces around the field and order

Solution

1. Step 1: Check syntax for createIndex

   The argument to createIndex must be an object with curly braces: { field: 1 }.

2. Step 2: Identify error in given command

   The command lacks curly braces around email: 1, so it is invalid syntax.

3. Final Answer:

   Missing curly braces around the field and order -> Option D

4. Quick Check:

   createIndex needs { field: 1 } syntax [OK]

Hint: Always use curly braces for index fields [OK]

Common Mistakes:

• Omitting curly braces
• Using strings instead of numbers for order
• Thinking any field cannot be indexed

5. You want to speed up queries that sort users by their score field in descending order. Which command correctly creates a single field index to optimize this?

hard

A. db.users.createIndex({ score: -1 })

B. db.users.createIndex({ score: 1 })

C. db.users.createIndex({ score: 'desc' })

D. db.users.createIndex({ score: 0 })

Solution

1. Step 1: Understand index order for sorting

   To optimize descending sort, the index must be created with -1 for descending order.

2. Step 2: Evaluate each option

   db.users.createIndex({ score: -1 }) uses { score: -1 } which is correct. The option with { score: 1 } is ascending order, the option with { score: 'desc' } uses invalid string, the option with { score: 0 } uses 0 which is invalid.

3. Final Answer:

   db.users.createIndex({ score: -1 }) -> Option A

4. Quick Check:

   Descending index = { field: -1 } [OK]

Hint: Use -1 for descending index order [OK]

Common Mistakes:

• Using 1 for descending sort
• Using strings like 'desc' instead of numbers
• Using 0 which is invalid