Operaciones masivas

Operación de inserción

Para insertar un documento, cree un InsertOneModel que especifique el documento que desea insertar. Para insertar varios documentos, debe crear un InsertOneModel para cada uno.

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 consulta 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 en 1 en el documento cuyo valor name es "Freya Polk" en la colección people. También establece el valor del campo manufacturer en "Premium Technologies" en todos los documentos cuyo valor category es "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 consulta especificado en una instancia ClientNamespacedReplaceOneModel, la operación reemplaza el primer resultado. Puede especificar un orden de clasificación en una instancia ClientReplaceOneOptions para aplicar un orden a los documentos coincidentes antes de que el controlador 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 WriteModel instancias 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 la versión de servidor MongoDB 8.0 o posterior, puede usar el método MongoClient.bulkWrite() para realizar operaciones masivas en varias bases de datos y colecciones a la vez.

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

Existen seis subtipos de ClientNamespacedWriteModel que se utilizan para representar operaciones de escritura. Para construir estos modelos de escritura, se pueden usar los métodos ClientNamespacedWriteModel correspondientes: insertOne(), updateOne(), updateMany(), replaceOne(), deleteOne() y deleteMany(). Estos métodos toman un objeto MongoNamespace que define en qué base de datos y colección se escribirá.

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.