Tutorial zur Konfiguration mehrerer Django-Datenbanken

In diesem Artikel wird hauptsächlich das Django-Multidatenbank-Konfigurations-Tutorial vorgestellt, das einen gewissen Referenzwert hat. Jetzt kann ich es mit allen Freunden teilen, die es brauchen.

Im Django-Projekt gibt es mehrere Datenbanken In einem Projekt ist es sehr üblich, mehrere APPs zu verwenden. In diesem Fall müssen Sie mehrere Datenbankverbindungen herstellen.

1. Ändern Sie die Einstellungskonfiguration des Projekts

Konfigurieren Sie mehrere Datenbankverbindungszeichenfolgen, die in Settings.py verbunden werden müssen

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'),
  },
}

Angenommen, wir verwenden jetzt 3 Datenbanken, eine Standardbibliothek, eine db01 und eine db02

2. Legen Sie das Routing der fest Datenbankregelmethode

Konfigurieren Sie DATABASE_ROUTERS in Settings.py

DATABASE_ROUTERS = ['Prject.database_router.DatabaseAppsRouter']

Projekt: Erstellt Django-Projektname (Projektname)

database_router: Definieren Sie den Namen der Routing-Regel-Datei „database_router.py“. Dieser Dateiname kann von Ihnen selbst definiert werden.

DatabaseAppsRouter: Der Klassenname der Routing-Regel. Diese Klasse ist in „database_router“ definiert .py-Datei

3. Legen Sie die Datenbank-Routing-Tabelle entsprechend der APP fest

Mit welcher Datenbank jede APP eine Verbindung herstellen möchte, muss abgeglichen werden Nehmen Sie in der Datei „settings.py“ die folgende Konfiguration vor:

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

Die oben genannten app01 und app02 sind die APP-Namen im Projekt, die den Datenbanken von zugewiesen sind db01 bzw. db02.

Um Djangos eigene Tabellen in Ihrer eigenen definierten Datenbank zu erstellen, können Sie Folgendes angeben: Admin, Authentifizierung, Inhaltstypen, Sitzungen für die festgelegte Datenbank. Wenn nicht angegeben, wird sie automatisch mit den Standardwerten erstellt (Standard). in der Datenbank

4. Erstellen Sie Datenbank-Routing-Regeln

im Projektstammpfad (auf der gleichen Ebene wie die Datei „settings.py“). Erstellen Sie die Datei „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. Beispiel für die Modellerstellung

in When Beim Erstellen von Datentabellenmodellen in den jeweiligen APPs müssen Sie den app_label-Namen der Tabelle angeben. Wenn dieser nicht angegeben ist, wird er unter dem standardmäßig konfigurierten Datenbanknamen

wie folgt erstellt:

Erstellen Sie Modelle unter 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"

Erstellen Sie Modelle unter 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"

Erstellen Sie Modelle in app03, ohne app_label anzugeben, erstellen Sie es unter Standard

6. Generieren Sie eine Datentabelle

Wenn Sie Djangos Migration verwenden, um eine generierte Tabelle zu erstellen, müssen Sie den Parameter –database hinzufügen. Andernfalls wird die Tabelle in den Modellen der APP ohne app_label in der standardmäßig angegebenen Datenbank erstellt, z :

Erstellen Sie die Tabelle in Modellen unter app01 in der Datenbank „db_01“ von db01

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

Erstellen Sie die Tabelle in Modellen unter app02 in db02 In der Datenbank „db_02“

./ manage.py migrate --database=db01

Erstellen Sie die Tabelle in Modellen unter app03 in der Standarddatenbank „sqlite3“

./ manage.py migrate --database=db02

Nachdem die obige Erstellung abgeschlossen ist, können alle anderen Erstellungs-, Abfrage-, Lösch- und anderen Vorgänge wie gewohnt ausgeführt werden. Es besteht keine Notwendigkeit, ähnliche Methoden wie

./ manage.py migrate

zu verwenden

Gehen Sie auf diese Weise vor.

Verwandte Empfehlungen:

So konfigurieren Sie URLs, wenn ein Django-Projekt mehrere Anwendungen enthält

Das obige ist der detaillierte Inhalt vonTutorial zur Konfiguration mehrerer Django-Datenbanken. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!