MongoDB Update Operations Interview Questions

Introduction

This guide covers essential MongoDB update operations commonly asked in technical interviews. Each question includes detailed answers and practical examples.

Medium

1. What are the different types of update operations in MongoDB?

MongoDB provides several types of update operations:

  • Single document updates (updateOne)
  • Multiple document updates (updateMany)
  • Find and modify operations (findOneAndUpdate)
  • Bulk updates (bulkWrite)
Update Methods:
  • updateOne(): Updates a single document
  • updateMany(): Updates multiple documents
  • findOneAndUpdate(): Finds and updates a document
  • replaceOne(): Replaces a document
  • bulkWrite(): Performs multiple write operations
Hard

2. What are MongoDB update modifiers and how do they work?

MongoDB update modifiers are special operators that modify document fields:

1. Field Update Operators
// $set: Sets the value of a field
db.users.updateOne(
    { email: "john@example.com" },
    { $set: { status: "active" } }
)

// $unset: Removes a field
db.users.updateOne(
    { email: "john@example.com" },
    { $unset: { tempField: "" } }
)

// $rename: Renames a field
db.users.updateOne(
    { email: "john@example.com" },
    { $rename: { "oldField": "newField" } }
)
2. Array Update Operators
// $push: Adds elements to an array
db.users.updateOne(
    { email: "john@example.com" },
    { $push: { roles: "admin" } }
)

// $addToSet: Adds unique elements to an array
db.users.updateOne(
    { email: "john@example.com" },
    { $addToSet: { roles: "user" } }
)

// $pull: Removes elements from an array
db.users.updateOne(
    { email: "john@example.com" },
    { $pull: { roles: "temp" } }
)
Hard

3. How do you perform atomic updates in MongoDB?

Atomic updates in MongoDB ensure operations are performed as a single unit:

1. Using Atomic Operators
// $inc: Increment a field
db.users.updateOne(
    { email: "john@example.com" },
    { $inc: { loginCount: 1 } }
)

// $mul: Multiply a field
db.users.updateOne(
    { email: "john@example.com" },
    { $mul: { points: 1.5 } }
)

// $min/$max: Update if new value is min/max
db.users.updateOne(
    { email: "john@example.com" },
    { $min: { highScore: 100 } }
)
2. Using Transactions
// Start a session
const session = client.startSession();

try {
    session.startTransaction();
    
    // Perform multiple operations
    await db.users.updateOne(
        { email: "john@example.com" },
        { $set: { status: "inactive" } },
        { session }
    );
    
    await db.logs.insertOne({
        action: "deactivate",
        userId: "john@example.com",
        timestamp: new Date()
    }, { session });
    
    await session.commitTransaction();
} catch (error) {
    await session.abortTransaction();
    throw error;
} finally {
    session.endSession();
}
Medium

4. What are the best practices for MongoDB update operations?

Best practices for MongoDB update operations include:

  • Use appropriate update operators
  • Implement proper error handling
  • Use atomic operations when needed
  • Consider performance implications
// Best practice: Use atomic operators
db.users.updateOne(
    { email: "john@example.com" },
    { 
        $set: { status: "active" },
        $inc: { loginCount: 1 },
        $currentDate: { lastLogin: true }
    }
)

// Best practice: Use upsert option
db.users.updateOne(
    { email: "john@example.com" },
    { $set: { status: "active" } },
    { upsert: true }
)

// Best practice: Use write concern
db.users.updateOne(
    { email: "john@example.com" },
    { $set: { status: "active" } },
    { 
        writeConcern: { w: "majority", wtimeout: 5000 }
    }
)

// Best practice: Use bulk operations
db.users.bulkWrite([
    {
        updateOne: {
            filter: { status: "inactive" },
            update: { $set: { status: "active" } }
        }
    },
    {
        updateMany: {
            filter: { lastLogin: { $lt: new Date() } },
            update: { $set: { status: "inactive" } }
        }
    }
])
Hard

5. How do you handle complex update scenarios?

Complex update scenarios require careful consideration of:

1. Conditional Updates
// Update based on conditions
db.users.updateOne(
    { 
        email: "john@example.com",
        status: "active",
        lastLogin: { $lt: new Date() }
    },
    { 
        $set: { status: "inactive" },
        $push: { 
            history: {
                action: "deactivate",
                reason: "inactivity",
                timestamp: new Date()
            }
        }
    }
)
2. Array Updates
// Update array elements
db.users.updateOne(
    { 
        email: "john@example.com",
        "orders.status": "pending"
    },
    { 
        $set: { "orders.$.status": "processing" },
        $currentDate: { "orders.$.updatedAt": true }
    }
)

// Update multiple array elements
db.users.updateOne(
    { email: "john@example.com" },
    { 
        $set: { 
            "orders.$[elem].status": "completed",
            "orders.$[elem].completedAt": new Date()
        }
    },
    { 
        arrayFilters: [{ "elem.status": "processing" }]
    }
)

Next Steps

Continue your MongoDB interview preparation with:

MongoDB Interview Questions