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 isMaster.maxWriteBatchSize field.此值显示在isMaster.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. 如果一个组超过此limit，客户端驱动程序会将该组划分为计数小于或等于该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.在分片集合上执行操作的有序列表通常比执行无序列表慢，因为对于有序列表，每个操作都必须等待前一个操作完成。

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. 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.

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().

Use insert() instead.改为使用insert()。

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. If an error is encountered, the number of successful write operations are displayed instead of a list of inserted _ids. 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.

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. 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. The following attempts to insert a document with a _id value that already exists:

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. The array of documents contains two documents with duplicate _id fields.

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.

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