db.collection.insertMany()

Execution of Operations操作的执行

By default, documents are inserted in the order they are provided.默认情况下，文档是按照提供的顺序插入的。

If ordered is set to true and an insert fails, the server does not continue inserting records.如果ordered设置为true并且插入失败，则服务器不会继续插入记录。

If ordered is set to false and an insert fails, the server continues inserting records. 如果ordered设置为false并且插入失败，则服务器将继续插入记录。Documents may be reordered by mongod to increase performance. 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值。The default value of maxWriteBatchSize is 100,000. maxWriteBatchSize的默认值为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个操作。

If the error report for a single batch grows too large, MongoDB truncates all remaining error messages to the empty string. 如果单个批次的错误报告过大，MongoDB会将所有剩余的错误消息截断为空字符串。If there are at least two error messages with total size greater than 1MB, they are trucated.如果至少有两条错误消息的总大小大于1MB，则对它们进行trucated。

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将创建并填充。

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字段中，而所有其他错误都显示在writeErrors字段。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. As such, your values may differ from those in the example.ObjectId值特定于运行操作时的机器和时间。因此，您的值可能与示例中的值不同。

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

The following example/operation uses insertMany() to insert documents that include the _id field. The value of _id must be unique within the collection to avoid a duplicate key error.以下示例/操作使用insertMany()插入包含_id字段的文档。_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. The following attempts to insert a document with a _id value that already exists:为作为唯一索引一部分的任何键（如_id）插入重复值会引发异常。以下尝试插入已存在_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. This will also stop additional documents left in the queue from being inserted.请注意，插入了一个文档：_id:13的第一个文档将成功插入，但第二个插入将失败。这也将阻止插入队列中剩余的其他文档。

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. The array of documents contains two documents with duplicate _id fields.以下尝试插入多个_id字段为且ordered: false的文档。文档数组包含两个具有重复_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.当item: "medium box"和item: "tape"的文档由于_id值重复而无法插入时，nInserted显示已插入其余5个文档。

Using Write Concern使用写入关注

Given a three member replica set, the following operation specifies a w of majority and wtimeout of 100:给定一个由三个成员组成的复制集，以下操作指定w为多数，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"
     }
   }
})