Home > Article > Backend Development > Django multi-database configuration tutorial
This article mainly introduces the django multi-database configuration tutorial, which has a certain reference value. Now I share it with everyone. Friends in need can refer to it
In the django project, there are multiple databases in one project. It is very common to use multiple APPs. Sometimes you want different APPs to connect to different databases. In this case, you need to establish multiple database connections.
1. Modify the project settings configuration
Configure multiple database connection strings that need to be connected in settings.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'sqlite3'),
},
'db01': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db_01'),
},
'db02': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db_02'),
},
}
Assume we are using 3 databases now, a default library, a db01 and a db02
2. Set the routing of the database Rule method
Configure DATABASE_ROUTERS in settings.py
DATABASE_ROUTERS = ['Prject.database_router.DatabaseAppsRouter']
Project: Created django project name (project_name)
database_router: Define the name of the routing rule database_router.py file, this file name can be defined by yourself
DatabaseAppsRouter: The class name of the routing rule, this class is defined in the database_router.py file
3. Set the database routing table corresponding to the APP
Which database each APP needs to connect to needs to be matched in the settings.py file Make the following configuration:
DATABASE_APPS_MAPPING = {
# example:
# 'app_name':'database_name',
'app02': 'db02',
'app01': 'db01',
'admin': 'db01',
'auth': 'db01',
'contenttypes': 'db01',
'sessions': 'db01',
}
The above app01 and app02 are the APP names in the project, which are assigned to the databases of db01 and db02 respectively.
In order to create django's own tables into your own defined database, you can specify: admin, auth, contenttypes, sessions to the set database. If not specified, it will be automatically created to the default ( default) in the database
4. Create database routing rules
in the root path of the project (at the same level as the settings.py file) Create database_router.py file:
from django.conf import settings
DATABASE_MAPPING = settings.DATABASE_APPS_MAPPING
class DatabaseAppsRouter(object):
"""
A router to control all database operations on models for different
databases.
In case an app is not set in settings.DATABASE_APPS_MAPPING, the router
will fallback to the `default` database.
Settings example:
DATABASE_APPS_MAPPING = {'app1': 'db1', 'app2': 'db2'}
"""
def db_for_read(self, model, **hints):
""""Point all read operations to the specific database."""
if model._meta.app_label in DATABASE_MAPPING:
return DATABASE_MAPPING[model._meta.app_label]
return None
def db_for_write(self, model, **hints):
"""Point all write operations to the specific database."""
if model._meta.app_label in DATABASE_MAPPING:
return DATABASE_MAPPING[model._meta.app_label]
return None
def allow_relation(self, obj1, obj2, **hints):
"""Allow any relation between apps that use the same database."""
db_obj1 = DATABASE_MAPPING.get(obj1._meta.app_label)
db_obj2 = DATABASE_MAPPING.get(obj2._meta.app_label)
if db_obj1 and db_obj2:
if db_obj1 == db_obj2:
return True
else:
return False
return None
def allow_syncdb(self, db, model):
"""Make sure that apps only appear in the related database."""
if db in DATABASE_MAPPING.values():
return DATABASE_MAPPING.get(model._meta.app_label) == db
elif model._meta.app_label in DATABASE_MAPPING:
return False
return None
def allow_migrate(self, db, app_label, model=None, **hints):
"""
Make sure the auth app only appears in the 'auth_db'
database.
"""
if db in DATABASE_MAPPING.values():
return DATABASE_MAPPING.get(app_label) == db
elif app_label in DATABASE_MAPPING:
return False
return None
5. Models creation example
In When creating models of data tables in respective APPs, you must specify the app_label name of the table. If not specified, it will be created under the database name configured in default.
is as follows:
Create models under app01
class Users(models.Model):
name = models.CharField(max_length=50)
passwd = models.CharField(max_length=100)
def __str__(self):
return "app01 %s " % self.name
class Meta:
app_label = "app01"
Create models under app02
class Users(models.Model):
username = models.CharField(max_length=100)
password = models.CharField(max_length=50)
age = models.IntegerField()
def __str__(self):
return "app02 %s" % self.username
class Meta:
app_label = "app02"
class Book(models.Model):
user = models.ForeignKey("Users", on_delete=models.CASCADE)
bookname = models.CharField(max_length=100)
def __str__(self):
return "%s: %s" % (self.user.username, self.bookname)
class Meta:
app_label = "app02"
Create models in app03 without specifying app_label and create them under default
class Users(models.Model): username = models.CharField(max_length=100)
6. Generate data table
When using django's migrate to create a generated table, you need to add the --database parameter. If not, the table in the models of the APP that does not specify app_label will be created into the database specified by default, such as:
Create the table in models under app01 into the database "db_01" of db01
./ manage.py migrate --database=db01
Create the table in models under app02 into db02 In the database "db_02"
./ manage.py migrate --database=db02
Create the table in models under app03 to the default database "sqlite3"
./ manage.py migrate
After the above creation is completed, all other creation, query, deletion and other operations can be performed as usual. There is no need to use something like
models.User.objects.using(dbname).all(）
Operation in this way.
Related recommendations:
How to configure the URL when the Django project contains multiple applications
The above is the detailed content of Django multi-database configuration tutorial. For more information, please follow other related articles on the PHP Chinese website!