Docs Home → MongoDB Manual

db.collection.updateMany()

On this page本页内容

Definition定义

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

mongosh Method

This page documents a mongosh method. This is not the documentation for database commands or language-specific drivers, such as Node.js.

For the database command, see the update command.

For MongoDB API drivers, refer to the language-specific MongoDB driver documentation.

For the legacy mongo shell documentation, refer to the documentation for the corresponding MongoDB Server release:

mongo shell v4.4

Updates all documents that match the specified filter for a collection.更新与集合的指定筛选器匹配的所有文档。

Syntax语法

The updateMany() method has the following form:updateMany()方法的形式如下：

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>        // Available starting in MongoDB 4.2.1
   }
)

Parameters参数

The updateMany() method takes the following parameters:updateMany()方法采用以下参数：

Parameter参数Type类型Description描述
filterdocumentThe selection criteria for the update. 更新的选择条件。The same query selectors as in the find() method are available.可以使用与find()方法中相同的查询选择器。
Specify an empty document { } to update all documents in the collection. 指定一个空文档{ }以更新集合中的所有文档。
updatedocument or pipelineThe modifications to apply. Can be one of the following: 要应用的修改。可以是以下内容之一：
Update document更新文档Contains only update operator expressions.仅包含更新运算符表达式。
For more information, see Update with an Update Operator Expressions Document 有关详细信息，请参阅使用更新运算符表达式文档进行更新
Aggregation pipeline聚合管道 (Starting in MongoDB 4.2在MongoDB 4.2中启动)Contains only the following aggregation stages: 仅包含以下聚合阶段： For more information, see Update with an Aggregation Pipeline.有关详细信息，请参阅使用聚合管道进行更新。

To update with a replacement document, see db.collection.replaceOne().要使用替换文档进行更新，请参阅db.collection.replaceOne()。

upsertbooleanOptional.可选的。When true, updateMany() either: 当为true时，updateMany()可以：
  • Creates a new document if no documents match the filter. For more details see upsert behavior.如果没有与filter匹配的文档，则创建新文档。有关更多详细信息，请参阅upsert行为。
  • Updates documents that match the filter.更新与filter匹配的文档。
To avoid multiple upserts, ensure that the filter fields are uniquely indexed.为了避免出现多个混乱，请确保对filter字段进行唯一索引。
Defaults to false. 默认为false。
writeConcerndocumentOptional.可选的。A document expressing the write concern. 表示写入关注的文件。Omit to use the default write concern.忽略使用默认的写入关注。
Do not explicitly set the write concern for the operation if run in a transaction. 如果在事务中运行，请不要显式设置操作的写入关注。To use write concern with transactions, see Transactions and Write Concern. 要在事务中使用写入关注，请参阅事务和写入关注。
collationdocumentOptional.可选的。
Specifies the collation to use for the operation.指定要用于操作的collation。
collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。
The collation option has the following syntax: collation选项具有以下语法：
collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}
When specifying collation, the locale field is mandatory; all other collation fields are optional. 指定排序规则时，locale字段是必需的；所有其他排序规则字段都是可选的。For descriptions of the fields, see Collation Document.有关字段的说明，请参阅排序规则文档。
If the collation is unspecified but the collection has a default collation (see db.createCollection()), the operation uses the collation specified for the collection.如果未指定排序规则，但集合具有默认排序规则（请参见db.createCollection()），则操作将使用为集合指定的排序规则。
If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons.如果没有为集合或操作指定排序规则，MongoDB将使用以前版本中使用的简单二进制比较进行字符串比较。
You cannot specify multiple collations for an operation. 不能为一个操作指定多个排序规则。For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort. 例如，不能为每个字段指定不同的排序规则，或者如果使用排序执行查找，则不能为查找使用一个排序规则，为排序使用另一个排序顺序。
arrayFiltersarrayOptional.可选的。An array of filter documents that determine which array elements to modify for an update operation on an array field.一组筛选文档，用于确定要为数组字段的更新操作修改哪些数组元素。
In the update document, use the $[<identifier>] filtered positional operator to define an identifier, which you then reference in the array filter documents. 在更新文档中，使用$[<identifier>]筛选的位置运算符来定义标识符，然后在数组筛选文档中引用该标识符。You cannot have an array filter document for an identifier if the identifier is not included in the update document. 如果标识符未包含在更新文档中，则不能为该标识符设置数组筛选器文档。
Note
The <identifier> must begin with a lowercase letter and contain only alphanumeric characters. <identifier>必须以小写字母开头，并且仅包含字母数字字符。
You can include the same identifier multiple times in the update document; however, for each distinct identifier ($[identifier]) in the update document, you must specify exactly one corresponding array filter document. 您可以在更新文档中多次包含相同的标识符；但是，对于更新文档中的每个不同标识符（$[identifier]），必须指定一个对应的数组筛选器文档。That is, you cannot specify multiple array filter documents for the same identifier. 也就是说，不能为同一标识符指定多个数组筛选器文档。For example, if the update statement includes the identifier x (possibly multiple times), you cannot specify the following for arrayFilters that includes 2 separate filter documents for x: 例如，如果更新语句包含标识符x（可能多次），则不能为arrayFilters指定以下内容，因为arrayFilters包含两个单独的x筛选文档：
// INVALID

[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]
However, you can specify compound conditions on the same identifier in a single filter document, such as in the following examples: 但是，您可以在单个筛选器文档中对同一标识符指定复合条件，例如以下示例：
// 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 } }
]
For examples, see Specify arrayFilters for an Array Update Operations. 有关示例，请参阅为数组更新操作指定arrayFilters。
hintDocument or stringOptional.可选的。A document or string that specifies the index to use to support the query predicate.指定用于支持查询谓词的索引的文档或字符串。
The option can take an index specification document or the index name string.该选项可以采用索引规范文档或索引名称字符串。
If you specify an index that does not exist, the operation errors.如果指定的索引不存在，则操作将出错。
For an example, see Specify hint for Update Operations. 有关示例，请参阅为更新操作指定hint。
New in version 4.2.1. 4.2.1版新增。

Returns返回值

The method returns a document that contains:该方法返回一个文档，该文档包含：

  • A boolean acknowledged as true if the operation ran with write concern or false if write concern was disabled如果操作在有写入关注的情况下运行，则布尔值acknowledged为true；如果写入关注被禁用，则acknowledged为false
  • matchedCount containing the number of matched documents包含匹配的文档数
  • modifiedCount containing the number of modified documents包含修改的文档数
  • upsertedId containing the _id for the upserted document包含被打乱的文档的_id

Access Control访问控制

On deployments running with authorization, the user must have access that includes the following privileges:在使用authorization运行的部署上，用户必须具有包括以下权限的访问权限：

  • update action on the specified collection(s).对指定集合执行操作。
  • find action on the specified collection(s).对指定集合执行操作。
  • insert action on the specified collection(s) if the operation results in an upsert.如果操作导致追加销售，则对指定集合执行操作。

The built-in role readWrite provides the required privileges.内置角色readWrite提供所需的权限。

Behavior行为

updateMany() updates all matching documents in the collection that match the filter, using the update criteria to apply modifications.使用update条件应用修改，更新集合中与filter匹配的所有匹配文档。

Upsert

If upsert: true and no documents match the filter, db.collection.updateMany() creates a new document based on the filter and update parameters.如果upsert: true并且没有文档与filter匹配，那么db.collection.updateMany()将根据筛选器和更新参数创建一个新文档。

If you specify upsert: true on a sharded collection, you must include the full shard key in the filter. 如果在分片集合上指定upsert: true，则必须在filter中包含完整的分片键。For additional db.collection.updateMany() behavior, see Sharded Collections.有关其他db.collection.updateMany()行为，请参阅分片集合。

See Update Multiple Documents with Upsert.请参见使用Upsert更新多个文档。

Update with an Update Operator Expressions Document使用更新运算符表达式文档进行更新

For the modification specification, the db.collection.updateMany() method can accept a document that only contains update operator expressions to perform.对于修改规范，db.collection.updateMany()方法可以接受只包含要执行的更新运算符表达式的文档。

For example:例如：

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

Update with an Aggregation Pipeline使用聚合管道更新

Starting in MongoDB 4.2, the db.collection.updateMany() method can accept an aggregation pipeline [ <stage1>, <stage2>, ... ] that specifies the modifications to perform. 从MongoDB 4.2开始，db.collection.updateMany()方法可以接受一个指定要执行的修改的聚合管道[ <stage1>, <stage2>, ... ]。The pipeline can consist of the following stages:管道可由以下阶段组成：

Using the aggregation pipeline allows for a more expressive update statement, such as expressing conditional updates based on current field values or updating one field using the value of another field(s).使用聚合管道可以实现更具表达力的更新语句，例如基于当前字段值表达条件更新，或者使用另一个字段的值更新一个字段。

For example:例如：

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

The $set and $unset used in the pipeline refers to the aggregation stages $set and $unset respectively, and not the update operators $set and $unset.管道中使用的$set和$unset分别指聚合阶段$set和$unset，而不是更新运算符$set和$unset。

For examples, see Update with Aggregation Pipeline.有关示例，请参阅使用聚合管道进行更新。

Capped Collections封顶集合

If an update operation changes the document size, the operation will fail.如果更新操作更改了文档大小，则该操作将失败。

Time Series Collections时间序列集合

The updateMany() method is available for time series collections starting in MongoDB 5.1.updateMany()方法可用于MongoDB 5.1中开始的时间序列集合。

Update commands must meet the following requirements:更新命令必须满足以下要求：

  • You can only match on the metaField field value.只能在metaField字段值上匹配。
  • You can only modify the metaField field value.您只能修改metaField字段值。
  • Your update document can only contain update operator expressions.更新文档只能包含更新运算符表达式。
  • Your update command must not limit the number of documents to be updated. 更新命令不得限制要更新的文档数。Set multi: true or use the updateMany() method.设置multi:true或使用updateMany()方法。
  • Your update command must not set upsert: true.您的更新命令不得设置upsert：true。

Sharded Collections分片集合

For a db.collection.updateMany() operation that includes upsert: true and is on a sharded collection, you must include the full shard key in the filter.对于包含upsert:true并且位于分片集合上的db.collection.updateMany()操作，必须在filter中包含完整的分片键。

Explainability解释能力

updateMany() is not compatible with db.collection.explain().

Transactions事务

db.collection.updateMany() can be used inside multi-document transactions.可以在多文档事务中使用。

Important

In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. 在大多数情况下，与单文档写入相比，多文档事务会产生更高的性能成本，并且多文档事务的可用性不应取代有效的模式设计。For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. 对于许多场景，非规范化数据模型（嵌入文档和数组）将继续是您的数据和用例的最佳选择。That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.也就是说，对于许多场景，对数据进行适当建模将最大限度地减少对多文档事务的需求。

For additional transactions usage considerations (such as runtime limit and oplog size limit), see also Production Considerations.有关其他事务使用注意事项（如运行时限制和操作日志大小限制），请参阅生产注意事项。

Upsert within Transactions事务中的Upsert

Starting in MongoDB 4.4, you can create collections and indexes inside a multi-document transaction if the transaction is not a cross-shard write transaction.从MongoDB 4.4开始，如果多文档事务不是跨分片写入事务，则可以在该事务内创建集合和索引。

Specifically, in MongoDB 4.4 and greater, db.collection.updateMany() with upsert: true can be run on an existing collection or a non-existing collection. 具体来说，在MongoDB 4.4及更高版本中，具有upsert:true的db.collection.updateMany()可以在现有集合或不存在的集合上运行。If run on a non-existing collection, the operation creates the collection.如果在不存在的集合上运行，则该操作将创建该集合。

In MongoDB 4.2 and earlier, the operation must be run on an existing collection.在MongoDB 4.2及更早版本中，操作必须在现有集合上运行。

Tip

See also: 另请参阅：

Create Collections and Indexes In a Transaction在事务中创建集合和索引

Write Concerns and Transactions撰写关注事项和事务

Do not explicitly set the write concern for the operation if run in a transaction. 如果在事务中运行，请不要显式设置操作的写入关注。To use write concern with transactions, see Transactions and Write Concern.要在事务中使用写入关注，请参阅事务和写入关注。

Examples实例

Update Multiple Documents更新多个文档

The restaurant collection contains the following documents: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 }

The following operation updates all documents where violations are greater than 4 and $set a flag for review:以下操作将更新violations（违规次数）大于4的所有文档，并$set一个标志以供审查：

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

The operation returns:操作返回：

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

The collection now contains the following documents:该集合现在包含以下文档：

{ "_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 }

If no matches were found, the operation instead returns:如果未找到匹配项，则操作将返回：

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

Setting upsert: true would insert a document if no match was found.如果未找到匹配项，则设置upsert: true将插入文档。

Update with Aggregation Pipeline使用聚合管道更新

Starting in MongoDB 4.2, the db.collection.updateMany() can use an aggregation pipeline for the update. The pipeline can consist of the following stages:从MongoDB 4.2开始，db.collection.updateMany()可以使用聚合管道进行更新。管道可由以下阶段组成：

Using the aggregation pipeline allows for a more expressive update statement, such as expressing conditional updates based on current field values or updating one field using the value of another field(s).使用聚合管道可以实现更具表达力的更新语句，例如基于当前字段值表达条件更新，或者使用另一个字段的值更新一个字段。

Example 1: Update with Aggregation Pipeline Using Existing Fields示例1：使用现有字段使用聚合管道进行更新

The following examples uses the aggregation pipeline to modify a field using the values of the other fields in the document.以下示例使用聚合管道使用文档中其他字段的值修改字段。

Create a students collection with the following documents:使用以下文档创建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") }
] )

Assume that instead of separate commentsSemester1 and commentsSemester2 fields, you want to gather these into a new comments field. 假设您不想将commentsSemester1和commentsSomester2字段分开，而是想将它们聚集到一个新的comments字段中。The following update operation uses an aggregation pipeline to:

  • add the new comments field and set the lastUpdate field.添加新的comments字段并设置lastUpdate字段。
  • remove the commentsSemester1 and commentsSemester2 fields for all documents in the collection.删除集合中所有文档的commentsSemester1和commentsSomester2字段。
db.students.updateMany(
   { },
   [
      { $set: { comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ]
)
Note

The $set and $unset used in the pipeline refers to the aggregation stages $set and $unset respectively, and not the update operators $set and $unset.管道中使用的$set和$unset分别指聚合阶段$set和$unset，而不是更新运算符$set和$unset。

First Stage第一阶段

The $set stage:$set阶段：

  • creates a new array field comments whose elements are the current content of the commentsSemester1 and commentsSemester2 fields and创建一个新的数组字段comments，其元素是commentsSemester1和commentsSomester2字段的当前内容
  • sets the field lastUpdate to the value of the aggregation variable NOW. 将字段lastUpdate设置为聚合变量NOW的值。The aggregation variable NOW resolves to the current datetime value and remains the same throughout the pipeline. 聚合变量NOW解析为当前日期时间值，并在整个管道中保持不变。To access aggregation variables, prefix the variable with double dollar signs $$ and enclose in quotes.要访问聚合变量，请在变量前面加上双美元符号$$并用引号括起来。
Second Stage第二阶段
The $unset stage removes the commentsSemester1 and commentsSemester2 fields.$unset阶段删除commentsSemester1和commentsSemoster2字段。

After the command, the collection contains the following documents:命令之后，集合包含以下文档：

{ "_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" ] }

Example 2: Update with Aggregation Pipeline Using Existing Fields Conditionally示例2：有条件地使用现有字段使用聚合管道进行更新

The aggregation pipeline allows the update to perform conditional updates based on the current field values as well as use current field values to calculate a separate field value.聚合管道允许更新基于当前字段值执行条件更新，并使用当前字段值计算单独的字段值。

For example, create a students3 collection with the following documents:例如，使用以下文档创建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") }
] )

Using an aggregation pipeline, you can update the documents with the calculated grade average and letter grade.使用聚合管道，可以使用计算出的平均成绩和字母成绩更新文档。

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"
     } } } }
   ]
)
Note

The $set used in the pipeline refers to the aggregation stage $set, and not the update operators $set.管道中使用的$set指的是聚合阶段$set，而不是更新运算符$set。

First Stage第一阶段

The $set stage:$set阶段：

  • calculates a new field average based on the average of the tests field. 基于tests字段的平均值来计算新的字段average。See $avg for more information on the $avg aggregation operator and $trunc for more information on the $trunc truncate aggregation operator.有关$avg聚合运算符的详细信息，请参阅$avg；有关$trunc截断聚合运算符的更多信息，请参阅$trunc。
  • sets the field lastUpdate to the value of the aggregation variable NOW. 将字段lastUpdate设置为聚合变量NOW的值。The aggregation variable NOW resolves to the current datetime value and remains the same throughout the pipeline. 聚合变量NOW解析为当前日期时间值，并在整个管道中保持不变。To access aggregation variables, prefix the variable with double dollar signs $$ and enclose in quotes.要访问聚合变量，请在变量前面加上双美元符号$$并用引号括起来。
Second Stage第二阶段
The $set stage calculates a new field grade based on the average field calculated in the previous stage. $set阶段根据上一阶段中计算的average字段来计算新的字段grade。See $switch for more information on the $switch aggregation operator.有关$switch聚合运算符的详细信息，请参阅$switch。

After the command, the collection contains the following documents:命令之后，集合包含以下文档：

{ "_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" }
Tip

See also: 另请参阅：

Updates with Aggregation Pipeline使用聚合管道进行更新

Update Multiple Documents with Upsert使用Upsert更新多个文档

The inspectors collection contains the following documents: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 }

The following operation updates all documents with Sector greater than 4 and inspector equal to "R. Coltrane":以下操作更新Sector大于4且inspector等于"R. Coltrane"的所有文档：

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

The operation returns:操作返回：

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

The collection now contains the following documents:该集合现在包含以下文档：

{ "_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 }

Since no documents matched the filter, and upsert was true, updateMany() inserted the document with a generated _id, the equality conditions from the filter, and the update modifiers.由于没有文档与筛选器匹配，并且upsert为true，updateMany()插入了具有生成的_id、filter中的相等条件和update修饰符的文档。

Update with Write Concern带写入关注的更新

Given a three member replica set, the following operation specifies a w of majority and wtimeout of 100:给定一个由三个成员组成的复制集，以下操作指定w为majority，wtimeout为100：

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

If the acknowledgement takes longer than the wtimeout limit, the following exception is thrown:如果确认花费的时间超过wtimeout限制，则引发以下异常：

Changed in version 4.4.4.4版更改。

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

The following table explains the possible values of errInfo.writeConcern.provenance:下表解释了errInfo.writeConcern.provenance出处的可能值：

Provenance来源Description描述
clientSuppliedThe write concern was specified in the application.写入关注已在应用程序中指定。
customDefaultThe write concern originated from a custom defined default value. 写入关注源自自定义定义的默认值。See setDefaultRWConcern.请参阅setDefaultRWConcern。
getLastErrorDefaultsThe write concern originated from the replica set's settings.getLastErrorDefaults field.写入关注源自复制副本集的settings.getLastErrorDefaults字段。
implicitDefaultThe write concern originated from the server in absence of all other write concern specifications.在没有所有其他写入关注规范的情况下，写入关注源自服务器。

Specify Collation指定排序规则

collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。

A collection myColl has the following documents:集合myColl包含以下文档：

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

The following operation includes the collation option:以下操作包括collation选项：

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

Specify arrayFilters for an Array Update Operations为数组更新操作指定arrayFilters

Starting in MongoDB 3.6, when updating an array field, you can specify arrayFilters that determine which array elements to update.从MongoDB 3.6开始，在更新数组字段时，可以指定arrayFilters来确定要更新的数组元素。

Update Elements Match arrayFilters Criteria更新匹配arrayFilters条件的元素

Create a collection students with the following documents:使用以下文档创建students集合：

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

To update all elements that are greater than or equal to 100 in the grades array, use the filtered positional operator $[<identifier>] with the arrayFilters option:要更新grades数组中大于或等于100的所有元素，请将已筛选的位置运算符$[<identifier>]与arrayFilters选项一起使用：

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

After the operation, the collection contains the following documents:操作后，集合包含以下文档：

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

Update Specific Elements of an Array of Documents更新文档数组的特定元素

Create a collection students2 with the following documents:使用以下文档创建集合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 }
      ]
   }
] )

To modify the value of the mean field for all elements in the grades array where the grade is greater than or equal to 85, use the filtered positional operator $[<identifier>] with the arrayFilters:要修改grades数组中等级大于或等于85的所有元素的mean字段值，请将筛选后的位置运算符$[<identifier>]与arrayFilters一起使用：

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

After the operation, the collection has the following documents:操作后，集合具有以下文档：

{
   "_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 }
   ]
}

Specify hint for Update Operations指定更新操作的hint

New in version 4.2.1. 4.2.1版新增。

Create a sample students collection with the following documents:使用以下文档创建示例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" }
] )

Create the following indexes on the collection:在集合上创建以下索引：

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

The following update operation explicitly hints to use the index { grade: 1 }:以下更新操作明确提示使用索引{ grade: 1 }：

Note

If you specify an index that does not exist, the operation errors.如果指定的索引不存在，则操作将出错。

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

The update command returns the following:update命令返回以下内容：

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

To see the index used, run explain on the operation:要查看使用的索引，请对操作运行explain：

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

User Roles and Document Updates用户角色和文档更新

Starting in MongoDB 7.0, you can use the new USER_ROLES system variable to return user roles.从MongoDB 7.0开始，您可以使用新的USER_ROLES系统变量来返回用户角色。

The example in this section shows updates to fields in a collection containing medical information. 本节中的示例显示了对包含医疗信息的集合中的字段的更新。The example reads the current user roles from the USER_ROLES system variable and only performs the updates if the user has a specific role.此示例从USER_ROLES系统变量中读取当前用户角色，并且仅当用户具有特定角色时才执行更新。

To use a system variable, add $$ to the start of the variable name. Specify the USER_ROLES system variable as $$USER_ROLES.要使用系统变量，请在变量名的开头添加$$。将USER_ROLES系统变量指定为$$USER_ROLES。

The example creates these users:该示例创建了以下用户：

  • James with a Billing role.James具有Billing角色。
  • Michelle with a Provider role.Michelle具有Provider角色。

Perform the following steps to create the roles, users, and collection:执行以下步骤以创建角色、用户和集合：

1

Create the roles创建角色

Create roles named Billing and Provider with the required privileges and resources.创建具有所需权限和资源的名为Billing和Provider的角色。

Run:

db.createRole( { role: "Billing", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )
db.createRole( { role: "Provider", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )
2

Create the users创建用户

Create users named James and Michelle with the required roles.创建具有所需角色的名为James和Michelle的用户。

db.createUser( {
   user: "James",
   pwd: "js008",
   roles: [
      { role: "Billing", db: "test" }
   ]
} )

db.createUser( {
   user: "Michelle",
   pwd: "me009",
   roles: [
      { role: "Provider", db: "test" }
   ]
} )
3

Create the collection创建集合

Run:运行：

db.medical.insertMany( [
   {
      _id: 0,
      patientName: "Jack Jones",
      diagnosisCode: "CAS 17",
      creditCard: "1234-5678-9012-3456"
   },
   {
      _id: 1,
      patientName: "Mary Smith",
      diagnosisCode: "ACH 01",
      creditCard: "6541-7534-9637-3456"
   }
] )

Log in as as Michelle, who has the Provider role, and perform an update:以Michelle的身份登录，Michelle具有Provider角色，并执行更新：

1

Log in as Michelle以Michelle身份登录

Run:运行：

db.auth( "Michelle", "me009" )
2

Perform update执行更新

Run:运行：

// Attempt to update many documents
db.medical.updateMany(
   // User must have the Provider role to perform the update
   { $expr: { $ne: [ {
      $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ] }, []
   ] } },
   // Update diagnosisCode
   { $set: { diagnosisCode: "ACH 02"} }
)

The previous example uses $setIntersection to return documents where the intersection between the "Provider" string and the user roles from $$USER_ROLES.role is not empty. 上一个示例使用$setIntersection返回"Provider"字符串与$$USER_ROLES.role中的用户角色之间的交集不为空的文档。Michelle has the Provider role, so the update is performed.Michelle具有Provider角色，因此执行更新。

Next, log in as as James, who does not have the Provider role, and attempt to perform the same update:接下来，以James的身份登录，James没有提供程序角色，并尝试执行相同的更新：

1

Log in as James以James身份登录

Run:运行：

db.auth( "James", "js008" )
2

Attempt to perform update尝试执行更新

Run:运行：

// Attempt to update many documents
db.medical.updateMany(
   // User must have the Provider role to perform the update
   { $expr: { $ne: [ {
      $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ] }, []
   ] } },
   // Update diagnosisCode
   { $set: { diagnosisCode: "ACH 02"} }
)

The previous example does not update any documents.上一个示例不更新任何文档。