MongoDB CRUD 基础与 Shell 操作

// 连接本地默认端口（27017）上的 MongoDB 实例
mongosh

// 连接并直接切换到指定数据库
mongosh "mongodb://localhost:27017/mydb"

// 使用带有用户名和密码验证的完整连接字符串
mongosh "mongodb://username:password@localhost:27017/mydb?authSource=admin"

// 连接三节点副本集（Replica Set），驱动会自动发现主节点
mongosh "mongodb://user:pass@node1:27017,node2:27017,node3:27017/mydb?replicaSet=rs0"

// 连接分片集群（通过 mongos 路由节点访问）
mongosh "mongodb://mongos1:27017,mongos2:27017/mydb"

// 连接 MongoDB Atlas 云托管服务（使用 SRV 记录自动解析集群节点）
mongosh "mongodb+srv://user:pass@cluster0.mongodb.net/mydb?retryWrites=true&w=majority"

// 查看当前正在使用的数据库名称
db

// 列出当前实例中所有数据库（执行此命令需要 listDatabases 权限）
show dbs

// 切换到指定数据库，若不存在则创建（MongoDB 采用惰性创建策略，首次写入时才真正创建）
use mydb

// 列出当前数据库下所有集合（Collections 类比关系型数据库的"表"）
show collections

// 查看当前服务器的运行状态，包括内存、连接数、操作计数器、锁状态等
db.serverStatus()

// 查看当前数据库的统计概览：文档数、索引数、数据大小、存储大小等
db.stats()

// 查看特定集合的统计信息
db.users.stats()

// 获取数据库级别的帮助文档
db.help()

// 获取集合级别的帮助文档
db.users.help()

// 查看集合的索引信息
db.users.getIndexes()

// 清空当前数据库中的所有集合（危险操作，生产环境禁用）
db.dropDatabase()

// 删除指定集合
db.users.drop()

// ~/.mongoshrc.js
// 开启慢查询分析，自动记录执行超过 100 毫秒的操作
db.setProfilingLevel(1, { slowms: 100 })

// 定义自定义提示符，显示当前数据库名和 ISO 格式时间
prompt = function() {
  return db.getName() + " [" + new Date().toISOString() + "] > ";
};

// 设置默认打印文档数量，防止意外输出百万级数据
db.getMongo().setReadPref("primaryPreferred")

// 正确：插入标准的 Date 类型
db.events.insertOne({ createdAt: new Date(), eventName: "user_login" })

// 错误：插入的是普通字符串 "new Date()"
db.events.insertOne({ createdAt: "new Date()", eventName: "user_login" })

// 向 users 集合插入一条典型用户文档
db.users.insertOne({
  name: "张三",
  email: "zhangsan@example.com",
  age: 28,
  tags: ["developer", "mongodb", "backend"],
  address: {
    city: "北京",
    district: "海淀区",
    zipCode: "100089"
  },
  isVip: false,
  balance: NumberDecimal("1280.50"),
  createdAt: new Date(),
  updatedAt: new Date()
})

{
  acknowledged: true,
  insertedId: ObjectId("64a1b2c3d4e5f6a7b8c9d0e1")
}

// 批量插入 3 条用户文档
db.users.insertMany([
  { name: "李四", email: "lisi@example.com", age: 32, status: "active", createdAt: new Date() },
  { name: "王五", email: "wangwu@example.com", age: 25, status: "pending", createdAt: new Date() },
  { name: "赵六", email: "zhaoliu@example.com", age: 45, status: "active", createdAt: new Date() },
  { name: "孙七", email: "sunqi@example.com", age: 19, status: "inactive", createdAt: new Date() }
])

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("64a1b2c3d4e5f6a7b8c9d0e2"),
    '1': ObjectId("64a1b2c3d4e5f6a7b8c9d0e3"),
    '2': ObjectId("64a1b2c3d4e5f6a7b8c9d0e4"),
    '3': ObjectId("64a1b2c3d4e5f6a7b8c9d0e5")
  }
}

// 有序插入示例：第三条因 email 重复而失败，第四条不会被处理
db.users.insertMany(
  [
    { name: "张三", email: "unique_a@example.com" },
    { name: "李四", email: "unique_b@example.com" },
    { name: "重复用户", email: "unique_a@example.com" },  // 违反唯一索引
    { name: "王五", email: "unique_c@example.com" }       // 不会被执行
  ],
  { ordered: true }
)
// 结果：前两条插入成功，第三条失败报错，操作终止

// 无序插入：失败不会中断，最大化数据导入量
db.users.insertMany(
  [
    { name: "张三", email: "batch01@example.com" },
    { name: "李四", email: "batch02@example.com" },
    { name: "重复A", email: "batch01@example.com" },   // 重复，失败
    { name: "重复B", email: "batch02@example.com" },   // 重复，失败
    { name: "王五", email: "batch03@example.com" }     // 仍然会被插入
  ],
  { ordered: false }
)
// 结果：第一条、第二条、第五条插入成功；第三条、第四条失败写入 writeErrors

// 场景一：使用业务自然键作为主键，减少冗余索引
db.products.insertOne({
  _id: "SKU-2026-8848",
  name: "机械键盘 K8",
  category: "数码外设",
  price: NumberDecimal("498.00"),
  stock: 120
})

// 场景二：与 MySQL 等外部关系型数据库的主键对齐
db.orders.insertOne({
  _id: NumberLong(1000001),
  mysqlOrderId: 1000001,
  userId: 5043,
  totalAmount: NumberDecimal("2599.00"),
  createdAt: new Date()
})

// 场景三：使用 UUID 保证跨数据中心的全局唯一性
db.logs.insertOne({
  _id: UUID("550e8400-e29b-41d4-a716-446655440000"),
  level: "ERROR",
  message: "Connection timeout",
  timestamp: new Date()
})

// 初始化计数器
db.counters.insertOne({ _id: "order_seq", seq: 0 })

// 获取下一个序列值的辅助函数
function getNextSequence(name) {
  var ret = db.counters.findOneAndUpdate(
    { _id: name },
    { $inc: { seq: 1 } },
    { returnDocument: "after", upsert: true }
  )
  return ret.seq
}

// 插入时使用自增 ID
db.orders.insertOne({
  _id: getNextSequence("order_seq"),
  customerName: "张三",
  total: 580,
  createdAt: new Date()
})

// 最高安全级别：等待大多数副本节点写入磁盘日志后再返回
// 适用于金融交易、订单状态变更等关键业务
db.users.insertOne(
  { name: "重要用户", balance: NumberDecimal("10000.00") },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
)

// 默认安全级别：等待主节点（Primary）确认即可
// 适用于一般业务数据，兼顾性能与一致性
db.users.insertOne(
  { name: "普通用户", tags: ["standard"] },
  { writeConcern: { w: 1 } }
)

// 最低安全级别：发后即忘（Fire and Forget）
// 适用于日志、监控指标等非关键数据，追求极致写入吞吐量
db.logs.insertOne(
  { level: "INFO", message: "Page visited", timestamp: new Date() },
  { writeConcern: { w: 0 } }
)

// 精确匹配：查找姓名为 "张三" 的用户
db.users.find({ name: "张三" })

// 精确匹配布尔值
db.users.find({ isVip: true })

// 精确匹配内嵌文档（注意：内嵌文档必须完全匹配，包括字段顺序）
db.users.find({ address: { city: "北京", district: "海淀区" } })

// 匹配内嵌文档的某个字段（更推荐的方式）
db.users.find({ "address.city": "北京" })

// $eq ：等于（equal，可省略不写）
db.users.find({ age: { $eq: 28 } })
db.users.find({ age: 28 }) // 二者等价

// $ne ：不等于（not equal）
db.users.find({ status: { $ne: "deleted" } })

// $gt / $gte ：大于 / 大于等于（greater than / greater than or equal）
db.users.find({ age: { $gt: 25 } })
db.users.find({ age: { $gte: 18 } })

// $lt / $lte ：小于 / 小于等于（less than / less than or equal）
db.users.find({ age: { $lt: 30 } })
db.products.find({ price: { $lte: NumberDecimal("500.00") } })

// 组合范围：18 <= age < 35
db.users.find({ age: { $gte: 18, $lt: 35 } })

// 日期范围查询：查找最近 7 天内创建的文档
// 注意 $gt 在 Date 类型上的行为是大于指定时间戳
db.events.find({
  createdAt: {
    $gte: new Date(new Date() - 7 * 24 * 60 * 60 * 1000)
  }
})

// $in ：字段值等于数组中任意一个元素即可匹配
db.users.find({ status: { $in: ["active", "pending"] } })

// 等效于 SQL：WHERE status IN ('active', 'pending')

// $in 对数组字段同样有效：查找 tags 中包含 "developer" 或 "designer" 的文档
db.users.find({ tags: { $in: ["developer", "designer"] } })

// $nin ：字段值不等于数组中任何一个元素
db.users.find({ status: { $nin: ["banned", "deleted", "suspended"] } })

// $and ：所有条件同时满足（隐式 and）
// 以下三种写法等价
db.users.find({ age: { $gte: 18 }, status: "active" })
db.users.find({ $and: [{ age: { $gte: 18 } }, { status: "active" }] })

// $or ：任一条件满足即可
// 查找状态为 active 或 age 大于 60 的用户
db.users.find({
  $or: [
    { status: "active" },
    { age: { $gt: 60 } }
  ]
})

// $and 与 $or 组合使用
// 查找 "active 且在北京" 或 "age > 60" 的用户
db.users.find({
  $or: [
    { $and: [{ status: "active" }, { "address.city": "北京" }] },
    { age: { $gt: 60 } }
  ]
})

// $not ：对条件取反（作用于表达式或正则）
db.users.find({ age: { $not: { $gte: 18 } } })  // age < 18
db.users.find({ name: { $not: /^张/ } })         // 名字不以"张"开头

// $nor ：所有条件都不满足（相当于 NOT (A OR B)）
db.users.find({
  $nor: [
    { status: "deleted" },
    { isVip: false }
  ]
})

// 查找 tags 字段中包含 "developer" 的文档（至少一个元素匹配即可）
db.users.find({ tags: "developer" })

// $all ：要求数组同时包含所有指定元素（顺序无关）
db.users.find({ tags: { $all: ["developer", "mongodb"] } })

// $size ：精确匹配数组长度
db.users.find({ tags: { $size: 3 } })

// $elemMatch ：数组中至少有一个元素满足所有指定条件
// 查找订单中至少有一件商品的价格高于 500 且数量大于 2
db.orders.find({
  items: {
    $elemMatch: {
      price: { $gt: 500 },
      quantity: { $gt: 2 }
    }
  }
})

// 危险：不使用 $elemMatch 的写法
// 这个查询的含义是：数组中有一个元素的 price > 500，且数组中有一个元素的 quantity > 2
// 但这两个条件可能分别由不同元素满足！
db.orders.find({
  "items.price": { $gt: 500 },
  "items.quantity": { $gt: 2 }
})

// 正确：要求同一元素同时满足 price > 500 和 quantity > 2
db.orders.find({
  items: {
    $elemMatch: {
      price: { $gt: 500 },
      quantity: { $gt: 2 }
    }
  }
})

// 查找 age 字段类型为 double（即 JavaScript Number）的文档
db.users.find({ age: { $type: "double" } })

// 查找 phone 字段存储为字符串的文档（可能其他文档是 NumberLong）
db.users.find({ phone: { $type: "string" } })

// 配合 $exists 检查字段是否缺失
db.users.find({ middleName: { $exists: false } })

// 数据清洗：找出 price 为字符串类型（需要数值化）的商品
db.products.find({ price: { $type: "string" } }).forEach(function(doc) {
  db.products.updateOne(
    { _id: doc._id },
    { $set: { price: NumberDecimal(doc.price) } }
  )
})

// 仅返回 name 和 email 字段（_id 默认返回，可显式排除）
db.users.find(
  { status: "active" },
  { name: 1, email: 1, _id: 0 }
)

// 排除密码字段和内部元数据，返回其余所有字段
db.users.find(
  { status: "active" },
  { passwordHash: 0, internalNotes: 0, auditLog: 0 }
)

// 投影嵌套文档中的特定字段
db.users.find(
  { status: "active" },
  { "address.city": 1, "address.zipCode": 1, name: 1 }
)

// 按年龄升序排列
db.users.find().sort({ age: 1 })

// 先按状态降序（active 在 pending 之前，因为字符串比较），再按创建时间降序
db.users.find().sort({ status: -1, createdAt: -1 })

// 多字段排序：先按城市升序，同城市内按年龄降序
db.users.find().sort({ "address.city": 1, age: -1 })

// 第 1 页，每页 10 条
db.users.find().sort({ createdAt: -1 }).skip(0).limit(10)

// 第 2 页，跳过前 10 条
db.users.find().sort({ createdAt: -1 }).skip(10).limit(10)

// 第 3 页
db.users.find().sort({ createdAt: -1 }).skip(20).limit(10)

// 基于上一页最后一条记录的游标时间戳进行分页（Keyset Pagination）
// 假设上一页最后一条记录的 createdAt 是 2026-08-01T10:00:00Z
var lastCreatedAt = ISODate("2026-08-01T10:00:00Z")
db.users.find({ createdAt: { $lt: lastCreatedAt } })
  .sort({ createdAt: -1 })
  .limit(10)

// 更新单条文档：将张三的手机号和更新时间修改
db.users.updateOne(
  { name: "张三" },
  {
    $set: {
      phone: "13800138000",
      "address.zipCode": "100190",
      updatedAt: new Date()
    }
  }
)

// 返回结果
{
  acknowledged: true,
  matchedCount: 1,
  modifiedCount: 1
}

// 批量更新：将所有 pending 状态用户改为 active
db.users.updateMany(
  { status: "pending" },
  {
    $set: {
      status: "active",
      activatedAt: new Date(),
      updatedAt: new Date()
    }
  }
)

// 给用户的积分余额增加 100
db.users.updateOne(
  { name: "张三" },
  { $inc: { points: 100 } }
)

// 给商品库存扣减 3 件（库存扣减配合条件检查防止超卖）
db.products.updateOne(
  { _id: "SKU-2026-8848", stock: { $gte: 3 } },
  {
    $inc: { stock: -3 },
    $set: { updatedAt: new Date() }
  }
)

// 同时处理多个数值字段
db.orders.updateOne(
  { _id: 1000001 },
  {
    $inc: { totalAmount: -50, discountUsed: 50 }
  }
)

// $push ：向数组尾部追加一个元素
db.users.updateOne(
  { name: "张三" },
  { $push: { tags: "golang" } }
)

// $push 配合 $each 一次性追加多个元素
db.users.updateOne(
  { name: "张三" },
  { $push: { tags: { $each: ["rust", "zig"] } } }
)

// $push + $each + $slice 保留数组最近 N 个元素（环形缓冲区模式）
db.users.updateOne(
  { name: "张三" },
  {
    $push: {
      loginHistory: {
        $each: [{ ip: "192.168.1.1", time: new Date() }],
        $slice: -10  // 只保留最近 10 条登录记录
      }
    }
  }
)

// $addToSet ：追加元素，但仅当元素不存在时才添加（数组版 Set 去重）
db.users.updateOne(
  { name: "张三" },
  { $addToSet: { tags: "mongodb" } }  // 若已有则不重复添加
)

// $addToSet 配合 $each 批量去重添加
db.users.updateOne(
  { name: "张三" },
  { $addToSet: { tags: { $each: ["vue", "react", "mongodb"] } } }
)

// $pull ：移除数组中所有匹配指定条件的元素
db.users.updateOne(
  { name: "张三" },
  { $pull: { tags: "mongodb" } }
)

// $pullAll ：移除数组中所有与指定值列表相等的元素
db.users.updateOne(
  { name: "张三" },
  { $pullAll: { tags: ["old_tag1", "old_tag2"] } }
)

// 删除用户的临时字段
db.users.updateOne(
  { name: "张三" },
  { $unset: { temporaryToken: "", sessionCache: "" } }
)

// 将旧字段名替换为新字段名（保留数据）
db.users.updateMany(
  {},
  { $rename: { "nickname": "displayName" } }
)

// 示例：用户签到系统，若当日记录存在则增加积分，不存在则初始化
db.dailyCheckins.updateOne(
  {
    userId: 5043,
    date: "2026-08-13"
  },
  {
    $inc: { points: 10, checkinCount: 1 },
    $setOnInsert: { firstCheckinAt: new Date() },
    $set: { lastCheckinAt: new Date() }
  },
  { upsert: true }
)

// 完全替换文档（_id 保持不变）
db.users.replaceOne(
  { name: "张三" },
  {
    name: "张三",
    email: "zhangsan@example.com",
    age: 29,
    profile: { bio: "" }
  }
)

// 删除指定 _id 的文档（最安全的删除方式）
db.users.deleteOne({ _id: ObjectId("64a1b2c3d4e5f6a7b8c9d0e1") })

// 删除满足条件的第一条文档
db.logs.deleteOne({ level: "DEBUG", createdAt: { $lt: ISODate("2026-01-01") } })

// 删除满足条件的所有文档
// ⚠️ 危险操作：执行前务必先用 find() 验证过滤条件
db.sessions.deleteMany({ expiredAt: { $lt: new Date() } })

{
  acknowledged: true,
  deletedCount: 5
}

// 软删除实现：添加删除标记和时间戳
db.users.updateOne(
  { _id: ObjectId("64a1b2c3d4e5f6a7b8c9d0e1") },
  {
    $set: {
      isDeleted: true,
      deletedAt: new Date(),
      deletedBy: "admin_001"
    },
    $unset: { sensitiveData: "" }  // 软删除时同步清理敏感字段
  }
)

// 查询时过滤掉已软删除的文档
db.users.find({ isDeleted: { $ne: true } })

// 创建 TTL 索引：deletedAt 字段后 30 天自动物理删除
db.users.createIndex(
  { deletedAt: 1 },
  { expireAfterSeconds: 2592000 }
)

// 这样软删除的文档在 30 天后会被 MongoDB 后台任务自动清理

db.collection.bulkWrite(
  [
    { insertOne: { document: { ... } } },
    { updateOne: { filter: { ... }, update: { ... }, upsert: true } },
    { updateMany: { filter: { ... }, update: { ... } } },
    { deleteOne: { filter: { ... } } },
    { deleteMany: { filter: { ... } } },
    { replaceOne: { filter: { ... }, replacement: { ... }, upsert: false } }
  ],
  { ordered: false } // 可选：同 insertMany 的有序/无序策略
)

// 订单批量处理：插入新订单、更新库存、删除购物车商品，一次完成
db.products.bulkWrite([
  {
    insertOne: {
      document: {
        _id: "ORDER-2026-0813-001",
        userId: 5043,
        items: [
          { sku: "SKU-8848", name: "机械键盘 K8", price: 498, qty: 1 },
          { sku: "SKU-9921", name: "人体工学椅", price: 1299, qty: 1 }
        ],
        total: 1797,
        status: "paid",
        createdAt: new Date()
      }
    }
  },
  {
    updateOne: {
      filter: { _id: "SKU-8848" },
      update: { $inc: { stock: -1 } }
    }
  },
  {
    updateOne: {
      filter: { _id: "SKU-9921" },
      update: { $inc: { stock: -1 } }
    }
  },
  {
    deleteMany: {
      filter: { userId: 5043, status: "cart" }
    }
  }
])

{
  acknowledged: true,
  insertedCount: 1,
  matchedCount: 2,
  modifiedCount: 2,
  deletedCount: 3,
  upsertedCount: 0,
  writeErrors: [],
  writeConcernErrors: []
}

// 无序批量操作：单条失败不影响其他操作，最大化吞吐量
db.users.bulkWrite(
  [
    { updateOne: { filter: { email: "user1@example.com" }, update: { $set: { status: "active" } } } },
    { updateOne: { filter: { email: "user2@example.com" }, update: { $set: { status: "active" } } } },
    { deleteOne: { filter: { email: "user999@example.com" } } } // 假设不存在，失败但不终止
  ],
  { ordered: false }
)

// 低效：N 次网络往返
var docs = Array.from({ length: 10000 }, (_, i) => ({ index: i, value: Math.random() }))
docs.forEach(doc => db.benchmark.insertOne(doc)) // 约 10-30 秒

// 高效：单次 bulkWrite（或分批 bulkWrite）
var ops = docs.map(doc => ({ insertOne: { document: doc } }))
db.benchmark.bulkWrite(ops, { ordered: false }) // 约 0.5-2 秒

// 方法 1：forEach 逐条处理
var cursor = db.orders.find({ status: "shipped" })
cursor.forEach(function(doc) {
  printjson(doc.totalAmount)
})

// 方法 2：hasNext / next 手动控制迭代
var cursor = db.users.find()
while (cursor.hasNext()) {
  var doc = cursor.next()
  print(doc.name)
}

// 方法 3：toArray 转换为数组（仅推荐小结果集）
var smallResult = db.users.find({ status: "pending" }).limit(100).toArray()
smallResult.forEach(doc => print(doc.name))

// 增大每批返回数量，减少网络往返（适合网络延迟高、单次处理量大的场景）
db.logs.find({ level: "INFO" }).batchSize(1000).forEach(function(doc) {
  // 处理每条日志
})

// 减小每批大小，降低单次内存占用（适合内存敏感的嵌入式客户端）
db.events.find().batchSize(10)

// 设置游标永不超时（需要尽快消费完成，处理完后必须手动关闭）
var cursor = db.largeCollection.find().noCursorTimeout()
try {
  while (cursor.hasNext()) {
    processDocument(cursor.next())  // 可能每条耗时很久
  }
} finally {
  cursor.close()  // 必须手动关闭，否则会长期占用服务器资源
}

var lastId = null
var batchSize = 1000

while (true) {
  var query = lastId ? { _id: { $gt: lastId } } : {}
  var docs = db.users.find(query).sort({ _id: 1 }).limit(batchSize).toArray()

  if (docs.length === 0) break

  docs.forEach(function(doc) {
    processDocument(doc)
  })

  lastId = docs[docs.length - 1]._id
}

db.users.insertMany([
  { name: "张三", phone: "13800138000" },
  { name: "李四", phone: null },
  { name: "王五" }  // 注意：没有 phone 字段
])

// 预期：只查到 phone 为 null 的李四
// 实际：查到了李四和王五！
db.users.find({ phone: null })

[
  { _id: ObjectId("..."), name: "李四", phone: null },
  { _id: ObjectId("..."), name: "王五" }
]

// 只查 phone 字段存在且值为 null 的文档（排除字段不存在的）
db.users.find({ phone: { $type: "null" } })

// 等效写法：同时要求字段存在且值为 null
db.users.find({ phone: { $eq: null, $exists: true } })

// 查 phone 字段完全不存在的文档
db.users.find({ phone: { $exists: false } })

// 查 phone 有实际值的文档（排除 null 和字段缺失）
db.users.find({ phone: { $ne: null, $exists: true } })

// 更简洁的写法（$ne null 隐式排除了字段不存在的文档）
db.users.find({ phone: { $ne: null } })

// 方案一：Schema Validation 在插入时校验字段必须存在
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "phone"],
      properties: {
        name: { bsonType: "string" },
        phone: { bsonType: ["string", "null"] }
      }
    }
  }
})

// 方案二：使用更明确的哨兵值替代 null
// 如 phone 未知时使用空字符串 "" 或 "UNKNOWN"，而非 null
db.users.updateMany(
  { phone: null },
  { $set: { phone: "" } }
)