db.collection.insertMany()

Execution of Operations操作的执行

By default documents are inserted in order.默认情况下，文档按顺序插入。

If ordered is set to false, documents are inserted in an unordered format and may be reordered by mongod to increase performance. 如果ordered设置为false，则文档将以无序格式插入，并可能由mongod重新排序以提高性能。Applications should not depend on ordering of inserts if using an unordered insertMany().如果使用无序insertMany()，则应用程序不应依赖于插入的顺序。

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个操作，则驱动程序将创建2个组，每个组包含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.在分片集合上执行有序操作列表通常比执行无序列表慢，因为对于有序列表，每个操作都必须等待上一个操作完成。

Collection Creation集合创建

If the collection does not exist, then insertMany() creates the collection on successful write.如果集合不存在，则insertMany()在成功写入时创建集合。

_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. 如果文档没有指定_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值在集合中必须唯一，以避免重复键错误。

Explainability解释能力

insertMany() is not compatible with db.collection.explain().与db.collection.explain()不兼容。

Error Handling错误处理

Inserts throw a BulkWriteError exception.插入引发BulkWriteError异常。

Excluding Write Concern errors, ordered operations stop after an error, while unordered operations continue to process any remaining write operations in the queue.不包括写入关注点错误，有序操作在错误后停止，而无序操作继续处理队列中的任何剩余写入操作。

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

Transactions事务

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

Insert Several Document without Specifying an _id Field插入多个文档而不指定_id字段

The following example uses db.collection.insertMany() to insert documents that do not contain the _id field:以下示例使用db.collection.insertMany()插入不包含_id字段的文档：

try {
   db.products.insertMany( [
      { item: "card", qty: 15 },
      { item: "envelope", qty: 20 },
      { item: "stamps" , qty: 30 }
   ] );
} catch (e) {
   print (e);
}

The operation returns the following document:该操作返回以下文档：

{
   "acknowledged" : true,
   "insertedIds" : [
      ObjectId("562a94d381cb9f1cd6eb0e1a"),
      ObjectId("562a94d381cb9f1cd6eb0e1b"),
      ObjectId("562a94d381cb9f1cd6eb0e1c")
   ]
}

Because the documents did not include _id, mongod creates and adds the _id field for each document and assigns it a unique ObjectId() value.由于文档不包含_id，mongod为每个文档创建并添加_id字段，并为其分配唯一的ObjectId()值。

The ObjectId values are specific to the machine and time when the operation is run. ObjectId值特定于运行操作的机器和时间。As such, your values may differ from those in the example.因此，您的值可能与示例中的值不同。

Insert Several Document Specifying an _id Field插入指定_id字段的多个文档

The following example/operation uses insertMany() to insert documents that include the _id field. 下面的示例/操作使用insertMany()插入包含_id字段的文档。The value of _id must be unique within the collection to avoid a duplicate key error._id的值在集合中必须是唯一的，以避免重复的键错误。

try {
   db.products.insertMany( [
      { _id: 10, item: "large box", qty: 20 },
      { _id: 11, item: "small box", qty: 55 },
      { _id: 12, item: "medium box", qty: 30 }
   ] );
} catch (e) {
   print (e);
}

The operation returns the following document:该操作返回以下文档：

{ "acknowledged" : true, "insertedIds" : [ 10, 11, 12 ] }

Inserting a duplicate value for any key that is part of a unique index, such as _id, throws an exception. 为属于唯一索引（如_id）的任何键插入重复值会引发异常。The following attempts to insert a document with a _id value that already exists:以下操作尝试插入已存在_id值的文档：

try {
   db.products.insertMany( [
      { _id: 13, item: "envelopes", qty: 60 },
      { _id: 13, item: "stamps", qty: 110 },
      { _id: 14, item: "packing tape", qty: 38 }
   ] );
} catch (e) {
   print (e);
}

Since _id: 13 already exists, the following exception is thrown:由于_id:13已存在，将引发以下异常：

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 0,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 13.0 }",
         "op" : {
            "_id" : 13,
            "item" : "stamps",
            "qty" : 110
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Note that one document was inserted: The first document of _id: 13 will insert successfully, but the second insert will fail. 请注意，插入了一个文档：_id:13的第一个文档将成功插入，但第二个插入将失败。This will also stop additional documents left in the queue from being inserted.这也将阻止插入队列中剩余的其他文档。

With ordered to false, the insert operation would continue with any remaining documents.如果ordered为false，插入操作将继续处理所有剩余文档。

Unordered Inserts无序插入

The following attempts to insert multiple documents with _id field and ordered: false. 下面尝试插入多个带有_id字段并且ordered: false的文档。The array of documents contains two documents with duplicate _id fields.文档数组包含两个具有重复_id字段的文档。

try {
   db.products.insertMany( [
      { _id: 10, item: "large box", qty: 20 },
      { _id: 11, item: "small box", qty: 55 },
      { _id: 11, item: "medium box", qty: 30 },
      { _id: 12, item: "envelope", qty: 100},
      { _id: 13, item: "stamps", qty: 125 },
      { _id: 13, item: "tape", qty: 20},
      { _id: 14, item: "bubble wrap", qty: 30}
   ], { ordered: false } );
} catch (e) {
   print (e);
}

The operation throws the following exception:该操作引发以下异常：

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 2,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 11.0 }",
         "op" : {
            "_id" : 11,
            "item" : "medium box",
            "qty" : 30
         }
      },
      {
         "index" : 5,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 13.0 }",
         "op" : {
            "_id" : 13,
            "item" : "tape",
            "qty" : 20
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 5,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

While the document with item: "medium box" and item: "tape" failed to insert due to duplicate _id values, nInserted shows that the remaining 5 documents were inserted.由于重复的_id值，item: "medium box"和item: "tape"的文档无法插入，但nInserted表示插入了其余5个文档。

Using Write Concern使用写入问题

Given a three member replica set, the following operation specifies a w of majority and wtimeout of 100:给定一个三成员副本集，以下操作指定w为majority，wtimeout为100：

try {
   db.products.insertMany(
      [
         { _id: 10, item: "large box", qty: 20 },
         { _id: 11, item: "small box", qty: 55 },
         { _id: 12, item: "medium box", qty: 30 }
      ],
      { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print (e);
}

If the primary and at least one secondary acknowledge each write operation within 100 milliseconds, it returns:如果主服务器和至少一个辅助服务器在100毫秒内确认每个写入操作，则返回：

{
  "acknowledged" : true,
  "insertedIds" : [
     ObjectId("562a94d381cb9f1cd6eb0e1a"),
     ObjectId("562a94d381cb9f1cd6eb0e1b"),
     ObjectId("562a94d381cb9f1cd6eb0e1c")
  ]
}

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。

This operation returns:此操作返回：

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
    // Added in MongoDB 4.4
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})