Operações em massa

Inserir operação

Para executar uma operação de inserção, crie um InsertOneModel especificando o documento que você deseja inserir. Para inserir vários documentos, você deve criar um InsertOneModel para cada documento que deseja inserir.

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={}}].

Operação de substituição

Para executar uma operação de substituição, crie um ReplaceOneModel especificando um filtro de query para o documento que você deseja substituir e o documento de substituição.

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

Operação de atualização

Para executar uma operação de atualização, crie um UpdateOneModel ou um UpdateManyModel que especifique um filtro de query e um documento de atualização.

O UpdateOneModel atualiza o primeiro documento que corresponde ao seu filtro de query, e o UpdateManyModel atualiza todos os documentos que correspondem ao seu filtro de query.

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

Excluir operação

Para executar uma operação de exclusão, crie um DeleteOneModel ou um DeleteManyModel que especifique um filtro de query para documentos que você deseja excluir.

O DeleteOneModel exclui o primeiro documento que corresponde ao filtro de query e o DeleteManyModel exclui todos os documentos que correspondem ao filtro de query.

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

Ordem de execução

O método bulkWrite() aceita um BulkWriteOptions opcional como segundo parâmetro para especificar se você deseja executar as operações em massa como ordenadas ou não.

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 }

Inserir operação

Este exemplo mostra como usar o método bulkWrite() para inserir dois documentos. Um documento é inserido na collection sample_db.people, enquanto o outro documento é inserido na collection sample_db.objects. A instância MongoNamespace define os bancos de dados e as collections aos quais cada operação de gravação se aplica.

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)

Operação de substituição

O exemplo a seguir mostra como usar o método bulkWrite() para substituir documentos existentes nas coleções sample_db.people e sample_db.things.

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)

Depois que esse exemplo for executado com êxito, o documento que tem um valor _id de 1 na coleção people é substituído por um novo documento. O documento na coleção things que tem um valor _id de 1 é substituído por um novo documento.

Opções de gravação em massa

Você pode passar uma instância de ClientBulkWriteOptions para o método bulkWrite() para especificar opções ao executar operações de gravação em massa.

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

Para executar uma operação em massa, você cria e passa uma lista de instâncias do WriteModel para o método bulkWrite().

Existem 6 subtipos diferentes de WriteModel: InsertOneModel, ReplaceOneModel, UpdateOneModel, UpdateManyModel, DeleteOneModel e DeleteManyModel.

Há duas maneiras de executar o método bulkWrite():

• Solicitado, que executa as operações em massa para que ocorra um erro, se houver

• Não ordenado, que executa todas as operações em massa em qualquer ordem e relata erros no final, se houver

Para saber mais sobre o bulkWrite comando da coleção, consulte a referência do método db.collection.bulkWrite() no Manual do servidor MongoDB .

MongoClient.bulkWrite()

Ao conectar a um sistema executando o servidor MongoDB versão 8.0 ou posterior, você pode usar o método MongoClient.bulkWrite() para executar operações em massa em vários bancos de dados e collections de uma só vez.

Para executar uma operação em massa do cliente , você cria uma lista de ClientNamespacedWriteModel instâncias para este método.

Há seis subtipos de ClientNamespacedWriteModel usados para representar operações de escrita. Para construir esses modelos de gravação, você pode usar os métodos ClientNamespacedWriteModel correspondentes insertOne(), updateOne(), updateMany(), replaceOne(), deleteOne() e deleteMany(). Esses métodos usam um objeto MongoNamespace que define em qual banco de dados e coleção escrever.

O método MongoClient.bulkWrite() também pode usar um objeto ClientBulkWriteOptions para especificar diferentes opções de como o comando é executado.

Para saber mais sobre o comando do cliente,bulkWrite consulte a referência do método bulkWrite() no Manual do servidor MongoDB .