Operações em massa

Inserir operação

Para executar uma operação de inserção, crie um InsertOneModel especificando o documento que você deseja inserir. Para inserir vários documentos, você deve criar um InsertOneModel para cada documento que deseja inserir.

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={}}].

Operação de substituição

Para executar uma operação de substituição, crie um ReplaceOneModel especificando um filtro de query para o documento que você deseja substituir pelo documento de substituição.

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

Operação de atualização

Para executar uma operação de atualização, crie um UpdateOneModel ou um UpdateManyModel especificando um filtro de query para documentos que você deseja atualizar com quais são as atualizações.

O UpdateOneModel atualiza o primeiro documento que corresponde ao seu filtro de query, e o UpdateManyModel atualiza todos os documentos que correspondem ao seu filtro de query.

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

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

Excluir operação

Para executar uma operação de exclusão, crie um DeleteOneModel ou um DeleteManyModel especificando um filtro de query para documentos que você deseja excluir.

O DeleteOneModel exclui o primeiro documento que corresponde ao filtro de query e o DeleteManyModel exclui todos os documentos que correspondem ao filtro de query.

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

Ordem de execução

O método bulkWrite() aceita um BulkWriteOptions opcional como segundo parâmetro para especificar se a execução das operações em massa é ordenada ou não.

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 }

Inserir exemplo

Este exemplo mostra como usar o método bulkWrite() para inserir dois documentos. Um documento é inserido na collection db.people, enquanto o outro documento é inserido na collection db.things. A instância MongoNamespace define os bancos de dados e as collections aos quais cada operação de gravação se aplica.

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

Exemplo de substituição

O exemplo a seguir mostra como usar o método bulkWrite() para substituir documentos existentes nas coleções db.people e 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);

Depois que esse exemplo for executado com êxito, o documento que tem um valor _id de 1 na coleção people é substituído por um novo documento. O documento na coleção things que tem um valor _id de 1 é substituído por um novo documento.

Opções de gravação em massa

Você pode passar uma instância de ClientBulkWriteOptions para o método bulkWrite() para especificar opções ao executar operações de gravação em massa.

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

MongoCollection.bulkWrite()

Para executar uma operação em massa, você cria e passa uma lista de instâncias do WriteModel para o método bulkWrite().

Existem 6 subtipos diferentes de WriteModel: InsertOneModel, ReplaceOneModel, UpdateOneModel, UpdateManyModel, DeleteOneModel e DeleteManyModel.

Há duas maneiras de executar o método bulkWrite():

• Solicitado, que executa as operações em massa para que ocorra um erro, se houver

• Não ordenado, que executa todas as operações em massa em qualquer ordem e relata erros no final, se houver

Para saber mais sobre o bulkWrite comando da coleção, consulte a referência do método db.collection.bulkWrite() no Manual do MongoDB Server .

MongoClient.bulkWrite()

Ao conectar a uma implementação executando o MongoDB Server versão 8.0 ou posterior, você pode usar o método MongoClient.bulkWrite() para executar operações em massa em vários bancos de dados e collections de uma só vez.

Para executar uma operação em massa do cliente , você cria uma lista de ClientNamespacedWriteModel instâncias para este método.

Há seis subtipos de ClientNamespacedWriteModel usados para representar operações de escrita. Para construir esses modelos de gravação, você pode usar os métodos ClientNamespacedWriteModel correspondentes insertOne(), updateOne(), updateMany(), replaceOne(), deleteOne() e deleteMany(). Esses métodos usam um objeto MongoNamespace que define em qual banco de dados e coleção escrever.

O método MongoClient.bulkWrite() também pode usar um objeto ClientBulkWriteOptions para especificar diferentes opções de como o comando é executado.

Para saber mais sobre o comando do cliente,bulkWrite consulte a referência do método bulkWrite() no Manual do MongoDB Server .