MongoDB 批量更新、批量新增、批量删除、批量替换

db.collection.bulkWrite()

提供可控执行顺序的批量写操作。

语法格式如下：

db.collection.bulkWrite(
   [ <operation 1>, <operation 2>, ... ],
   {
      writeConcern : <document>,
      ordered : <boolean>
   }
)

参数类型描述

array

bulkWrite() 写操作的数组。支持操作：insertOne、updateOne、updateMany、deleteOne、deleteMany、replaceOne

writeConcern

document

可选， write concern 文档，省略则使用默认的 write concern。

boolean

可选，表示mongod实例有序还是无序执行操作。默认值true。

方法返回值：

bulkWrite() 接收一个写操作的字段之后执行他们中的每一个。默认是有序的执行。

插入单个文档到集合中。

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

updateOne 更新集合中 filter 匹配的单个文档。如果匹配到多个文档 updateOne 仅升级第一个匹配到的文档。

db.collection.bulkWrite( [
   { updateOne :
      {
         "filter" : <document>,
         "update" : <document>,
         "upsert" : <boolean>
      }
   }
] )

updateMany 更新集合中所有匹配到的文档。

db.collection.bulkWrite( [
   { updateMany :
      {
         "filter" : <document>,
         "update" : <document>,
         "upsert" : <boolean>
      }
   }
] )

对字段的升级操作比如 $set 、$unset 、$rename等。

默认情况 upsert 为 false。

replaceOne 替换集合中 filter 匹配到的单个文档。如果匹配到多个文档 replaceOne 只会更换一个匹配到的文档。

db.collection.bulkWrite([
   { replaceOne :
      {
         "filter" : <document>,
         "replacement" : <document>,
         "upsert" : <boolean>
      }
   }
] )

replacement 字段中不能包含 update 操作。

默认情况 upsert 为 false。

deleteOne 删除集合中 filter 匹配到的单个文档。如果匹配到多个文档 deleteOne 只会删掉一个匹配到的文档。

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

deleteMany 删除集合中 filter 匹配到的所有文档。

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

如果文档未指定 _id 字段，则mongod会在 insert 或 upsert 文档之前添加 _id 字段并指定唯一的ObjectId。 大多数驱动程序会建立一个ObjectId并插入到 _id 字段，但即使驱动程序或应用程序没有，mongod将建立并填充 _id。

如果文档包含 _id 字段，则 _id 值在集合中需要是唯一的，以防止重复键错误。

更新或更换操作不能指定与原始文档不同的 _id 值。

ordered 参数指定 bulkWrite() 是否有序执行，默认情况下是有序执行。

含有6个操作的 bulkWrite() 代码如下：

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

默认情况下 ordered : true ,每个操作将会有序的执行，从第一个insertOne 到最后一个deleteMany 顺序执行。

应用程序不依赖操作执行顺序是，可以设定 ordered 为 false ，此时mongod 会再次排序操作来提升性能。

含有6个操作无序的 bulkWrite() 代码如下：

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

对于ordered：falsemongodb批量insert，操作结果可能会有所不同。 例如，deleteOne或deleteMany 删除的文档可能会变多或变少，具体取决于deleteOne或deleteMany 是在insertOne，updateOne，updateMany或replaceOne操作之前或以后的运行。

每组操作最多可以有1000次操作。 如果一个组达到此，MongoDB会将该组划分为1000或最小的组。 例如，如果队列包含2000个操作，MongoDB将创建2个组，每个组具有1000个操作。

大小跟分组制度是外部的执行细节，在未来的版本中可能会有所变化。

在分片集合上执行有序操作一般比执行无序操作慢，因为针对有序，每个操作需要期待上一个操作完成。

bulkWrite() 写操作在固定集合上使用有所限制。

bulkWrite() 在错误出现时会抛出 BulkWriteError 异常。

排除Write Concern错误，有序操作在出现错误后中止，及无序操作继续处理队列中的剩余写入操作。

Write Concern 错误显示在 writeConcernErrors字段中，而所有其它错误都显示在writeErrors字段中。 如果碰到错误，则显示成功写入操作的次数而不是插入的_id值。 有序操作显示遇到的单个错误mongodb批量insert，而无序操作显示变量中的每个错误。

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 }

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

操作结果如下：

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

如果 第二个 insertOne 操作的 _id 是集合中尚未存在的，则会抛出以下错误：

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

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/ruanjian/article-140935-1.html