Bulk Write Operations批量写入操作

db.collection.bulkWrite()

The following db.collection.bulkWrite() example runs the following operations on the pizzas collection:以下db.collection.bulkWrite()示例对pizzas集合运行以下操作：

• Adds two documents using insertOne.使用insertOne添加两个文档。
• Updates a document using updateOne.使用updateOne更新文档。
• Deletes a document using deleteOne.使用deleteOne删除文档。
• Replaces a document using replaceOne.使用replaceOne替换文档。

try {
   db.pizzas.bulkWrite( [
      { insertOne: { document: { _id: 3, type: "beef", size: "medium", price: 6 } } },
      { insertOne: { document: { _id: 4, type: "sausage", size: "large", price: 10 } } },
      { updateOne: {
         filter: { type: "cheese" },
         update: { $set: { price: 8 } }
      } },
      { deleteOne: { filter: { type: "pepperoni"} } },
      { replaceOne: {
         filter: { type: "vegan" },
         replacement: { type: "tofu", size: "small", price: 4 }
      } }
   ] )
} catch( error ) {
   print( error )
}

Example output, which includes a summary of the completed operations:示例输出，其中包括已完成操作的摘要：

{
   acknowledged: true,
   insertedCount: 2,
   insertedIds: { '0': 3, '1': 4 },
   matchedCount: 2,
   modifiedCount: 2,
   deletedCount: 1,
   upsertedCount: 0,
   upsertedIds: {}
}

For more examples, see db.collection.bulkWrite() Examples.有关更多示例，请参阅db.collection.bulkWrite()示例。

Mongo.bulkWrite()

This example uses Mongo.bulkWrite() to perform the following operations in order:此示例使用Mongo.bulkWrite()按顺序执行以下操作：

• inserts a document into the db.authors collection将文档插入到db.authors集合中
• inserts a document into the db.books collection将文档插入db.books集合中
• updates the previous document更新上一个文档

db.getMongo().bulkWrite(
   [
      {
         namespace: 'db.authors',
         name: 'insertOne',
         document: { name: 'Stephen King' }
      },
      {
         namespace: 'db.books',
         name: 'insertOne',
         document: { name: 'It' }
      },
      {
         namespace: 'db.books',
         name: 'updateOne',
         filter: { name: 'it' },
         update: { $set: { year: 1986 } }
      }
   ],
   {
      ordered: true,
      bypassDocumentValidation: true
   }
)

mongosh performs the bulk write in order and returns the following document:按顺序执行批量写入并返回以下文档：

{
   acknowledged: true,
   insertedCount: 2,
   matchedCount: 1,
   modifiedCount: 1,
   deletedCount: 0,
   upsertedCount: 0,
   insertResults: { '1': { insertedId: ObjectId('67ed8ce8efd926c84cab7945') },
                    '2': { insertedId: ObjectId('67ed8ce8efd926c84cab7946') } }
   updateResults: { '1': { matchedCount: 1, modifiedCount: 1, didUpsert: false } }
}

Pre-Split the Collection预拆分集合

If your sharded collection is empty and you are not using hashed sharding for the first key of your shard key, then your collection has only one initial chunk, which resides on a single shard. MongoDB must then take time to receive data and distribute chunks to the available shards. 如果分片集合是空的，并且你没有对分片键的第一个键使用哈希分片，那么集合只有一个初始块，它位于一个分片上。然后，MongoDB必须花时间接收数据并将块分发到可用的分片。To avoid this performance cost, pre-split the collection by creating ranges in a sharded cluster.为了避免这种性能成本，可以通过在分片集群中创建范围来预分割集合。

Unordered Writes to mongos无序地写入到mongos

To improve write performance to sharded clusters, perform an unordered bulk write by setting ordered to false when you call your preferred method or command. mongos can attempt to send the writes to multiple shards simultaneously. 为了提高对分片集群的写入性能，在调用首选方法或命令时，通过将ordered设置为false来执行无序批量写入。mongos可以尝试同时向多个分片发送写入。For empty collections, first pre-split the collection as described in Split Chunks in a Sharded Cluster.对于空集合，首先按照分片集群中的分割块中的描述对集合进行预分割。

Avoid Monotonic Throttling避免单调节流

If your shard key increases monotonically during an insert, then all inserted data goes to the last chunk in the collection, which will always end up on a single shard. Therefore, the insert capacity of the cluster will never exceed the insert capacity of that single shard.如果分片键在插入过程中单调增加，那么所有插入的数据都会到达集合中的最后一个块，而这个块最终会出现在一个分片上。因此，集群的插入容量永远不会超过单个分片的插入容量。

If your insert volume is larger than what a single shard can process, and if you cannot avoid a monotonically increasing shard key, then consider the following modifications to your application:如果插入量大于单个分片可以处理的容量，并且如果您无法避免单调递增的分片键，那么请考虑对应用程序进行以下修改：

• Reverse the binary bits of the shard key. This preserves the information and avoids correlating insertion order with increasing sequence of values.反转分片键的二进制位。这保留了信息，并避免了将插入顺序与值的递增序列相关联。
• Swap the first and last 16-bit words to "shuffle" the inserts.交换第一个和最后一个16位字以“洗牌”插入。

using namespace mongo;
OID make_an_id() {
  OID x = OID::gen();
  const unsigned char *p = x.getData();
  swap( (unsigned short&) p[0], (unsigned short&) p[10] );
  return x;
}

void foo() {
  // create an object
  BSONObj o = BSON( "_id" << make_an_id() << "x" << 3 << "name" << "jane" );
  // now we may insert o into a sharded collection
}