Introduction à la façon dont Django utilise plusieurs méthodes de base de données

Certains projets peuvent impliquer l'utilisation de plusieurs bases de données, et la méthode est très simple. Ensuite, cet article vous présentera la méthode d'utilisation de plusieurs bases de données dans Django. Les amis qui en ont besoin peuvent s'y référer

Certains projets peuvent impliquer l'utilisation de plusieurs bases de données. La méthode est très simple.

1. Définissez BASE DE DONNÉES dans les paramètres

Par exemple, si vous souhaitez utiliser deux bases de données :

DATABASES = {
  'default': {
    'NAME': 'app_data',
    'ENGINE': 'django.db.backends.postgresql',
    'USER': 'postgres_user',
    'PASSWORD': 's3krit'
  },
  'users': {
    'NAME': 'user_data',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'priv4te'
  }
}

De cette manière, deux bases de données sont identifiées, l'une avec l'alias par défaut et l'autre avec l'alias utilisateur. L'alias de la base de données peut être déterminé arbitrairement.

L'alias par défaut est spécial Lorsqu'un Modèle n'est pas spécifiquement sélectionné dans la route, la base de données par défaut est utilisée par défaut.

Bien sûr, la valeur par défaut peut également être définie sur vide :

DATABASES = {
  'default': {},
  'users': {
    'NAME': 'user_data',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'superS3cret'
  },
  'customers': {
    'NAME': 'customer_data',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_cust',
    'PASSWORD': 'veryPriv@ate'
  }
}

De cette façon, comme il n'y a pas de base de données par défaut, vous devez définir à tous les modèles, y compris Le modèle de la bibliothèque tierce est utilisé pour effectuer la sélection de routage de la base de données.

2. Spécifiez app_label

class MyUser(models.Model):
  ...
  class Meta:
    app_label = 'users'

pour le modèle qui doit effectuer la sélection de base de données. 3. Écrivez les routeurs de base de données<. 🎜>

Database Router est utilisé pour déterminer quelle base de données un modèle utilise. Il définit principalement les quatre méthodes suivantes :

db_for_read(model, **hints)

Spécifie quelle base de données le modèle utilise pour lire.

db_for_write(model, **hints)

Spécifie dans quelle base de données le modèle doit être écrit.

allow_relation(obj1, obj2, **hints)

Déterminez si obj1 et obj2 peuvent être associés, principalement utilisés pour les clés étrangères et plusieurs à plusieurs opérations.

allow_migrate(db, app_label, model_name=None, **hints)

Détermine si l'opération de migration peut être exécutée sur la base de données avec l'alias db.

Un exemple complet :

Paramètres de la base de données :

DATABASES = {
  'default': {},
  'auth_db': {
    'NAME': 'auth_db',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'swordfish',
  },
  'primary': {
    'NAME': 'primary',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'spam',
  },
  'replica1': {
    'NAME': 'replica1',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'eggs',
  },
  'replica2': {
    'NAME': 'replica2',
    'ENGINE': 'django.db.backends.mysql',
    'USER': 'mysql_user',
    'PASSWORD': 'bacon',
  },
}

Si vous souhaitez obtenir les effets suivants :

La lecture et l'écriture du modèle dont app_label est auth sont terminées dans auth_db, le reste de l'écriture du modèle est terminé dans le primaire et la lecture est terminée de manière aléatoire dans réplique1 et réplique2.

auth :

class AuthRouter(object):
  """
  A router to control all database operations on models in the
  auth application.
  """
  def db_for_read(self, model, **hints):
    """
    Attempts to read auth models go to auth_db.
    """
    if model._meta.app_label == 'auth':
      return 'auth_db'
    return None
  def db_for_write(self, model, **hints):
    """
    Attempts to write auth models go to auth_db.
    """
    if model._meta.app_label == 'auth':
      return 'auth_db'
    return None
  def allow_relation(self, obj1, obj2, **hints):
    """
    Allow relations if a model in the auth app is involved.
    """
    if obj1._meta.app_label == 'auth' or \
      obj2._meta.app_label == 'auth':
      return True
    return None
  def allow_migrate(self, db, app_label, model_name=None, **hints):
    """
    Make sure the auth app only appears in the 'auth_db'
    database.
    """
    if app_label == 'auth':
      return db == 'auth_db'
    return None

De cette façon, la lecture et l'écriture du Modèle dont app_label est auth se terminent dans auth_db, et les associations sont autorisées . Migrate est uniquement dans la base de données auth_db.

Le reste :

import random
class PrimaryReplicaRouter(object):
  def db_for_read(self, model, **hints):
    """
    Reads go to a randomly-chosen replica.
    """
    return random.choice(['replica1', 'replica2'])
  def db_for_write(self, model, **hints):
    """
    Writes always go to primary.
    """
    return 'primary'
  def allow_relation(self, obj1, obj2, **hints):
    """
    Relations between objects are allowed if both objects are
    in the primary/replica pool.
    """
    db_list = ('primary', 'replica1', 'replica2')
    if obj1._state.db in db_list and obj2._state.db in db_list:
      return True
    return None
  def allow_migrate(self, db, app_label, model_name=None, **hints):
    """
    All non-auth models end up in this pool.
    """
    return True

De cette façon, la lecture se fait de manière aléatoire dans la réplique1 et la réplique2, et l'écriture utilise le primaire.

Enfin, définissez-le dans les paramètres :

DATABASE_ROUTERS = ['path.to.AuthRouter', 'path.to.PrimaryReplicaRouter']

et c'est tout.

Lors de l'exécution d'une opération de migration :

$ ./manage.py migrate
$ ./manage.py migrate --database=users

L'opération de migration opère par défaut sur la base de données par défaut. Pour opérer sur d'autres bases de données, vous pouvez utiliser. Option --database, suivie de l'alias de la base de données.

En conséquence, les commandes dbshell, dumpdata et loaddata ont toutes l'option --database.

Vous pouvez également sélectionner manuellement l'itinéraire :

Requête :

>>> # This will run on the 'default' database.
>>> Author.objects.all()
>>> # So will this.
>>> Author.objects.using('default').all() 
>>> # This will run on the 'other' database.
>>> Author.objects.using('other').all()

Enregistrer :

>>> my_object.save(using='legacy_users')

Déplacer :

>>> p = Person(name='Fred')
>>> p.save(using='first') # (statement 1)
>>> p.save(using='second') # (statement 2)

Le code ci-dessus posera des problèmes lorsque p est enregistré pour la première fois dans la première base de données, il générera par défaut une clé primaire de sorte que lors de l'enregistrement dans la deuxième base de données, p ait déjà une clé primaire. Cette clé primaire ne posera pas de problèmes si elle n'est pas utilisée, mais si elle a été utilisée précédemment, les données d'origine seront écrasées. .

Il existe deux solutions :

1. Effacez la clé primaire avant de sauvegarder :

>>> p = Person(name='Fred')
>>> p.save(using='first')
>>> p.pk = None # Clear the primary key.
>>> p.save(using='second') # Write a completely new object.

2. Utilisez force_insert

>>> p = Person(name='Fred')
>>> p.save(using='first')
>>> p.save(using='second', force_insert=True)

pour supprimer :

De quelle base de données l'objet a été obtenu et où supprimer

>>> u = User.objects.using('legacy_users').get(username='fred')
>>> u.delete() # will delete from the `legacy_users` database

Si vous souhaitez transférer un objet de la base de données Legacy_users vers la base de données new_users :

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!