Bulk Update of Documents in MongoDB

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this tutorial, we’ll look at performing bulk updates and insert operations in MongoDB. Additionally, MongoDB provides API calls that allow inserting or retrieving multiple documents in a single operation. MongoDB uses the Array or Batch interfaces which greatly improve database performance by reducing the number of calls between the client and the database.

In this tutorial, we’ll look at both the solutions using MongoDB Shell and Java driver code.

Let’s dive into implementing the bulk updating of documents in MongoDB.

2. Database Initialization

First of all, we need to connect to the mongo shell:

mongo --host localhost --port 27017

Now, set up a database baeldung and a sample collection populations:

use baeldung;
db.createCollection(populations);

Let’s add some sample data into the collection populations using insertMany method:

db.populations.insertMany([
{
    "cityId":1124,
    "cityName":"New York",
    "countryName":"United States",
    "continentName":"North America",
    "population":22
},
{
    "cityId":1125,
    "cityName":"Mexico City",
    "countryName":"Mexico",
    "continentName":"North America",
    "population":25
},
{
    "cityId":1126,
    "cityName":"New Delhi",
    "countryName":"India",
    "continentName":"Asia",
    "population":45
},
{
    "cityId":1134,
    "cityName":"London",
    "countryName":"England",
    "continentName":"Europe",
    "population":32
}]);

The above insertMany query will return the following document:

{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("623575049d55d4e137e477f6"),
        ObjectId("623575049d55d4e137e477f7"),
        ObjectId("623575049d55d4e137e477f8"),
        ObjectId("623575049d55d4e137e477f9")
    ]
}

Here, we inserted four documents in the above query to perform all the types of write bulk operations in MongoDB.

The database baeldung has been created successfully, and all the required data is also inserted into the collection populations, so we’re ready to perform the bulk update.

3. Using MongoDB Shell Query

The bulk operations builder of MongoDB is used to construct a list of write operations in bulk for a single collection. We can initialize bulk operations in 2 different ways. The method initializeOrderedBulkOp is used to perform bulk operations in the ordered list of write operations. One of the drawbacks of the initializeOrderedBulkOp is that if an error occurs while processing any write operations, MongoDB will return without processing the remaining write operations in the list.

We can use insert, update, replace and remove methods to perform different types of operations in a single DB call. As an illustration, let’s look into the bulk write operation query using the MongoDB shell:

db.populations.bulkWrite([
    { 
        insertOne :
            { 
                "document" :
                    {
                        "cityId":1128,
                        "cityName":"Kathmandu",
                        "countryName":"Nepal",
                        "continentName":"Asia",
                        "population":12
                    }
            }
    },
    { 
        insertOne :
            { 
                "document" :
                    {
                        "cityId":1130,
                        "cityName":"Mumbai",
                        "countryName":"India",
                        "continentName":"Asia",
                        "population":55
                    }
            }
    },
    { 
        updateOne :
            { 
                "filter" : 
                     { 
                         "cityName": "New Delhi"
                     },
                 "update" : 
                     { 
                         $set : 
                         { 
                             "status" : "High Population"
                         } 
                     }
            }
    },
    { 
        updateMany :
            { 
                "filter" : 
                     { 
                         "cityName": "London"
                     },
                 "update" : 
                     { 
                         $set : 
                         { 
                             "status" : "Low Population"
                         } 
                     }
            }
    },
    { 
        deleteOne :
            { 
                "filter" : 
                    { 
                        "cityName":"Mexico City"
                    } 
            }
    },
    { 
        replaceOne :
            {
                "filter" : 
                    { 
                        "cityName":"New York"
                    },
                 "replacement" : 
                    {
                        "cityId":1124,
                        "cityName":"New York",
                        "countryName":"United States",
                        "continentName":"North America",
                        "population":28
                    }
             }
    }
]);

The above bulkWrite query will return the following document:

{
    "acknowledged" : true,
    "deletedCount" : 1,
    "insertedCount" : 2,
    "matchedCount" : 3,
    "upsertedCount" : 0,
    "insertedIds" : 
        {
            "0" : ObjectId("623575f89d55d4e137e477f9"),
            "1" : ObjectId("623575f89d55d4e137e477fa")
        },
    "upsertedIds" : {}
}

Here, in the above query, we performed all the types of write operations, i.e., insertOne, updateOne, deleteOne, replaceOne.

First, we used insertOne method to insert a new document into the collection. Secondly, we used updateOne to update the document of cityName “New Delhi”. Later, we used the deleteOne method to delete a document from the collection based on the filter. Finally, we used replaceOne to replace a complete document with filter cityName “New York”.

4. Using Java Driver

We have discussed the MongoDB shell query to perform the bulk write operations. Before creating the bulk write operation, let’s first create a MongoClient connection with the collection populations of the database baeldung:

MongoClient mongoClient = new MongoClient("localhost", 27017);
MongoDatabase database = mongoClient.getDatabase("baeldung");
MongoCollection<Document> collection = database.getCollection("populations");

Here, we created the connection with the MongoDB server, running on default port 27017. Let’s now implement the same bulk operations using the Java code:

List<WriteModel<Document>> writeOperations = new ArrayList<WriteModel<Document>>();
writeOperations.add(new InsertOneModel<Document>(new Document("cityId", 1128)
  .append("cityName", "Kathmandu")
  .append("countryName", "Nepal")
  .append("continentName", "Asia")
  .append("population", 12)));
writeOperations.add(new InsertOneModel<Document>(new Document("cityId", 1130)
  .append("cityName", "Mumbai")
  .append("countryName", "India")
  .append("continentName", "Asia")
  .append("population", 55)));
writeOperations.add(new UpdateOneModel<Document>(new Document("cityName", "New Delhi"),
  new Document("$set", new Document("status", "High Population"))
));
writeOperations.add(new UpdateManyModel<Document>(new Document("cityName", "London"),
  new Document("$set", new Document("status", "Low Population"))
));
writeOperations.add(new DeleteOneModel<Document>(new Document("cityName", "Mexico City")));
writeOperations.add(new ReplaceOneModel<Document>(new Document("cityId", 1124), 
  new Document("cityName", "New York").append("cityName", "United States")
    .append("continentName", "North America")
    .append("population", 28)));
BulkWriteResult bulkWriteResult = collection.bulkWrite(writeOperations);
System.out.println("bulkWriteResult:- " + bulkWriteResult);

Here, we first created a list of writeModel to add all the different types of write operations into a single update list. Furthermore, we used InsertOneModel, UpdateOneModel, UpdateManyModel, DeleteOneModel, and ReplaceOneModel in our query. Finally, the bulkWrite method executed all the operations at once.

5. Conclusion

In this article, we have learned to perform bulk operations in MongoDB using different kinds of write operations. We performed the insertion, updating, deletion, and replacement of documents all in a single DB query. In addition, we learned the use cases of initializeOrderedBulkOp into the bulk update in MongoDB.

At first, we looked into the use cases of the bulk operations in MongoDB shell query, and then we discussed the corresponding Java driver code.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.