Operaciones masivas

Operación de inserción

Para llevar a cabo una operación de inserción, crea un InsertOneModel especificando el documento que deseas insertar. Para insertar varios documentos, debe crear un InsertOneModel para cada documento que desee insertar.

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

Operación de reemplazo

Para realizar una operación de reemplazo, cree un ReplaceOneModel especificando un filtro de query para el documento que desea reemplazar y el documento de reemplazo.

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

Operación de actualización

Para realizar una operación de actualización, cree un UpdateOneModel o un UpdateManyModel que especifique un filtro de consulta y un documento de actualización.

UpdateOneModel actualiza el primer documento que coincide con su filtro de consulta y UpdateManyModel actualiza todos los documentos que coinciden con su filtro de consulta.

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

Operación de eliminación

Para realizar una operación de eliminación, cree un DeleteOneModel o un DeleteManyModel que especifique un filtro de query para los documentos que desea eliminar.

DeleteOneModel elimina el primer documento que coincide con su filtro de consulta y DeleteManyModel elimina todos los documentos que coinciden con su filtro de consulta.

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

Orden de ejecución

El método bulkWrite() acepta un BulkWriteOptions opcional como segundo parámetro para especificar si desea ejecutar las operaciones masivas de forma ordenada o desordenada.

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 }

Operación de inserción

Este ejemplo muestra cómo usar el método bulkWrite() para insertar dos documentos. Un documento se inserta en la colección sample_db.people y el otro en la colección sample_db.objects. La instancia MongoNamespace define las bases de datos y colecciones a las que se aplica cada operación de escritura.

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)

Operación de actualización

El siguiente ejemplo muestra cómo utilizar el método bulkWrite() para actualizar documentos existentes en las colecciones sample_db.people y 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)

Este ejemplo incrementa el valor del campo age por 1 en el documento que tiene un valor name de "Freya Polk" en la colección people. También establece el valor del campo manufacturer en "Premium Technologies" en todos los documentos que tienen un valor de category de "electronic" en la colección objects.

Si varios documentos coinciden con el filtro de consulta especificado en una ClientNamespacedUpdateOneModel instancia, la operación actualiza el primer resultado. Puede especificar un orden de clasificación en una instancia ClientUpdateOneOptions para aplicarlo a los documentos coincidentes antes de que el servidor realice la operación de actualización, como se muestra en el siguiente código:

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

Operación de reemplazo

El siguiente ejemplo muestra cómo utilizar el método bulkWrite() para reemplazar documentos existentes en las colecciones sample_db.people y 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)

Tras la correcta ejecución de este ejemplo, el documento con un valor _id de 1 en la colección people se reemplaza por un nuevo documento. El documento de la colección objects con un valor _id de 1 se reemplaza por un nuevo documento.

Si varios documentos coinciden con el filtro de query especificado en una instancia de ClientNamespacedReplaceOneModel, la operación reemplaza el primer resultado. Se puede especificar un orden de clasificación en una instancia de ClientReplaceOneOptions para aplicar un orden a los documentos coincidentes antes de que el driver realice la operación de reemplazo, como se muestra en el siguiente código:

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

Opciones de escritura masiva

Puede pasar una instancia de ClientBulkWriteOptions al método bulkWrite() para especificar opciones al ejecutar las operaciones de escritura masiva.

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 realizar una operación masiva, crea y pasa una lista de instancias de WriteModel al método bulkWrite().

Hay 6 subtipos diferentes de WriteModel: InsertOneModel, ReplaceOneModel, UpdateOneModel, UpdateManyModel, DeleteOneModel y DeleteManyModel.

Hay dos formas de ejecutar el método bulkWrite():

• Ordenado, que realiza las operaciones en masa en orden hasta que se produzca un error, si lo hay

• Desordenado, que realiza todas las operaciones en masa en cualquier orden e informa errores al final, si los hay

Para obtener más información sobre el comando de colección,bulkWrite consulte la referencia del método db.collection.bulkWrite() en el Manual del servidor MongoDB.

MongoClient.bulkWrite()

Al conectarse a una implementación que ejecuta una versión 8.0 o posterior del servidor MongoDB, puede usar el MongoClient.bulkWrite() método para realizar operaciones por lotes en varias bases de datos y colecciones a la vez.

Para realizar una operación masiva del cliente, crea una y pasa una lista de instancias ClientNamespacedWriteModel a este método.

Existen seis subtipos de ClientNamespacedWriteModel que son utilizados para representar las operaciones de guardar. Para construir estos modelos de guardado, puedes utilizar los métodos correspondientes ClientNamespacedWriteModel, insertOne(), updateOne(), updateMany(), replaceOne(), deleteOne() y deleteMany(). Estos métodos requieren un objeto MongoNamespace que define a qué base de datos y colección guardar.

El método MongoClient.bulkWrite() también puede tomar un objeto ClientBulkWriteOptions para especificar diferentes opciones sobre cómo se ejecuta el comando.

Para aprender más sobre el comando de cliente bulkWrite, consulta la referencia del método bulkWrite() en el Manual del servidor de MongoDB.