Schema versioning strategies in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Output of schema version check query

Given a MongoDB collection users where each document has a schemaVersion field, what is the output of this query?

db.users.find({ schemaVersion: { $lt: 3 } }).count()

Assuming the collection has 5 documents with schemaVersion values: 1, 2, 3, 4, 5.

MongoDB

db.users.find({ schemaVersion: { $lt: 3 } }).count()

A 3

B 5

C 2

D 0

💡 Hint

Count documents where schemaVersion is less than 3.

Documents with schemaVersion 1 and 2 match the condition, so count is 2.

🧠 Conceptual

intermediate

Choosing a schema versioning strategy

Which schema versioning strategy is best when you want to keep old and new document formats in the same MongoDB collection and handle them differently in your application?

A Add a <code>schemaVersion</code> field and write application logic to handle each version

B Create a new collection for each schema version

C Overwrite old documents with new schema without versioning

D Use MongoDB transactions to lock schema changes

💡 Hint

Think about how to identify document versions inside the same collection.

Adding a schemaVersion field allows the application to detect and handle different document formats in one collection.

🔧 Debug

advanced

Identify the error in schema migration script

This MongoDB migration script aims to update all documents from schemaVersion 1 to 2 by adding a new field status with value active. What error will this script cause?

db.users.updateMany(
  { schemaVersion: 1 },
  { $set: { status: 'active' }, $inc: { schemaVersion: 1 } }
)

A Update does not change <code>schemaVersion</code> field

B No error, updates documents correctly

C Runtime error because <code>schemaVersion</code> is not numeric

D SyntaxError due to incorrect update operators usage

💡 Hint

Check if multiple update operators are combined correctly in one update document.

No error, the script correctly uses multiple update operators ($set and $inc) at the top level of the update document.

❓ optimization

advanced

Optimizing schema version queries

You have a large MongoDB collection with mixed schema versions. You often query documents with schemaVersion 3. Which index will optimize these queries best?

A { schemaVersion: 1 }

B { status: 1 }

C { schemaVersion: 1, createdAt: -1 }

D { createdAt: -1 }

💡 Hint

Index fields used in query filters for faster lookups.

An index on schemaVersion speeds up queries filtering by that field.

🧠 Conceptual

expert

Handling schema evolution with minimal downtime

What is the best approach to evolve MongoDB document schemas in a live system with zero downtime and backward compatibility?

A Drop the collection and recreate it with the new schema

B Disable writes during schema migration

C Update all documents in a single blocking migration operation

D Use a schemaVersion field and write application code to support multiple versions simultaneously

💡 Hint

Consider how to keep the system running while supporting old and new data formats.

Using a schemaVersion field allows the application to read and write documents in different formats without downtime.

Practice

1. What is the main purpose of adding a schemaVersion field in MongoDB documents?

easy

A. To track changes in the document structure over time

B. To improve query performance automatically

C. To encrypt the document data

D. To store user authentication details

Solution

1. Step 1: Understand schemaVersion role

   The schemaVersion field is used to mark which version of the document structure is currently in use.

2. Step 2: Identify its purpose in schema versioning

   This helps developers know what format the data is in and apply necessary migrations when the schema changes.

3. Final Answer:

   To track changes in the document structure over time -> Option A

4. Quick Check:

   schemaVersion tracks structure changes = C [OK]

Hint: Remember schemaVersion marks document format version [OK]

Common Mistakes:

• Thinking schemaVersion improves query speed
• Confusing schemaVersion with encryption
• Assuming schemaVersion stores user info

2. Which of the following is the correct way to add a schemaVersion field with value 2 to a MongoDB document using an update query?

easy

A. db.collection.updateOne({ _id: id }, { $push: { schemaVersion: 2 } })

B. db.collection.updateOne({ _id: id }, { schemaVersion: 2 })

C. db.collection.updateOne({ _id: id }, { $set: { schemaVersion: 2 } })

D. db.collection.updateOne({ _id: id }, { $inc: { schemaVersion: 2 } })

Solution

1. Step 1: Recall MongoDB update syntax

   To set or update a field, use the $set operator with the new value.

2. Step 2: Check each option

   db.collection.updateOne({ _id: id }, { $set: { schemaVersion: 2 } }) correctly uses $set to assign schemaVersion: 2. Bare object updates lack an update operator (invalid), $push is for arrays, and $inc increments numbers.

3. Final Answer:

   db.collection.updateOne({ _id: id }, { $set: { schemaVersion: 2 } }) -> Option C

4. Quick Check:

   Use $set to update fields = A [OK]

Hint: Use $set to add or update fields in MongoDB [OK]

Common Mistakes:

• Forgetting to use $set operator
• Using $push for non-array fields
• Using $inc to set a fixed value

3. Given the following documents in a collection:

{ "_id": 1, "name": "Alice", "schemaVersion": 1 }

{ "_id": 2, "name": "Bob", "schemaVersion": 2 }

What will be the result of this query?

db.collection.find({ schemaVersion: { $lt: 2 } })

medium

A. [{ "_id": 1, "name": "Alice", "schemaVersion": 1 }, { "_id": 2, "name": "Bob", "schemaVersion": 2 }]

B. [{ "_id": 2, "name": "Bob", "schemaVersion": 2 }]

C. []

D. [{ "_id": 1, "name": "Alice", "schemaVersion": 1 }]

Solution

1. Step 1: Understand the query condition

   The query filters documents where schemaVersion is less than 2.

2. Step 2: Check each document against condition

   Document with schemaVersion 1 matches (1 < 2). Document with 2 does not (2 is not less than 2).

3. Final Answer:

   [{ "_id": 1, "name": "Alice", "schemaVersion": 1 }] -> Option D

4. Quick Check:

   schemaVersion < 2 returns only version 1 docs = D [OK]

Hint: Check numeric conditions carefully in queries [OK]

Common Mistakes:

• Including documents with schemaVersion equal to 2
• Returning empty result incorrectly
• Confusing $lt with $lte operator

4. You have a migration script to update documents from schemaVersion 1 to 2. The script uses:

db.collection.updateMany({ schemaVersion: 1 }, { $set: { schemaVersion: 2, newField: true } })

But after running, some documents still show schemaVersion 1. What is a likely cause?

medium

A. Documents were missing the schemaVersion field

B. The update query syntax is incorrect

C. The updateMany command does not support $set

D. The migration script ran on the wrong collection

Solution

1. Step 1: Analyze the update query filter

   The filter matches documents where schemaVersion equals 1 exactly.

2. Step 2: Consider documents missing the field

   If some documents lack the schemaVersion field, they won't match the filter and won't be updated.

3. Final Answer:

   Documents were missing the schemaVersion field -> Option A

4. Quick Check:

   Missing field means no match = B [OK]

Hint: Check if all docs have the field before filtering [OK]

Common Mistakes:

• Assuming updateMany syntax is wrong
• Believing $set is unsupported in updateMany
• Not verifying the collection name

5. You want to migrate documents from multiple schema versions to the latest version 3. Your current documents have schemaVersion 1 or 2. Which strategy best ensures all documents are updated correctly?

hard

A. Directly update all documents with version 1 or 2 to version 3 in one step

B. Run separate migration scripts: first update version 1 to 2, then update version 2 to 3

C. Delete all documents with version less than 3 and insert new ones

D. Ignore schemaVersion and update documents randomly

Solution

1. Step 1: Understand incremental migrations

   Updating schema versions step-by-step ensures each migration applies necessary changes safely.

2. Step 2: Evaluate options

   Run separate migration scripts: first update version 1 to 2, then update version 2 to 3 runs migrations in order: 1 to 2, then 2 to 3, preserving data integrity. Directly update all documents with version 1 or 2 to version 3 in one step risks skipping intermediate changes. Delete all documents with version less than 3 and insert new ones loses data. Ignore schemaVersion and update documents randomly is unsafe.

3. Final Answer:

   Run separate migration scripts: first update version 1 to 2, then update version 2 to 3 -> Option B

4. Quick Check:

   Incremental migrations keep data safe = A [OK]

Hint: Migrate stepwise through versions, not skipping steps [OK]

Common Mistakes:

• Trying to skip intermediate schema versions
• Deleting data instead of migrating
• Ignoring schemaVersion field