How do CRUD operations work in MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) operations in MongoDB use methods on collections. They work with documents and use a flexible, JSON-like query syntax — different from SQL but conceptually similar.

## Create — insert documents

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Read — query documents

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

Queries use a **filter document** (`{ field: value }`) describing what to match, with operators (`$gt`, `$lt`, `$in`, etc.) for conditions. Projection (`{ name: 1 }`) selects which fields to return.

## Update — modify documents

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

Updates take a **filter** (which documents) and an **update document** using **operators** like `$set` (set a field), `$inc` (increment), `$push` (add to an array) — you don't replace the whole document (unless intended).

## Delete — remove documents

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
```

## Why it matters

CRUD operations are the foundation of working with any database, so understanding how they work in MongoDB is essential everyday knowledge for using it.

The operations — **inserting** documents (`insertOne`/`insertMany`), **querying** with filter documents and operators (`find`/`findOne` with `{ field: value }` filters, comparison operators like `$gt`, and projections to select fields), **updating** with filters and update operators (`updateOne`/`updateMany` with `$set`, `$inc`, etc.), and **deleting** (`deleteOne`/`deleteMany`) — are how applications create, read, modify, and remove data in MongoDB, which is the core of most database interaction.

Understanding MongoDB's distinctive approach is important: queries use a **filter document** (a JSON-like object describing what to match, with operators) rather than SQL's `WHERE` syntax, and updates use **update operators** (`$set` to change fields, `$inc` to increment, `$push` for arrays) rather than full-document replacement — a different but learnable model.

Since CRUD is the fundamental, constant operation in any data-driven application, and since MongoDB's CRUD methods, filter-document queries, and update operators are how you interact with the database day-to-day, understanding MongoDB CRUD operations — the methods, the filter/operator query syntax, and the update operators — is essential, must-know knowledge for any MongoDB development, the equivalent of knowing SELECT/INSERT/UPDATE/DELETE for SQL and the practical foundation for working with the database.