NoSQL Top

Build a Dashboard Using Cassandra, Astra, and Stargate:

>> CHECK OUT THE ARTICLE
Persistence top

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

>> CHECK OUT THE COURSE

1. Overview

MongoDB is a cross-platform, document-oriented, open-source NoSQL database, written in C++. Additionally, MongoDB provides high performance, high availability, and automatic scaling.

In order to update the documents in MongoDB, we can use different methods like updateOne, findOneAndUpdate, etc. Furthermore, MongoDB provides various operators for the update methods.

In this tutorial, we'll discuss different approaches to perform update operations in MongoDB. For each approach, we'll first discuss the mongo shell query and then its implementation in Java.

2. Database Setup

Before we move on to the update queries, let's first create a database, baeldung, and a sample collection, student:

use baeldung;
db.createCollection(student);

As an illustration, let’s add a few documents into the collection student using the insertMany query:

db.student.insertMany([
    {
        "student_id": 8764,
        "student_name": "Paul Starc",
        "address": "Hostel 1",
        "age": 16,
        "roll_no":199406
    },
    {
        "student_id": 8765,
        "student_name": "Andrew Boult",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199408
    }
]);

On successful insertion, we’ll get a JSON with acknowledged:true:

{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("621b078485e943405d04b557"),
	ObjectId("621b078485e943405d04b558")
    ]
}

Let's now dive deep into different ways to update the documents in MongoDB.

3. Using the updateOne Method

An update operation in MongoDB can be done by adding a new field, removing a field, or updating an existing field. The updateOne method updates a single document in a collection based on the applied query filter. It first finds the document that matches the filter and then updates the specified fields.

In addition, we can use different operators such as $set, $unset, $inc, etc., with the update method.

To demonstrate, let's look into the query to update a single document of a collection:

db.student.updateOne(
    { 
        "student_name" : "Paul Starc"
    },
    { 
        $set: {
            "address" : "Hostel 2"
        }
    }
 );

We'll get an output similar to the one shown below:

{
    "acknowledged":true,
    "matchedCount":1,
    "modifiedCount":1
}

Let's now check out the Java driver code of the above updateOne query:

UpdateResult updateResult = collection.updateOne(Filters.eq("student_name", "Paul Starc"),
Updates.set("address", "Hostel 2"));

Here, firstly we have used the student_name field to filter the documents. Then we update the address of the document with student_name “Paul Starc”.

4. Using the updateMany Method

The updateMany method updates all the documents in MongoDB collections that match the given filter. One of the benefits of using the updateMany is that we can update multiple documents without losing the fields of old documents.

Let's see the MongoDB shell query using updateMany method:

db.student.updateMany(
    { 
        age: { 
            $lt: 20
         } 
    },
    { 
        $set:{ 
            "Review" : true 
        }
    }
);

The above command will return the following output:

{
    "acknowledged":true,
    "matchedCount":2,
    "modifiedCount":2
}

Here, matchedCount contains the number of matched documents, whereas modifiedCount contains the modified documents number.

Let's now look into the Java driver code using the updateMany method:

UpdateResult updateResult = collection.updateMany(Filters.lt("age", 20), Updates.set("Review", true));

Here, all the documents with age less than 20 will be filtered, and the Review field will be set to true.

5. Using the replaceOne Method

The replaceOne method of MongoDB replaces the entire document. One of the drawbacks of the replaceOne is that all the older fields will be replaced by the new fields, and the older fields will also be lost:

db.student.replaceOne(
    { 
        "student_id": 8764
    },
    {
        "student_id": 8764,
        "student_name": "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406
    }
);

In this case, we'll get the following output:

{
    "acknowledged":true,
    "matchedCount":1,
    "modifiedCount":1
}

If no matches are found, the operation returns the matchedCount as 0:

{
    "acknowledged":true,
    "matchedCount":0,
    "modifiedCount":0
}

Let's write the corresponding Java driver code using the replaceOne method:

Document replaceDocument = new Document();
replaceDocument
  .append("student_id", 8764)
  .append("student_name", "Paul Starc")
  .append("address", "Hostel 2")
  .append("age",18)
  .append("roll_no", 199406);
UpdateResult updateResult = collection.replaceOne(Filters.eq("student_id", 8764), replaceDocument);

In the above code, we've created a document by which the older document will be replaced. The document with student_id 8764 will be replaced with the newly created document.

6. Using the findOneAndReplace Method

The findOneAndReplace method is one of the advanced update methods provided by MongoDB, and it replaces the first matched document based on the given selection criteria. By default, this method returns the original document. We can use different options of the findOneAndReplace to sort and project documents if required.

In short, findOneAndReplace replaces the first matching document of the collection on the basis of the applied filter:

db.student.findOneAndReplace(
    { 
        "student_id" : { 
            $eq : 8764 
        }
    },
    { 
        "student_id" : 8764,
        "student_name" : "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406 
    },
    {
        returnNewDocument: false
    }
);

This query will return the following document:

{
    "student_id":8764,
    "student_name":"Paul Starc",
    "address":"Hostel 1",
    "age":16,
    "roll_no":199406
}

If we set returnNewDocument to true, the operation would then return the replaced document instead:

{
    "student_id":8764,
    "student_name":"Paul Starc",
    "address":"Hostel 2",
    "age":18,
    "roll_no":199406
}

Let's now use the findOneAndReplace method to project the student_id and age fields in the returned document:

db.student.findOneAndReplace(
    { 
        "student_id" : {
        $eq : 8764 
        } 
    },
    { 
        "student_id" : 8764, 
        "student_name" : "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406 
    },
    { 
        projection: { 
            "_id" : 0,
            "student_id":1,
            "age" : 1 
        } 
    }
);

The output of the above query will only contain the projected fields:

{
    "student_id":"8764",
    "age":16
}

The Java driver code of the above query with various options of the findOneAndReplace:

Document replaceDocument = new Document();
replaceDocument
  .append("student_id", 8764)
  .append("student_name", "Paul Starc")
  .append("address", "Hostel 2")
  .append("age", 18)
  .append("roll_no", 199406);
Document sort = new Document("roll_no", 1);
Document projection = new Document("_id", 0).append("student_id", 1).append("address", 1);
Document resultDocument = collection.findOneAndReplace(
  Filters.eq("student_id", 8764), 
  replaceDocument,
  new FindOneAndReplaceOptions().upsert(true).sort(sort).projection(projection).returnDocument(ReturnDocument.AFTER));

In the above query, the findOneAndReplace method will first sort the documents in ascending order based on roll_no, and the newly created document replaces the document with student_id “8764”.

7. Using the findOneAndUpdate Method

The findOneAndUpdate method updates the first matched document in the collection. If more than one document matches the selection criteria, then it updates only the first matched document. When we update the document, the value of the _id field remains unchanged:

db.student.findOneAndUpdate(
    { 
        "student_id" : 8764
    },
    { 
        $inc : { 
            "roll_no" : 5
        } 
    },
    { 
        sort: { 
            "roll_no" : 1 
        }, 
        projection: { 
            "_id" : 0,
            "student_id":1,
            "address" : 1
        }
    }
);

The output of the query will only contain the studentId and address of the older document:

{
    "student_id":8764,
    "address":"Hostel 1"
}

The Java driver code of the above query, using different options of the findOneAndUpdate is as follows:

Document sort = new Document("roll_no", 1);
Document projection = new Document("_id", 0).append("student_id", 1).append("address", 1);
Document resultDocument = collection.findOneAndUpdate(
  Filters.eq("student_id", 8764),
  Updates.inc("roll_no", 5), 
  new FindOneAndUpdateOptions().sort(sort).projection(projection).returnDocument(ReturnDocument.BEFORE));

In this case, the findOneAndUpdate method will first sort the document in ascending order based on roll_no. The above query increments the roll_no by 5 and then returns the student_id and address fields.

8. Conclusion

In this article, we've seen various ways to update the documents in MongoDB. First, we looked into the MongoDB shell query, and then we discussed the corresponding Java driver code.

The implementation of all these examples and code snippets 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!