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 Tutorial de introducción.

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 consulta que especifica los criterios utilizados para buscar coincidencias en los documentos de 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, cree una instancia de UpdateManyModel y pase los mismos argumentos. UpdateManyModel actualiza todos los documentos que coinciden con su filtro de consulta.

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 consulta especificado en la instancia ReplaceOneModel, la operación reemplaza el primer resultado. Puede especificar una ordenación 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 eliminar un documento, cree una instancia de DeleteOneModel y pase un filtro de consulta que especifique el documento que desea eliminar. DeleteOneModel elimina solo el primer documento que coincide con su filtro de consulta.

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 WriteModel para cada operación que desee realizar, pase una lista de estas instancias al método bulkWrite(). De forma predeterminada, el método ejecuta las operaciones en el orden en que están definidas en la lista.

El siguiente ejemplo realiza múltiples operaciones de escritura utilizando 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 falla alguna de las operaciones de escritura, el controlador Java Reactive Streams señala MongoBulkWriteException y no realiza ninguna otra operación individual. MongoBulkWriteException incluye un BulkWriteError al que se puede acceder mediante el método MongoBulkWriteException.getWriteErrors(), que proporciona detalles de 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 luego invoque uno o más de sus métodos para modificar la operación de escritura. Puede encadenar estas llamadas a métodos. Para modificar el comportamiento de la operación de escritura, pase la instancia de la clase como último argumento del 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 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 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 consulta especificado en una ClientNamespacedReplaceOneModel instancia, la operación reemplaza el primer resultado. Puede especificar un orden de clasificación en una instancia ClientReplaceOneOptions para aplicarlo a los documentos coincidentes antes de que el servidor realice la operación de reemplazo, 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 ClientNamespacedWriteModel para cada operación que desee realizar, pase una lista de estas instancias al método bulkWrite() del cliente. De forma predeterminada, el método ejecuta las operaciones en el orden especificado.

El siguiente ejemplo realiza múltiples operaciones de escritura utilizando 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 alguna de las operaciones de escritura falla, el controlador genera un ClientBulkWriteException y no realiza ninguna otra operación individual. ClientBulkWriteException incluye un BulkWriteError al que se puede acceder mediante 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 realiza 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:

• Colección Escritura masiva

  • bulkWrite()

  • InsertOneModel

  • UpdateOneModel

  • ActualizarMuchosModelos

  • ReemplazarUnModelo

  • Eliminar un modelo

  • EliminarMuchosModelos

  • BulkWriteResult

  • Error de escritura masiva

  • Excepción de escritura masiva de Mongo

• Escritura masiva del cliente

  • bulkWrite()

  • Modelo de escritura con espacio de nombres de cliente

  • Espacio de nombres Mongo

  • ClientBulkWriteOptions

  • Resultado de escritura masiva del cliente