db.collection.update() (mongosh method方法)

Replace Document Operations on a Sharded Collection替换分片集合上的文档操作

Replace document operations attempt to target a single shard, first by using the query filter. If the operation cannot target a single shard by the query filter, it then attempts to target by the replacement document.替换文档操作首先尝试使用查询筛选器来定位单个分片。如果操作无法通过查询筛选器定位单个分片，则它会尝试通过替换文档定位。

In earlier versions, the operation attempts to target using the replacement document.在早期版本中，该操作尝试使用替换文档作为目标。

upsert on a Sharded Collection分片集合的upsert

For a db.collection.update() 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.update()操作，您必须在筛选器中包含完整的分片键：

• For an update operation.用于更新操作。
• For a replace document operation.用于替换文档操作。

However, documents in a sharded collection can be missing the shard key fields. 但是，分片集合中的文档可能会缺少分片键字段。To target a document that is missing the shard key, you can use the null equality match in conjunction with another filter condition (such as on the _id field). For example:要针对缺少分片键的文档，您可以将null相等匹配与另一个筛选条件结合使用（例如在_id字段上）。例如：

{ _id: <value>, <shardkeyfield>: null } // _id of the document missing shard key

Shard Key Modification分片键修改

You can update a document's shard key value unless the shard key field is the immutable _id field.您可以更新文档的分片键值，除非分片键字段是不可变的_id字段。

To modify the existing shard key value with db.collection.update():要使用db.collection.update()修改现有的分片键值，请执行以下操作：

• You must run on a mongos. Do not issue the operation directly on the shard.必须在mongos上运行。不要直接在分片上执行操作。
• You must run either in a transaction or as a retryable write.您必须在事务中运行或作为可重试写入运行。
• You must specify multi: false.您必须指定multi:false。
• You must include an equality query filter on the full shard key.您必须在完整分片键上包含一个相等查询筛选器。

See also upsert on a Sharded Collection.另请参阅分片集合的upsert。

Missing Shard Key缺少分片钥匙

Documents in a sharded collection can be missing the shard key fields. 分片集合中的文档可能缺少分片键字段。To use db.collection.update() to set the document's missing shard key, you must run on a mongos. 要使用db.collection.update()设置文档缺少的分片键，您必须在mongos上运行。Do not issue the operation directly on the shard.不要直接在分片上执行操作。

In addition, the following requirements also apply:此外，以下要求也适用：

See also:另请参阅：

• upsert on a Sharded Collection分片集合的upsert
• Missing Shard Key Fields缺少分片键段

Upsert within Transactions事务中的失误

You can create collections and indexes inside a distributed transaction if the transaction is not a cross-shard write transaction.如果分布式事务不是跨分片写入事务，则可以在该事务内创建集合和索引。

db.collection.update() with upsert: true can be run on an existing collection or a non-existing collection. If run on a non-existing collection, the operation creates the collection.db.collection.update()配合upsert: true可以在现有集合或不存在的集合上运行。如果在不存在的集合上运行，则该操作将创建该集合。

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.要对事务使用写关注，请参阅事务和写关注。

Upsert with Duplicate Values出现重复值

Upserts can create duplicate documents, unless there is a unique index to prevent duplicates.除非有唯一索引来防止重复，否则Upsert可以创建重复的文档。

Consider an example where no document with the name Andy exists and multiple clients issue the following command at roughly the same time:考虑一个例子，其中不存在名为Andy的文档，多个客户端大约同时发出以下命令：

db.people.update(
   { name: "Andy" },
   { $inc: { score: 1 } },
   {
     upsert: true,
     multi: true
   }
)

If all update() operations finish the query phase before any client successfully inserts data, and there is no unique index on the name field, each update() operation may result in an insert, creating multiple documents with name: Andy.如果所有update()操作在任何客户端成功插入数据之前完成查询阶段，并且name字段上没有唯一索引，则每个update()运算都可能导致插入，从而创建多个name: Andy的文档。

A unique index on the name field ensures that only one document is created. With a unique index in place, the multiple update() operations now exhibit the following behavior:name字段上的唯一索引可确保只创建一个文档。有了唯一的索引，多个update()操作现在表现出以下行为：

• Exactly one update() operation will successfully insert a new document.只需执行一次update()操作，即可成功插入新文档。

• Other update() operations either update the newly-inserted document or fail due to a unique key collision.其他update()操作要么更新新插入的文档，要么由于唯一键冲突而失败。

  In order for other update() operations to update the newly-inserted document, all of the following conditions must be met:为了让其他update()操作更新新插入的文档，必须满足以下所有条件：

  • The target collection has a unique index that would cause a duplicate key error.目标集合具有唯一索引，这将导致重复键错误。
  • The update operation is not updateMany or multi is false.更新操作未updateMany或multi为false。

  • The update match condition is either:更新匹配条件为：

    • A single equality predicate. For example 一个等式谓词。例如{ "fieldA" : "valueA" }
    • A logical AND of equality predicates. For example 等式谓词的逻辑AND。例如{ "fieldA" : "valueA", "fieldB" : "valueB" }
  • The fields in the equality predicate match the fields in the unique index key pattern.相等谓词中的字段与唯一索引键模式中的字段匹配。
  • The update operation does not modify any fields in the unique index key pattern.更新操作不会修改唯一索引键模式中的任何字段。

The following table shows examples of upsert operations that, when a key collision occurs, either result in an update or fail.下表显示了当发生键冲突时，导致更新或失败的upsert操作示例。

{ name : 1 }

db.people.updateOne(
   { name: "Andy" },
   { $inc: { score: 1 } },
   { upsert: true }
)

{ name : 1 }

db.people.updateOne(
   { name: { $ne: "Joe" } },
   { $set: { name: "Andy" } },
   { upsert: true }
 )

{ name : 1 }

db.people.updateOne(
  { name: "Andy", email: "andy@xyz.com" },
  { $set: { active: false } },
  { upsert: true }
)

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. The following update operation uses an aggregation pipeline to:假设您不想将commentsSemester1和commentsSemester2字段分开，而是想将它们集合到一个新的comments字段中。以下更新操作使用聚合管道来：

• 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和commentsSemester2字段。

db.members.update(
   { },
   [
      { $set: { comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ],
   { multi: true }
)

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和commentsSemester2字段的当前内容，以及
• 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和commentsSemester2字段。

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

Perform Conditional Updates Based on Current Field Values根据当前字段值执行条件更新

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.update(
   { },
   [
     { $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"
     } } } }
   ],
   { multi: true }
)

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:29:35.340Z"), "average" : 92, "grade" : "A" }
{ "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2020-01-24T17:29:35.340Z"), "average" : 90, "grade" : "A" }
{ "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2020-01-24T17:29:35.340Z"), "average" : 75, "grade" : "C" }

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

To update all array elements which match a specified criteria, use the arrayFilters parameter.要更新符合指定条件的所有数组元素，请使用arrayFilters参数。

In mongosh, create a students collection with the following documents:在mongosh中，使用以下文档创建一个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的所有元素，请使用带arrayFilters选项的筛选位置运算符$[<identifier>]：

db.students.update(
   { grades: { $gte: 100 } },
   { $set: { "grades.$[element]" : 100 } },
   {
     multi: true,
     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更新文档数组的特定元素

You can also use the arrayFilters parameter to update specific document fields within an array of documents.您还可以使用arrayFilters参数更新文档数组中的特定文档字段。

In mongosh, create a students2 collection with the following documents:在mongosh中，使用以下文档创建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.update(
   { },
   { $set: { "grades.$[elem].mean" : 100 } },
   {
     multi: true,
     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 }
   ]
}