服务器启动后Django多个动态数据库

Question

我是 django 的新手，并试图找出对我来说在 django 中动态使用多个数据库的最佳解决方案。 我知道 django 能够使用在 settings.py 文件中注册的多个数据库，但在我的情况下，我有一个主数据库（sqlite）作为我的存储库，我创建了所有模型，其余的 api 视图集用于这个。

用户可以通过输入连接信息来选择连接到 Oracle 数据库，然后我需要从该数据库中收集数据并将其插入到我的存储库中。用户可以通过app注册多个Oracle数据库。我想知道是否应该使用纯 cx_Oracle 类来处理来自 django 的连接，或者是否应该在 settings.py 中注册它们？

前端中的每个视图都映射到一个特定的数据库，我需要在它们之间切换上下文，如果我使用 cx_Oracle 类，如何将请求路由到后端的正确类实例？

任何帮助或见解将不胜感激，我在互联网上没有找到任何与我的用例匹配的内容。

Answer 1

正如在 cmets 中发现的那样 - here 是一篇描述如何通过动态选择数据库来设置服务器实例的文章，因此它的作者应该获得所有荣誉。重申基本方法：

1. 创建代表数据库连接的模型类：

   class Database(models.Model):
       name = models.CharField(max_length=256, unique=True)
       config = JSONField()
   

2. 添加label 属性以区分数据库连接实体。这里需要在django设置中设置字符串DYNAMIC_DATABASES_PREFIX和DYNAMIC_DATABASES_SEPARATOR，但也可以硬编码为一些常量：

   class Database(models.Model):
       ...
       @property
       def label(self):
           # We want to be able to identify the dynamic databases and apps
           # So we prepend their names with a common string
           prefix = getattr(settings, 'DYNAMIC_DATABASES_PREFIX', 'DYNAMIC_DATABASE')
           separator = getattr(settings, 'DYNAMIC_DATABASES_SEPARATOR', '_')
           return '{}{}{}'.format(prefix, separator, self.pk)
   

3. 添加一种方法，用于将 db 连接添加到 django 的 db 连接/从中删除 db 连接（漂亮的部分是为每个 db 连接放置一个虚拟应用程序 - 这样我们可以拥有具有重复表名的不同数据库）：

   class Database(models.Model):
       ...
       def register(self):
           # label for the database connection and dummy app
           label = self.label
           # Do we have this database registered yet
           if label not in connections._databases:
               # Register the database
               connections._databases[label] = self.config
               # Break the cached version of the database dict so it'll find our new database
               del connections.databases
           # Have we registered our fake app that'll hold the models for this database
           if label not in apps.app_configs:
               # We create our own AppConfig class, because the Django one needs a path to the module that is the app.
               # Our dummy app obviously doesn't have a path
               AppConfig2 = type('AppConfig'.encode('utf8'),(AppConfig,),
                                 {'path': '/tmp/{}'.format(label)})
               app_config = AppConfig2(label, label)
               # Manually register the app with the running Django instance
               apps.app_configs[label] = app_config
               apps.app_configs[label].models = {}
   
       def unregister(self):
           label = self.label
           if label in apps.app_configs:
               del apps.app_configs[label]
           if label in apps.all_models:
               del apps.all_models[label]
           if label in connections._databases:
               del connections._databases[label]
               del connections.databases
   

4. 通过连接名称添加连接查找，该连接还将注册到正在运行的 django 实例的连接，使其可操作：

   class Database(models.Model):
       ...
       def get_model(self, table_name):
           # Ensure the database connect and it's dummy app are registered
           self.register()
           label = self.label
           model_name = table_name.lower().replace('_', '')
   
           # Is the model already registered with the dummy app?
           if model_name not in apps.all_models[label]:
               # Use the "inspectdb" management command to get the structure of the table for us.
               file_obj = StringIO()
               Command(stdout=file_obj).handle(database=label, table_name_filter=lambda t: t == table_name)
               model_definition = file_obj.getvalue()
               file_obj.close()
   
               # Make sure that we found the table and have a model definition
               loc = model_definition.find('(models.Model):')
               if loc != -1:
                   # Ensure that the Model has a primary key.
                   # Django doesn't support multiple column primary keys,
                   # So we have to add a primary key if the inspect command didn't
                   if model_definition.find('primary_key', loc) == -1:
                       loc = model_definition.find('(', loc + 14)
                       model_definition = '{}primary_key=True, {}'.format(model_definition[:loc + 1], model_definition[loc + 1:])
                   # Ensure that the model specifies what app_label it belongs to
                   loc = model_definition.find('db_table = \'{}\''.format(table_name))
                   if loc != -1:
                       model_definition = '{}app_label = \'{}\'\n        {}'.format(model_definition[:loc], label, model_definition[loc:])
   
                   # Register the model with Django. Sad day when we use 'exec'
                   exec(model_definition, globals(), locals())
                   # Update the list of models that the app
                   # has to match what Django now has for this app
                   apps.app_configs[label].models = apps.all_models[label]
               else:
                   logger.info('Could not find table: %s %s', label, table_name)
           else:
               logger.info('Already added dynamic model: %s %s', label, table_name)
   
           # If we have the connection, app and model. Return the model class
           if (label in connections._databases and label in apps.all_models and model_name in apps.all_models[label]):
               return apps.get_model(label, model_name)
   

5. 创建自定义数据库路由，使用提到的配置字符串进行数据库选择：

   class DynamicDatabasesRouter(object):
       label_prefix = '{}{}'.format(
           getattr(settings, 'DYNAMIC_DATABASES_PREFIX', 'DYNAMIC_DATABASE'),
           getattr(settings, 'DYNAMIC_DATABASES_SEPARATOR', '_')
       )
   
       def db_for_read(self, model, **hints):
           if model._meta.app_label.startswith(self.label_prefix):
               # We know that our app_label matches the database connection's name
               return model._meta.app_label
           return None
   
       def db_for_write(self, model, **hints):
           if model._meta.app_label.startswith(self.label_prefix):
               # We know that our app_label matches the database connection's name
               return model._meta.app_label
           return None
   
       def allow_relation(self, obj1, obj2, **hints):
           return None
   
       def allow_migrate(self, db, app_label, model_name=None, **hints):
           return None
   

6. 在设置中注册路由器：

   DATABASE_ROUTERS = ['myapp.routing.DynamicDatabasesRouter']
   

7. （可选）如果您使用该模型，请在管理站点中修改它：

   def config(conn):
       return json.dumps(conn.config)
   config.short_description = 'Config'
   
   class DatabaseAdmin(admin.ModelAdmin):
       list_display = ('name', config)
   
   admin.site.register(Database, DatabaseAdmin)
   

视图中的示例用法：

class HomeView(TemplateView):
    template_name = 'home.html'

    def get_context_data(self):
        context = super(HomeView, self).get_context_data()

        # We can pick which dynamic database connection we want based on a GET parameter
        db = Database.objects.get(pk=self.request.GET.get('env', 1))
        # Pass the database instance to the template so we can display it.
        context['db'] = db

        # Get a model class for a table in our dynamic database.
        # Lets pretend there's a table called 'author'
        Author = db.get_model('author')
        authors = Author.objects.all().order_by('name')
        # Send the author instances to the template for iterating over.
        context['authors'] = authors

        return context