A document is stored in BSON (Binary JSON) format and typically looks like this:

{
  "_id": "ObjectId(...)",
  "name": "John",
  "age": 25
}

Every document contains a unique _id field. If you do not provide one, MongoDB automatically generates an ObjectId.

Create Operations

insertOne()

db.users.insertOne({
  name: "John",
  age: 25
})

insertMany()

db.users.insertMany([
  { name: "John", age: 25 },
  { name: "Alice", age: 30 }
])

Read Operations

find()

db.users.find({})

Filtering Documents

db.users.find({ age: 25 })

Pretty Printing

db.users.find().pretty()

Query Operators

Greater Than ($gt)

db.users.find({
  age: { $gt: 18 }
})

Less Than ($lt)

db.users.find({
  age: { $lt: 50 }
})

Update Operations

updateOne()

db.users.updateOne(
  { name: "John" },
  {
    $set: {
      age: 26
    }
  }
)

updateMany()

db.users.updateMany(
  {},
  {
    $set: {
      active: true
    }
  }
)

Why $set Is Important

Using $set updates only the specified fields. If you want to replace the entire document, use replaceOne().

db.users.replaceOne(
  { name: "John" },
  { age: 30 }
)

Delete Operations

deleteOne()

db.users.deleteOne({
  name: "John"
})

deleteMany()

db.users.deleteMany({
  active: false
})

Understanding MongoDB Cursors

Many developers assume that find() immediately returns all matching documents. It doesn't.

const cursor = db.users.find({})

MongoDB returns a cursor, which acts as a pointer into a result set.

find()
   ↓
Cursor
   ↓
Documents fetched in batches

Why Does MongoDB Use Cursors?

Returning millions of documents at once would consume enormous amounts of memory and network bandwidth. Instead, MongoDB fetches results in batches.

Iterating Through a Cursor

for await (const user of cursor) {
  console.log(user)
}

Converting a Cursor to an Array

const users = await db.users.find({}).toArray()

toArray() loads all matching documents into memory.

Key Takeaways

• MongoDB CRUD consists of Create, Read, Update, and Delete operations.
• insertOne() and insertMany() create documents.
• find() retrieves documents from a collection.
• Query operators such as $gt and $lt allow filtering.
• updateOne() and updateMany() modify documents.
• $set updates specific fields without replacing the entire document.
• deleteOne() and deleteMany() remove documents.
• find() returns a cursor, not the actual data.
• Cursors allow MongoDB to fetch data efficiently in batches.
• toArray() converts a cursor into an in-memory array of documents.