批量操作

插入操作

如需执行插入操作，请创建 InsertOneModel，指定要插入的文档。如需插入多个文档，必须为每个要插入的文档创建一个 InsertOneModel。

val juneDoc = InsertOneModel(Person(3, "June Carrie", 17))
val kevinDoc = InsertOneModel(Person(4, "Kevin Moss", 22))

try {
    val bulkOperations = listOf(
        (InsertOneModel(Person(1, "James Smith", 13))),
        (InsertOneModel(Person(3, "Colin Samuels")))
    )
    val bulkWrite = collection.bulkWrite(bulkOperations)
} catch (e: MongoBulkWriteException) {
    println("A MongoBulkWriteException occurred with the following message: " + e.message)
}

A MongoBulkWriteException occurred with the following message:
Bulk write operation error on server sample-shard-00-02.pw0q4.mongodb.net:27017.
Write errors: [BulkWriteError{index=0, code=11000, message='E11000 duplicate key
error collection: crudOps.bulkWrite index: _id_ dup key: { _id: 1 }', details={}}].

替换操作

要执行替换操作，请创建ReplaceOneModel ，为要替换的文档和替换文档指定查询筛选器。

val filter = Filters.eq("_id", 1)
val insert = Person(1, "Celine Stork", location = "San Diego, CA")
val doc = ReplaceOneModel(filter, insert)

val opts = ReplaceOptions().sort(Sorts.ascending("_id"))

更新操作

要执行更新操作，请创建指定查询筛选器和更新文档的UpdateOneModel或UpdateManyModel 。

UpdateOneModel 更新与查询筛选器匹配的第一个文档，UpdateManyModel 更新与查询筛选器匹配的所有文档。

val filter = Filters.eq("_id", 2)
val update = Updates.inc(Person::age.name, 1)
val doc = UpdateOneModel<Person>(filter, update)

val opts = UpdateOptions().sort(Sorts.ascending("_id"))

删除操作

要执行删除操作，请创建DeleteOneModel或DeleteManyModel ，为要删除的文档指定查询筛选器。

DeleteOneModel 删除与查询筛选器匹配的第一个文档，DeleteManyModel 删除与查询筛选器匹配的所有文档。

val deleteId1 = DeleteOneModel<Person>(Filters.eq("_id", 1))
val deleteAgeLt30 = DeleteManyModel<Person>(Filters.lt(Person::age.name, 30))

执行顺序

bulkWrite()方法接受可选的BulkWriteOptions作为第二个参数，以指定是要按有序还是无序执行批量操作。

val insertMdl = InsertOneModel(Person(6, "Zaynab Omar", 37))
val replaceMdl = ReplaceOneModel(
    Filters.eq("_id", 1),
    Person(1, "Sandy Kane", location = "Helena, MT")
)
val updateMdl  = UpdateOneModel<Person>(
        Filters.eq("_id", 6),
        Updates.set(Person::name.name, "Zaynab Hassan")
    )
val deleteMdl = DeleteManyModel<Person>(Filters.gt(Person::age.name, 50))
val bulkOperations = listOf(
    insertMdl,
    replaceMdl,
    updateMdl,
    deleteMdl
)
val result = collection.bulkWrite(bulkOperations)

{ "_id": 1, "name": "Sandy Kane", "location": "Helena, MT" }
{ "_id": 8, "name": "Shayla Ray", "age": 20 }
{ "_id": 6, "name": "Zaynab Hassan", "age": 37 }

val options = BulkWriteOptions().ordered(false)
val unorderedResult = collection.bulkWrite(bulkOperations, options)

{ "_id": 1, "name": "Sandy Kane", "location": "Helena, MT" }
{ "_id": 8, "name": "Shayla Ray", "age": 20 }
{ "_id": 6, "name": "Zaynab Omar", "age": 37 }

插入操作

此示例演示如何使用 bulkWrite() 方法插入两个文档。 将一个文档插入到 sample_db.people集合中，而将另一文档插入到 sample_db.objects集合中。 MongoNamespace实例定义每个写入操作适用的数据库和集合。

val docsToInsert = mutableListOf<ClientNamespacedWriteModel>()
docsToInsert.add(
    ClientNamespacedWriteModel
        .insertOne(
            MongoNamespace("sample_db", "people"),
            Person(2, "Julia Smith")
        )
)
docsToInsert.add(
    ClientNamespacedWriteModel
        .insertOne(
            MongoNamespace("sample_db", "objects"),
            Object(2, "washing machine")
        )
)
val clientBulkResult = client.bulkWrite(docsToInsert)

更新操作

以下示例展示如何使用 bulkWrite() 方法更新sample_db.people 和 sample_db.objects 集合中的现有文档：

val docsToInsert = mutableListOf<ClientNamespacedWriteModel>()
docsToInsert.add(
    ClientNamespacedWriteModel
        .updateOne(
            MongoNamespace("sample_db", "people"),
            Filters.eq(Person::name.name, "Freya Polk"),
            Updates.inc(Person::age.name, 1)
        )
)
docsToInsert.add(
    ClientNamespacedWriteModel
        .updateMany(
            MongoNamespace("sample_db", "objects"),
            Filters.eq(Object::category.name, "electronic"),
            Updates.set(Object::manufacturer.name, "Premium Technologies")
        )
)
val clientBulkResult = client.bulkWrite(docsToInsert)

此示例将 people集合中 name 值为 "Freya Polk" 的文档中 age字段的值递增 1。它还将 objects集合中 category 值为 "electronic" 的所有文档的 manufacturer字段的值设置为 "Premium Technologies"。

如果多个文档与 ClientNamespacedUpdateOneModel 实例中指定的查询过滤匹配，则该操作会更新第一个结果。您可以在 ClientUpdateOneOptions 实例中指定排序顺序，以便在服务器执行更新操作之前对匹配的文档应用顺序，如以下代码所示：

val options =  ClientUpdateOneOptions
    .clientUpdateOneOptions()
    .sort(Sorts.ascending("_id"))

替换操作

以下示例演示如何使用 bulkWrite() 方法替换 sample_db.people 和 sample_db.objects 集合中的现有文档。

val docsReplacements = mutableListOf<ClientNamespacedWriteModel>()
docsReplacements.add(
    ClientNamespacedWriteModel
        .replaceOne(
            MongoNamespace("sample_db", "people"),
            Filters.eq(Person::id.name, 1),
            Person(1, "Frederic Hilbert")
        )
)
docsReplacements.add(
    ClientNamespacedWriteModel
        .replaceOne(
            MongoNamespace("sample_db", "objects"),
            Filters.eq(Object::id.name, 1),
            Object(1, "ironing board")
        )
)
val clientBulkResult = client.bulkWrite(docsReplacements)

此示例成功运行后，people集合中 _id 值为 1 的文档将替换为新文档。 objects集合中 _id 值为 1 的文档将替换为新文档。

如果多个文档与 ClientNamespacedReplaceOneModel 实例中指定的查询过滤匹配，则该操作将替换第一个结果。您可以在 ClientReplaceOneOptions 实例中指定排序顺序，以便在驾驶员执行替换操作之前对匹配的文档应用顺序，如以下代码所示：

val options =  ClientReplaceOneOptions
    .clientReplaceOneOptions()
    .sort(Sorts.ascending("_id"))

BulkWriteOptions

您可以将 ClientBulkWriteOptions 的实例传递给 bulkWrite() 方法，以在运行批量写入操作时指定选项。

val namespace = MongoNamespace("sample_db", "people")
val options = ClientBulkWriteOptions
    .clientBulkWriteOptions()
    .ordered(false)
val bulkOperations = listOf(
    ClientNamespacedWriteModel.insertOne(
        namespace,
        Person(2, "Rudra Suraj")
    ),
    // Causes duplicate key error
    ClientNamespacedWriteModel.insertOne(
        namespace,
        Person(2, "Wendy Zhang")
    ),
    ClientNamespacedWriteModel.insertOne(
        namespace,
        Person(4, "Mario Bianchi")
    )
)
val result = client.bulkWrite(bulkOperations, options)

MongoCollection.bulkWrite()

要执行批量操作，您需要创建 WriteModel 实例列表并将其传递给 bulkWrite() 方法。

有 6 种不同的 WriteModel 子类型：InsertOneModel、ReplaceOneModel、UpdateOneModel、UpdateManyModel、DeleteOneModel 和 DeleteManyModel。

有两种方法可以执行 bulkWrite() 方法：

• 有序，按顺序执行批量操作，直到出现错误（如有）

• 无序，以任何顺序执行所有批量操作，并在最后报告错误（如果有）

要学习；了解有关集合bulkWrite 命令的更多信息，请参阅数据库。 集合.bulkWrite()MongoDB服务器手册中的方法参考。

MongoClient.bulkWrite()

连接到运行MongoDB服务器版本 8.0 或更高版本的部署时，可以使用 MongoClient.bulkWrite() 方法同时对多个数据库和集合执行批量操作。

要执行客户端批量操作，您可以创建一个传递给此方法的 ClientNamespacedWriteModel 实例列表。

ClientNamespacedWriteModel 有六个子类型用于表示写入操作。 要构建这些写入模型，可以使用相应的 ClientNamespacedWriteModel 方法 insertOne()、updateOne()、updateMany()、replaceOne()、deleteOne() 和 deleteMany()。 这些方法接受一个 MongoNamespace对象，该对象定义要写入的数据库和集合。

MongoClient.bulkWrite() 方法还可以接受 ClientBulkWriteOptions对象来指定命令执行方式的不同选项。

要学习；了解有关客户端bulkWrite 命令的更多信息，请参阅MongoDB服务器手册中的 bulkWrite() 方法参考。