How to use multiple database in django

In today's article, I will tell you how to use multiple databases for your project. If you like this article, then write it, you can also see our Django course. You can use multiple databases by defining multiple database connections in your settings.py file. First, you will need to install the django-multidb-router package, which is a database router that allows you to specify which database a specific model should use.

Then in your settings.py file, you will need to specify the different databases you want to use and give them unique names. Here is an example of how you might define two databases, one for authentication and one for data storage:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    },
    'data_storage': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabasestorage',
        'USER': 'mydatabasestorageuser',
        'PASSWORD': 'mydatabasestoragepassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Then you need to specify which database the model should be saved on by adding using parameter in the objects.create() method like this

from myapp.models import MyModel
MyModel.objects.using('data_storage').create(name='myname')

You also need to add the MultiDBRouter class in your settings.py file

DATABASE_ROUTERS = ['path.to.MultiDBRouter']

You can also specify which database a specific model should use by creating a custom database router and adding it to the DATABASE_ROUTERS list in your settings.py file. You can find more information and examples in the Django documentation.

Another way to use multiple databases in Django is by creating a custom database router. A database router is a class that determines which database a specific model should use. You can create a custom router by subclassing django.db.routers.BaseRouter and implementing the db_for_read and db_for_write methods.

Here is an example of a custom router that routes all read operations to the "data_storage" database and all write operations to the "default" database:

class MyRouter(BaseRouter):
    def db_for_read(self, model, **hints):
        if model._meta.app_label == 'myapp':
            return 'data_storage'
        return None

    def db_for_write(self, model, **hints):
        if model._meta.app_label == 'myapp':
            return 'default'
        return None

You can specify this router in the DATABASE_ROUTERS setting in the settings.py file

DATABASE_ROUTERS = ['path.to.MyRouter']

You can also define database routers that use different databases for different models by implementing the allow_migrate method, which determines if a specific model can be migrated to a specific database.

You can also use other database routers like django-tenant-schemas and django-sharding which are more powerful and suitable for complex projects.

It's worth noting that when using multiple databases, you need to make sure that the database connections are thread-safe, especially when using database connections like SQLite.

Another important aspect to consider when using multiple databases in Django is how to handle transactions. By default, Django automatically creates a transaction when you run a query and rolls it back if an exception occurs. However, when using multiple databases, you need to manually control the transactions to ensure that all queries are executed in the correct order and that the data remains consistent across all databases.

Django provides the django.db.transaction module that allows you to manage transactions across multiple databases. You can use the atomic decorator or context manager to create a transaction that spans multiple databases.

Here's an example of how you can use the atomic decorator to create a transaction across multiple databases:

from django.db import transaction

@transaction.atomic(using='data_storage')
def my_view(request):
    # this will be executed in a transaction
    MyModel.objects.using('data_storage').create(name='myname')
    # this will also be executed in the same transaction
    MyModel2.objects.create(name='myname2')

You can also use the atomic context manager to create a transaction:

from django.db import transaction

def my_view(request):
    with transaction.atomic(using='data_storage'):
        # this will be executed in a transaction
        MyModel.objects.using('data_storage').create(name='myname')
        # this will also be executed in the same transaction
        MyModel2.objects.create(name='myname2')

Keep in mind that when using the atomic context manager or decorator, it will automatically roll back the transaction if an exception occurs, so you don't need to handle it manually.

It's also important to note that not all database backends support transactions across multiple databases, so it's important to check the documentation of the database backend you're using to see if it supports this feature.

In summary, using multiple databases in Django requires a good understanding of database connections, transactions and database routers. It's important to test your code and make sure that the data remains consistent across all databases, and that the performance of your application is not affected by the use of multiple databases.