Django MongoDB Integration Setting Up: 3 Easy Methods

The Python Programming Language’s simple yet robust capabilities have made it popular among developers. This has led to the high usage of Django, a Python framework, in most modern software businesses. To store the application development-related data, Django users are turning towards MongoDB. They wish to establish a Django MongoDB integration to boost their application development process.

This blog will introduce you to both MongoDB and Django along with their key features. It will also discuss 3 methods to seamlessly connect MongoDB to Django. Read along to learn the steps and limitations associated with Django MongoDB integration!

Prerequisites

To set up the Django MongoDB integration, you must have:

• Install MongoDB version (anyone amongst 3.4, 3.6, 4.0). 
• Install pymongo>=3.4 on your system from. 

What is MongoDB?

MongoDB, is an open-source C++ based NoSQL Database. Its popularity stems from the fact that it provides you with data storage without having any constraints regarding the Data Structure and type of fields. This document-oriented storage operates on the JSON format and uses a Dynamic Schema for storing data. Moreover, the MongoDB Documents are designed in JSON objects like format, and allow you to work in a familiar environment while using MongoDB.

MongoDB enables you to easily delete existing fields and add new ones. It also allows you to customize the record structure(MongoDB Documents). Furthermore, because of the MongoDB Objects’ hierarchical relationships, you can store Arrays and other complex Data Structures seamlessly. Today, MongoDB, due to its unique features, finds applications in a multitude of businesses including Facebook, eBay, Google, etc.

Key Features of MongoDB

The following features make MongoDB a popular choice over traditional Databases:

• Schema-Less Database: MongoDB uses a JSON-like format to store data and therefore can store documents, each of which has its own set of Fields. This way you don’t have to worry about the syntax-related constraints prevalent in traditional Relational Databases.
• Index-based Document: MongoDB databases have Primary and Secondary Indices as markers for your data fields. This promotes faster and simpler data extraction for your work.
• Horizontal Scalability: MongoDB performs sharding which involves distributing your data among multiple servers. It also provides you with a Shard Key to partition huge data sets into small data chunks, which you can disperse uniformly among the multiple Shards. 
• Replication: MongoDB is popular for maintaining high data availability. It creates several data copies and saves them on distinct servers. This way, you can retrieve data safely in case a server fails.

What is Django?

Django is an open-source Python Framework (Web) that operates on the Model–Template–Views architecture. An American non-profit company named Django Software Foundation is responsible for the maintenance of Django. This Python Framework allows you to build high-quality Web Services/Applications seamlessly. Furthermore, you can leverage this tool for both types of developments, frontend, and backend.

Django works on strict design principles and simplifies the implementation of web-development approaches. This tool finds applications in various popular applications such as Instagram, Washington Times, Mozilla, etc. Django’s main task is to connect the Data Model to the Database Engine. It supports a variety of databases and does everything possible to generate hyper-fast development.

Key Features of Django

Django’s following features make it a popular choice for Python developers:

• Secure: Django has in-built methods to protect your application from pitfalls and it does not allow you to perform risky operations like storing session information in cookies. 
• Scalable: Django’s native design allows all of its components to operate independently. Since Django’s various components are independent, you can ad hardware to scale them and meet your increased requirements.
• Versatile: Django allows you to develop almost any kind of website, from Content Management Systems (CMS) to Social Networks.
• Portable: Django is written in Python and therefore you’re allowed to run your applications across servers from different platforms like Linux, Windows, etc. 

Methods to Setup Django MongoDB Integrations

You can easily set up the Django MongoDB Integration using the following 3 methods:

• Method 1: Setting Up Django MongoDB Integration Using MongoEngine
• Method 2: Setting Up Django MongoDB Integration Using Django
• Method 3: Setting Up Django MongoDB Integration Using PyMongo

Method 1: Setting Up Django MongoDB Integration Using MongoEngine

MongoEngine is a popular Object Mapper tool used for mapping MongoDB Documents using Python. You can leverage MongoEngine to set up the MongoDB Django integration using the following steps:

Step 1: Install MongoEngine

Use the following statement on your python editor to install MongoEngine:

pip install -u mongoengine

Step 2: Customize settings.py 

Start your Django project, navigate to the settings.py file and paste the following code: 

import mongoengine
mongoengine.connect(db=DATABASE_NAME, host=DATABASE_HOST, username=USERNAME, password=PASSWORD)
#DATABASES = {
# 'default': {
# 'ENGINE': 'djongo', #'django.db.backends.sqlite3',
# 'NAME': 'blogs', # DB name
# 'USER': 'root', # DB User name <optional>
# }
#}

Keep in mind to comment on the DATABASES section in the above code for now. 

Step 3: Import Project Documents

To import the required Documents from the mongoengine, enter the following code in your Model.py file:

from mongoengine import Document, fields
class Blogs(Document):
  name = fields.StringField()
   topic = fields.StringField()
   date = fields.DateTimeField()
   addition_info = fields.DictField()

Method 2: Setting Up Django MongoDB Integration Using Djongo

Don’t get confused between Django and Djongo. It’s not a typo. Django is an open-source project and is regularly maintained. It allows you to use all Django features, including Django ORM.

One important thing to note here is that Djongo doesn’t create a MongoDB database but instead connects to one. So you need to have a MongoDB database already created. Let’s create the MongoDB database first. Djongo helps connect to this database and acts as a SQL-to-MongoDB transporter.

Download MongoDB Compass and install it on your system. Next, click on the “create database” button to generate a NoSQL Database in MongoDB as shown below:

Step 2: Install the Django Package & Create a Project

Enter the following command in your terminal or git_bash(for Windows) to install the Django Package:

pip install django

Install Djongo

pip install djongo

Next, build a new Django Project in your preferred location using the following command:

django-admin startproject mysite 

Step 3: Customize the settings.py file

Go to the setting.py file and add the following database setting:

#If your database is in your local machine
DATABASES = {
   ‘default’: {
      ‘ENGINE’: ‘djongo’,
      ‘NAME’: ‘your-db-name’,
      ‘USER’: ‘root’,               # Database User name <optional>
   }
}

Now, execute the migrate command given below:

python3 manage.py migrate

This way you can successfully set up the Django MongoDB integration using Djongo. For more information about Djongo you can visit.

Method 3: Setting Up Django MongoDB Integration Using PyMongo

The PyMongo tool stores the python distribution required for working with MongoDB. It is a great tool to write and save JSON data in your MongoDB database. To set up Django MongoDB integration using PyMongo, first install PyMongo on your system as follows:

pip install pymongo

After initializing the Django project Create utils.py in the project folder and add the following lines of code:

from pymongo import MongoClient
def get_db_handle(db_name, host, port, username, password):
    client = MongoClient(host=host,
                         port=int(port),
                         username=username,
                         password=password
                        )
    db_handle = client[db_name]
    return db_handle, client
def get_collection_handle(db_handle,collection_name):
    return db_handle[collection_name]

Now, using the above function, you can fetch/write data in the views.py file or anywhere else in your MongoDB as shown in the below code:

from project.utils import get_db_handle, get_collection_handle
db_handle, mongo_client = get_db_handle(DATABASE_NAME, DATABASE_HOST, 
DATABASE_PORT, USERNAME, PASSWORD)
collection_handle = get_collection_handle(db_handle, REGIONS_COLLECTION)
collection_handle.find({...})
collection_handle.insert({...})
collection_handle.update({...})

That’s it! Your MongoDB Django integration is ready. You can also read more about MongoDB and Python connections on our blog.

Limitations of MongoDB Django Integration

The popular MongoDB Django integration comes along with the following limitations:

• The most general intent behind MongoDB Django integration is to replace SQL with MongoDB in Django. This is because users wish to store JSON data in MongoDB and search it. However, this integration also carries the complexity of stapling MongoDB (a non-relational database) into a framework-based ecosystem(Django) that is built to operate with relational databases.
• You may also try to set up the MongoDB Django Integration to amplify data processing performance. Now, this will happen if you execute MongoDB without implementing any write safeguards. However, it is a dangerous and insecure approach and carries a huge risk that your data may fall into corruption issues. 
• You should also keep in mind that Django is designed to operate on a relational database backend. Now, if you go beyond the original design and try to integrate with NoSQL Databases, the software development process of your company will become slower and may even frustrate the team. Furthermore, your team may face issues by not being able to utilize their tools fully within the Django ecosystem.

Conclusion

This article introduced you to MongoDB and Django along with their key features. It also explained the 3 methods using which you can set up the Django MongoDB integration easily. It further elaborated on the limitations that you may face while using these 2 tools together.

Share your views on Django MongoDB integration in the comments section!