db. 集合.findAndModify()（mongosh方法）

性能

可重试写入需要 findAndModify() 方法在执行更新之前将整个文档复制到副本集中每个节点的特殊端集合中。这会使 findAndModify() 在处理大型文档或大型副本集时成为一项昂贵的操作。

fields 投射

fields 选项接受以下格式的文档：

{ field1: <value>, field2: <value> ... }

使用唯一索引进行 upsert

除非有唯一索引来防止重复，否则 upsert 可能会创建重复的文档。

以某一情况为例，其中不存在名为 Andy 的文档，且多个客户端大致会在同一时间发出以下命令：

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

如果所有findOneAndUpdate()操作在任何客户端成功插入数据之前完成查询阶段，并且name字段上没有唯一索引，则每个findOneAndUpdate()操作都可能导致插入，从而使用name: Andy创建多个文档。

name字段上的唯一索引可确保只创建一个文档。 使用唯一索引后，多个findOneAndUpdate()操作现在会表现出以下行为：

• 只需执行一次 findOneAndUpdate() 操作就能成功插入一个新文档。

• 其他findOneAndUpdate()操作要么更新新插入的文档，要么由于唯一键冲突而失败。

  为了使其他findOneAndUpdate()操作能够更新新插入的文档，必须满足以下所有条件：

  • 目标collection具有会导致重复键错误的唯一索引。

  • 更新操作不是updateMany或multi是false 。

  • 更新匹配条件为：

    • 单个相等谓词。例如 { "fieldA" : "valueA" }

    • 等式谓词的逻辑 AND。例如 { "fieldA" : "valueA", "fieldB" : "valueB" }

  • 相等谓词中的字段与唯一索引键模式中的字段匹配。

  • 更新操作不会修改唯一索引键模式中的任何字段。

下表显示了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 }
)

分片集合

要在分片集合上使用 findAndModify：

• 如果仅针对一个分片，则可以在 query 字段中使用部分分片键，或者，

• 可以在 query字段中提供完整分片键的相等条件。

• 从版本 7.1 开始，您不需要在查询规范中提供分片键 或 _id 字段。

分片集合中的文档可能缺少分片键字段。要定位缺失分片键的文档，可将 null 等值匹配 与其他过滤条件（例如针对 _id 字段）结合使用。例如：

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

模式验证

db.collection.findAndModify() 方法新增了对 bypassDocumentValidation 选项的支持，因而在带有验证规则的集合中插入或更新文档时，可绕过模式验证。

与 update 方法的比较

更新文档时，db.collection.findAndModify() 和 updateOne() 方法的操作方式不同：

• 如果有多个文档符合更新条件，则对于 db.collection.findAndModify()，可以指定 sort 来控制要更新哪个文档。

  updateOne() 更新第一个匹配的文档。

• 默认情况下，db.collection.findAndModify() 返回修改前的文档版本。要获取更新后的文档，请使用new选项。

  updateOne() 方法返回一个包含操作状态的 WriteResult() 对象。

  要返回更新后的文档，请使用 find() 方法。但是，在更新和文档检索之间，其他更新可能已修改了文档。此外，如果更新只修改了一个文档，但有多个文档匹配，则需要使用额外的逻辑来识别已更新的文档。

修改单个文档时，db.collection.findAndModify() 和 updateOne() 方法都会对文档进行原子更新。有关这些方法的交互和操作顺序的更多详细信息，请参阅原子性和事务。

事务

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

Oplog 条目

如果 db.collection.findAndModify() 操作成功找到并修改了文档，则该操作会在 oplog（操作日志）上添加一个条目。如果操作失败或者未找到要修改的文档，则该操作不会为 oplog 添加条目。

写关注错误

在 6.0 之前的 MongoDB 版本中，如果对分片集群运行 findAndModify 命令，mongos 则会在分片响应包含错误时丢弃 writeConcernError 文档。在 MongoDB 6.0 及更高版本中，mongos 会返回 writeConcernError。

更新和返回

以下方法将更新并返回 people 集合中与查询条件匹配的现有文档：

db.people.findAndModify({
    query: { name: "Tom", state: "active", rating: { $gt: 10 } },
    sort: { rating: 1 },
    update: { $inc: { score: 1 } }
})

该方法执行以下操作：

1. query 在 people 集合中找到一个文档，其中 name 字段的值为 Tom，state 字段的值为 active，rating 字段的值为 greater than 10。

2. sort 会对查询结果进行升序排序。如有多个文档满足 query 条件，该方法将会选择对按此 sort 排序的第一个文档进行修改。

3. 更新 increments，将 score 字段的值加 1。

4. 该方法返回为此更新选择的原始（即 修改前的）文档：

   {
     "_id" : ObjectId("50f1e2c99beb36a0f45c6453"),
     "name" : "Tom",
     "state" : "active",
     "rating" : 100,
     "score" : 5
   }

   要返回更新文档，请在方法中添加new:true选项。

   如果没有文档与 query 条件匹配，则该方法将返回 null。

更新插入

以下方法包含针对 update 操作的 upsert: true 选项，它可用于更新匹配的文档；或者，如果没有匹配的文档，则创建一个新文档：

db.people.findAndModify({
    query: { name: "Gus", state: "active", rating: 100 },
    sort: { rating: 1 },
    update: { $inc: { score: 1 } },
    upsert: true
})

如果该方法找到匹配的文档，则执行更新。

如果该方法没有找到匹配的文档，则会创建一个新文档。由于该方法包含 sort 选项，因此，它返回一个空文档 { } 作为原始（修改前）文档：

{ }

如果该方法不包含 sort 选项，则将返回 null。

null

returnNewDocument

以下方法包含 upsert: true 选项和 new:true 选项。此命令会更新匹配的文档并返回更新后的文档；或者，如果没有匹配的文档，则插入某一文档并在 value 字段中返回新插入的文档。

在以下示例中，people 集合中没有文档与 query 条件匹配：

db.people.findAndModify({
    query: { name: "Pascal", state: "active", rating: 25 },
    sort: { rating: 1 },
    update: { $inc: { score: 1 } },
    upsert: true,
    new: true
})

该方法返回新插入的文档：

{
   "_id" : ObjectId("50f49ad6444c11ac2448a5d6"),
   "name" : "Pascal",
   "rating" : 25,
   "score" : 1,
   "state" : "active"
}

排序和删除

通过在 rating 字段中包含 sort 规范，以下示例从 people 集合中删除 state 值为 active 且具有匹配文档中最低rating 的单个文档：

db.people.findAndModify(
   {
     query: { state: "active" },
     sort: { rating: 1 },
     remove: true
   }
)

该方法返回已删除的文档：

{
   "_id" : ObjectId("52fba867ab5fdca1299674ad"),
   "name" : "XYZ123",
   "score" : 1,
   "state" : "active",
   "rating" : 3
}

指定排序规则。

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

集合 myColl 包含以下文档：

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

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

db.myColl.findAndModify({
    query: { category: "cafe", status: "a" },
    sort: { category: 1 },
    update: { $set: { status: "Updated" } },
    collation: { locale: "fr", strength: 1 }
});

该操作将返回以下文档：

{ "_id" : 1, "category" : "café", "status" : "A" }

为数组更新操作指定 arrayFilters

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

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

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

{ "_id" : 1, "grades" : [ 95, 92, 90 ] }
{ "_id" : 2, "grades" : [ 98, 100, 100 ] }
{ "_id" : 3, "grades" : [ 95, 110, 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.students2.findAndModify({
   query: { _id : 1 },
   update: { $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" : 75, "std" : 6 },
      { "grade" : 87, "mean" : 90, "std" : 3 },
      { "grade" : 85, "mean" : 85, "std" : 4 }
   ]
}

使用聚合管道进行更新

db.collection.findAndModify() 可以接受聚合管道以用于更新。该管道可以由以下阶段组成：

• $addFields 及其别名 $set

• $project 及其别名 $unset

• $replaceRoot 及其别名 $replaceWith

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

例如，使用以下文档创建名为 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 }
      ]
   }
] )

以下操作查找 _id 字段等于 1 的文档，并使用聚合管道根据 grades 字段计算新字段 total 的值：

db.students2.findAndModify( {
   query: {  "_id" : 1 },
   update: [ { $set: { "total" : { $sum: "$grades.grade" } } } ],  // The $set stage is an alias for ``$addFields`` stage
   new: true
} )

该操作返回更新后 的文档：

{
   "_id" : 1,
   "grades" : [ { "grade" : 80, "mean" : 75, "std" : 6 }, { "grade" : 85, "mean" : 90, "std" : 4 }, { "grade" : 85, "mean" : 85, "std" : 6 } ],
   "total" : 250
}

使用以下项中的变量： let

要定义可在命令中其他位置访问的变量，请使用 let 选项。

创建集合 cakeFlavors：

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

以下示例在 let 中定义了 targetFlavor 变量，并使用这些变量将蛋糕口味从樱桃更改为橙子：

db.cakeFlavors.findAndModify( {
   query: {
      $expr: { $eq: [ "$flavor", "$$targetFlavor" ] }
   },
   update: { flavor: "orange" },
   let: { targetFlavor: "cherry" }
} )

用户角色和文档更新

从 MongoDB 7.0 开始，您可以使用新的 USER_ROLES 系统变量来返回用户角色。

本部分中的示例展示了包含医疗信息的集合中的字段更新。该示例从 USER_ROLES 系统变量中读取当前用户角色，并且仅在用户具有特定角色时才执行更新。

要使用系统变量，请将$$添加到变量名称的开头。将USER_ROLES系统变量指定为$$USER_ROLES。

该示例创建这些用户：

• James 角色为 Billing。

• Michelle 角色为 Provider。

执行以下步骤以创建角色、用户和集合：

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

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

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

以角色为 Provider 的 Michelle 身份登录，然后执行更新：

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

// Attempt to find and modify document
db.medical.findAndModify( {
   query:
      { $and: [
         {
            // Only update the document for Mary Smith
            patientName: { $eq: "Mary Smith" }
         },
         {
            // User must have the Provider role to perform the update
            $expr: { $ne: [ {
               $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ]
            }, [] ] }
         }
      ]
   },
   // Update document
   update: {
      patientName: "Mary Smith",
      diagnosisCode: "ACH 03",
      creditCard: "6541-7534-9637-3456"
   }
} )

前面的示例使用 $setIntersection 返回文档，其中，"Provider" 字符串与 $$USER_ROLES.role 中的用户角色之间的交集不为空。Michelle 的角色为 Provider，因此，将执行更新。

接下来，以不具有 Provider 角色的 James 身份登录，并尝试执行相同更新：

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

// Attempt to find and modify document
db.medical.findAndModify( {
   query:
      { $and: [
         {
            // Only update the document for Mary Smith
            patientName: { $eq: "Mary Smith" }
         },
         {
            // User must have the Provider role to perform the update
            $expr: { $ne: [ {
               $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ]
            }, [] ] }
         }
      ]
   },
   // Update document
   update: {
      patientName: "Mary Smith",
      diagnosisCode: "ACH 03",
      creditCard: "6541-7534-9637-3456"
   }
} )

前面的示例没有更新任何文档。