CRUD в MongoDB

db.users.insertOne({
    email: 'alice@example.com',
    name: 'Алиса',
    age: 30,
})

db.users.insertMany([
    { email: 'a@b.com', name: 'Алиса' },
    { email: 'c@d.com', name: 'Боб' },
], { ordered: false })

const result = await users.insertOne({ ... })
result.insertedId  // ObjectId

db.users.find()

db.users.findOne({ email: 'a@b.com' })

db.users.find(
    { is_active: true },
    { email: 1, name: 1, _id: 0 }
)

db.users.find().sort({ created_at: -1 }).limit(10)

const cursor = db.users
    .find()
    .sort({ created_at: -1 })
    .skip(20)
    .limit(10)

// page 1
db.users.find().sort({ _id: 1 }).limit(10)

// page 2 — после last_id
const last = '...'
db.users.find({ _id: { $gt: ObjectId(last) } }).sort({ _id: 1 }).limit(10)

db.users.updateOne(
    { _id: userId },
    { $set: { name: 'Новое' } }
)

db.users.updateMany(
    { age: { $lt: 18 } },
    { $set: { is_minor: true } }
)

db.users.updateOne(
    { email: 'a@b.com' },
    { $set: { name: 'Алиса' } },
    { upsert: true }
)

db.users.replaceOne(
    { _id: userId },
    { email: 'new@b.com', name: 'New' }
)
// ⚠️ Всё, что не указано — удаляется

db.users.deleteOne({ _id: userId })

db.users.deleteMany({ is_inactive: true })

db.users.deleteMany({})

{ age: 25 }
{ age: { $eq: 25 } }
{ age: { $ne: 25 } }
{ age: { $gt: 18 } }
{ age: { $gte: 18 } }
{ age: { $lt: 65 } }
{ age: { $lte: 65 } }
{ age: { $in: [18, 25, 30] } }
{ age: { $nin: [1, 2, 3] } }

{ $and: [{ age: { $gte: 18 } }, { country: 'RU' }] }
{ $or: [{ status: 'paid' }, { status: 'shipped' }] }
{ $nor: [{ a: 1 }, { b: 2 }] }
{ age: { $not: { $gt: 18 } } }

{ bio: { $exists: true } }
{ bio: { $exists: false } }
{ age: { $type: 'int' } }
{ age: { $type: ['int', 'double'] } }

{ email: { $regex: '^a', $options: 'i' } }
// $options: i — case-insensitive, m — multiline, x — extended

// Или через литерал
{ email: /^a/i }

{ tags: 'php' }                  // содержит php
{ tags: ['php', 'js'] }          // точно этот массив
{ tags: { $all: ['php', 'js'] } } // содержит все
{ tags: { $size: 3 } }            // длина 3
{ tags: { $elemMatch: { $gt: 5, $lt: 10 } } }  // хотя бы один элемент подходит

{ 'address.city': 'Москва' }              // точечная нотация
{ address: { city: 'Москва', street: 'X' } }  // точное совпадение документа (порядок важен)

{ $and: [{ age: { $gte: 18 } }, { age: { $lte: 65 } }] }

{ $or: [{ status: 'paid' }, { status: 'shipped' }] }

{
    $and: [
        { $or: [{ status: 'paid' }, { status: 'shipped' }] },
        { created_at: { $gte: ISODate('2026-01-01') } },
    ],
}

{ age: { $gte: 18 }, country: 'RU' }
// = { $and: [{ age: { $gte: 18 } }, { country: 'RU' }] }

// ❌ Ошибка — второй перезапишет первый
{ age: { $gte: 18 }, age: { $lte: 65 } }

// ✅
{ $and: [{ age: { $gte: 18 } }, { age: { $lte: 65 } }] }
// Или короче
{ age: { $gte: 18, $lte: 65 } }

{ email: 1, name: 1 }
// _id тоже включится

{ password: 0, metadata: 0 }

{ email: 1, _id: 0 }

{ 'items.name': 1 }
// вернёт items как массив объектов только с name

{ comments: { $slice: 5 } }        // первые 5
{ comments: { $slice: -5 } }       // последние 5
{ comments: { $slice: [10, 5] } } // с 10-го, 5 штук

{ items: { $elemMatch: { price: { $gt: 100 } } } }
// вернёт только первый подходящий элемент

.sort({ created_at: -1 })
.sort({ age: 1, name: -1 })   // два поля

.sort({ 'address.city': 1 })

.sort({ tags: 1 })   // по минимальному элементу

.find().limit(10)
.find().skip(20).limit(10)
.find().batchSize(100)   // размер батча по сети

const cursor = db.users.find({ is_active: true })
while (await cursor.hasNext()) {
    const doc = await cursor.next()
    // ...
}

db.users.countDocuments({ is_active: true })
db.users.estimatedDocumentCount()   // быстрее, но приблизительно

db.users.distinct('country')
// [ 'RU', 'US', 'DE' ]

db.users.distinct('tags')
// все теги без дублей

db.users.find({ country: 'RU', age: { $gte: 18 } })

db.orders.find({
    status: 'paid',
    created_at: { $gte: new Date(Date.now() - 7 * 86400 * 1000) },
}).sort({ created_at: -1 })

db.products.find({
    tags: 'sale',
    price: { $lt: NumberDecimal('1000') },
})

db.users.find({ bio: { $exists: false } })
// или
db.users.find({ bio: null })

db.users.find({ email: 'a@b.com' }).explain('executionStats')

db.users.createIndex({ email: 1 })
db.users.createIndex({ country: 1, age: -1 })
db.users.createIndex({ tags: 1 })
db.users.createIndex({ 'address.city': 1 })
db.users.createIndex({ email: 1 }, { unique: true })

db.users.getIndexes()

const session = db.getMongo().startSession()
session.startTransaction()

try {
    const users = session.getDatabase('myapp').users
    const accounts = session.getDatabase('myapp').accounts

    await users.updateOne(
        { _id: fromId },
        { $inc: { balance: -100 } },
        { session }
    )
    await accounts.updateOne(
        { _id: toId },
        { $inc: { balance: 100 } },
        { session }
    )

    await session.commitTransaction()
} catch (e) {
    await session.abortTransaction()
    throw e
} finally {
    await session.endSession()
}

db.users.bulkWrite([
    { insertOne: { document: { email: 'a@b.com' } } },
    { updateOne: { filter: { email: 'c@d.com' }, update: { $set: { name: 'X' } } } },
    { deleteOne: { filter: { email: 'x@y.com' } } },
])

COLLSCAN по миллионам

{ $and: [{ a: 1 }, { b: 2 }] }   // = { a: 1, b: 2 }

{ age: { $gte: 18 }, age: { $lte: 65 } }   // ошибка

skip(1000000) — медленно

Стирает поля

Медленнее, индексы остаются

Дорого

Медленно