Schema versioning strategies in MongoDB - Mini Project: Build & Apply

Schema Versioning Strategies in MongoDB

📖 Scenario: You work for a company that stores user profiles in a MongoDB collection. Over time, the profile structure changes as new features are added. You need to manage different versions of the user profile schema to keep the data consistent and allow smooth upgrades.

🎯 Goal: Build a MongoDB document structure that includes a schema version field and write queries to handle documents based on their schema version.

📋 What You'll Learn

Create a MongoDB collection with user profile documents including a schemaVersion field.

Add a configuration variable to represent the current schema version.

Write a query to find all user profiles with an older schema version.

Write a query to update user profiles to the latest schema version.

💡 Why This Matters

🌍 Real World

Managing schema versions in MongoDB helps keep data consistent as applications evolve and new features require changes to data structure.

💼 Career

Database developers and administrators often need to handle schema migrations and versioning to ensure smooth application upgrades and data integrity.

1

Create initial user profiles with schema version

Create a MongoDB collection called userProfiles and insert three documents with the exact fields: name, email, and schemaVersion. Use these exact values: { name: "Alice", email: "[e-mail]", schemaVersion: 1 }, { name: "Bob", email: "[e-mail]", schemaVersion: 1 }, { name: "Charlie", email: "[e-mail]", schemaVersion: 2 }.

MongoDB

// Insert the three user profile documents with schemaVersion
// Your code here

Hint

Use insertMany to add multiple documents to the userProfiles collection.

2

Set current schema version variable

Create a variable called currentSchemaVersion and set it to the number 2 to represent the latest schema version.

MongoDB

db.userProfiles.insertMany([
  { name: "Alice", email: "[e-mail]", schemaVersion: 1 },
  { name: "Bob", email: "[e-mail]", schemaVersion: 1 },
  { name: "Charlie", email: "[e-mail]", schemaVersion: 2 }
])

// Create currentSchemaVersion variable
// Your code here

Hint

Use const to declare the variable currentSchemaVersion and assign it the value 2.

3

Query user profiles with older schema versions

Write a MongoDB query to find all documents in userProfiles where schemaVersion is less than currentSchemaVersion. Use the variable currentSchemaVersion in your query.

MongoDB

db.userProfiles.insertMany([
  { name: "Alice", email: "[e-mail]", schemaVersion: 1 },
  { name: "Bob", email: "[e-mail]", schemaVersion: 1 },
  { name: "Charlie", email: "[e-mail]", schemaVersion: 2 }
])

const currentSchemaVersion = 2

// Find user profiles with schemaVersion less than currentSchemaVersion
// Your code here

Hint

Use find with a query object that uses $lt to compare schemaVersion with currentSchemaVersion.

4

Update old user profiles to latest schema version

Write a MongoDB update query to set the schemaVersion field to currentSchemaVersion for all documents in userProfiles where schemaVersion is less than currentSchemaVersion. Use updateMany.

MongoDB

db.userProfiles.insertMany([
  { name: "Alice", email: "[e-mail]", schemaVersion: 1 },
  { name: "Bob", email: "[e-mail]", schemaVersion: 1 },
  { name: "Charlie", email: "[e-mail]", schemaVersion: 2 }
])

const currentSchemaVersion = 2

const oldProfiles = db.userProfiles.find({ schemaVersion: { $lt: currentSchemaVersion } })

// Update old profiles to currentSchemaVersion
// Your code here

Hint

Use updateMany with a filter for documents with older schema versions and set their schemaVersion to currentSchemaVersion.

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