db.collection.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字段中提供完整分片键的相等条件。

分片集合中的文档可能缺少分片键字段。要定位缺失分片键的文档，可将 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 添加条目。

更新和返回

以下方法将更新并返回 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"
   }
} )

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