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 UpdateManyModel que especifique un filtro de query y un documento de actualización.

El UpdateOneModel actualiza el primer documento que coincide con tu filtro de query y el UpdateManyModel actualiza todos los documentos que coinciden con tu 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"))

Borrar operació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 borra el primer documento que coincida con tu filtro de query y DeleteManyModel borra todos los documentos que coincidan con tu filtro de query.

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 como ordenadas o desordenadas.

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 utilizar el método bulkWrite() para insertar dos documentos. Un documento se inserta en la colección sample_db.people, mientras que el otro documento se inserta 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 query especificado en una instancia de ClientNamespacedUpdateOneModel, la operación actualiza el primer resultado. Puedes especificar un orden de clasificación en una ClientUpdateOneOptions instancia para aplicar un orden 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)

Después de que este ejemplo se ejecute correctamente, el documento que tiene un valor _id de 1 en la colección people se reemplaza por un documento nuevo. El documento en la colección objects que tiene un valor _id de 1 se reemplaza con 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 en masa.

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.

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

• Ordered, que realiza las operaciones masivas en orden hasta que se produce un error, si lo hay

• Sin orden, realiza todas las operaciones masivas en cualquier orden e informa de errores al final, si los hay

Para obtener más información sobre el comando de colección bulkWrite, consulte la db.collection.bulkWrite() referencia del método 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.