findAndModify

On this page本页内容

Definition定义

findAndModify

The findAndModify command modifies and returns a single document. findAndModify命令修改并返回单个文档。By default, the returned document does not include the modifications made on the update. 默认情况下，返回的文档不包括对更新所做的修改。To return the document with the modifications made on the update, use the new option.要返回包含更新时所做修改的文档，请使用new选项。

The command has the following syntax:该命令语法如下所示：

{
  findAndModify: <collection-name>,
  query: <document>,
  sort: <document>,
  remove: <boolean>,
  update: <document or aggregation pipeline>,
  new: <boolean>,
  fields: <document>,
  upsert: <boolean>,
  bypassDocumentValidation: <boolean>,
  writeConcern: <document>,
  collation: <document>,
  arrayFilters: <array>,
  hint: <document|string>,
  comment: <any>
}

The findAndModify command takes the following fields:findAndModify命令包含以下字段：

Field字段Type类型Description描述
query document

Optional.可选。The selection criteria for the modification. 修改的选择标准。The query field employs the same query selectors as used in the db.collection.find() method. query字段使用的查询选择器与db.collection.find()方法中使用的相同。Although the query may match multiple documents, findAndModify will only select one document to modify.尽管查询可能匹配多个文档，但findAndModify只会选择一个文档进行修改。

If unspecified, defaults to an empty document.如果未指定，则默认为空文档。

Starting in MongoDB 4.2 (and 4.0.12+, 3.6.14+, and 3.4.23+), the operation errors if the query argument is not a document.从MongoDB 4.2（以及4.0.12+、3.6.14+和3.4.23+）开始，如果查询参数不是文档，则会出现操作错误。

sort

 document

Optional.可选。Determines which document the operation modifies if the query selects multiple documents. 确定如果查询选择多个文档，操作将修改哪个文档。findAndModify modifies the first document in the sort order specified by this argument.按照此参数指定的排序顺序修改第一个文档。

Starting in MongoDB 4.2 (and 4.0.12+, 3.6.14+, and 3.4.23+), the operation errors if the sort argument is not a document.从MongoDB 4.2（以及4.0.12+、3.6.14+和3.4.23+）开始，如果排序参数不是文档，则会出现操作错误。

In MongoDB, sorts are inherently stable, unless sorting on a field which contains duplicate values:在MongoDB中，排序本质上是稳定的，除非对包含重复值的字段进行排序：

  • a stable sort is one that returns the same sort order each time it is performed稳定排序是每次执行时返回相同排序顺序的排序
  • an unstable sort is one that may return a different sort order when performed multiple times不稳定排序是指在多次执行时可能返回不同排序顺序的排序

If a stable sort is desired, include at least one field in your sort that contains exclusively unique values. 如果需要稳定排序，请在排序中至少包含一个包含唯一值的字段。The easiest way to guarantee this is to include the _id field in your sort query.保证这一点的最简单方法是在排序查询中包含_id字段。

See Sort Stability for more information.有关更多信息，请参阅排序稳定性。

remove boolean Must specify either the remove or the update field. 必须指定remove或update字段。Removes the document specified in the query field. 删除query字段中指定的文档。Set this to true to remove the selected document . 将此设置为true将该字段设置为true可删除所选文档。The default is false.默认值为false。
update document or array

Must specify either the remove or the update field. 必须指定remove或update字段。Performs an update of the selected document.执行所选文档的更新。

new boolean Optional.可选。When true, returns the modified document rather than the original. 如果为true，则返回修改后的文档，而不是原始文档。The findAndModify method ignores the new option for remove operations. findAndModify方法忽略remove操作的new选项。The default is false.默认值为false。
fields document

Optional.可选。A subset of fields to return. 要返回的字段的子集。The fields document specifies an inclusion of a field with 1, as in: fields: { <field1>: 1, <field2>: 1, ... }. fields文档指定包含一个带有1的字段，如：fields: { <field1>: 1, <field2>: 1, ... }。See Projection.请参阅投影。

Starting in MongoDB 4.2 (and 4.0.12+, 3.6.14+, and 3.4.23+), the operation errors if the fields argument is not a document.从MongoDB 4.2（以及4.0.12+、3.6.14+和3.4.23+）开始，如果fields参数不是文档，则会出现操作错误。

upsert boolean

Optional.可选。Used in conjunction with the update field.与update字段一起使用。

When true, findAndModify() either:如果为true，则findAndModify()可以：

  • Creates a new document if no documents match the query. 如果没有与query匹配的文档，则创建新文档。For more details see upsert behavior.有关更多详细信息，请参阅upsert行为。
  • Updates a single document that matches the query.更新与query匹配的单个文档。

To avoid multiple upserts, ensure that the query fields are uniquely indexed.要避免多个upsert，请确保query字段的索引是唯一的。

Defaults to false.默认为false。

bypassDocumentValidation boolean

Optional.可选。Enables findAndModify to bypass document validation during the operation. 允许findAndModify在操作过程中绕过文档验证。This lets you update documents that do not meet the validation requirements.这允许您更新不符合验证要求的文档。

New in version 3.2.版本3.2中的新功能。

writeConcern document

Optional.可选。A document expressing the write concern. 表达写入关注的文档。Omit to use the default write concern.忽略使用默认的写关注点。

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

New in version 3.2.版本3.2中的新功能。

maxTimeMS integer Optional.可选。Specifies a time limit in milliseconds for processing the operation.指定处理操作的时间限制（以毫秒为单位）。
findAndModify string The collection against which to run the command.要对其运行命令的集合。
collation document

Optional.可选。

Specifies the collation to use for the operation.指定要用于该操作的排序规则。

Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号的规则。

The collation option has the following syntax:collation选项语法如下所示：

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

When specifying collation, the locale field is mandatory; all other collation fields are optional. 指定排序规则时，locale字段是必需的；所有其他排序规则字段都是可选的。For descriptions of the fields, see Collation Document.有关这些字段的描述，请参阅排序规则文档。

If the collation is unspecified but the collection has a default collation (see db.createCollection()), the operation uses the collation specified for the collection.如果未指定排序规则，但集合具有默认排序规则（请参见db.createCollection()），则操作将使用为集合指定的排序规则。

If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons.如果没有为集合或操作指定排序规则，MongoDB将使用以前版本中用于字符串比较的简单二进制比较。

You cannot specify multiple collations for an operation. 不能为一个操作指定多个排序规则。For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort.例如，不能为每个字段指定不同的排序规则，或者如果使用排序执行查找，则不能对查找使用一种排序规则，对排序使用另一种排序规则。

New in version 3.4.版本3.4中的新功能。

arrayFilters array

Optional.可选。An array of filter documents that determine which array elements to modify for an update operation on an array field.筛选文档的数组，用于确定要为数组字段上的更新操作修改哪些数组元素。

In the update document, use the $[<identifier>] filtered positional operator to define an identifier, which you then reference in the array filter documents. 在更新文档中，使用$[<identifier>]筛选的位置运算符定义一个标识符，然后在数组筛选文档中引用该标识符。You cannot have an array filter document for an identifier if the identifier is not included in the update document.如果标识符未包含在更新文档中，则不能使用标识符的数组筛选器文档。

Note

The <identifier> must begin with a lowercase letter and contain only alphanumeric characters.<identifier>必须以小写字母开头，并且只包含字母数字字符。

You can include the same identifier multiple times in the update document; however, for each distinct identifier ($[identifier]) in the update document, you must specify exactly one corresponding array filter document. 您可以在更新文档中多次包含同一标识符；但是，对于更新文档中的每个不同标识符（$[identifier]），必须指定一个对应的数组筛选器文档。That is, you cannot specify multiple array filter documents for the same identifier. 也就是说，不能为同一标识符指定多个数组筛选器文档。For example, if the update statement includes the identifier x (possibly multiple times), you cannot specify the following for arrayFilters that includes 2 separate filter documents for x:例如，如果更新语句包含标识符x（可能多次），则不能为包含x的两个单独筛选文档的arrayFilters指定以下内容：

// INVALID

[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]

However, you can specify compound conditions on the same identifier in a single filter document, such as in the following examples:但是，您可以在单个筛选文档中对同一标识符指定复合条件，如以下示例中所示：

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

For examples, see Array Update Operations with arrayFilters.有关示例，请参阅使用arrayFilters的数组更新操作。

Note

arrayFilters is not available for updates that use an aggregation pipeline.不适用于使用聚合管道的更新。

New in version 3.6.版本3.6中的新功能。

hint document or string

Optional.可选。A document or string that specifies the index to use to support the query.指定用于支持query的索引的文档或字符串。

The option can take an index specification document or the index name string.该选项可以采用索引规范文档或索引名称字符串。

If you specify an index that does not exist, the operation errors.如果指定的索引不存在，则操作将出错。

For an example, see Specify hint for findAndModify Operations.有关示例，请参阅为findAndModify操作指定提示。

New in version 4.4.版本4.4中的新功能。

comment any

Optional.可选。A user-provided comment to attach to this command. 用户提供了要附加到此命令的注释。Once set, this comment appears alongside records of this command in the following locations:设置后，此注释将与此命令的记录一起出现在以下位置：

A comment can be any valid BSON type (string, integer, object, array, etc).注释可以是任何有效的BSON类型（字符串、整数、对象、数组等）。

New in version 4.4.版本4.4中的新功能。

Output输出

The findAndModify command returns a document with the following fields:findAndModify命令返回包含以下字段的文档：

Field字段Type类型Description描述
value document Contains the command’s returned value. 包含命令的返回值。See value for details.有关详细信息，请参阅值。
lastErrorObject document Contains information about updated documents. 包含有关更新文档的信息。See lastErrorObject for details.有关详细信息，请参阅lastErrorObject。
ok number Contains the command’s execution status. 包含命令的执行状态。1 on success, or 0 if an error occurred.成功时为1，发生错误时为0。

lastErrorObject

The lastErrorObject embedded document contains the following fields:

Field字段Type类型Description描述
updatedExisting boolean Contains true if an update operation modified an existing document.
upserted document Contains the ObjectId of the inserted document if an update operation with upsert: true resulted in a new document.

value

For remove operations, value contains the removed document if the query matches a document. If the query does not match a document to remove, value contains null.

For update operations, the value embedded document contains the following:

  • If the new parameter is not set or is false:
    • the pre-modification document if the query matches a document;
    • otherwise, null.
  • If new is true:
    • the modified document if the query returns a match;
    • the inserted document if upsert: true and no document matches the query;
    • otherwise, null.

Behavior行为

Upsert and Unique Index

When the findAndModify command includes the upsert: true option and the query field(s) is not uniquely indexed, the command could insert a document multiple times in certain circumstances.

Consider an example where no document with the name Andy exists and multiple clients issue the following command:

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

If all the commands finish the query phase before any command starts the modify phase, and there is no unique index on the name field, the commands may each perform an upsert, creating multiple duplicate documents.

To prevent the creation of multiple duplicate documents, create a unique index on the name field. With the unique index in place, then the multiple findAndModify commands will exhibit one of the following behaviors:

  • Exactly one findAndModify successfully inserts a new document.
  • Zero or more findAndModify commands update the newly inserted document.
  • Zero or more findAndModify commands fail when they attempt to insert a duplicate. If the command fails due to a unique index constraint violation, you can retry the command. Absent a delete of the document, the retry should not fail.

Sharded Collections

To use findAndModify on a sharded collection, the query filter must include an equality condition on the shard key.

Starting in version 4.4, 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:例如：

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

Shard Key Modification

Starting in MongoDB 4.2, you can update a document’s shard key value unless the shard key field is the immutable _id field. Before MongoDB 4.2, a document’s shard key field value is immutable.

Warning

Starting in version 4.4, documents in sharded collections can be missing the shard key fields. Take precaution to avoid accidentally removing the shard key when changing a document’s shard key value.

To modify the existing shard key value with findAndModify:

  • You must run on a mongos. Do not issue the operation directly on the shard.
  • You must run either in a transaction or as a retryable write.
  • You must include an equality filter on the full shard key.

Missing Shard Key

Starting in version 4.4, documents in a sharded collection can be missing the shard key fields. To use findAndModify to set the document’s missing shard key:

  • You must run on a mongos. Do not issue the operation directly on the shard.
  • You must run either in a transaction or as a retryable write if the new shard key value is not null.
  • You must include an equality filter on the full shard key.

Tip

Since a missing key value is returned as part of a null equality match, to avoid updating a null-valued key, include additional query conditions (such as on the _id field) as appropriate.

See also:

Document Validation

The findAndModify command adds support for the bypassDocumentValidation option, which lets you bypass document validation when inserting or updating documents in a collection with validation rules.

Comparisons with the update Method

When updating a document, findAndModify and the update() method operate differently:

  • By default, both operations modify a single document. However, the update() method with its multi option can modify more than one document.
  • If multiple documents match the update criteria, for findAndModify, you can specify a sort to provide some measure of control on which document to update.

    With the default behavior of the update() method, you cannot specify which single document to update when multiple documents match.

  • By default, findAndModify returns an object that contains the pre-modified version of the document, as well as the status of the operation. To obtain the updated document, use the new option.

    The update() method returns a WriteResult object that contains the status of the operation. To return the updated document, use the find() method. However, other updates may have modified the document between your update and the document retrieval. Also, if the update modified only a single document but multiple documents matched, you will need to use additional logic to identify the updated document.

When modifying a single document, both findAndModify and the update() method atomically update the document. See Atomicity and Transactions for more details about interactions and order of operations of these methods.

Transactions

findAndModify can be used inside multi-document transactions.

Important

In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.

For additional transactions usage considerations (such as runtime limit and oplog size limit), see also Production Considerations.

Upsert within Transactions

Starting in MongoDB 4.4 with feature compatibility version (fcv) "4.4", you can create collections and indexes inside a multi-document transaction if the transaction is not a cross-shard write transaction.

As such, for the feature compatibility version (fcv) is "4.4" or greater, findAndModify with upsert: true can be run against an existing collection or a non-existing collection. If run against a non-existing collection, the operation creates the collection.

If the feature compatibility version (fcv) is "4.2" or less, the operation must be against an existing collection.

See also参阅

Create Collections and Indexes In a Transaction

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.

Examples示例

Update and Return

The following command updates an existing document in the people collection where the document matches the query criteria:

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

This command performs the following actions:

  1. The query finds a document in the people collection where the name field has the value Tom, the state field has the value active and the rating field has a value greater than 10.
  2. The sort orders the results of the query in ascending order. If multiple documents meet the query condition, the command will select for modification the first document as ordered by this sort.
  3. The update increments the value of the score field by 1.
  4. The command returns a document with the following fields:

    • The lastErrorObject field that contains the details of the command, including the field updatedExisting which is true, and
    • The value field that contains the original (i.e. pre-modification) document selected for this update:

      {
  "lastErrorObject" : {
     "connectionId" : 1,
     "updatedExisting" : true,
     "n" : 1,
     "syncMillis" : 0,
     "writtenTo" : null,
     "err" : null,
     "ok" : 1
  },
  value" : {
    "_id" : ObjectId("54f62d2885e4be1f982b9c9c"),
    "name" : "Tom",
    "state" : "active",
    "rating" : 100,
    "score" : 5
  },
  "ok" : 1
}

To return the modified document in the value field, add the new:true option to the command.

If no document match the query condition, the command returns a document that contains null in the value field:

{ "value" : null, "ok" : 1 }

The mongo shell and many drivers provide a findAndModify() helper method. Using the shell helper, this previous operation can take the following form:

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

However, the findAndModify() shell helper method returns only the unmodified document, or if new is true, the modified document.

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

upsert: true

The following findAndModify command includes the upsert: true option for the update operation to either update a matching document or, if no matching document exists, create a new document:

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

If the command finds a matching document, the command performs an update.

If the command does not find a matching document, the update with upsert: true operation results in an insertion and returns a document with the following fields:

  • The lastErrorObject field that contains the details of the command, including the field upserted that contains the _id value of the newly inserted document, and
  • The value field containing null.
{
  "value" : null,
  "lastErrorObject" : {
     "updatedExisting" : false,
     "n" : 1,
     "upserted" : ObjectId("54f62c8bc85d4472eadea26f")
  },
  "ok" : 1
}

Return New Document

The following findAndModify command includes both upsert: true option and the new:true option. The command either updates a matching document and returns the updated document or, if no matching document exists, inserts a document and returns the newly inserted document in the value field.

In the following example, no document in the people collection matches the query condition:

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

The command returns the newly inserted document in the value field:

{
  "lastErrorObject" : {
     "connectionId" : 1,
     "updatedExisting" : false,
     "upserted" : ObjectId("54f62bbfc85d4472eadea26d"),
     "n" : 1,
     "syncMillis" : 0,
     "writtenTo" : null,
     "err" : null,
     "ok" : 1
  },
  "value" : {
     "_id" : ObjectId("54f62bbfc85d4472eadea26d"),
     "name" : "Pascal",
     "rating" : 25,
     "state" : "active",
     "score" : 1
  },
  "ok" : 1
}

Sort and Remove

By including a sort specification on the rating field, the following example removes from the people collection a single document with the state value of active and the lowest rating among the matching documents:

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

The command returns the deleted document:

{
  "lastErrorObject" : {
     "connectionId" : 1,
     "n" : 1,
     "syncMillis" : 0,
     "writtenTo" : null,
     "err" : null,
     "ok" : 1
  },
  "value" : {
     "_id" : ObjectId("54f62a6785e4be1f982b9c9b"),
     "name" : "XYZ123",
     "score" : 1,
     "state" : "active",
     "rating" : 3
  },
  "ok" : 1
}

Specify Collation

New in version 3.4.版本3.4中的新功能。

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:

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

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

The operation returns the following document:

{
   "lastErrorObject" : {
      "updatedExisting" : true,
      "n" : 1
   },
   "value" : {
      "_id" : 1,
      "category" : "café",
      "status" : "A"
   },
   "ok" : 1
}

Array Update Operations with arrayFilters

Note

arrayFilters is not available for updates that use an aggregation pipeline.

New in version 3.6.版本3.6中的新功能。

Starting in MongoDB 3.6, when updating an array field, you can specify arrayFilters that determine which array elements to update.

Update Elements Match arrayFilters Criteria

Note

arrayFilters is not available for updates that use an aggregation pipeline.

Create a collection students with the following documents:

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

To modify all elements that are greater than or equal to 100 in the grades array, use the positional $[<identifier>] operator with the arrayFilters option:

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

The operation updates the grades field for a single document, and after the operation, the collection has the following documents:

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

Update Specific Elements of an Array of Documents

Note

arrayFilters is not available for updates that use an aggregation pipeline.

Create a collection students2 with the following documents:

db.students2.insert([
   {
      "_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 }
      ]
   }
])

The following operation finds a document where the _id field equals 1 and uses the filtered positional operator $[<identifier>] with the arrayFilters to modify the mean for all elements in the grades array where the grade is greater than or equal to 85.

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

The operation updates the grades field for a single document, and 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" : 75, "std" : 6 },
      { "grade" : 87, "mean" : 90, "std" : 3 },
      { "grade" : 85, "mean" : 85, "std" : 4 }
   ]
}

Use an Aggregation Pipeline for Updates

Starting in MongoDB 4.2, findAndModify can accept an aggregation pipeline for the update. The pipeline can consist of the following stages:

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, create a collection students2 with the following documents:

db.students2.insert([
   {
      "_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 }
      ]
   }
])

The following operation finds a document where the _id field equals 1 and uses an aggregation pipeline to calculate a new field total from the grades field:

db.runCommand(
   {
     findAndModify: "students2",
     query: {  "_id" : 1 },
     update: [ { $set: { "total" : { $sum: "$grades.grade" } } } ],
     new: true
   }
)

Note

The $set used in the pipeline refers to the aggregation stage $set and not the update operator $set.

After the operation, the collection has the following documents:

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

Specify hint for findAndModify Operations

New in version 4.4.版本4.4中的新功能。

From the mongo shell, create a members collection with the following documents:

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 operation explicitly hints to use the index { status: 1 }:

db.runCommand({
   findAndModify: "members",
   query: { "points": { $lte: 20 }, "status": "P" },
   remove: true,
   hint: { status: 1 }
})

Note

If you specify an index that does not exist, the operation errors.

To see the index used, run explain on the operation:

db.runCommand(
   {
     explain: {
       findAndModify: "members",
       query: { "points": { $lte: 20 }, "status": "P" },
       remove: true,
       hint: { status: 1 }
     },
     verbosity: "queryPlanner"
   }
)

See also参阅

Linearizable Reads via findAndModify