MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

MongoDB更新多个文档的方法与技巧

2021-07-201.5k 阅读

MongoDB 更新多个文档的基本方法

使用 updateMany 方法

在 MongoDB 中，updateMany 方法用于更新集合中满足指定条件的多个文档。其基本语法如下：

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>
   }
)
  • <filter>：用于指定筛选条件，只有满足该条件的文档才会被更新。这是一个文档对象，类似于查询条件。
  • <update>：指定要应用的更新操作。这也是一个文档对象，包含更新操作符，如 $set、$inc 等。
  • upsert（可选）：如果设置为 true，当没有文档匹配筛选条件时，会插入一个新文档。默认为 false。
  • writeConcern（可选）：用于指定写入操作的确认级别。
  • collation（可选）：用于指定字符串比较的规则，如区分大小写等。

假设我们有一个名为 users 的集合，其中的文档结构如下：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "name": "Alice",
  "age": 30,
  "city": "New York"
}

要将所有年龄大于 25 岁的用户的城市更新为 "San Francisco"，可以使用以下代码：

db.users.updateMany(
  { "age": { $gt: 25 } },
  { $set: { "city": "San Francisco" } }
)

在上述代码中，{ "age": { $gt: 25 } } 是筛选条件，{ $set: { "city": "San Francisco" } } 是更新操作，使用 $set 操作符将 city 字段的值设置为 "San Francisco"。

结合数组操作符更新多个文档

当文档中包含数组字段时，我们可以利用数组操作符来更新多个文档中的数组元素。例如，假设有一个 orders 集合，文档结构如下：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "customer": "Bob",
  "items": [
    { "product": "Apple", "quantity": 2 },
    { "product": "Banana", "quantity": 3 }
  ]
}

如果要将所有订单中所有产品为 "Apple" 的数量增加 1，可以使用以下代码：

db.orders.updateMany(
  {},
  { $inc: { "items.$[elem].quantity": 1 } },
  { arrayFilters: [ { "elem.product": "Apple" } ] }
)

这里使用了 $inc 操作符来增加数量，$[elem] 是数组过滤器的占位符，arrayFilters 选项指定了数组过滤条件，即只对产品为 "Apple" 的数组元素进行操作。

使用批量操作更新多个文档

Bulk Write 操作

除了 updateMany 方法，MongoDB 还提供了 bulkWrite 方法，它允许在一个请求中执行多个写操作，包括更新多个文档。bulkWrite 的语法如下：

db.collection.bulkWrite(
   [ <write operation 1>, <write operation 2>,... ],
   {
     writeConcern: <document>,
     ordered: <boolean>
   }
)
  • <write operation>：可以是 updateOne、updateMany、insertOne、deleteOne 等写操作文档。
  • writeConcern（可选）：指定写入操作的确认级别。
  • ordered（可选）：如果设置为 true（默认值），操作将按顺序执行，一旦某个操作失败，后续操作将被中止；如果设置为 false，所有操作都会尝试执行，无论前面的操作是否失败。

假设我们要更新 users 集合中的多个文档，同时执行两个更新操作：将年龄大于 30 岁的用户的城市更新为 "Los Angeles"，将年龄小于 25 岁的用户的职业设置为 "Student"。可以使用以下代码：

db.users.bulkWrite([
  {
    updateMany: {
      filter: { "age": { $gt: 30 } },
      update: { $set: { "city": "Los Angeles" } }
    }
  },
  {
    updateMany: {
      filter: { "age": { $lt: 25 } },
      update: { $set: { "occupation": "Student" } }
    }
  }
])

在上述代码中，bulkWrite 接受一个包含两个 updateMany 操作的数组。这样可以在一次请求中执行多个更新操作，提高效率。

处理批量操作中的错误

在使用 bulkWrite 时，了解如何处理错误非常重要。如果 ordered 为 true，一旦某个操作失败，后续操作将被中止。可以通过捕获 bulkWrite 操作返回的结果来检查是否有错误发生。例如：

try {
  const result = db.users.bulkWrite([
    {
      updateMany: {
        filter: { "age": { $gt: 30 } },
        update: { $set: { "city": "Los Angeles" } }
      }
    },
    {
      updateMany: {
        filter: { "age": { $lt: 25 } },
        update: { $set: { "occupation": "Student" } }
      }
    }
  ]);
  console.log(result);
} catch (e) {
  console.error("Bulk write operation failed:", e);
}

在上述代码中，try - catch 块用于捕获 bulkWrite 操作可能抛出的错误。如果操作成功，result 将包含操作的详细信息，如更新的文档数量等。

条件更新多个文档

使用 $cond 操作符进行条件更新

$cond 操作符在 MongoDB 中用于根据条件执行不同的操作。在更新多个文档时，可以利用 $cond 实现更复杂的条件更新。例如，假设我们有一个 products 集合，文档结构如下：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "name": "Laptop",
  "price": 1000,
  "discount": 0
}

如果价格大于 500，我们希望将折扣设置为 10%，否则设置为 5%。可以使用以下代码：

db.products.updateMany(
  {},
  {
    $set: {
      "discount": {
        $cond: [
          { $gt: [ "$price", 500 ] },
          0.1,
          0.05
        ]
      }
    }
  }
)

在上述代码中，$cond 操作符接受一个数组，第一个元素是条件 { $gt: [ "$price", 500 ] }，如果条件为真，返回 0.1，否则返回 0.05，并将结果设置为 discount 字段的值。

嵌套条件更新

有时候，我们可能需要进行嵌套的条件更新。例如，对于上述 products 集合，如果价格大于 1000 且库存大于 50，将折扣设置为 15%；如果价格大于 500 且库存大于 30，将折扣设置为 10%；否则设置为 5%。可以使用以下代码：

db.products.updateMany(
  {},
  {
    $set: {
      "discount": {
        $cond: [
          { $and: [ { $gt: [ "$price", 1000 ] }, { $gt: [ "$stock", 50 ] } ] },
          0.15,
          {
            $cond: [
              { $and: [ { $gt: [ "$price", 500 ] }, { $gt: [ "$stock", 30 ] } ] },
              0.1,
              0.05
            ]
          }
        ]
      }
    }
  }
)

这里通过嵌套 $cond 操作符实现了更复杂的嵌套条件更新逻辑。

性能优化与注意事项

索引对更新性能的影响

在更新多个文档时，索引起着至关重要的作用。如果更新操作的筛选条件字段上没有索引，MongoDB 可能需要全表扫描来查找满足条件的文档，这会导致性能低下。例如，在以下更新操作中：

db.users.updateMany(
  { "email": "example@example.com" },
  { $set: { "status": "active" } }
)

如果 email 字段上没有索引，MongoDB 会遍历集合中的每一个文档来查找匹配的文档。为了提高性能，可以在 email 字段上创建索引：

db.users.createIndex({ "email": 1 })

这样，在执行更新操作时，MongoDB 可以利用索引快速定位到满足条件的文档，大大提高更新效率。

避免大文档更新

更新大文档可能会导致性能问题。当更新一个大文档时，MongoDB 可能需要移动数据以适应更新后的文档大小，这会增加磁盘 I/O 和内存开销。如果可能，尽量避免对大文档进行更新，或者将大文档拆分成多个小文档。例如，假设我们有一个包含大量历史订单数据的文档：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "customer": "Alice",
  "orders": [
    { "orderId": 1, "date": "2020 - 01 - 01", "amount": 100 },
    { "orderId": 2, "date": "2020 - 02 - 01", "amount": 200 },
    // 大量订单数据
  ]
}

如果要更新其中的某个订单信息，每次更新都可能涉及到整个大文档的移动。可以考虑将订单数据拆分成单独的文档，以减少更新时的开销：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "customer": "Alice",
  "orderId": 1,
  "date": "2020 - 01 - 01",
  "amount": 100
}
{
  "_id": ObjectId("5f999999999999999999999a"),
  "customer": "Alice",
  "orderId": 2,
  "date": "2020 - 02 - 01",
  "amount": 200
}

这样，在更新单个订单时，只需要更新对应的小文档，性能会得到显著提升。

监控更新操作性能

为了确保更新操作的性能，MongoDB 提供了一些工具来监控操作的执行情况。例如，可以使用 explain 方法来查看查询和更新操作的执行计划。对于更新操作，可以在 updateMany 或 bulkWrite 操作后调用 explain 方法，如下所示：

db.users.updateMany(
  { "age": { $gt: 30 } },
  { $set: { "city": "Los Angeles" } }
).explain("executionStats")

explain("executionStats") 会返回详细的执行统计信息，包括扫描的文档数、匹配的文档数、更新的文档数等。通过分析这些信息，可以找出性能瓶颈并进行优化。

此外，MongoDB 的日志文件也可以提供有关更新操作的信息。可以通过查看日志文件来了解更新操作的执行时间、是否有错误发生等。在生产环境中，定期分析日志和性能统计信息是保持数据库高效运行的重要手段。

与其他 MongoDB 特性结合的更新

多文档事务中的更新

从 MongoDB 4.0 开始，支持多文档事务。在事务中，可以对多个文档进行更新操作，确保数据的一致性。例如，假设我们有两个集合 accounts 和 transactions，accounts 集合存储账户信息，transactions 集合记录交易记录。在一次转账操作中，需要从一个账户扣除金额，并在另一个账户增加金额，同时记录交易。可以使用以下代码实现：

const session = db.getMongo().startSession();
session.startTransaction();
try {
  db.accounts.updateOne(
    { "accountId": "A1" },
    { $inc: { "balance": -100 } },
    { session }
  );
  db.accounts.updateOne(
    { "accountId": "A2" },
    { $inc: { "balance": 100 } },
    { session }
  );
  db.transactions.insertOne(
    { "from": "A1", "to": "A2", "amount": 100 },
    { session }
  );
  session.commitTransaction();
} catch (e) {
  session.abortTransaction();
  console.error("Transaction failed:", e);
} finally {
  session.endSession();
}

在上述代码中，通过 startSession 启动一个会话，然后在会话中开始事务。在事务中，对 accounts 集合的两个文档进行更新操作，并向 transactions 集合插入一条记录。如果所有操作都成功，通过 commitTransaction 提交事务；如果有任何操作失败，通过 abortTransaction 回滚事务。

基于聚合管道的更新

MongoDB 4.2 引入了基于聚合管道的更新操作。这种方式允许在更新文档时使用聚合框架的强大功能，如分组、排序、过滤等。例如，假设我们有一个 sales 集合，文档结构如下：

{
  "_id": ObjectId("5f9999999999999999999999"),
  "product": "Phone",
  "quantity": 5,
  "price": 500,
  "total": 0
}

我们希望根据 quantity 和 price 字段计算每个文档的 total 字段值。可以使用基于聚合管道的更新：

db.sales.updateMany(
  {},
  [
    {
      $set: {
        "total": { $multiply: [ "$quantity", "$price" ] }
      }
    }
  ],
  { multi: true }
)

在上述代码中，updateMany 的第二个参数是一个聚合管道数组。这里使用 $set 操作符和 $multiply 表达式计算 total 字段的值，并更新集合中的所有文档。multi: true 表示对所有匹配的文档进行更新。

基于聚合管道的更新为复杂的文档更新提供了更灵活和强大的方式，可以处理一些传统更新方法难以实现的场景。

通过以上对 MongoDB 更新多个文档的方法与技巧的详细介绍，包括基本方法、批量操作、条件更新、性能优化以及与其他特性结合的更新，希望能帮助你在实际开发中更高效地处理文档更新操作，确保数据库的性能和数据一致性。在实际应用中，需要根据具体的业务需求和数据特点选择合适的更新方式，并不断优化更新操作以提高系统的整体性能。