Tutoriel de configuration multi-bases de données Django

Cet article présente principalement le tutoriel de configuration multi-bases de données Django, qui a une certaine valeur de référence. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

Dans le projet Django, il existe plusieurs bases de données. dans un projet. Il est très courant d'utiliser plusieurs applications. Parfois, vous souhaitez que différentes applications se connectent à différentes bases de données. Dans ce cas, vous devez établir plusieurs connexions à la base de données.

1. Modifier la configuration des paramètres du projet

Configurer plusieurs chaînes de connexion à la base de données qui doivent être connectées dans 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'),
  },
}

Supposons maintenant que nous utilisions 3 bases de données, une bibliothèque par défaut, une db01 et une db02

2. Configurez le Méthode de règle de routage de base de données

Configurez DATABASE_ROUTERS dans settings.py

DATABASE_ROUTERS = ['Prject.database_router.DatabaseAppsRouter']

Projet : Nom du projet Django établi ( project_name)

database_router : Définissez le nom du fichier de la règle de routage database_router.py, ce nom de fichier peut être défini par vous-même

DatabaseAppsRouter : Le nom de classe de la règle de routage, cette classe est dans le database_router Fichier .py Définissez

3. Définissez la table de routage de la base de données correspondant à l'application

À quelle base de données chaque application souhaite se connecter, vous avez besoin pour définir les paramètres correspondants, dans paramètres Effectuez la configuration suivante dans le fichier .py :

DATABASE_APPS_MAPPING = {
  # example:
  # 'app_name':'database_name',
  'app02': 'db02',
  'app01': 'db01',
  'admin': 'db01',
  'auth': 'db01',
  'contenttypes': 'db01',
  'sessions': 'db01',
}

Les app01 et app02 ci-dessus sont les noms d'application dans le projet , qui sont affectés respectivement aux bases de données db01 et db02.

Afin de créer les propres tables de Django dans votre propre base de données définie, vous pouvez spécifier : admin, auth, contenttypes, sessions dans la base de données définie. Si cela n'est pas spécifié, elle sera automatiquement créée par défaut (par défaut). dans la base de données

4. Créez des règles de routage de la base de données

dans le chemin racine du projet (au même niveau que le fichier settings.py) Créez le fichier database_router.py :

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. Exemple de création de modèles

Lors de la création de modèles de tables de données dans leurs APP respectives, vous devez spécifier le nom app_label de la table S'il n'est pas spécifié, elle sera créée sous le nom de la base de données configuré par défaut,

comme suit :

Créer des modèles sous 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"

Créer des modèles sous 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"

Créez des modèles dans app03 sans spécifier app_label, créez-les par défaut

class Users(models.Model):  
  username = models.CharField(max_length=100)

6. Générez Table de données

Lors de l'utilisation de la migration de Django pour créer la table générée, vous devez ajouter le paramètre –database. Sinon, la table dans les modèles de l'APP qui ne spécifie pas app_label le fera. être créé par défaut dans la base de données spécifiée, telle que :

Créer la table dans les modèles sous app01 dans la base de données "db_01" de db01

./ manage.py migrate --database=db01

Créer la table dans les modèles sous app02 dans la base de données "db_02" de db02

./ manage.py migrate --database=db02

Créer la table dans les modèles sous app03 dans la valeur par défaut base de données" sqlite3"

./ manage.py migrate

Une fois la création ci-dessus terminée, toutes les autres opérations de création, requête, suppression et autres peuvent être effectuées comme d'habitude, pas besoin utiliser une méthode comme

models.User.objects.using(dbname).all(）

.

Recommandations associées :

Comment configurer les URL lorsqu'un projet Django contient plusieurs applications

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!