update (database command)（数据库命令）

Update Statements更新语句

Each element of the updates array is an update statement document. Each document contains the following fields:updates数组的每个元素都是一个更新语句文档。每个文档包含以下字段：

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

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

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

Returns返回

The command returns a document that contains the status of the operation. For example:该命令返回一个包含操作状态的文档。例如：

{
   "ok" : 1,
   "nModified" : 0,
   "n" : 1,
   "upserted" : [
      {
         "index" : 0,
         "_id" : ObjectId("52ccb2118908ccd753d65882")
      }
   ]
}

For details of the output fields, see Output.有关输出字段的详细信息，请参阅输出。

Limitations局限性

If you set multi: true, use the update command only for idempotent operations.如果设置multi:true，则仅对幂等操作使用update命令。

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

The update statement field u can accept a document that only contains update operator expressions. For example:更新语句字段u可以接受仅包含更新运算符表达式的文档。例如：

updates: [
   {
     q: <query>,
     u: { $set: { status: "D" }, $inc: { quantity: 2 } },
      ...
   },
   ...
]

Then, the update command updates only the corresponding fields in the document.然后，update命令仅更新文档中的相应字段。

Update with a Replacement Document使用替换文档进行更新

The update statement field u field can accept a replacement document, i.e. the document contains only field:value expressions. For example:更新语句字段u字段可以接受替换文档，即文档仅包含field:value表达式。例如：

updates: [
   {
      q: <query>,
      u: { status: "D", quantity: 4 },
      ...
   },
   ...
]

Then the update command replaces the matching document with the update document. 然后，update命令将匹配的文档替换为更新文档。The update command can only replace a single matching document; i.e. the multi field cannot be true. update命令只能替换单个匹配的文档；即multi字段不能为true。The update command does not replace the _id value.update命令不会替换_id值。

Multi-Update Failures多次更新失败

If a single document fails to update in an update command with the multi parameter set to true, no further documents update as part of that command.如果在multi参数设置为true的更新命令中，单个文档无法更新，则该命令中不会有其他文档更新。

For example, create a members collection with the following documents:例如，使用以下文档创建members集合：

db.members.insertMany( [
   { "_id" : 1, "member" : "Taylor", "status" : "pending", "points" : 1},
   { "_id" : 2, "member" : "Alexis", "status" : "enrolled", "points" : 59},
   { "_id" : 3, "member" : "Elizabeth", "status" : "enrolled", "points" : 34}
] )

The following operation creates a document validator on the members collection with a rule that the points value can not equal 60.以下操作使用points值不能等于60的规则在members集合上创建文档验证器。

db.runCommand( {
   collMod: "members",
   validator: { points: { $ne: 60 } }
} )

This update command increases the points field of every document by 1.此更新命令将每个文档的points数字段增加1。

db.runCommand(
 {
    update: "members",
    updates: [
     {
         q: {},
         u: { $inc: { points: 1 } },
         multi: true
     }
    ]
 }
)

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

{ _id: 1, member: 'Taylor', status: 'A', points: 2 }
{ _id: 2, member: 'Alexis', status: 'D', points: 59 }
{ _id: 3, member: 'Elizabeth', status: 'C', points: 34 }

The update command updated the points value of the first document but failed to update the second document because of the validator rule that the points value can not equal 60. The third document did not update because no further documents update following a write error.更新命令更新了第一个文档的points值，但由于验证器规则points值不能等于60，因此无法更新第二个文档。第三个文档没有更新，因为在写入错误后没有其他文档更新。

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

The update statement field u field can accept an aggregation pipeline [ <stage1>, <stage2>, ... ] that specifies the modifications to perform. The pipeline can consist of the following stages:更新语句字段u字段可以接受指定要执行的修改的聚合管道[ <stage1>, <stage2>, ... ]。该管道可以由以下阶段组成：

• $addFields and its alias 及其别名$set
• $project and its alias 及其别名$unset
• $replaceRoot and its alias 及其别名$replaceWith

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:例如：

updates: [
   {
      q: <query>,
      u: [
        { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
        { $unset: [ "misc1", "misc2" ] }
      ],
      ...
   },
   ...
]

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

Upsert with Unique Index使用唯一索引进行upsert

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.runCommand(
   {
     update: "people",
     updates: [
       { q: { name: "Andy" }, u: { $inc: { score: 1 } }, multi: true, upsert: 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操作都可能导致插入，从而创建多个名为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 }
)

Limits限制

For each update element in the updates array, the sum of the query and the update sizes (i.e. q and u ) must be less than or equal to the maximum BSON document size.对于updates数组中的每个更新元素，查询和更新大小之和（即q和u）必须小于或等于BSON文档的最大大小。

The total number of update statements in the updates array must be less than or equal to the maximum bulk size.updates数组中的更新语句总数必须小于或等于最大批量大小。

Schema Validation模式验证

The update command adds support for the bypassDocumentValidation option, which lets you bypass schema validation when inserting or updating documents in a collection with validation rules.>update命令添加了对bypassDocumentValidation选项的支持，该选项允许您在使用验证规则在集合中插入或更新文档时绕过模式验证。

Sharded Collections分片化集合

Transactions事务

update can be used inside distributed transactions.可以在分布式事务中使用。

Update Specific Fields of One Document更新一个文档的特定字段

Use update operators to update only the specified fields of a document.使用更新运算符仅更新文档的指定字段。

For example, create a members collection with the following documents:例如，使用以下文档创建members集合：

db.members.insertMany([
   { _id: 1, member: "abc123", status: "Pending", points: 0, misc1: "note to self: confirm status", misc2: "Need to activate" },
   { _id: 2, member: "xyz123", status: "D", points: 59, misc1: "reminder: ping me at 100pts", misc2: "Some random comment" },
])

The following command uses the $set and $inc update operators to update the status and the points fields of a document where the member equals "abc123":以下命令使用$set和$inc更新运算符来更新文档的status和points字段，其中成员等于“abc123”：

db.runCommand(
   {
      update: "members",
      updates: [
         {
           q: { member: "abc123" }, u: { $set: { status: "A" }, $inc: { points: 1 } }
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

Because <update> document does not specify the optional multi field, the update only modifies one document, even if more than one document matches the q match condition.因为<update>文档没有指定可选的multi字段，所以即使有多个文档符合q匹配条件，更新也只会修改一个文档。

The returned document shows that the command found and updated a single document. The command returns:返回的文档显示该命令找到并更新了一个文档。命令返回：

{ "n" : 1, "nModified" : 1, "ok" : 1, <additional fields if run on a replica set/sharded cluster> }

See Output for details.详见输出。

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

{ "_id" : 1, "member" : "abc123", "status" : "A", "points" : 1, "misc1" : "note to self: confirm status", "misc2" : "Need to activate" }
{ "_id" : 2, "member" : "xyz123", "status" : "D", "points" : 59, "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }

Update Specific Fields of Multiple Documents更新多个文档的特定字段

Use update operators to update only the specified fields of a document, and include the multi field set to true in the update statement.使用更新运算符仅更新文档的指定字段，并在更新语句中将multi字段设置为true。

For example, a members collection contains the following documents:例如，members集合包含以下文档：

{ "_id" : 1, "member" : "abc123", "status" : "A", "points" : 1, "misc1" : "note to self: confirm status", "misc2" : "Need to activate" }
{ "_id" : 2, "member" : "xyz123", "status" : "D", "points" : 59, "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }

The following command uses the $set and $inc update operators to modify the status and the points fields respectively of all documents in the collection:以下命令使用$set和$inc更新运算符分别修改集合中所有文档的status字段和points字段：

db.runCommand(
   {
      update: "members",
      updates: [
         { q: { }, u: { $set: { status: "A" }, $inc: { points: 1 } }, multi: true }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

The update modifies all documents that match the query specified in the q field, namely the empty query which matches all documents in the collection.更新将修改与q字段中指定的查询匹配的所有文档，即与集合中的所有文档匹配的空查询。

The returned document shows that the command found and updated multiple documents. For a replica set, the command returns:返回的文档显示该命令找到并更新了多个文档。对于副本集，该命令返回：

{ "n" : 2, "nModified" : 2, "ok" : 1,  <additional fields if run on a replica set/sharded cluster> }

See Output for details.详见输出。

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

{ "_id" : 1, "member" : "abc123", "status" : "A", "points" : 2, "misc1" : "note to self: confirm status", "misc2" : "Need to activate" }
{ "_id" : 2, "member" : "xyz123", "status" : "A", "points" : 60, "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }

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

The update command can use an aggregation pipeline for the update. The pipeline can consist of the following stages:update命令可以使用聚合管道进行更新。管道可包括以下阶段：

• $addFields and its alias 及其别名$set
• $project and its alias 及其别名$unset
• $replaceRoot and its alias 及其别名$replaceWith

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).使用聚合管道允许更具表现力的更新语句，例如基于当前字段值表示条件更新，或使用另一个字段的值更新一个字段。

{ "_id" : 1, "member" : "abc123", "status" : "A", "points" : 2, "misc1" : "note to self: confirm status", "misc2" : "Need to activate" }
{ "_id" : 2, "member" : "xyz123", "status" : "A", "points" : 60, "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }

db.runCommand(
   {
      update: "members",
      updates: [
         {
           q: { },
           u: [
              { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
              { $unset: [ "misc1", "misc2" ] }
           ],
           multi: true
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

{ "n" : 2, "nModified" : 2, "ok" : 1, <additional fields if run on a replica set/sharded cluster> }

{ "_id" : 1, "member" : "abc123", "status" : "Modified", "points" : 2, "comments" : [ "note to self: confirm status", "Need to activate" ] }
{ "_id" : 2, "member" : "xyz123", "status" : "Modified", "points" : 60, "comments" : [ "reminder: ping me at 100pts", "Some random comment" ] }

db.students.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ] },
   { "_id" : 2, "tests" : [ 94, 88, 90 ] },
   { "_id" : 3, "tests" : [ 70, 75, 82 ] }
] );

db.runCommand(
   {
      update: "students",
      updates: [
         {
           q: { },
           u: [
                 { $set: { average : { $avg: "$tests" } } },
                 { $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
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

{ "n" : 3, "nModified" : 3, "ok" : 1, <additional fields if run on a replica set/sharded cluster> }

{ "_id" : 1, "tests" : [ 95, 92, 90 ], "average" : 92.33333333333333, "grade" : "A" }
{ "_id" : 2, "tests" : [ 94, 88, 90 ], "average" : 90.66666666666667, "grade" : "A" }
{ "_id" : 3, "tests" : [ 70, 75, 82 ], "average" : 75.66666666666667, "grade" : "C" }

Bulk Update批量更新

The following example performs multiple update operations on the members collection:以下示例对members集合执行多个更新操作：

db.runCommand(
   {
      update: "members",
      updates: [
         { q: { status: "P" }, u: { $set: { status: "D" } }, multi: true },
         { q: { _id: 5 }, u: { _id: 5, name: "abc123", status: "A" }, upsert: true }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

The returned document shows that the command modified 10 documents and inserted a document with the _id value 5. See Output for details.返回的文档显示，该命令修改了10个文档，并插入了一个_id值为5的文档。详见输出。

{
   "ok" : 1,
   "nModified" : 10,
   "n" : 11,
   "upserted" : [
      {
         "index" : 1,
         "_id" : 5
      }
   ]
}

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.runCommand({
   update: "myColl",
   updates: [
     { q: { category: "cafe", status: "a" }, u: { $set: { status: "Updated" } }, collation: { locale: "fr", strength: 1 } }
   ]
})

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

When updating an array field, you can specify arrayFilters that determine which array elements to update.更新数组字段时，可以指定arrayFilters来确定要更新的数组元素。

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

db.runCommand( {
   update: "students",
   updates: [
     { q: { grades: { $gte: 100 } }, u: { $set: { "grades.$[element]" : 100 } }, arrayFilters: [ { "element": { $gte: 100 } } ], multi: true}
   ]
} )

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

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

db.runCommand({
   update: "students2",
   updates: [
     { q: { }, u: { $set: { "grades.$[elem].mean" : 100 } }, arrayFilters: [ { "elem.grade": { $gte: 85 } } ], multi: true }
   ]
})

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

Create a sample members collection with the following documents:使用以下文档创建示例members集合：

db.members.insertMany([
   { "_id" : 1, "member" : "abc123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 2, "member" : "xyz123", "status" : "A", "points" : 60,  "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" },
   { "_id" : 3, "member" : "lmn123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 4, "member" : "pqr123", "status" : "D", "points" : 20,  "misc1" : "Deactivated", "misc2" : null },
   { "_id" : 5, "member" : "ijk123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 6, "member" : "cde123", "status" : "A", "points" : 86,  "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }
])

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

db.members.createIndex( { status: 1 } )
db.members.createIndex( { points: 1 } )

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

db.runCommand({
   update: "members",
   updates: [
     { q: { "points": { $lte: 20 }, "status": "P" }, u: { $set: { "misc1": "Need to activate" } }, hint: { status: 1 }, multi: true }
   ]
})

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

{ "n" : 3, "nModified" : 3, "ok" : 1 }

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

db.runCommand(
   {
     explain: {
       update: "members",
       updates: [
         { q: { "points": { $lte: 20 }, "status": "P" }, u: { $set: { "misc1": "Need to activate" } }, hint: { status: 1 }, multi: true }
       ]
     },
     verbosity: "queryPlanner"
   }
)

The explain does not modify the documents.explain不会修改文件。

Use Variables in let Option or c Field在let选项或c字段中使用变量

Variables can be defined in the let option or the c field and accessed in the updates array.变量可以在let选项或c字段中定义，并在updates数组中访问。

Create a collection cakeFlavors:创建一个系列cakeFlavors：

db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

The following example defines targetFlavor and newFlavor variables in let and uses the variables to change the cake flavor from cherry to orange:以下示例在let中定义了targetFlavor和newFlavor变量，并使用这些变量将蛋糕风味从樱桃味更改为橙色：

db.runCommand( {
   update: db.cakeFlavors.getName(),
   updates: [
      { q: { $expr: { $eq: [ "$flavor", "$$targetFlavor" ] } },
        u: [ { $set: { flavor: "$$newFlavor" } } ] }
   ],
   let : { targetFlavor: "cherry", newFlavor: "orange" }
} )

The next example defines targetFlavor and newFlavor variables in c and uses the variables to change the cake flavor from chocolate to vanilla:下一个例子在c中定义了targetFlavor和newFlavor变量，并使用这些变量将蛋糕的味道从巧克力改为香草：

db.runCommand( {
   update: db.cakeFlavors.getName(),
   updates: [
      { q: { $expr: { $eq: [ "$flavor", "$$targetFlavor" ] } },
        u: [ { $set: { flavor: "$$newFlavor" } } ],
        c: { targetFlavor: "chocolate", newFlavor: "vanilla" } }
    ]
} )

Update Operation with a Sort使用排序更新操作

Create the following restaurantsSort collection:创建以下restaurantsSort集合：

db.restaurantsSort.insertMany( [
   { _id: 1, name: "Pizza Place", rating: 4, violations: 2 },
   { _id: 2, name: "Burger Joint", rating: 3, violations: 5 },
   { _id: 3, name: "Taco Shop", rating: 4, violations: 1 }
] )

The following example replaces "Pizza Place" with "Clean Eats":以下示例将"Pizza Place"替换为"Clean Eats"：

db.runCommand( {
   update: "restaurantsSort",
   updates: [ {
      // Find the restaurants with a rating of 4查找评级为4的餐厅
      q: { rating: 4 },

      // Replace the found restaurant with Clean Eats
      u: { name: "Clean Eats", rating: 4, violations: 2 },

      // Only update one restaurant仅更新一家餐厅
      multi: false,

      // Sort restaurants found by the most violations with a descending sort对违规次数最多的餐厅进行降序排序
      sort: { violations: -1 }
   } ]
} )

The example:示例：

• Finds restaurants with a rating of 4, which are "Pizza Place" and "Taco Shop".查找rating为4的餐厅，分别是"Pizza Place"（披萨店）和"Taco Shop"（塔可店）。
• Sorts the found restaurants by violations in descending order, which places "Pizza Place" in the first position.按violations（违规行为）降序排列找到的餐厅，将“Pizza Place”放在第一位。
• Replaces "Pizza Place" with "Clean Eats".将"Pizza Place"替换为"Clean Eats"。

The following query returns the restaurants:以下查询返回餐厅：

db.restaurantsSort.find()

Output shows "Pizza Place" was replaced with "Clean Eats":输出显示"Pizza Place"被替换为"Clean Eats"：

[
   { _id: 1, name: 'Clean Eats', rating: 4, violations: 2 },
   { _id: 2, name: 'Burger Joint', rating: 3, violations: 5 },
   { _id: 3, name: 'Taco Shop', rating: 4, violations: 1 }
]