Learning MongoDB - Update & Delete Operations

#Introduction

In episode 3 you could already store and read data. Now it's time to complete the CRUD phase with the last two operations: Update and Delete. Both sound trivial, but in the real world this is exactly where a lot of data gets corrupted — a wrong update can wipe out valuable fields, and a delete with the wrong filter can destroy an entire collection.

Episode 4 will build your confidence in mutation operations. The roadmap: first we learn the four update methods — updateOne, updateMany, replaceOne, and findOneAndUpdate; second we dissect update operators for fields and arrays; third we discuss deletes; and finally we master the clever upsert pattern. Let's get started.

#Update Operations

#updateOne and updateMany

These two functions update documents based on a filter. The difference is only in the number of documents processed: updateOne updates the first matching document, updateMany updates all that match. The syntax is always of the form { filter, update }:

db.products.updateOne(
  { name: "Sneaker" },
  { $set: { price: 425000 } }
)
 
db.products.updateMany(
  { category: "elektronik" },
  { $set: { onSale: true } }
)

Notice the $set operator — it adds or changes specific fields without touching other fields. It's the safest and most frequently used operator.

#replaceOne: Replacing the Entire Document

Unlike $set, which changes part of the fields, replaceOne replaces the entire document with a new one (except for _id, which is preserved). It's used when you want to completely rewrite a document:

db.users.replaceOne(
  { email: "siti@example.com" },
  { name: "Siti Rahmawati", email: "siti@example.com", role: "mentor" }
)

The hidden danger here: old documents with fields not mentioned in the new document will lose them. Before using replaceOne, make sure you really intend to discard all the old fields.

#findOneAndUpdate: Update and Return the Document

findOneAndUpdate performs the update and immediately returns the document — a single atomic operation, without needing a separate query. By default it returns the document before it was changed; use the { returnDocument: "after" } option to get the post-update version:

db.users.findOneAndUpdate(
  { email: "siti@example.com" },
  { $inc: { loginCount: 1 } },
  { returnDocument: "after" }
)

The example above increments loginCount by 1 and immediately returns the updated document — a common pattern for login counters or process statuses.

#Update Operators

#Field Operators

Besides $set, there are other operators that serve different update patterns:

db.products.updateOne(
  { name: "Laptop Gaming" },
  {
    $inc: { stock: -1 },
    $mul: { price: 0.95 },
    $set: { lastSoldAt: ISODate() },
    $currentDate: { updatedAt: true }
  }
)

A single call can hold many operators at once — all executed atomically on the document.

#Array Operators

Array data is a strength of the document database, and MongoDB has dedicated operators to manipulate it:

db.users.updateOne(
  { email: "siti@example.com" },
  {
    $push: { skills: { $each: ["mongodb", "docker"], $position: 0 } },
    $addToSet: { tags: "backend" }
  }
)
 
db.users.updateOne(
  { email: "siti@example.com" },
  { $pull: { skills: "docker" } }
)

The first example adds two skills at once to the beginning of the array and adds the backend tag without duplicates. The second example pulls the docker skill out. These patterns are very useful for lists, shopping carts, or tags.

#Delete Operations

#deleteOne and deleteMany

Deleting data in MongoDB is as easy as updating it — and just as dangerous:

db.products.deleteOne({ name: "Kaos Polos" })
 
db.sessions.deleteMany({ expiresAt: { $lt: ISODate() } })

deleteOne removes the first matching document, deleteMany removes all that match. Note the second example: this kind of expired-data cleanup pattern is very common in the real world.

#findOneAndDelete

Like findOneAndUpdate, findOneAndDelete deletes a single document and immediately returns it. Useful when you need the deleted data for further processing (e.g. moving it to an archive):

const deleted = db.orders.findOneAndDelete({ _id: ObjectId("66xxxxxxxxxxxxxxxxxxxxxxxx") })
deleted

With this, you can take the deleted document and save it to an archive collection in a follow-up operation.

#The Upsert Pattern

Upsert is a clever pattern that combines insert and update: if no document matches the filter, MongoDB creates it; if one already exists, MongoDB updates it. Enable it with the { upsert: true } option:

db.users.updateOne(
  { email: "budi@example.com" },
  { $set: { name: "Budi Santoso", loginCount: 1 } },
  { upsert: true }
)

Run the same command twice and compare the results: the first time MongoDB performs an insert (with an upsertedId in the result), the second time it performs an update. Upserts are very useful for visit counters, user sessions, or synchronizing data from external APIs.

#Conclusion

In episode 4 you completed the CRUD operations. For Update: updateOne and updateMany for partial mutations, replaceOne for full replacement, and findOneAndUpdate, which returns the document atomically. For Delete: deleteOne, deleteMany, and findOneAndDelete. You also mastered field update operators ($set, $inc, $unset, and others), array operators ($push, $pull, $addToSet), and the upsert pattern that combines insert and update.

Key takeaways:

• updateOne vs updateMany are distinguished by the number of documents processed.
• $set changes specific fields; replaceOne replaces the entire document.
• findOneAndUpdate with returnDocument: "after" returns the latest version.
• Array operators like $push, $pull, and $addToSet keep arrays tidy.
• upsert: true creates a new document if the filter doesn't match — watch out for accidental creation.

In the next episode, episode 5, we deepen querying capabilities: Advanced Query Filters & Operators. You'll use comparison operators $gt, $in, and $ne, logical operators $and, $or, $nor, element operators $exists and $type, array operators $all, $elemMatch, and $size, as well as learn sorting, limit, skip, and pagination. See you in episode 5!