Docs 菜单
Docs 主页
/
MongoDB Manual
/ / /

db.collection.findAndModify()

在此页面上

  • 定义
  • 兼容性
  • 语法
  • 返回数据
  • 行为
  • 示例

带有驱动程序的 MongoDB

本页介绍了 mongosh方法。要查看 MongoDB 驱动程序中的等效方法,请参阅您的编程语言的相应页面:

C#Java SyncNode.jsPyMongoCC++GoJava RSKotlin CoroutineKotlin SyncPHPMongoidRustScala
db.collection.findAndModify(document)

重要

已弃用的 mongosh 方法

请使用 findOneAndUpdate()findOneAndDelete()findOneAndReplace() 代替。

更新并返回单个文档。 默认情况下,返回的文档不包括更新时所做的修改。 要返回包含更新时所做修改的文档,请使用new选项。

此方法可用于以下环境中托管的部署:

  • MongoDB Atlas:用于云中 MongoDB 部署的完全托管服务

注意

所有 MongoDB Atlas 集群都支持此命令。有关所有命令的信息,请参阅不支持的命令

5.0 版本中的更改

findAndModify() 方法采用以下形式:

db.collection.findAndModify({
query: <document>,
sort: <document>,
remove: <boolean>,
update: <document or aggregation pipeline>,
new: <boolean>,
fields: <document>,
upsert: <boolean>,
bypassDocumentValidation: <boolean>,
writeConcern: <document>,
maxTimeMS: <integer>,
collation: <document>,
arrayFilters: [ <filterdocument1>, ... ],
let: <document> // Added in MongoDB 5.0
});

db.collection.findAndModify() 方法接受带有以下嵌入式文档字段的文档参数:

Parameter
类型
说明
query
文档

可选。修改的选择条件。query 字段使用的查询选择器db.collection.find() 方法中使用的查询选择器相同。虽然查询可能会匹配多个文档,但 db.collection.findAndModify() 只选择一个文档进行修改

如果未指定,则默认为空文档。

如果查询参数不是文档,则操作出错。

sort

文档

可选。如果查询选择了多个文档,则确定该操作更新了哪个文档。db.collection.findAndModify() 按此参数指定的排序顺序更新第一个文档。

如果 sort 参数不是文档,则操作错误。

MongoDB 不按特定顺序将文档存储在集合中。对包含重复值的字段进行排序时,可能会以任何顺序返回包含这些值的文档。

如果需要一致的排序顺序,请在排序中至少纳入一个包含唯一值的字段。最简单方法是在排序查询中纳入 _id 字段。

有关更多信息,请参阅排序一致性

remove
布尔
必须指定 removeupdate 字段。删除 query 字段中指定的文档。将此字段设置为 true 可删除所选文档。默认值为 false
update
文档或数组

必须指定 removeupdate 字段。执行所选文档的更新。

new
布尔
可选。 当true时,返回更新后的文档而不是原始文档。 默认值为false
fields
文档

可选。要返回的字段的子集。fields 文档指定包含值为 1 的字段,如:fields: { <field1>: 1, <field2>: 1, ... }

如果 fields 参数不是文档,则操作出错。

有关投影的更多信息,请参阅 fields 投影

upsert
布尔

可选。与 update 字段结合使用。

truefindAndModify() 时:

  • 如果没有文档与 query 匹配,则创建一个新文档。有关详细信息,请参阅更新或插入行为

  • 更新与 query 匹配的单份文档。

为避免出现多个 upsert 操作,请确保 query 字段具有唯一索引。请参阅使用唯一索引进行 upsert 以查看示例。

默认值为 false;即,在未找到匹配项时插入新文档。

bypassDocumentValidation
布尔
可选。启用 db.collection.findAndModify() 可在操作过程中绕过文档验证。这样便可更新不符合验证要求的文档。
writeConcern
文档

可选。表达写关注的文档。省略以使用默认写关注。

如果是在事务中运行,则请勿显式设置此操作的写关注。要将写关注与事务一起使用,请参阅事务和写关注。

maxTimeMS
non-negative integer

可选。

指定时间限制(以毫秒为单位)。如果您未指定 maxTimeMS 值,操作将不会超时。如果值为 0 ,则显式指定默认无限制行为。

MongoDB 使用与 db.killOp() 相同的机制终止超过分配的时间限制的操作。MongoDB 仅在指定的中断点之一中终止操作。

collation
文档

可选。

指定用于操作的排序规则

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

排序规则选项的语法如下:

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

指定排序规则时,locale 字段为必填字段;所有其他排序规则字段均为可选字段。有关字段的说明,请参阅排序规则文档

如果未指定排序规则,但集合具有默认排序规则(请参阅 db.createCollection()),则操作将使用为集合指定的排序规则。

如果没有为收集或操作指定排序规则,MongoDB 将使用先前版本中使用的简单二进制比较来进行字符串比较。

您不能为一个操作指定多个排序规则。例如,您不能为每个字段指定不同的排序规则,或者如果执行带排序的查找,则不能使用一种排序规则进行查找而另一种排序规则进行排序。

arrayFilters
阵列

选修的。大量过滤器文档,用于确定针对大量字段的更新操作要修改哪些大量元素。

在更新文档中,使用 $[<identifier>] 筛选后的位置运算符来定义标识符,然后在数组筛选文档中引用该标识符。如果更新文档中未包含某一标识符,则无法获得该标识符的数组筛选文档。

<identifier> 必须以小写字母开头,且只能包含字母数字字符。

您可以在更新文档中多次包含相同的标识符;但对于更新文档中的每个不同标识符 ($[identifier]),您必须准确指定一个对应的数组筛选器文档。也就是说,不能为同一个标识符指定多个数组筛选器文档。例如,如果更新语句包含标识符 x(可能多次),则不能为 arrayFilters 指定以下内容,其中包括 x 的 2 个单独的筛选器文档:

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

有关示例,请参阅为数组更新操作指定 arrayFilters

arrayFilters 不适用于使用聚合管道的更新。

文档

可选。

指定包含变量列表的文档。这样可以将变量与查询文本分开,从而提高命令的可读性。

文档语法为:

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

变量设置为表达式返回的值,并且之后不能再进行更改。

要访问命令中的变量值,请使用双美元符号前缀 ($$) 以及 $$<variable_name> 形式的变量名称。例如:$$targetTotal

要使用变量筛选结果,您必须在 $expr 操作符中访问该变量。

有关使用 let 和变量的完整示例,请参阅let 中使用变量

版本 5.0 中的新增功能

对于删除操作,如果该查询与某一文档匹配,findAndModify() 将返回已删除的文档。如果该查询与要删除的文档不匹配,findAndModify() 将返回 null

对于更新操作,findAndModify() 返回以下内容之一:

  • 如果未设置 new 参数或为 false

    • 如果查询结果与文档匹配,则返回修改前的文档;

    • 否则,返回 null

  • 如果 newtrue

    • 如果查询返回匹配项,则返回更新后的文档;

    • 如果设置了 upsert: true 且没有与查询匹配的文档,则返回插入的文档;

    • 否则,返回 null

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

版本8.0中的新增功能:要以更好的性能更新用户定义排序中的第一个文档,请使用带有sort选项的db.collection.updateOne()方法。

重要

语言一致性

在调整 find()findAndModify() 投影以便与聚合的 $project 阶段保持一致的过程中:

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

{ field1: <value>, field2: <value> ... }
投射
说明
<field>: <1 or true>
指定包含字段。如果为投影值指定非零整数,则该操作会将该值视为true
<field>: <0 or false>
指定排除某个字段。
"<field>.$": <1 or true>

使用 $ 数组投影操作符返回与数组字段的查询条件匹配的第一个元素。如果您为该投影值指定非零整数,则该操作会将该值视为 true

不可用于视图。

<field>: <array projection>

使用数组投影操作符($elemMatch$slice)指定要包含的数组元素。

不可用于视图。

<field>: <aggregation expression>

指定投影字段的值。

通过使用聚合表达式和语法(包括使用文本和聚合变量),可以投影新字段或使用新值投影现有字段。

  • 如果您为投影值指定非数字、非布尔文字(例如文字字符串、数量或操作符表达式),则该字段将使用新值进行投影,例如:

    • { field: [ 1, 2, 3, "$someExistingField" ] }

    • { field: "New String Value" }

    • { field: { status: "Active", total: { $sum: "$existingArray" } } }

  • 要投影字段的字面值,请使用 $literal 聚合表达式,例如:

    • { field: { $literal: 5 } }

    • { field: { $literal: true } }

    • { field: { $literal: { fieldWithValue0: 0, fieldWithValue1: 1 } } }

对于嵌入文档中的字段,您可以使用以下任一方式指定字段:

  • 点符号,例如 "field.nestedfield": <value>

  • 嵌套表单,例如 { field: { nestedfield: <value> } }

默认情况下,返回的文档中包含 _id 字段,除非您在投影中显式指定 _id: 0 来隐藏该字段。

projection 不能同时包含包含和排除规范,但 _id 字段除外:

  • 显式包含字段的投影中,_id 字段是您可以显式排除的唯一字段。

  • 明确排除字段的投影中,_id字段是您可以明确包含的唯一字段;但是,默认情况下包含_id字段。

有关投影的更多信息,另请参阅:

除非有唯一索引来防止重复,否则 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具有会导致重复键错误的唯一索引。

    • 更新操作不是updateManymultifalse

    • 更新匹配条件为:

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

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

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

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

下表显示了upsert操作的示例,当发生键冲突时,这些操作要么导致更新,要么失败。

唯一索引键模式
更新操作
结果
{ name : 1 }
db.people.updateOne(
{ name: "Andy" },
{ $inc: { score: 1 } },
{ upsert: true }
)
匹配文档的score字段递增 1。
{ name : 1 }
db.people.updateOne(
{ name: { $ne: "Joe" } },
{ $set: { name: "Andy" } },
{ upsert: true }
)
操作失败是因为它修改了唯一索引键模式 ( name ) 中的字段。
{ name : 1 }
db.people.updateOne(
{ name: "Andy", email: "andy@xyz.com" },
{ $set: { active: false } },
{ upsert: true }
)
操作失败,因为等值谓词字段( nameemail )与索引键字段( name )不匹配。

要在分片集合上使用 findAndModify

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

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

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

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

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

您可以更新文档的分片键值,除非分片键字段是不可变的 _id 字段。

警告

分片集合中的文档可能缺少分片键字段。采取预防措施,避免在更改文档的分片键值时意外删除分片键。

要更新现有的分片键值(使用 db.collection.findAndModify()),请执行以下操作:

  • 必须mongos 上运行。请勿直接对分片发出此操作。

  • 必须事务中运行,或者以可重试写入的形式运行。

  • 必须在完整分片键上包含相等筛选器。

分片集合中的文档可能缺少分片键字段。要使用 db.collection.findAndModify() 设置文档缺失的分片键:

  • 必须mongos 上运行。请勿直接对分片发出此操作。

  • 如果新的分片键值不是 null,则必须事务中运行或作为可重试写入运行。

  • 必须在完整分片键上包含相等筛选器。

提示

由于缺失的键值是作为 null 相等匹配的一部分返回的,因此为避免更新空值键,请酌情纳入其他查询条件(例如 _id 字段)。

另请参阅:

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

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

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

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

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

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

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

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

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

重要

在大多数情况下,与单文档写入操作相比,分布式事务会产生更高的性能成本,并且分布式事务的可用性不应取代有效的模式设计。在许多情况下,非规范化数据模型(嵌入式文档和数组)仍然是数据和使用案例的最佳选择。换言之,对于许多场景,适当的数据建模将最大限度地减少对分布式事务的需求。

有关其他事务使用注意事项(如运行时间限制和 oplog 大小限制),另请参阅生产注意事项

如果分布式事务不是跨分片写入事务,则可以在该事务中创建集合和索引。

具有 upsert: truedb.collection.findAndModify() 可以在现有集合或不存在的集合上运行。如果在不存在的集合上运行,该操作将创建集合。

提示

另请参阅:

如果是在事务中运行,则请勿显式设置此操作的写关注。要将写关注与事务一起使用,请参阅事务和写关注。

如果 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. querypeople 集合中找到一个文档,其中 name 字段的值为 Tomstate 字段的值为 activerating 字段的值为 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

以下方法包含 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 确定要更新哪些数组元素。

注意

arrayFilters 不适用于使用聚合管道的更新。

使用以下文档创建集合 students

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

要更新grades数组中所有大于或等于100的元素,请使用经过滤的位置操作符$[<identifier>]arrayFilters选项(运用db.collection.findAndModify()方法):

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

该操作更新单个文档的 grades 字段,完成该操作后,集合中将包含以下文档:

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

注意

arrayFilters 不适用于使用聚合管道的更新。

使用以下文档创建集合 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的文档,并使用筛选后的位置运算符$[<identifier>]arrayFilters来更新grades数组中分数大于以下值的所有元素的mean :小于或等于85

db.students2.findAndModify({
query: { _id : 1 },
update: { $set: { "grades.$[elem].mean" : 100 } },
arrayFilters: [ { "elem.grade": { $gte: 85 } } ]
})

该操作更新单个文档的 grades 字段,完成该操作后,集合中将包含以下文档:

{
"_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() 可以接受聚合管道以用于更新。该管道可以由以下阶段组成:

使用聚合分析管道可以进行更具表现力的更新声明,例如基于当前字段值的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
} )

注意

管道中使用的 $set 指的是聚合阶段 $set 而不是更新操作符 $set

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

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

版本 5.0 中的新增功能

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

注意

要使用变量筛选结果,您必须在 $expr 操作符中访问该变量。

创建集合 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

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

1

创建名为 BillingProvider 的角色,并赋予所需权限和资源。

运行:

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

创建名为 JamesMichelle 的用户,并赋予所需角色。

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

运行:

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

以角色为 ProviderMichelle 身份登录,然后执行更新:

1

运行:

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

运行:

// 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 身份登录,并尝试执行相同更新:

1

运行:

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

运行:

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

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

后退

db.collection.find