Django使用多數據庫

有些項目可能涉及到使用多個數據庫的情況，方法很簡單。

1.在settings中設定DATABASE

比如要使用兩個數據庫：

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

這樣就確定了2個數據庫，別名一個為default，一個為user。數據庫的別名可以任意確定。

default的別名比較特殊，一個Model在路由中沒有特別選擇時，默認使用default數據庫。

當然，default也可以設置為空：

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

這樣，因為沒有了默認的數據庫，就需要為所有的Model，包括使用的第三方庫中的Model做好數據庫路由選擇。

2.為需要做出數據庫選擇的Model規定app_label

class MyUser(models.Model):
    ...

    class Meta:
        app_label = 'users'

3.寫Database Routers

Database Router用來確定一個Model使用哪一個數據庫，主要定義以下四個方法：

db_for_read(model, **hints)

規定model使用哪一個數據庫讀取。

db_for_write(model, **hints)

規定model使用哪一個數據庫寫入。

allow_relation(obj1, obj2, **hints)

確定obj1和obj2之間是否可以產生關聯， 主要用於foreign key和 many to many操作。

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

確定migrate操作是否可以在別名為db的數據庫上運行。

一個完整的例子：

數據庫設定：

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

如果想要達到如下效果：

app_label為auth的Model讀寫都在auth_db中完成，其余的Model寫入在primary中完成，讀取隨機在replica1和replica2中完成。

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

這樣app_label為auth的Model讀寫都在auth_db中完成，允許有關聯，migrate只在auth_db數據庫中可以運行。

其余的：

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

這樣讀取在隨機在replica1和replica2中完成，寫入使用primary。

最后在settings中設定：

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

就可以了。

進行migrate操作時：

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

migrate操作默認對default數據庫進行操作，要對其它數據庫進行操作，可以使用--database選項，后面為數據庫的別名。

與此相應的，dbshell，dumpdata，loaddata命令都有--database選項。

也可以手動的選擇路由：

查詢：

>>> # 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()

保存：

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

移動：

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

以上的代碼會產生問題，當p在first數據庫中第一次保存時，會默認生成一個主鍵，這樣使用second數據庫保存時，p已經有了主鍵，這個主鍵如果未被使用不會產生問題，但如果先前被使用了，就會覆蓋原先的數據。

有兩個解決方法;

1.保存前清除主鍵：

>>> 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.使用force_insert

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

刪除：

從哪個數據庫取得的對象，從哪刪除

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

如果想把一個對象從legacy_users數據庫轉移到new_users數據庫：

>>> user_obj.save(using='new_users')
>>> user_obj.delete(using='legacy_users')