For enquiries call:
+1-469-442-0620
HomeBlogWeb DevelopmentHow To Perform MongoDB Atomic Operations
Explore how to create atomic operations in MongoDB. In a database, an atomic operation is an undivided and complex series of database operations in which either all or none of the operations occur. The term atomicity refers to the guarantee that no partial database updates will occur, i.e., either the entire set of updates will occur, or nothing will occur, and any partial changes (if any) will be rolled back.
In database terminology, atomic operations are a series of chained and sophisticated database operations. In this series, either all or none of the series' aspects will be altered. There is no such thing as a partial database change in atomic operations.
The partial update will cause more harm than outright rejecting the entire series. As a result, operational operations are critical in all databases, including MongoDB.
There is only room for complete database updates and changes in atomic operations. If any partial updates are made, the entire database will be rolled back.
In cases where a partial update would cause more harm than rolling back, we use atomic operations. In the real world, we may need to maintain our database in this manner in some cases. We will go over it in greater detail in the latter part of this article.
We can clearly explain atomic operations in MongoDB by using the acronym ACID, which stands for Atomicity, Consistency, Isolation, and Durability.
As previously discussed, the only way to maintain atomicity in MongoDB is to keep all related information in a single document that is updated on a regular basis. A single document of this type can be created using embedded documents, as shown below. Embedded documents ensure that all updates to a single document are atomic.
An example of an item purchase document is shown below:
First, create a database with name "atomic_mongo" using the command:
use atomic_mongo
Now, create a collection under it with the command:
db.createCollection(“atomic”)
Now, add the data in the collection using following command:
db.atomic.save ({ ... "_id":101, ... "item_name": "Realme GT Neo2", ... "category": "handset", ... "warranty_period": 2, ... "city": "Jaipur", ... "country": "India", ... "item_total": 10, ... "item_available": 5, ... "item_bought_by": [ ... { ... "customer": "Mohit", ... "date": "20-Nov-2021" ... }, ... { ... "customer": "Akash", ... "date": "19-Nov-2021" ... }, ... { ... "customer": "Ankit", ... "date": "18-Nov-2021" ... }, ... { ... "customer": "Ishan", ... "date": "17-Nov-2021" ... } ... ] ... }); WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : 101 })
Now, you can write the following query to print the document of the database:
> db.atomic.find().pretty();
Output:
The document above is an embedded document in which we have embedded customer information based on the item purchased in the item bought by field. This single document will assist in determining whether an item is in stock or not when a customer places a new order using the item available field. If an item is available, we will deduct one from the item available field and add a new customer name and date of purchase details of item_bought_by field of the document.
Now, for this functionality we will use the findAndModify command. This command allows you to search and update the document at the same time:
> db.atomic.findAndModify({ ... ... query:{_id:101,item_available:{$gt:0}}, ... ... update:{ ... ... $inc:{item_available:-1}, ... ... $push:{item_bought_by:{customer:"Madan",date:"18-Nov-2021"}} ... ... } ... ... }); { "_id" : 101, "item_name" : "Realme GT Neo2", "category" : "handset", "warranty_period" : 2, "city" : "Jaipur", "country" : "India", "item_total" : 10, "item_available" : 5, "item_bought_by" : [ { "customer" : "Mohit", "date" : "20-Nov-2021" }, { "customer" : "Akash", "date" : "19-Nov-2021" }, { "customer" : "Ankit", "date" : "18-Nov-2021" }, { "customer" : "Ishan", "date" : "17-Nov-2021" } ] }
To check the modified document in the database, use the following query:
> db.atomic.find().pretty();
In this case, we first searched for an item with the ID 101; when such an item is found, we increment the item available field by -1 and update the item bought by field by adding the customer's name and the date of purchase.
Then, using the find and pretty method, we print the overall purchase detail. The item available field has been reduced from 5 to 4 and new customer details have been added to the item bought by field.
Our approach of embedding the document and utilising the findAndModify query ensures that the product purchase information is only updated if the product is available. And because the entire transaction is contained within the same query, it is atomic.
Consider the alternative scenario in which we kept the product availability and the information on who purchased the product separate. In this case, we'll use the first query to see if the product is available. The purchase information will then be updated in the second query. However, it is possible that in the time between these two queries, another user purchased the product, and it is no longer available. Without realising it, our second query will update the purchase information based on the results of the first query. This will cause inconsistency in the database because we sold a product that is no longer available.
There are two types of atomic updates we can use:
A write operation on a single document in MongoDB is atomic. When fields must be updated at the same time, embedding them within the same document ensures that the fields can be updated atomically.
Let’s update the above example we have taken earlier:
{ "_id" : "101", "item_name" : "Realme GT Neo2", "category" : "handset", "warranty_period" : 2, "city" : "Jaipur", "country" : "India", "item_total" : 10, "item_available" : 5, "item_bought_by" : [ { "customer" : "Mohit", "date" : "20-Nov-2021" }, { "customer" : "Akash", "date" : "19-Nov-2021" }, { "customer" : "Ankit", "date" : "18-Nov-2021" }, { "customer" : "Ishan", "date" : "17-Nov-2021" }, { "customer" : "Madan", "date" : "18-Nov-2021" } ] }
Write the following code to implement the updateOne() method in the above example:
db.atomic.updateOne({_id : 101}, {$push: {item_bought_by:{ $each: [{"customer" : "Vikas", "date" : "17-Nov-2021"},{"customer" : “Bhavesh”, "date" : "16-Nov-2021"}]} }});
Output:
The above code will return:
You can check the updated documents with the pretty and find method:
db.atomic.find().pretty()
With the help of updateMany(), we can update more than two documents in the database collection. When a single write operation (e.g. db.collection.updateMany()) modifies multiple documents, the modification of each document is atomic, but the operation as a whole is not atomic.
Syntax:
db.collection.updateMany(
<filter>,
<update>,
{
upsert: <boolean>,
writeConcern: <document>,
collation: <document>,
arrayFilters: [ <filterdocument1>, ... ],
hint: <document|string> // Available starting in MongoDB 4.2.1
}
)
First, create another document in the collection “atomic” with the same fields we used earlier.
Follow the below code to create new document:
db.atomic.save ({ ... "_id":102, ... "item_name": "CrossBeats Ace", ... "category": "Smart Watch", ... "warranty_period": 2, ... "city": "Jaipur", ... "country": "India", ... "item_total": 10, ... "item_available": 10, ... "item_bought_by": [ ... ] ... }); WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : 101 })
Write the following code to implement the updateMany() method:
db.atomic.updateMany({city : "Jaipur"}, {$inc: { item_available: -2}, $push: {item_bought_by:{ $each: [{"customer" : "Aachal","date": "17-Nov-2021"},{"customer" : "Khushi","date":"16-Nov-2021"}]} }});
Output:
The above code will return:
{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }
Use the find and pretty method to check the documents available now in the collection.
In the above example, we have used the data of customers who have purchased both handset and Smart Watch and updated them into the documents of _id: 101 & _id: 102 with the help of updateMany() method.
As you can see, updateMany() method has updated both the documents in the database.
Unlock your coding potential with our programming course certificate. Gain the skills and knowledge to excel in the tech industry. Enroll now!
We talked about how to implement atomic operations in MongoDB. Multi-document atomic transactions are not supported by MongoDB. However, we can still achieve atomicity in MongoDB by using a single document, as demonstrated in this article with an item purchase example.
Although working with multi-document tasks is not possible, using atomic operations in MongoDB is simple. As a result, beginning with version 4.0, MongoDB will support atomic operations in a variety of scenarios.
There are numerous real-world problems where we can use an atomic operation, such as in a purchase record. It will prevent mutual exclusions, thereby preventing data corruption in a variety of ways.
Examine the source codes in the article carefully and follow them as you see fit. After a few practice rounds, you will be able to apply the atomic operation in real-world problems as needed.
| Name | Date | Fee | Know more |
|---|
