MongoDB: 更新文档：updateOne与updateMany详解

// ❌ 反例：先查再改（竞态条件）
app.post('/api/orders', async (req, res) => {
  const product = await Product.findOne({ sku: 'PHONE-001' });

  if (product.stock <= 0) {
    return res.status(400).json({ error: 'Out of stock' });
  }

  // ⚠️ 这里并发问题：两个请求都读到 stock=1
  await Product.updateOne(
    { sku: 'PHONE-001' },
    { $inc: { stock: -1 } }
  );
  // 两个请求都成功扣减，结果库存变成 -1
});

// ✅ 正例：用条件 + 原子操作
app.post('/api/orders', async (req, res) => {
  const result = await Product.updateOne(
    { sku: 'PHONE-001', stock: { $gt: 0 } },  // 关键：条件过滤
    { $inc: { stock: -1 } }
  );

  if (result.modifiedCount === 0) {
    return res.status(400).json({ error: 'Out of stock' });
  }
  // 只修改了 1 个文档说明成功
});

// === updateOne 基本用法 ===
db.products.updateOne(
  { sku: "PHONE-001" },        // filter
  { $set: { price: 699.99 } }  // update
);

// 返回结果：
// {
//   acknowledged: true,
//   matchedCount: 1,    // 匹配的文档数
//   modifiedCount: 1,   // 修改的文档数
//   upsertedCount: 0,   // 插入的文档数
//   upsertedId: null    // 插入的 _id
// }

const result = await Product.updateOne(
  { sku: 'PHONE-001' },
  { $set: { stock: 50 } }
);

result.acknowledged;   // true（写入已确认）
result.matchedCount;    // 1（找到 1 个匹配）
result.modifiedCount;   // 1（实际修改 1 个）
result.upsertedCount;   // 0（没有插入）

const result = await Product.updateOne(
  { sku: 'NOT_EXIST' },
  { $set: { stock: 0 } }
);
print(result.matchedCount);   // 0
print(result.modifiedCount);  // 0
// 不报错，仅不修改

// === 修改单个字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { price: 699.99 } }
);

// === 修改多个字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  {
    $set: {
      price: 699.99,
      stock: 50,
      lastUpdated: new Date()
    }
  }
);

// === 嵌套字段更新 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "specs.battery": "5000mAh" } }
);

// === mongoose 等价写法 ===
const result = await Product.updateOne(
  { sku: 'PHONE-001' },
  { $set: { price: 699.99, lastUpdated: new Date() } }
);

// mongoose 操作成功执行
// 数据库查询/更新结果

// === updateMany 基本用法 ===
db.products.updateMany(
  { category: 'Electronics' },   // filter（多条匹配）
  { $set: { discount: 0.1 } }    // update（批量应用）
);

// 返回结果：
// {
//   acknowledged: true,
//   matchedCount: 250,     // 匹配 250 个
//   modifiedCount: 250,    // 修改 250 个
//   upsertedCount: 0
// }

// ⚠️ updateMany 不支持事务回滚
// 如果中途失败，已修改的部分不会回滚

// ⚠️ 大批量更新可能锁集合
// 推荐使用批量大小控制：
const BATCH_SIZE = 1000;
let modified = 0;
let lastId = null;

while (true) {
  const result = await Product.updateMany(
    {
      category: 'Electronics',
      _id: { $gt: lastId }
    },
    { $set: { onSale: true } },
    { limit: BATCH_SIZE }  // mongoose 选项
  );
  if (result.modifiedCount === 0) break;
  modified += result.modifiedCount;
}

// === 给所有 Electronics 商品打 9 折 ===
db.products.updateMany(
  { category: 'Electronics' },
  { $mul: { price: 0.9 } }
);

// === 给所有过期商品下架 ===
db.products.updateMany(
  { expiryDate: { $lt: new Date() } },
  { $set: { isActive: false } }
);

// === 给所有 5 星评分商品加标签 ===
db.products.updateMany(
  { rating: { $gte: 4.8 } },
  { $addToSet: { tags: 'top-rated' } }
);

// 执行成功

// === updateOne：只修改指定字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { price: 699 } }
);
// 结果：{ _id, sku, title, price: 699, stock, category, ... }（保留其他字段）

// === replaceOne：替换整个文档 ===
db.products.replaceOne(
  { sku: 'PHONE-001' },
  { sku: 'PHONE-001', title: 'New Phone', price: 799 }
);
// 结果：{ _id, sku, title: 'New Phone', price: 799 }
// ⚠️ 其他字段（stock、category 等）全部丢失！

// ✅ 适用：完全重写文档
db.users.replaceOne(
  { _id: 'user_001' },
  {
    _id: 'user_001',
    name: 'Alice',
    email: 'alice@example.com',
    role: 'admin',
    updatedAt: new Date()
  }
);

// ❌ 不适用：只想修改一个字段（用 updateOne + $set）

// === 设置字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { stock: 50, isActive: true } }
);

// === 设置嵌套字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "specs.battery": "5000mAh" } }
);

// === 数组元素设置 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "tags.0": "5g", "tags.1": "amoled" } }
);

// === 删除单个字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $unset: { discount: "" } }
);

// === 删除多个字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $unset: { discount: "", internalNotes: "" } }
);

// === 删除嵌套字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $unset: { "specs.battery": "" } }
);

// === 库存扣减 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $inc: { stock: -1 } }
);

// === 浏览量 +1 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $inc: { viewCount: 1 } }
);

// === 评分累加（多字段）===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $inc: { stock: -1, soldCount: 1, viewCount: 1 } }
);

// === 打 9 折 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $mul: { price: 0.9 } }
);

// === 价格翻倍 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $mul: { price: 2 } }
);

// === 重命名字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $rename: { "stock": "inventory" } }
);
// stock → inventory

// === 重命名嵌套字段 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $rename: { "specs.battery": "specs.batteryCapacity" } }
);

// === $min：只在值更小时更新 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $min: { price: 500 } }
);
// 如果当前 price > 500，改为 500；否则不变

// === $max：只在值更大时更新 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $max: { price: 1000 } }
);

// === 设置当前时间 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $currentDate: { lastModified: true } }
);

// === 设置为 Date 类型 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $currentDate: { lastModified: { $type: "date" } } }
);

// === 仅在 upsert 插入时设置默认值 ===
db.products.updateOne(
  { sku: 'NEW-001' },
  {
    $set: { price: 599 },
    $setOnInsert: { createdAt: new Date(), stock: 0 }
  },
  { upsert: true }
);
// 如果插入：{ sku: 'NEW-001', price: 599, createdAt: ..., stock: 0 }
// 如果更新：{ sku: 'NEW-001', price: 599 }（不设置 createdAt、stock）

// === 订单支付成功后更新订单状态 ===
db.orders.updateOne(
  { _id: orderId },
  {
    $set: {
      status: 'paid',
      paidAt: new Date(),
      paymentMethod: 'credit_card'
    },
    $inc: { version: 1 },         // 乐观锁版本号
    $currentDate: { updatedAt: true }
  }
);

// === 用户登录后更新最后登录时间 ===
db.users.updateOne(
  { _id: userId },
  {
    $set: { lastLoginAt: new Date(), lastLoginIp: '192.168.1.1' },
    $inc: { loginCount: 1 }
  }
);

// 执行成功

// === 添加单个元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $push: { tags: 'bestseller' } }
);

// === 添加多个元素（$each）===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $push: { tags: { $each: ['5g', 'amoled', 'fast-charging'] } } }
);

// === 限制数组大小（$slice + $position）===
db.products.updateOne(
  { sku: 'PHONE-001' },
  {
    $push: {
      tags: {
        $each: ['new1', 'new2', 'new3'],
        $slice: -5,            // 只保留最后 5 个
        $position: 0           // 从开头插入
      }
    }
  }
);

// === 删除指定值 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $pull: { tags: 'old-tag' } }
);

// === 删除满足条件的所有元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $pull: { tags: { $in: ['outdated1', 'outdated2'] } } }
);

// === 仅添加不存在的元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $addToSet: { tags: 'new-tag' } }
);
// 如果 tags 已包含 'new-tag'，不重复添加

// === 添加多个（$each）===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $addToSet: { tags: { $each: ['tag1', 'tag2'] } } }
);

// === 删除最后一个元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $pop: { tags: 1 } }
);

// === 删除第一个元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $pop: { tags: -1 } }
);

// === 通过位置索引更新 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "tags.0": "updated-first-tag" } }
);

// === 通过 $ 定位符更新（找到的第一个匹配元素）===
db.products.updateOne(
  { sku: 'PHONE-001', "reviews.userId": 'user_001' },
  { $set: { "reviews.$.helpful": 10 } }
);
// 找到 userId='user_001' 的评论，设置其 helpful 字段

// === 批量更新数组元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "reviews.$[].status": "approved" } }
);
// 所有评论 status → approved

// === 更新所有数组元素 ===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "reviews.$[].status": "approved" } }
);

// === 条件更新数组元素（arrayFilters）===
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "reviews.$[lowRating].flagged": true } },
  {
    arrayFilters: [{ "lowRating.rating": { $lt: 2 } }]
  }
);
// 仅标记评分 < 2 的评论

// === 场景：电商评论系统 ===
// 1. 添加评论
db.products.updateOne(
  { sku: 'PHONE-001' },
  {
    $push: {
      reviews: {
        userId: 'user_001',
        rating: 5,
        content: 'Excellent phone!',
        createdAt: new Date(),
        helpful: 0
      }
    }
  }
);

// 2. 删除用户的某条评论
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $pull: { reviews: { userId: 'user_001' } } }
);

// 3. 标记低分评论
db.products.updateOne(
  { sku: 'PHONE-001' },
  { $set: { "reviews.$[r].flagged": true } },
  { arrayFilters: [{ "r.rating": { $lt: 2 } }] }
);

// 4. 限制评论数组最多 100 条
db.products.updateOne(
  { sku: 'PHONE-001' },
  {
    $push: {
      reviews: {
        $each: [newReview],
        $slice: -100
      }
    }
  }
);

// 执行成功

// === upsert: false（默认）===
const result1 = await Product.updateOne(
  { sku: 'NEW-001' },
  { $set: { price: 599 } }
);
print(result1.matchedCount);   // 0（未匹配）
print(result1.modifiedCount);  // 0
print(result1.upsertedCount);  // 0

// === upsert: true ===
const result2 = await Product.updateOne(
  { sku: 'NEW-001' },
  { $set: { price: 599 } },
  { upsert: true }
);
print(result2.upsertedCount);  // 1（插入 1 条）
print(result2.upsertedId);     // ObjectId('...')

// === 完整 upsert 模式 ===
db.products.updateOne(
  { sku: 'NEW-001' },
  {
    $set: { price: 599, updatedAt: new Date() },
    $setOnInsert: { createdAt: new Date(), stock: 0, viewCount: 0 }
  },
  { upsert: true }
);

// === 不存在时插入：{ sku: 'NEW-001', price: 599, updatedAt: ..., createdAt: ..., stock: 0, viewCount: 0 }
// === 存在时更新：{ sku: 'NEW-001', price: 599, updatedAt: ..., createdAt: <旧值> }

// === 用户登录记录 upsert ===
db.user_logins.updateOne(
  {
    userId: 'user_001',
    date: '2026-07-01'
  },
  {
    $set: { lastLoginAt: new Date() },
    $inc: { loginCount: 1 },
    $setOnInsert: { firstLoginAt: new Date() }
  },
  { upsert: true }
);
// 每天首次登录创建记录，后续更新

// === 购物车 upsert ===
db.carts.updateOne(
  { userId: 'user_001' },
  {
    $set: { updatedAt: new Date() },
    $inc: { totalItems: 2 }
  },
  { upsert: true }
);

// 执行成功

// ✅ 安全：filter + 原子操作
const result = await Product.updateOne(
  { sku: 'PHONE-001', stock: { $gt: 0 } },
  { $inc: { stock: -1 } }
);

// ❌ 不安全：先查再改（竞态条件）
const product = await Product.findOne({ sku: 'PHONE-001' });
if (product.stock > 0) {
  await Product.updateOne(
    { sku: 'PHONE-001' },
    { $inc: { stock: -1 } }
  );
}

// === 优化 1：批量更新替代多次单条 ===
// ❌ 慢：100 次 updateOne
for (const item of items) {
  await Product.updateOne({ sku: item.sku }, { $inc: { stock: -item.qty } });
}

// ✅ 快：1 次 bulkWrite
await Product.bulkWrite(
  items.map(item => ({
    updateOne: {
      filter: { sku: item.sku, stock: { $gte: item.qty } },
      update: { $inc: { stock: -item.qty, soldCount: item.qty } }
    }
  })),
  { ordered: false }
);

// === 优化 2：使用索引字段过滤 ===
// ✅ 有索引：db.products.updateOne({ sku: 'PHONE-001' }, ...)
// ⚠️ 无索引：db.products.updateOne({ title: 'Phone' }, ...)

// === UpdateResult 处理 ===
async function updateProductStock(sku, qty) {
  const result = await Product.updateOne(
    { sku, stock: { $gte: qty } },
    { $inc: { stock: -qty, soldCount: qty } }
  );

  if (result.matchedCount === 0) {
    throw new Error(`库存不足或商品不存在: ${sku}`);
  }

  if (result.modifiedCount === 0) {
    throw new Error('更新失败');
  }

  return result;
}