Persistence top

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

>> CHECK OUT THE COURSE

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 example of all the cases can be found over on GitHub.

NoSql Bottom

Build a Dashboard Using Cassandra, Astra, and Stargate

>> CHECK OUT THE ARTICLE
Persistence bottom
Get started with Spring Data JPA through the reference Learn Spring Data JPA course: >> CHECK OUT THE COURSE
Persistence footer banner
Comments are closed on this article!