Operaciones de escritura masiva

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.

InsertOneModel<Document> juneDoc = new InsertOneModel<>(new Document("name", "June Carrie")
                                                            .append("age", 17));
                                                  
InsertOneModel<Document> kevinDoc = new InsertOneModel<>(new Document("name", "Kevin Moss")
                                                            .append("age", 22));

try {
    List<WriteModel<Document>> bulkOperations = new ArrayList<>();
    // Creates instructions to insert documents
    InsertOneModel<Document> doc1 = new InsertOneModel<>(new Document("_id", 1));
    InsertOneModel<Document> doc3 = new InsertOneModel<>(new Document("_id", 3));
    
    bulkOperations.add(doc1);
    bulkOperations.add(doc3);
    
    // Runs a bulk write operation for the specified insert WriteModels
    collection.bulkWrite(bulkOperations); 
// Prints a message if any exceptions occur during the bulk write operation
} catch (MongoBulkWriteException e){
    System.out.println("A MongoBulkWriteException occurred with the following message: " + e.getMessage());
}

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 que especifique un filtro de consulta para el documento que desea reemplazar con el documento de reemplazo.

ReplaceOneModel<Document> celineDoc = new ReplaceOneModel<>(
                                    Filters.eq("_id", 1), 
                                    new Document("name", "Celine Stork")
                                        .append("location", "San Diego, CA"));

ReplaceOptions options = ReplaceOptions.sort(Sorts.ascending("_id"));

Operación de actualización

Para realizar una operación de actualización, cree un UpdateOneModel o un UpdateManyModel especificando un filtro de consulta para los documentos que desea actualizar con las actualizaciones.

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.

UpdateOneModel<Document> updateDoc = new UpdateOneModel<>(
                                    Filters.eq("_id", 2), 
                                    Updates.set("age", 31));

UpdateOptions options = UpdateOptions.sort(Sorts.ascending("_id"));

Operación de eliminación

Para realizar una operación de eliminación, cree un DeleteOneModel o un DeleteManyModel especificando un filtro de consulta 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.

DeleteOneModel<Document> deleteDoc = new DeleteOneModel<>(Filters.eq("_id", 1));

Orden de ejecución

El método bulkWrite() acepta un BulkWriteOptions opcional como segundo parámetro para especificar si la ejecución de las operaciones masivas está ordenada o no.

List<WriteModel<Document>> bulkOperations = new ArrayList<>();
// Creates instructions to insert a document
InsertOneModel<Document> insertDoc = new InsertOneModel<>(new Document("_id", 6)
                                                        .append("name", "Zaynab Omar")
                                                        .append("age", 37));
// Creates instructions to replace the first document matched by the query                                       
ReplaceOneModel<Document> replaceDoc = new ReplaceOneModel<>(Filters.eq("_id", 1), 
                                        new Document("name", "Sandy Kane")
                                            .append("location", "Helena, MT")); 
// Creates instructions to update the first document matched by the query                                                                 
UpdateOneModel<Document> updateDoc = new UpdateOneModel<>(Filters.eq("name", "Zaynab Omar"), 
                                        Updates.set("name", "Zaynab Hassan"));
// Creates instructions to delete all documents matched by the query                                
DeleteManyModel<Document> deleteDoc = new DeleteManyModel<>(Filters.gt("age", 50));
bulkOperations.add(insertDoc);
bulkOperations.add(replaceDoc);
bulkOperations.add(updateDoc);
bulkOperations.add(deleteDoc);
// Runs a bulk write operation for the specified the insert, replace, update, and delete WriteModels in order
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 }

BulkWriteOptions options = new BulkWriteOptions().ordered(false);
// Runs a bulk write operation for the specified insert, replace, update, and delete WriteModels in any order
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 }

Ejemplo de escritura masiva: archivo completo

El siguiente código es un archivo completo e independiente que realiza las siguientes acciones:

1. Crea una lista de instancias de las clases InsertOneModel, UpdateOneModel, DeleteOneModel y ReplaceOneModel.

2. Ejecuta una operación bulkWrite() ordenada que realiza las escrituras especificadas en la lista de modelos.

// Runs bulk write operations on a collection by using the Java driver
package org.example;
import java.util.Arrays;
import org.bson.Document;
import com.mongodb.MongoException;
import com.mongodb.bulk.BulkWriteResult;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.InsertOneModel;
import com.mongodb.client.model.ReplaceOneModel;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.model.UpdateOptions;
public class BulkWrite {
    public static void main(String[] args) {
        // Replace the uri string with your MongoDB deployment's connection string
        String uri = "<connection string uri>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            // Runs a bulk write operation for the specified insert, update, delete, and replace operations
            BulkWriteResult result = collection.bulkWrite(
                    Arrays.asList(
                            new InsertOneModel<>(new Document("name", "A Sample Movie")),
                            new InsertOneModel<>(new Document("name", "Another Sample Movie")),
                            new InsertOneModel<>(new Document("name", "Yet Another Sample Movie")),
                            new UpdateOneModel<>(new Document("name", "A Sample Movie"),
                                    new Document("$set", new Document("name", "An Old Sample Movie")),
                                    new UpdateOptions().upsert(true)),
                            new DeleteOneModel<>(new Document("name", "Yet Another Sample Movie")),
                            new ReplaceOneModel<>(new Document("name", "Yet Another Sample Movie"),
                                    new Document("name", "The Other Sample Movie").append("runtime",  "42"))
                            ));
            // Prints the number of inserted, updated, and deleted documents
            System.out.println("Result statistics:" +
                    "\ninserted: " + result.getInsertedCount() +
                    "\nupdated: " + result.getModifiedCount() +
                    "\ndeleted: " + result.getDeletedCount());
        }
    }
}

Result statistics:
inserted: 3
updated: 2
deleted: 1

Insertar ejemplo

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

MongoNamespace peopleNamespace = new MongoNamespace("db", "people");
MongoNamespace thingsNamespace = new MongoNamespace("db", "things");
List<ClientNamespacedWriteModel> bulkOperations = new ArrayList<>();
bulkOperations.add(ClientNamespacedWriteModel
        .insertOne(
                peopleNamespace,
                new Document("name", "Julia Smith")
        )
);
bulkOperations.add(ClientNamespacedWriteModel
        .insertOne(
                thingsNamespace,
                new Document("object", "washing machine")
        )
);
ClientBulkWriteResult result = mongoClient.bulkWrite(bulkOperations);

Ejemplo de actualización

El siguiente ejemplo muestra cómo utilizar el método bulkWrite() para actualizar documentos existentes en las colecciones db.people y db.things:

MongoNamespace peopleNamespace = new MongoNamespace("db", "people");
MongoNamespace thingsNamespace = new MongoNamespace("db", "things");
List<ClientNamespacedWriteModel> bulkOperations = new ArrayList<>();
bulkOperations.add(ClientNamespacedWriteModel.updateOne(
                peopleNamespace,
                Filters.eq("name", "Freya Polk"),
                Updates.inc("age", 1)
        )
);
bulkOperations.add(ClientNamespacedWriteModel.updateMany(
                thingsNamespace,
                Filters.eq("category", "electronic"),
                Updates.set("manufacturer", "Premium Technologies")
        )
);
ClientBulkWriteResult result = mongoClient.bulkWrite(bulkOperations);

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 things.

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 controlador realice la operación de actualización, como se muestra en el siguiente código:

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

Ejemplo de reemplazo

El siguiente ejemplo muestra cómo utilizar el método bulkWrite() para reemplazar documentos existentes en las colecciones db.people y db.things:

MongoNamespace peopleNamespace = new MongoNamespace("db", "people");
MongoNamespace thingsNamespace = new MongoNamespace("db", "things");
List<ClientNamespacedWriteModel> bulkOperations = new ArrayList<>();
bulkOperations.add(ClientNamespacedWriteModel.replaceOne(
                peopleNamespace,
                Filters.eq("_id", 1),
                new Document("name", "Frederic Hilbert")
        )
);
bulkOperations.add(ClientNamespacedWriteModel.replaceOne(
                thingsNamespace,
                Filters.eq("_id", 1),
                new Document("object", "potato")
        )
);
ClientBulkWriteResult result = mongoClient.bulkWrite(bulkOperations);

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 things 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:

ClientReplaceOneOptions 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.

MongoNamespace namespace = new MongoNamespace("db", "people");
ClientBulkWriteOptions options = ClientBulkWriteOptions
        .clientBulkWriteOptions()
        .ordered(false);
List<ClientNamespacedWriteModel> bulkOperations = new ArrayList<>();
bulkOperations.add(
        ClientNamespacedWriteModel.insertOne(
                namespace,
                new Document("_id", 1).append("name", "Rudra Suraj")
        )
);
// Causes a duplicate key error
bulkOperations.add(
        ClientNamespacedWriteModel.insertOne(
                namespace,
                new Document("_id", 1).append("name", "Mario Bianchi")
        )
);
bulkOperations.add(
        ClientNamespacedWriteModel.insertOne(
                namespace,
                new Document("name", "Wendy Zhang")
        )
);
ClientBulkWriteResult result = mongoClient.bulkWrite(bulkOperations, options);

Excepción de escritura masiva

Si el controlador detecta un error durante una operación de escritura masiva, lanza una MongoBulkWriteException. Un campo MongoBulkWriteException contiene un writeErrors campo que consiste en una lista de uno o más WriteError objetos asociados con la misma operación de escritura masiva.

Considere una colección con una regla de validación de esquema donde el valor del campo quantity debe ser de tipo int. En el siguiente ejemplo, el controlador genera una excepción MongoBulkWriteException al intentar insertar un documento con un valor de campo quantity de "three" y otro con un valor de campo quantity de "ten".

Exception in thread "main" com.mongodb.MongoBulkWriteException: Bulk write
operation result had errors at
com.mongodb.internal.connection.ProtocolHelper.getBulkWriteException(ProtocolHelper.java:258)
... at
BulkWriteMultipleValidationErrorsExample.main(BulkWriteMultipleValidationErrorsExample.java:30)
Caused by: com.mongodb.MongoWriteException: WriteError{code=121,
message='Document failed validation', details={ operator: "$jsonSchema",
schemaRules: { bsonType: "int", description: "must be an integer" },
offendingDocument: {"name":"Apple","quantity":"three"} }} at
com.mongodb.internal.connection.WriteResultHelper.createWriteException(WriteResultHelper.java:50)
at com.mongodb.internal.connection.ProtocolHelper.getBulkWriteException(ProtocolHelper.java:254)
... 19 more
Caused by: com.mongodb.MongoWriteException: WriteError{code=121,
message='Document failed validation', details={ operator: "$jsonSchema",
schemaRules: { bsonType: "int", description: "must be an integer" },
offendingDocument: {"name":"Banana","quantity":"ten"} }} at
com.mongodb.internal.connection.WriteResultHelper.createWriteException(WriteResultHelper.java:50)
at
com.mongodb.internal.connection.ProtocolHelper.getBulkWriteException(ProtocolHelper.java:254)
... 19 more

Para obtener más información sobre la validación del esquema, consulte Validación del esquema en la sección Entradas del manual del servidor.

Documentación de la API

Para aprender más sobre los métodos y clases utilizados para realizar operaciones de escritura masiva en esta sección, consulta la siguiente documentación de API:

Entradas del manual del servidor

• MongoCollection.bulkWrite()

• MongoClient.bulkWrite()

• Validación de esquema