Operaciones de escritura masiva

Datos de muestra

Los ejemplos de esta guía utilizan la colección de los sample_restaurants.restaurants 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, consulte Comenzar tutorial.

Operaciones de inserción

Para realizar una operación de inserción, cree una instancia de InsertOneModel y pase el documento que desea 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, cree una instancia de UpdateOneModel y pase los siguientes argumentos:

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

• Operación de actualización que desea realizar. Para más información sobre las operaciones de actualización, consulte la guía "Operadores de actualización de campos" en el manual de MongoDB Server.

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 elimina todos los campos y valores de un documento específico, excepto el campo _id, y los reemplaza por otros nuevos. Para realizar una operación de reemplazo, cree una instancia de ReplaceOneModel y pase un filtro de consulta, así como los campos y valores que desea 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 eliminar varios documentos, cree una instancia de DeleteManyModel y pase un filtro de consulta que especifique los documentos que desea eliminar. DeleteManyModel elimina todos los documentos que coinciden con su filtro de consulta.

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 escritura masiva

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().

Puede usar los siguientes métodos en la clase BulkWriteOptions para modificar un método de escritura. 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 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:

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

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 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 escritura masiva

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

  • ActualizarMuchosModelos

  • ReemplazarUnModelo

  • Eliminar un modelo

  • DeleteManyModel

  • BulkWriteResult

  • Error de escritura masiva

  • MongoBulkWriteException

• Guardado Masivo del Cliente

  • bulkWrite()

  • Modelo de escritura con espacio de nombres de cliente

  • MongoNamespace

  • ClientBulkWriteOptions

  • ClientBulkWriteResult