django多数据库

关系数据库

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

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

migrate 管理命令一次操作一个数据库。默认情况下，它在default 数据库上操作，但是通过提供一个–database 参数，你可以告诉migrate 同步一个不同的数据库。

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

如果你不想每个应用都被同步到同一台数据库上，你可以定义一个 数据库路由。

数据库路由是一个类，它提供4个方法：

如果一个数据库操作能够提供其它额外的信息可以帮助选择一个数据库，它将在hints字典中提供。合法的hints 的详细信息在下文给出。

如果没有建议，则返回None。

如果一个数据库操作能够提供其它额外的信息可以帮助选择一个数据库，它将在hints字典中提供。 合法的hints 的详细信息在下文给出。

如果没有建议，则返回None。

位置参数app_label 是正在迁移的应用的标签。

大部分迁移操作设置model_name的值为正在迁移的模型的model. _meta.model_name（模型的__name__ 的小写）。对于RunPython和RunSQL 操作它的值为None，除非这两个操作使用hint 提供它。

hints 用于某些操作来传递额外的信息给路由。

当设置了model_name时，hints 通常通过键’model’包含该模型的类。注意，它可能是一个历史模型，因此不会有自定的属性、方法或管理器。你应该只依赖_meta。

这个方法还可以用来决定一个给定数据库上某个模型的可用性。

注意，如果这个方法返回False，迁移将默默地不会在模型上做任何操作。这可能导致你应用某些操作之后出现损坏的外键、表多余或者缺失。

路由不必提供所有这些方法 —— 它可以省略一个或多个。如果某个方法缺失，在做相应的检查时Django 将忽略该路由。

DATABASES = {
    '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',
    },
}

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=None, **hints):
"""
        Make sure the auth app only appears in the 'auth_db'
        database.

"""
        if app_label == 'auth':
            return db == 'auth_db'
        return None

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=None, **hints):
"""
        All non-auth models end up in this pool.

"""
        return True

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

>>>
>>> Author.objects.all()

>>>
>>> Author.objects.using('default').all()

>>>
>>> Author.objects.using('other').all()

对Model.save()使用using 关键字来指定数据应该保存在哪个数据库。
例如，若要保存一个对象到legacy_users 数据库，你应该使用：

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

默认情况下，删除一个已存在对象的调用将在与获取对象时使用的相同数据库上执行：

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

Django 的管理站点没有对多数据库的任何显式的支持。如果你给数据库上某个模型提供的管理站点不想通过你的路由链指定，你将需要编写自定义的ModelAdmin类用来将管理站点导向一个特殊的数据库。

ModelAdmin 对象具有5个方法，它们需要定制以支持多数据库：

class MultiDBModelAdmin(admin.ModelAdmin):

    using = 'other'

    def save_model(self, request, obj, form, change):

        obj.save(using=self.using)

    def delete_model(self, request, obj):

        obj.delete(using=self.using)

    def get_queryset(self, request):

        return super(MultiDBModelAdmin, self).get_queryset(request).using(self.using)

    def formfield_for_foreignkey(self, db_field, request=None, **kwargs):

        return super(MultiDBModelAdmin, self).formfield_for_foreignkey(db_field, request=request, using=self.using, **kwargs)

    def formfield_for_manytomany(self, db_field, request=None, **kwargs):

        return super(MultiDBModelAdmin, self).formfield_for_manytomany(db_field, request=request, using=self.using, **kwargs)

redis

from .redis_pools import master,slave1,slave2

import redis
master=redis.ConnectionPool(host='127.0.0.1',port=6379)
slave1=redis.ConnectionPool(host='127.0.0.1',port=6380)
slave2=redis.ConnectionPool(host='127.0.0.1',port=6381)

from pool import master,salve1,slave2
import redis
writer=redis.Redis(connection_pool=master)
reader1=redis.Redis(connection_pool=slave1)
reader2=redis.Redis(connection_pool=slave2)

writer.set('username','general_zy',60)
reader1.get('username')
reader2.get('username')

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    },
    "user": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6380",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    }
}

from django_redis import get_redis_connection
conn=get_redis_connection('default')
user=get_redis_connection('default')
conn.set('username','general_zy')
user.get('username')

from django.core.cache import cache
cache.set('username','general_zy')
cache.get('username')

Original: https://blog.csdn.net/General_zy/article/details/122270774
Author: General_zy
Title: django多数据库