Implementation of Transactions in MongoDB

After learning all the concepts of Transactions, let’s see how to use transactions in MongoDB. We will look at the step by step guide, along with queries of Transaction implementation in MongoDB.

Implementing transactions in MongoDB includes the usage of the startSession, withTransaction, and commitTransaction strategies. Below is a simple example in Python using the PyMongo driver.

Python

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017")
database = client["your_database"]

with client.start_session() as session:
    session.start_transaction()
    try:
        # Perform operations within the transaction
        database.collection1.insert_one({"key": "value"}, session=session)
        database.collection2.update_one({"key": "old_value"}, {"$set": {"key": "new_value"}}, session=session)

        # Commit the transaction
        session.commit_transaction()
    except Exception as e:
        # Abort the transaction in case of an error
        print("An error occurred:", e)
        session.abort_transaction()

Explanation: This Python code uses PyMongo to perform a transaction in MongoDB, inserting a document into “collection1” and updating a document in “collection2.” If any operation fails, the transaction is aborted.

Start_session(): This is a technique in PyMongo that begins a brand new session for executing transactions. A session is a context wherein data is read and written. It may used to execute a couple of operations, both read or write, inside a single transaction.

Start_transaction(): This is a technique that starts offevolved a brand new transaction inside a consultation. All the operations finished inside this transaction will follow the ACID Properties. If any operation fails, the transaction can be aborted, and all changes made in the transaction will be rolledback.

Commit_transaction(): This technique is used for all modifications made within a transaction to the database. Once a transaction is dedicated, all adjustments are permanent and visible to different sessions.

Abort_transaction(): If an error occurs throughout the execution of a transaction, this approach can be used to abort the transaction. Aborting a transaction will roll back all modifications made inside the transaction, leaving the database in its unique form before the transaction start.

WithTransaction: This is a utility feature provided by using MongoDB drivers that starts a brand new consultation, executes a given feature (which contains the operations to be performed within the transaction), and automatically commits or aborts the transaction based totally on whether or not the performed efficiently or threw an exception. This simplifies transaction managing by means of abstracting the boilerplate code for starting, committing, and aborting transactions.

Output: This code starts a consultation and a transaction inside that session. It inserts a report into `collection1` and modifies a document in `collection2`. If any operation does not succeed, then it cancels the transaction, and if all operations are positive, then it finalizes the transaction.

Note: Please rename `"your_database"`, `"collection1"`, and `"collection2"` with the genuine names of your
database and collections. Also, interchange `"key": "cost"`, `"key": "old_value"`, and `"key": "new_value" along
with your genuine  keys and values.

Transactions in MongoDB

Transactions in MongoDB allow merging groups of operations as a single atomic unit. They provide atomicity, consistency, isolation, and durability (ACID) properties to ensure that complex operations can be safely and reliably performed.

It is an important attribute for maintaining data consistency when working on large projects.

In this article, we will learn about transactions in MongoDB including what they involve, advantages as well as disadvantages associated with them, implementation, and other related concerns.

Table of Content