Operaciones de escritura masiva

Datos de muestra

Los ejemplos en esta guía utilizan la colección sample_restaurants.restaurants de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta el Comenzar tutorial.

Operaciones de inserción

Para realizar una operación de inserción, crea una instancia de InsertOneModel y pasa el documento que deseas insertar.

El siguiente ejemplo crea una instancia de InsertOneModel:

InsertOneModel<Document> operation = new InsertOneModel<>(
        new Document("name", "Mongo's Deli")
                .append("cuisine", "Sandwiches"));

Para insertar varios documentos, cree una instancia de InsertOneModel para cada documento.

Operaciones de actualizar

Para actualizar un documento, crea una instancia de UpdateOneModel y pasa los siguientes argumentos:

• Filtro de query que especifica los criterios utilizados para emparejar documentos en su colección.

• Operación de actualización que deseas realizar. Para obtener más información sobre las operaciones de actualización, consulta la guía Operadores de actualización de campo en el Manual del Servidor MongoDB.

El siguiente ejemplo crea una instancia de UpdateOneModel:

UpdateOneModel<Document> operation = new UpdateOneModel<>(
        eq("name", "Mongo's Deli"),
        set("cuisine", "Sandwiches and Salads"));

Si varios documentos coinciden con el filtro de query especificado en la instancia UpdateOneModel, la operación actualiza el primer resultado. Puedes especificar un ordenamiento en una instancia UpdateOptions 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:

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

Para actualizar varios documentos, crea una instancia de UpdateManyModel y pasa los mismos argumentos. UpdateManyModel actualiza todos los documentos que coincidan con su filtro de query.

El siguiente ejemplo crea una instancia de UpdateManyModel:

UpdateManyModel<Document> operation = new UpdateManyModel<>(
        eq("name", "Mongo's Deli"),
        set("cuisine", "Sandwiches and Salads"));

Reemplazar operaciones

Una operación de reemplazo remueve todos los campos y valores de un documento especificado, excepto el campo _id, y los reemplaza con otros nuevos. Para realizar una operación de reemplazo, crea una instancia de ReplaceOneModel y pasa un filtro de query, así como los campos y valores que quieras almacenar en el documento correspondiente.

El siguiente ejemplo crea una instancia de ReplaceOneModel:

ReplaceOneModel<Document> operation = new ReplaceOneModel<>(
        eq("name", "Original Pizza"),
        new Document("name", "Mongo's Pizza")
                .append("borough", "Manhattan"));

Si varios documentos coinciden con el filtro de query especificado en la instancia ReplaceOneModel, la operación reemplaza el primer resultado. Puedes especificar una medida en una instancia ReplaceOptions para aplicar un orden a los documentos coincidentes antes de que el servidor realice la operación de reemplazo, como se muestra en el siguiente código:

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

Operaciones de borrar

Para borrar un documento, crea una instancia de DeleteOneModel y pasa un filtro de query especificando el documento que deseas borrar. DeleteOneModel elimina solo el primer documento que coincide con el filtro de query.

El siguiente ejemplo crea una instancia de DeleteOneModel:

DeleteOneModel<Document> operation = new DeleteOneModel<>(
        eq("restaurant_id", "5678"));

Para borrar varios documentos, crea una instancia de DeleteManyModel y pasa un filtro de query que especifique los documentos que deseas borrar. DeleteManyModel remueve todos los documentos que coinciden con tu filtro de query.

El siguiente ejemplo crea una instancia de DeleteManyModel:

DeleteManyModel<Document> operation = new DeleteManyModel<>(
        eq("name", "Mongo's Deli"));

Realizar la Operación Masiva

Después de definir una instancia de WriteModel para cada operación que desee realizar, pase una lista de estas instancias al método bulkWrite(). Por defecto, el método ejecuta las operaciones en el orden en que se definen en la lista.

El siguiente ejemplo realiza múltiples operaciones de escritura usando el método bulkWrite():

Publisher<BulkWriteResult> bulkWritePublisher = restaurants.bulkWrite(
        Arrays.asList(new InsertOneModel<>(
                        new Document("name", "Mongo's Deli")
                                .append("cuisine", "Sandwiches")
                                .append("borough", "Manhattan")
                                .append("restaurant_id", "1234")),
                new InsertOneModel<>(new Document("name", "Mongo's Deli")
                                .append("cuisine", "Sandwiches")
                                .append("borough", "Brooklyn")
                                .append("restaurant_id", "5678")),
                new UpdateManyModel<>(eq("name", "Mongo's Deli"),
                        set("cuisine", "Sandwiches and Salads")),
                new DeleteOneModel<>(eq("restaurant_id", "1234"))));
BulkWriteResult bulkResult = Mono.from(bulkWritePublisher).block();
System.out.println(bulkResult.toString());

AcknowledgedBulkWriteResult{insertedCount=2, matchedCount=2, removedCount=1, modifiedCount=2, upserts=[], inserts=[BulkWriteInsert{index=0, id=BsonObjectId{value=66a7e0a6c08025218b657208}}, BulkWriteInsert{index=1, id=BsonObjectId{value=66a7e0a6c08025218b657209}}]}

Si alguna de las operaciones de escritura falla, el controlador Java Reactive Streams señala un MongoBulkWriteException y no realiza ninguna otra operación individual. MongoBulkWriteException incluye un BulkWriteError al que se puede acceder utilizando el método MongoBulkWriteException.getWriteErrors(), el cual proporciona detalles sobre la falla individual.

Personalizar guardado masivo

La clase BulkWriteOptions contiene métodos que modifican el comportamiento del método bulkWrite(). Para usar la clase BulkWriteOptions, construya una nueva instancia de la clase y, a continuación, llame a uno o más de sus métodos para modificar la operación de guardar. Puede encadenar estas llamadas de método juntas. Para modificar el comportamiento de la operación de guardar, pasa la instancia de la clase como el último argumento al método bulkWrite().

Puedes utilizar los siguientes métodos en la clase BulkWriteOptions para modificar un método de guardar. Todos los métodos son opcionales.

El siguiente ejemplo llama al método bulkWrite() del ejemplo anterior, pero establece la opción ordered en False:

Publisher<BulkWriteResult> bulkWritePublisher = restaurants.bulkWrite(
        Arrays.asList(new InsertOneModel<>(
                        new Document("name", "Mongo's Deli")
                                .append("cuisine", "Sandwiches")
                                .append("borough", "Manhattan")
                                .append("restaurant_id", "1234")),
                new InsertOneModel<>(new Document("name", "Mongo's Deli")
                                .append("cuisine", "Sandwiches")
                                .append("borough", "Brooklyn")
                                .append("restaurant_id", "5678")),
                new UpdateManyModel<>(eq("name", "Mongo's Deli"),
                        set("cuisine", "Sandwiches and Salads")),
                new DeleteOneModel<>(eq("restaurant_id", "1234"))), 
                new BulkWriteOptions().ordered(false));
BulkWriteResult bulkResult = Mono.from(bulkWritePublisher).block();
System.out.println(bulkResult.toString());

AcknowledgedBulkWriteResult{insertedCount=2, matchedCount=2, removedCount=1, modifiedCount=2, upserts=[], inserts=[BulkWriteInsert{index=0, id=BsonObjectId{value=66a7e03cce430c5854b6caf9}}, BulkWriteInsert{index=1, id=BsonObjectId{value=66a7e03cce430c5854b6cafa}}]}

Si alguna de las operaciones de escritura en una escritura masiva desordenada falla, el driver de Java Reactive Streams informa los errores solo después de intentar todas las operaciones.

Operaciones de inserción

Este ejemplo muestra cómo crear modelos que contienen instrucciones para insertar dos documentos. Un documento se inserta en la colección db.people y el otro documento se inserta en la colección db.things. La instancia MongoNamespace define la base de datos y la colección de destino a las que se aplica cada operación de guardar.

ClientNamespacedInsertOneModel personToInsert = ClientNamespacedWriteModel
        .insertOne(
                new MongoNamespace("db", "people"),
                new Document("name", "Julia Smith")
);
ClientNamespacedInsertOneModel thingToInsert = ClientNamespacedWriteModel
        .insertOne(
                new MongoNamespace("db", "things"),
                new Document("object", "washing machine")
);

Operaciones de actualizar

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

ClientNamespacedUpdateOneModel personUpdate = ClientNamespacedWriteModel
        .updateOne(
                new MongoNamespace("db", "people"),
                Filters.eq("name", "Freya Polk"),
                Updates.inc("age", 1)
        );
ClientNamespacedUpdateManyModel thingUpdate = ClientNamespacedWriteModel
        .updateMany(
                new MongoNamespace("db", "things"),
                Filters.eq("category", "electronic"),
                Updates.set("manufacturer", "Premium Technologies")
        );

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

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:

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

Reemplazar operaciones

El siguiente ejemplo muestra cómo crear modelos para reemplazar documentos existentes en las colecciones db.people y db.things:

ClientNamespacedReplaceOneModel personReplacement = ClientNamespacedWriteModel
        .replaceOne(
                new MongoNamespace("db", "people"),
                Filters.eq("_id", 1),
                new Document("name", "Frederic Hilbert")
        );
ClientNamespacedReplaceOneModel thingReplacement = ClientNamespacedWriteModel
        .replaceOne(
                new MongoNamespace("db", "things"),
                Filters.eq("_id", 1),
                new Document("object", "potato")
        );

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 things 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. Puedes especificar un orden de clasificación en una instancia de ClientReplaceOneOptions para aplicar un orden a los documentos coincidentes antes de que el servidor realice la operación de reemplazo, tal como se muestra en el siguiente código:

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

Realizar la Operación Masiva

Después de definir una instancia de ClientNamespacedWriteModel para cada operación que desee realizar, pase una lista de estas instancias al método del cliente bulkWrite(). Por defecto, el método ejecuta las operaciones en el orden en que se especifican.

El siguiente ejemplo realiza múltiples operaciones de escritura usando el método bulkWrite():

MongoNamespace peopleNamespace = new MongoNamespace("db", "people");
MongoNamespace thingsNamespace = new MongoNamespace("db", "things");
List<ClientNamespacedWriteModel> bulkOperations = Arrays.asList(
        ClientNamespacedWriteModel
                .insertOne(
                        peopleNamespace,
                        new Document("name", "Corey Kopper")
                ),
        ClientNamespacedWriteModel
                .replaceOne(
                        thingsNamespace,
                        Filters.eq("_id", 1),
                        new Document("object", "potato")
                )
);
Publisher<ClientBulkWriteResult> bulkWritePublisher = mongoClient
        .bulkWrite(bulkOperations);
ClientBulkWriteResult clientBulkResult = Mono
        .from(bulkWritePublisher)
        .block();
System.out.println(clientBulkResult.toString());

AcknowledgedSummaryClientBulkWriteResult{insertedCount=1, matchedCount=1, ...}

Si cualquiera de las operaciones de escritura falla, el driver genera un ClientBulkWriteException y no realiza ninguna otra operación individual. ClientBulkWriteException incluye un BulkWriteError al cual se puede acceder utilizando el método ClientBulkWriteException.getWriteErrors(), que proporciona detalles de la falla individual.

Personalizar guardado masivo

Puede pasar una instancia de ClientBulkWriteOptions al método bulkWrite() para personalizar cómo el controlador ejecuta la operación de escritura masiva.

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

Documentación de la API

Para aprender más sobre cualquiera de los métodos o tipos analizados en esta guía, consulta la siguiente documentación de API:

• Guardar masivo de colecciones

  • bulkWrite()

  • InsertOneModel

  • UpdateOneModel

  • UpdateManyModel

  • ReplaceOneModel

  • DeleteOneModel

  • DeleteManyModel

  • BulkWriteResult

  • BulkWriteError

  • MongoBulkWriteException

• Guardado Masivo del Cliente

  • bulkWrite()

  • ClientNamespacedWriteModel

  • MongoNamespace

  • ClientBulkWriteOptions

  • ClientBulkWriteResult