Docs 菜单
Docs 主页
/
MongoDB Manual
/
参考
/
mongosh 方法
/
集合

db.collection.updateMany()

在此页面上

  • 定义
  • 兼容性
  • 语法
  • 访问控制
  • 行为
  • 示例

带驱动程序的 MongoDB

本页面提供 mongosh 方法的相关信息。要查看 MongoDB 驱动程序中的等效方法，请参阅编程语言的相应页面：

C#Java SyncNode.jsPyMongoCC++GoJava RSKotlin CoroutineKotlin SyncPHPMongoidRustScala

定义

db.collection.updateMany(filter, update, options)

更新与收集的指定过滤器匹配的所有文档。

兼容性

此方法可用于以下环境中托管的部署：

  • MongoDB Atlas：用于云中 MongoDB 部署的完全托管服务

注意

所有 MongoDB Atlas 集群都支持此命令。有关 Atlas 对所有命令的支持的信息，请参阅不支持的命令。

  • MongoDB Enterprise：基于订阅、自我管理的 MongoDB 版本

  • MongoDB Community：源代码可用、免费使用且可自行管理的 MongoDB 版本

语法

updateMany() 方法采用以下形式：

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>,
     let: <document>
   }
)

参数

updateMany() 方法使用以下参数：

Parameter
类型
说明

筛选器

文档

更新的选择条件。可以使用与 find() 方法中相同的查询选择器。

指定一个空文档 { } 以更新收集中的所有文档。

update

文档或管道

要应用的修改。可以是以下之一：

Update document

只包含更新操作符表达式。

有关详细信息，请参阅使用更新操作符表达式文档进行更新

聚合管道

仅包含以下聚合阶段：

有关更多信息，请参阅使用聚合管道进行更新。

要使用替换文档进行更新，请参阅 db.collection.replaceOne()。

upsert

布尔

可选。 当true updateMany()时， 将：

  • 如果没有文档与 filter 匹配，则创建一个新文档。有关详细信息，请参阅更新或插入行为。

  • 更新与 filter 匹配的文档。

要避免多次更新或插入，请确保 filter 字段具有唯一索引。

默认值为 false。

writeConcern

文档

可选。表达写关注的文档。省略以使用默认写关注。

如果是在事务中运行，则请勿显式设置此操作的写关注。要将写关注与事务一起使用，请参阅事务和写关注。

collation

文档

可选。

指定用于操作的排序规则。

排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号规则。

排序规则选项的语法如下：

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

指定排序规则时，locale 字段为必填字段；所有其他排序规则字段均为可选字段。有关字段的说明，请参阅排序规则文档。

如果未指定排序规则，但集合具有默认排序规则（请参阅 db.createCollection()），则操作将使用为集合指定的排序规则。

如果没有为收集或操作指定排序规则，MongoDB 将使用先前版本中使用的简单二进制比较来进行字符串比较。

您不能为一个操作指定多个排序规则。例如，您不能为每个字段指定不同的排序规则，或者如果执行带排序的查找，则不能使用一种排序规则进行查找而另一种排序规则进行排序。

arrayFilters

阵列

选修的。大量过滤器文档，用于确定针对大量字段的更新操作要修改哪些大量元素。

在更新文档中，使用 $[<identifier>] 筛选后的位置运算符来定义标识符，然后在数组筛选文档中引用该标识符。如果更新文档中未包含某一标识符，则无法获得该标识符的数组筛选文档。

<identifier> 必须以小写字母开头，且只能包含字母数字字符。

您可以在更新文档中多次包含相同的标识符；但对于更新文档中的每个不同标识符 ($[identifier])，您必须准确指定一个对应的数组筛选器文档。也就是说，不能为同一个标识符指定多个数组筛选器文档。例如，如果更新语句包含标识符 x（可能多次），则不能为 arrayFilters 指定以下内容，其中包括 x 的 2 个单独的筛选器文档：

// INVALID
[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]

但是，您可以在单个过滤器文档中的同一标识符上指定复合条件，例如以下示例：

// Example 1
[
  { $or: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 2
[
  { $and: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 3
[
  { "x.a": { $gt: 85 }, "x.b": { $gt: 80 } }
]

有关示例，请参阅为数组更新操作指定 arrayFilters。

提示

文档或字符串

可选。指定用于支持查询谓词的索引的文档或字符串。

该选项可以采用索引规范文档或索引名称字符串。

如果指定不存在的索引，则操作出错。

有关示例，请参阅为更新操作指定 hint。

let

文档

可选。

指定包含变量列表的文档。这样可以将变量与查询文本分开，从而提高命令的可读性。

文档语法为：

{
  <variable_name_1>: <expression_1>,
  ...,
  <variable_name_n>: <expression_n>
}

变量设置为表达式返回的值，并且之后不能再进行更改。

要访问命令中的变量值，请使用双美元符号前缀 ($$) 以及 $$<variable_name> 形式的变量名称。例如：$$targetTotal。

要使用变量筛选结果，您必须在 $expr 操作符中访问该变量。

有关使用 let 和变量的完整示例，请参阅使用 let 变量进行更新。

返回：

该方法返回包含以下内容的文档：

  • 如果操作使用写关注来运行，则布尔值 acknowledged 为 true；如果已禁用写关注，则为 false

  • matchedCount 包含匹配文档的数量

  • modifiedCount 包含已修改文档的数量

  • upsertedId ，包含用于已更新或插入的文档的 _id

  • upsertedCount 包含更新或插入文档的数量

访问控制

在使用 authorization 运行的部署中，用户必须具有包含以下特权的访问权限：

  • update 针对指定集合的操作。

  • find 针对指定集合的操作。

  • insert 如果操作导致更新插入，则对指定收集执行操作。

内置角色readWrite提供所需的特权。

行为

updateMany() 查找集合中与 filter 匹配的所有文档，并应用 update 参数指定的修改。

updateMany() 单独修改每个文档。每次文档写入都是一个原子操作，但 updateMany()作为一个整体不是原子操作。如果您的使用案例需要写入多个文档的原子性，请使用事务。

如果单个文档更新失败，则保留失败之前写入的所有文档更新，但不会更新任何剩余的匹配文档。有关此行为的详细信息，请参阅多次更新失败。

提示

另请参阅：

分片集合以了解有关分分片的集合中updateMany() 行为的更多信息。

限制

  • updateMany() 只应用于幂等操作。

更新插入

如果 upsert: true 且没有文档与 filter 匹配，db.collection.updateMany() 将基于 filter 和 update 参数创建新文档。

如果在一个分片集合上指定 upsert: true，则必须在 filter 中包含完整的分片键。有关其他 db.collection.updateMany() 行为，请参阅分片集合。

请参阅使用 Upsert 更新多个文档。

使用更新操作符表达式文档进行更新

对于修改规范，db.collection.updateMany() 方法可接受仅含要执行的更新操作符表达式的文档。

例如：

db.collection.updateMany(
   <query>,
   { $set: { status: "D" }, $inc: { quantity: 2 } },
   ...
)

使用聚合管道进行更新

db.collection.updateMany() 方法可以接受指定要执行的修改的聚合管道 [ <stage1>, <stage2>, ... ]。该管道可以由以下阶段组成：

使用聚合分析管道可以进行更具表现力的更新声明，例如基于当前字段值的Express条件更新或使用另一个字段的值更新一个字段。

例如：

db.collection.updateMany(
   <query>,
   [
      { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
      { $unset: [ "misc1", "misc2" ] }
   ]
   ...
)

注意

在此管道中， $set 和 $unset 是聚合阶段，不是更新操作符。聚合阶段$set和$unset为文档添加新字段，并且不修改现有字段值。

有关更新操作符的更多信息，请参阅$set 和 $unset。

有关示例，请参阅使用聚合管道进行更新。

固定大小集合

如果更新操作更改了文档大小，则操作将失败。

时间序列集合

从 MongoDB 5.1 开始，updateMany() 方法可用于时间序列集合。

更新命令必须满足以下要求：

  • 您只能匹配 metaField 字段值。

  • 您只能修改 metaField 字段值。

  • 您的更新文档只能包含更新操作符表达式。

  • 您的更新命令不得限制要更新的文档数量。设置 multi: true 或使用 updateMany() 方法。

  • 更新命令不得设置 upsert: true。

分片集合

updateMany() 与分片的集合一起使用时会表现出以下行为：

  • updateMany() 包含 upsert: true 的操作必须在 filter 中包含完整的分分片键。

  • updateMany()如果您尝试在范围迁移或分片分片键值更新期间运行 ，则该操作在某些情况下可能会丢失文档。为确保更新所有文档，请使用幂等更新并重新运行命令，直到不再应用更新。有关使用updateMany() 进行幂等更新的更多信息，请参阅幂等更新。

可解释性

updateMany() 与 db.collection.explain() 不兼容。

事务

db.collection.updateMany() 可以在分布式事务中使用。

重要

在大多数情况下，与单文档写入操作相比，分布式事务会产生更高的性能成本，并且分布式事务的可用性不应取代有效的模式设计。在许多情况下，非规范化数据模型（嵌入式文档和数组）仍然是数据和使用案例的最佳选择。换言之，对于许多场景，适当的数据建模将最大限度地减少对分布式事务的需求。

有关其他事务使用注意事项（如运行时间限制和 oplog 大小限制），另请参阅生产注意事项。

在 ACID 事务中进行更新或插入 (upsert)

如果事务不是跨分片写事务，则可以在分布式事务中创建集合和索引。

具有 upsert: true 的 db.collection.updateMany() 可以在现有集合或不存在的集合上运行。如果在不存在的集合上运行，该操作将创建集合。

提示

另请参阅：

在事务中创建集合和索引

写关注和事务

如果是在事务中运行，则请勿显式设置此操作的写关注。要将写关注与事务一起使用，请参阅事务和写关注。

Oplog 条目

updateMany() 为每个成功更新的文档在oplog （操作日志）中添加一个条目。如果没有文档更新，则updateMany() 不会向oplog添加条目。

示例

Idempotent Updates

以下示例演示了使用 updateMany()进行的幂等更新：

一家公司向所有收入低于 100 美元、000 美元的员工加薪 1 美元、000 美元。

考虑包含以下文档的 employees 集合：

db.employees.insertMany( [
   { "_id" : 1, "name" : "Rob", "salary" : 37000 },
   { "_id" : 2, "name" : "Trish", "salary" : 65000 },
   { "_id" : 3, "name" : "Zeke", "salary" : 99999 },
   { "_id" : 4, "name" : "Mary", "salary" : 200000 }
] )

以下命令会匹配所有收入低于 100、000 美元且未加薪的员工，将这些工资递增 1、000 美元，并将 raiseApplied 设为 true：

db.employees.updateMany(
   { salary: { $lt: 100000 }, raiseApplied: { $ne: true } },
   { $inc: { salary: 1000 }, $set: { raiseApplied: true } }
)

updateMany() 分别修改匹配的 employee 文档。单个文档更新是原子操作，但 updateMany() 操作作为一个整体不是原子操作。

如果该操作无法更新所有匹配的文档，您可以安全地重新运行幂等命令，直到没有其他文档与指定的过滤匹配。在这种情况下，每个文档的 salary字段仅更新一次，无论重试多少次，因为该命令是幂等的。

当所有符合条件的员工获得加薪后，您可以使用以下命令删除raiseApplied字段：

db.employees.updateMany(
   { },
   { $unset: { raiseApplied: 1 } }
)

更新多个文档

restaurant 集合包含以下文档：

{ "_id" : 1, "name" : "Central Perk Cafe", "violations" : 3 }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "violations" : 2 }
{ "_id" : 3, "name" : "Empire State Sub", "violations" : 5 }
{ "_id" : 4, "name" : "Pizza Rat's Pizzaria", "violations" : 8 }

以下操作更新所有 violations 大于 4 且$set 为审核标记的文档：

try {
   db.restaurant.updateMany(
      { violations: { $gt: 4 } },
      { $set: { "Review" : true } }
   );
} catch (e) {
   print(e);
}

该操作返回：

{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }

该集合现在包含以下文档：

{ "_id" : 1, "name" : "Central Perk Cafe", "violations" : 3 }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "violations" : 2 }
{ "_id" : 3, "name" : "Empire State Sub", "violations" : 5, "Review" : true }
{ "_id" : 4, "name" : "Pizza Rat's Pizzaria", "violations" : 8, "Review" : true }

如果未找到匹配项，那么操作将返回：

{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }

如果未找到匹配项，设置 upsert: true 将插入一个文档。

使用聚合管道进行更新

db.collection.updateMany() 可以使用聚合管道进行更新。该管道可以由以下阶段组成：

使用聚合分析管道可以进行更具表现力的更新声明，例如基于当前字段值的Express条件更新或使用另一个字段的值更新一个字段。

示例 1：使用现有字段并通过聚合管道进行更新

以下示例使用聚合分析管道使用文档中其他字段的值来修改字段。

使用以下文档创建 students 集合：

db.students.insertMany( [
   { "_id" : 1, "student" : "Skye", "points" : 75, "commentsSemester1" : "great at math", "commentsSemester2" : "loses temper", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "students" : "Elizabeth", "points" : 60, "commentsSemester1" : "well behaved", "commentsSemester2" : "needs improvement", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") }
] )

假设您不想将 commentsSemester1 和 commentsSemester2 字段分开，而是将它们收集到新的 comments 字段中。以下更新操作使用聚合管道：

  • 添加新的 comments 字段并设置 lastUpdate 字段。

  • 删除集合中所有文档的 commentsSemester1 和 commentsSemester2 字段。

db.students.updateMany(
   { },
   [
      { $set: { comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ]
)

注意

在此管道中， $set 和 $unset 是聚合阶段，不是更新操作符。聚合阶段$set和$unset为文档添加新字段，并且不修改现有字段值。

有关更新操作符的更多信息，请参阅$set 和 $unset。

第一个阶段：

$set 阶段：

  • 创建一个新的数组字段 comments，其元素是 commentsSemester1 和 commentsSemester2 字段的当前内容，并且

  • 将字段 lastUpdate 设置为聚合变量 NOW 的值。聚合变量 NOW 解析为当前的日期时间值，并在整个管道中保持不变。要访问聚合变量，在变量前加上双美元符号 $$ 并用引号引起来。

第二阶段
$unset 阶段删除 commentsSemester1 和 commentsSemester2 字段。

执行该命令之后，集合中将包含以下文档：

{ "_id" : 1, "student" : "Skye", "status" : "Modified", "points" : 75, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "great at math", "loses temper" ] }
{ "_id" : 2, "student" : "Elizabeth", "status" : "Modified", "points" : 60, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "well behaved", "needs improvement" ] }

示例 2：使用现有字段有条件地通过 Aggregation Pipeline 进行更新

聚合分析管道允许更新根据当前字段值执行条件更新以及使用当前字段值计算单独的字段值。

例如，使用以下文档创建 students3 集合：

db.students3.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") }
] )

使用聚合分析管道，您可以使用计算出的平均成绩和字母等级来更新文档。

db.students3.updateMany(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] } , lastUpdate: "$$NOW" } },
     { $set: { grade: { $switch: {
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ]
)

注意

在此管道中， $set 和 $unset 是聚合阶段，不是更新操作符。聚合阶段$set和$unset为文档添加新字段，并且不修改现有字段值。

有关更新操作符的更多信息，请参阅$set 和 $unset。

第一个阶段：

$set 阶段：

  • 根据 tests 字段的平均值计算新字段 average。有关 $avg 聚合操作符的详细信息，请参阅 $avg，有关 $trunc 截断聚合操作符的详细信息，请参阅 $trunc。

  • 将字段 lastUpdate 设置为聚合变量 NOW 的值。聚合变量 NOW 解析为当前的日期时间值，并在整个管道中保持不变。要访问聚合变量，在变量前加上双美元符号 $$ 并用引号引起来。

第二阶段
$set 阶段根据上一阶段计算的 average 字段计算新字段 grade。有关 $switch 聚合操作符的更多信息，请参阅 $switch。

执行该命令之后，集合中将包含以下文档：

{ "_id" : 1, "tests" : [ 95, 92, 90 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 92, "grade" : "A" }
{ "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 90, "grade" : "A" }
{ "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 75, "grade" : "C" }

提示

另请参阅：

使用聚合管道进行更新。

使用更新或插入来更新多个文档。

inspectors 集合包含以下文档：

{ "_id" : 92412, "inspector" : "F. Drebin", "Sector" : 1, "Patrolling" : true },
{ "_id" : 92413, "inspector" : "J. Clouseau", "Sector" : 2, "Patrolling" : false },
{ "_id" : 92414, "inspector" : "J. Clouseau", "Sector" : 3, "Patrolling" : true },
{ "_id" : 92415, "inspector" : "R. Coltrane", "Sector" : 3, "Patrolling" : false }

以下操作更新所有 Sector 大于 4 且 inspector 等于 "R. Coltrane" 的文档：

try {
   db.inspectors.updateMany(
      { "Sector" : { $gt : 4 }, "inspector" : "R. Coltrane" },
      { $set: { "Patrolling" : false } },
      { upsert: true }
   );
} catch (e) {
   print(e);
}

该操作返回：

{
   "acknowledged" : true,
   "matchedCount" : 0,
   "modifiedCount" : 0,
   "upsertedId" : ObjectId("56fc5dcb39ee682bdc609b02"),
   "upsertedCount": 1
}

该集合现在包含以下文档：

{ "_id" : 92412, "inspector" : "F. Drebin", "Sector" : 1, "Patrolling" : true },
{ "_id" : 92413, "inspector" : "J. Clouseau", "Sector" : 2, "Patrolling" : false },
{ "_id" : 92414, "inspector" : "J. Clouseau", "Sector" : 3, "Patrolling" : true },
{ "_id" : 92415, "inspector" : "R. Coltrane", "Sector" : 3, "Patrolling" : false },
{ "_id" : ObjectId("56fc5dcb39ee682bdc609b02"), "inspector" : "R. Coltrane", "Patrolling" : false }

由于没有文档与过滤器匹配，并且 upsert 是 true，updateMany() 使用生成的 _id、来自 filter 的相等条件以及 update 修饰符插入文档。

使用写关注更新

给定一个三成员副本集，以下操作指定 majority 的 w 和 100 的 wtimeout：

try {
   db.restaurant.updateMany(
       { "name" : "Pizza Rat's Pizzaria" },
       { $inc: { "violations" : 3}, $set: { "Closed" : true } },
       { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print(e);
}

如果确认花费的时间超过wtimeout限制，则会引发以下异常：

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})

下表解释了 errInfo.writeConcern.provenance 的可能值：

来源
说明

clientSupplied

应用程序中指定了写关注。

customDefault

写入关注源自自定义的默认值。请参阅 setDefaultRWConcern。

getLastErrorDefaults

写关注源自副本集的 settings.getLastErrorDefaults 字段。

implicitDefault

在没有所有其他写入关注规范的情况下，写入关注源自服务器。

指定排序规则。

排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号规则。

集合 myColl 包含以下文档：

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

以下操作包括排序规则选项：

db.myColl.updateMany(
   { category: "cafe" },
   { $set: { status: "Updated" } },
   { collation: { locale: "fr", strength: 1 } }
);

为数组更新操作指定 arrayFilters

更新数组字段时，您可以指定 arrayFilters 确定要更新哪些数组元素。

更新元素匹配 arrayFilters 条件

使用以下文档创建集合 students：

db.students.insertMany( [
   { "_id" : 1, "grades" : [ 95, 92, 90 ] },
   { "_id" : 2, "grades" : [ 98, 100, 102 ] },
   { "_id" : 3, "grades" : [ 95, 110, 100 ] }
] )

要更新 grades 数组中大于或等于 100 的所有元素，请使用带有 arrayFilters 选项的筛选位置运算符 $[<identifier>]：

db.students.updateMany(
   { grades: { $gte: 100 } },
   { $set: { "grades.$[element]" : 100 } },
   { arrayFilters: [ { "element": { $gte: 100 } } ] }
)

操作完成后，集合包含以下文档：

{ "_id" : 1, "grades" : [ 95, 92, 90 ] }
{ "_id" : 2, "grades" : [ 98, 100, 100 ] }
{ "_id" : 3, "grades" : [ 95, 100, 100 ] }

更新文档数组的特定元素

使用以下文档创建集合 students2：

db.students2.insertMany( [
   {
      "_id" : 1,
      "grades" : [
         { "grade" : 80, "mean" : 75, "std" : 6 },
         { "grade" : 85, "mean" : 90, "std" : 4 },
         { "grade" : 85, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "grade" : 90, "mean" : 75, "std" : 6 },
         { "grade" : 87, "mean" : 90, "std" : 3 },
         { "grade" : 85, "mean" : 85, "std" : 4 }
      ]
   }
] )

要修改 grades 数量中等级大于或等于 85 的所有元素的 mean 字段的值，请将过滤后的位置操作符 $[<identifier>] 与 arrayFilters 结合使用：

db.students2.updateMany(
   { },
   { $set: { "grades.$[elem].mean" : 100 } },
   { arrayFilters: [ { "elem.grade": { $gte: 85 } } ] }
)

操作完成后，集合有以下文档：

{
   "_id" : 1,
   "grades" : [
      { "grade" : 80, "mean" : 75, "std" : 6 },
      { "grade" : 85, "mean" : 100, "std" : 4 },
      { "grade" : 85, "mean" : 100, "std" : 6 }
   ]
}
{
   "_id" : 2,
   "grades" : [
      { "grade" : 90, "mean" : 100, "std" : 6 },
      { "grade" : 87, "mean" : 100, "std" : 3 },
      { "grade" : 85, "mean" : 100, "std" : 4 }
   ]
}

为更新操作指定 hint

使用以下文档创建示例 students 集合：

db.students.insertMany( [
   { "_id" : 1, "student" : "Richard", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 2, "student" : "Jane", "grade" : "A", "points" : 60,  "comments1" : "well behaved", "comments2" : "fantastic student" },
   { "_id" : 3, "student" : "Ronan", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 4, "student" : "Noah", "grade" : "D", "points" : 20,  "comments1" : "needs improvement", "comments2" : null },
   { "_id" : 5, "student" : "Adam", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 6, "student" : "Henry", "grade" : "A", "points" : 86,  "comments1" : "fantastic student", "comments2" : "well behaved" }
] )

在集合上创建以下索引：

db.students.createIndex( { grade: 1 } )

以下更新操作明确提示使用索引 { grade: 1 }：

注意

如果指定不存在的索引，则操作出错。

db.students.updateMany(
   { "points": { $lte: 20 }, "grade": "F" },
   { $set: { "comments1": "failed class" } },
   { hint: { grade: 1 } }
)

更新命令返回以下内容：

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

要查看是否使用提示索引，运行 $indexStats 管道：

db.students.aggregate( [ { $indexStats: { } }, { $sort: { name: 1 } }, { $match: {key: { grade: 1 } } } ] )

后退

db.collection.update

来年

db.collection.updateOne