db.collection.bulkWrite()

Write Operations写入操作

db.collection.bulkWrite( [
   { insertOne : { "document" : <document> } }
] )

db.collection.bulkWrite( [
   { updateOne :
      {
         "filter": <document>,
         "update": <document or pipeline>,            // Changed in 4.2
         "upsert": <boolean>,
         "collation": <document>,                     // Available starting in 3.4
         "arrayFilters": [ <filterdocument1>, ... ],  // Available starting in 3.6
         "hint": <document|string>                    // Available starting in 4.2.1
      }
   }
] )

db.collection.bulkWrite( [
   { updateMany :
      {
         "filter" : <document>,
         "update" : <document or pipeline>,          // Changed in MongoDB 4.2
         "upsert" : <boolean>,
         "collation": <document>,                    // Available starting in 3.4
         "arrayFilters": [ <filterdocument1>, ... ], // Available starting in 3.6
         "hint": <document|string>                   // Available starting in 4.2.1
      }
   }
] )

db.collection.bulkWrite([
   { replaceOne :
      {
         "filter" : <document>,
         "replacement" : <document>,
         "upsert" : <boolean>,
         "collation": <document>,
                    // Available starting in 3.4
         "hint": <document|string>
                   // Available starting in 4.2.1

      }
   }
] )

db.collection.bulkWrite([
   { deleteOne : {
      "filter" : <document>,
      "collation" : <document>                   // Available starting in 3.4
   } }
] )

db.collection.bulkWrite([
   { deleteMany: {
      "filter" : <document>,
      "collation" : <document>                    // Available starting in 3.4
   } }
] )

_id Field字段

If the document does not specify an _id field, then mongod adds the _id field and assign a unique ObjectId() for the document before inserting or upserting it. 如果文档没有指定_id字段，则mongod会添加_id字段并在插入或升迁文档之前为其分配唯一的ObjectId()。Most drivers create an ObjectId and insert the _id field, but the mongod will create and populate the _id if the driver or application does not.大多数驱动程序创建ObjectId并插入_id字段，但如果驱动程序或应用程序没有创建_id，则mongod将创建并填充_id。

If the document contains an _id field, the _id value must be unique within the collection to avoid duplicate key error.如果文档包含_id字段，则_id值在集合中必须唯一，以避免重复的键错误。

Update or replace operations cannot specify an _id value that differs from the original document.更新或替换操作不能指定与原始文档不同的_id值。

Execution of Operations操作的执行

The ordered parameter specifies whether bulkWrite() will execute operations in order or not. ordered参数指定bulkWrite()是否按顺序执行操作。By default, operations are executed in order.默认情况下，操作是按顺序执行的。

The following code represents a bulkWrite() with five operations.以下代码表示具有五个操作的bulkWrite()。

db.collection.bulkWrite(
   [
      { insertOne : <document> },
      { updateOne : <document> },
      { updateMany : <document> },
      { replaceOne : <document> },
      { deleteOne : <document> },
      { deleteMany : <document> }
   ]
)

In the default ordered : true state, each operation will be executed in order, from the first operation insertOne to the last operation deleteMany.在默认的ordered:true状态下，每个操作都将按顺序执行，从第一个操作insertOne到最后一个操作deleteMany。

If ordered is set to false, operations may be reordered by mongod to increase performance. 如果ordered设置为false，则mongod可能会对操作重新排序以提高性能。Applications should not depend on order of operation execution.应用程序不应依赖于操作执行的顺序。

The following code represents an unordered bulkWrite() with six operations:以下代码表示具有六个操作的无序bulkWrite()：

db.collection.bulkWrite(
   [
      { insertOne : <document> },
      { updateOne : <document> },
      { updateMany : <document> },
      { replaceOne : <document> },
      { deleteOne : <document> },
      { deleteMany : <document> }
   ],
   { ordered : false }
)

With ordered : false, the results of the operation may vary. 对于ordered:false，操作结果可能会有所不同。For example, the deleteOne or deleteMany may remove more or fewer documents depending on whether the run before or after the insertOne, updateOne, updateMany, or replaceOne operations.例如，deleteOne或deleteMany可以删除更多或更少的文档，具体取决于是在insertOne、updateOne、updateMany还是replaceOne操作之前还是之后运行。

The number of operations in each group cannot exceed the value of the maxWriteBatchSize of the database. 每个组中的操作数不能超过数据库的maxWriteBatchSize的值。As of MongoDB 3.6, this value is 100,000. 截至MongoDB 3.6，该值为100000。This value is shown in the hello.maxWriteBatchSize field.此值显示在hello.maxWriteBatchSize字段中。

This limit prevents issues with oversized error messages. 此限制可防止出现过大错误消息的问题。If a group exceeds this limit, the client driver divides the group into smaller groups with counts less than or equal to the value of the limit. 如果组超过此限制，客户端驱动程序会将组划分为计数小于或等于限制值的较小组。For example, with the maxWriteBatchSize value of 100,000, if the queue consists of 200,000 operations, the driver creates 2 groups, each with 100,000 operations.例如，maxWriteBatchSize值为100000时，如果队列包含200000个操作，则驱动程序会创建两个组，每个组包含100000个操作。

Starting in MongoDB 3.6, once the error report for a single batch grows too large, MongoDB truncates all remaining error messages to the empty string. 从MongoDB 3.6开始，一旦单个批次的错误报告变得太大，MongoDB就会将所有剩余的错误消息截断为空字符串。Currently, begins once there are at least 2 error messages with total size greater than 1MB.当前，当至少有2条总大小大于1MB的错误消息时开始。

The sizes and grouping mechanics are internal performance details and are subject to change in future versions.尺寸和分组机制是内部性能细节，在未来版本中可能会更改。

Executing an ordered list of operations on a sharded collection will generally be slower than executing an unordered list since with an ordered list, each operation must wait for the previous operation to finish.在分片集合上执行操作的有序列表通常比执行无序列表慢，因为对于有序列表，每个操作都必须等待前一个操作完成。

Capped Collections封顶集合

bulkWrite() write operations have restrictions when used on a capped collection.在封顶集合上使用bulkWrite()写入操作时有限制。

updateOne and updateMany throw a WriteError if the update criteria increases the size of the document being modified.如果update条件增加了正在修改的文档的大小，updateOne和updateMany将引发WriteError。

replaceOne throws a WriteError if the replacement document has a larger size than the original document.如果replacement文档的大小大于原始文档，replaceOne将抛出WriteError。

deleteOne and deleteMany throw a WriteError if used on a capped collection.如果在封顶集合上使用deleteOne和deleteMany，则会引发WriteError。

Time Series Collections时间序列集合

bulkWrite() write operations have restrictions when used on a time series collection. 写入操作在时间序列集合上使用时有限制。Only insertOne can be used on time series collections. 在时间序列集合上只能使用insertOne。All other operations will return a WriteError.所有其他操作都将返回WriteError。

Error Handling错误处理

db.collection.bulkWrite() throws a BulkWriteError exception on errors (unless the operation is part of a transaction on MongoDB 4.0). db.collection.bulkWrite()对错误抛出BulkWrineError异常（除非该操作是MongoDB 4.0上事务的一部分）。See Error Handling inside Transactions.请参阅事务内部的错误处理。

Excluding Write Concern errors, ordered operations stop after an error, while unordered operations continue to process any remaining write operations in the queue, unless when run inside a transaction. 除非在事务内部运行，否则除写关注点错误外，有序操作在出错后停止，而无序操作继续处理队列中的任何剩余写操作。See Error Handling inside Transactions.请参阅事务内部的错误处理。

Write concern errors are displayed in the writeConcernErrors field, while all other errors are displayed in the writeErrors field. 写问题错误显示在writeConcernErrors字段中，而所有其他错误显示在writeErrors字段中。If an error is encountered, the number of successful write operations are displayed instead of the inserted _id values. 如果遇到错误，将显示成功的写入操作数，而不是插入的_id值。Ordered operations display the single error encountered while unordered operations display each error in an array.有序操作显示遇到的单个错误，而无序操作显示数组中的每个错误。

Transactions事务

db.collection.bulkWrite() can be used inside multi-document transactions.可以在多文档事务中使用。

Bulk Write Operations批量写入操作

The characters collection in the guidebook database contains the following documents:guidebook数据库中的characters集合包含以下文档：

{ "_id" : 1, "char" : "Brisbane", "class" : "monk", "lvl" : 4 },
{ "_id" : 2, "char" : "Eldon", "class" : "alchemist", "lvl" : 3 },
{ "_id" : 3, "char" : "Meldane", "class" : "ranger", "lvl" : 3 }

The following bulkWrite() performs multiple operations on the collection:以下bulkWrite()对集合执行多个操作：

try {
   db.characters.bulkWrite([
      { insertOne: { "document": { "_id": 4, "char": "Dithras", "class": "barbarian", "lvl": 4 } } },
      { insertOne: { "document": { "_id": 5, "char": "Taeln", "class": "fighter", "lvl": 3 } } },
      { updateOne : {
         "filter" : { "char" : "Eldon" },
         "update" : { $set : { "status" : "Critical Injury" } }
      } },
      { deleteOne : { "filter" : { "char" : "Brisbane"} } },
      { replaceOne : {
         "filter" : { "char" : "Meldane" },
         "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl": 4 }
      } }
   ]);
} catch (e) {
   print(e);
}

The operation returns the following:该操作返回以下结果：

{
   "acknowledged" : true,
   "deletedCount" : 1,
   "insertedCount" : 2,
   "matchedCount" : 2,
   "upsertedCount" : 0,
   "insertedIds" : {
      "0" : 4,
      "1" : 5
   },
   "upsertedIds" : {
   }
}

If the collection had contained a document with "_id" : 5" before executing the bulk write, then when the bulk write is executed, the following duplicate key exception would be thrown for the second insertOne:如果集合在执行批量写入之前包含一个带有"_id" : 5"的文档，那么当执行批量写入时，将为第二个insertOne抛出以下重复键异常：

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 1,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: guidebook.characters index: _id_ dup key: { _id: 5.0 }",
         "op" : {
            "_id" : 5,
            "char" : "Taeln",
            "class" : "fighter",
            "lvl" : 3
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Since ordered is true by default, only the first operation completes successfully. 由于默认情况下ordered为true，因此只有第一个操作成功完成。The rest are not executed. 其余部分不执行。Running the bulkWrite() with ordered : false would allow the remaining operations to complete despite the error.运行带有ordered:false的bulkWrite()将允许剩余操作完成，尽管出现错误。

Unordered Bulk Write无序批量写入

The characters collection in the guidebook database contains the following documents:guidebook数据库中的characters集合包含以下文档：

{ "_id" : 1, "char" : "Brisbane", "class" : "monk", "lvl" : 4 },
{ "_id" : 2, "char" : "Eldon", "class" : "alchemist", "lvl" : 3 },
{ "_id" : 3, "char" : "Meldane", "class" : "ranger", "lvl" : 3 }

The following bulkWrite() performs multiple unordered operations on the characters collection. 以下bulkWrite()对characters集合执行多个unordered操作。Note that one of the insertOne stages has a duplicate _id value:请注意，其中一个insertOne阶段具有重复的_id值：

try {
   db.characters.bulkWrite([
      { insertOne: { "document": { "_id": 4, "char": "Dithras", "class": "barbarian", "lvl": 4 } } },
      { insertOne: { "document": { "_id": 4, "char": "Taeln", "class": "fighter", "lvl": 3 } } },
      { updateOne : {
         "filter" : { "char" : "Eldon" },
         "update" : { $set : { "status" : "Critical Injury" } }
      } },
      { deleteOne : { "filter" : { "char" : "Brisbane"} } },
      { replaceOne : {
         "filter" : { "char" : "Meldane" },
         "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl": 4 }
      } }
   ], { ordered : false } );
} catch (e) {
   print(e);
}

The operation returns the following:该操作返回以下结果：

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 1,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: guidebook.characters index: _id_ dup key: { _id: 4.0 }",
         "op" : {
            "_id" : 4,
            "char" : "Taeln",
            "class" : "fighter",
            "lvl" : 3
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 2,
   "nModified" : 2,
   "nRemoved" : 1,
   "upserted" : [ ]
})

Since this was an unordered operation, the writes remaining in the queue were processed despite the exception.由于这是一个unordered操作，因此尽管出现异常，队列中剩余的写入仍被处理。

Bulk Write with Write Concern具有写入问题的批量写入

The enemies collection contains the following documents:enemies集合包含以下文档：

{ "_id" : 1, "char" : "goblin", "rating" : 1, "encounter" : 0.24 },
{ "_id" : 2, "char" : "hobgoblin", "rating" : 1.5, "encounter" : 0.30 },
{ "_id" : 3, "char" : "ogre", "rating" : 3, "encounter" : 0.2 },
{ "_id" : 4, "char" : "ogre berserker" , "rating" : 3.5, "encounter" : 0.12}

The following bulkWrite() performs multiple operations on the collection using a write concern value of "majority" and timeout value of 100 milliseconds:以下bulkWrite()使用写入关注值"majority"和超时值100毫秒对集合执行多个操作：

try {
   db.enemies.bulkWrite(
      [
         { updateMany :
            {
               "filter" : { "rating" : { $gte : 3} },
               "update" : { $inc : { "encounter" : 0.1 } }
            },
         },
         { updateMany :
            {
               "filter" : { "rating" : { $lt : 2} },
               "update" : { $inc : { "encounter" : -0.25 } }
            },
         },
         { deleteMany : { "filter" : { "encounter": { $lt : 0 } } } },
         { insertOne :
            {
               "document" :
                  {
                     "_id" :5, "char" : "ogrekin" , "rating" : 2, "encounter" : 0.31
                  }
            }
         }
      ],
      { writeConcern : { w : "majority", wtimeout : 100 } }
   );
} catch (e) {
   print(e);
}

If the total time required for all required nodes in the replica set to acknowledge the write operation is greater than wtimeout, the following writeConcernError is displayed when the wtimeout period has passed.如果副本集中所有必需节点确认写入操作所需的总时间大于wtimeout，则在wtimeout时间段过后，将显示以下writeConcernError。

BulkWriteError({
   "writeErrors" : [ ],
   "writeConcernErrors" : [
      {
         "code" : 64,
         "codeName" : "WriteConcernFailed",
         "errmsg" : "waiting for replication timed out",
         "errInfo" : {
            "wtimeout" : true
         }
      },
      {
         "code" : 64,
         "codeName" : "WriteConcernFailed",
         "errmsg" : "waiting for replication timed out",
         "errInfo" : {
            "wtimeout" : true
         }
      },
      {
         "code" : 64,
         "codeName" : "WriteConcernFailed",
         "errmsg" : "waiting for replication timed out",
         "errInfo" : {
            "wtimeout" : true
         }
      }
   ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 4,
   "nModified" : 4,
   "nRemoved" : 1,
   "upserted" : [ ]
})

The result set shows the operations executed since writeConcernErrors errors are not an indicator that any write operations failed.结果集显示执行的操作，因为writeConcernErrors错误并不能指示任何写入操作失败。