Django的多数据库处理（垂直分库和水平分库）

垂直分库指的是根据应用来分数据库，比如博客一个数据库，论坛一个数据库。水平分库是指，根据某些规则，将同一个应用/表的数据分布在不同的库上。比如根据用户ID把用户的博客文章分布在5个数据库上。

垂直分库，可以参考如下的文档。
Easy Multi-Database Support for Django
http://www.eflorenzano.com/blog/post/easy-multi-database-support-django/
这篇文章的主要思路是，继承Manager创建一个MultiDBManager，在建立Model的时候用MultiDBManager替换默认的Manager，在MultiDBManager构造时指定数据库。

核心的设计思路是，在外部设置settings的数据库连接的值，在db内部使用。

Python代码 复制代码
  1. for name, database in settings.DATABASES.iteritems():   
  2.     for key, value in database.iteritems():   
  3.         setattr(settings, key, value)   
  4.   
  5. do something  


这样作其实是很费劲的，因为django在设计之初就没有考虑到multi-db的问题，connection都是直接读取的setting的配置，所有和数据库相关的地方都是“静态”的。

水平分库，可以参考如下的讨论链接，但是这家伙只是给出了思路，不过分析的很全面。
Proposal: user-friendly API for multi-database support
http://groups.google.com/group/django-developers/browse_thread/thread/9f0353fe0682b73

因为我的代码很乱（夹杂其他功能），所以我也只给出思路和部分代码。假设一个应用场景如下：用户的消息，根据用户的ID（数字）分布在2个数据库中，则用户ID对2求余就可以了。改动的地方，主要是BaseDatabaseWrapper（这是数据库连接的wraper，也是多类型(mysql,postgresql之类)数据库支持的基类），为__init__函数增加传入数据库编号参数。其次增加一个Manager，可以传入数据库编号，选择数据库连接。最后是，改动模型，CRUD时增加数据库编号参数。

1.setting.py
Python代码 复制代码
  1. DATABASE_ENGINE = 'mysql'  
  2. DATABASE_NAME = 'master'  
  3. DATABASE_USER = '001'  
  4. DATABASE_PASSWORD = ''  
  5. DATABASE_HOST = '127.0.0.1'  
  6. DATABASE_PORT = '3306'  
  7.   
  8. DATABASES = dict(   
  9.     msg_0 = dict(   
  10.         DATABASE_NAME='msg0',   
  11.     ),   
  12.     msg_1 = dict(   
  13.         DATABASE_NAME='msg1',   
  14.     ),   
  15. )  


2.模拟一个settings.py出来，还有别的办法，我当时用的笨办法。
Python代码 复制代码
  1. class DBSetting:   
  2.     def __init__(self,settings,db):   
  3.         self.DEBUG = False  
  4.         self.DATABASE_HOST = settings.DATABASE_HOST   
  5.         self.DATABASE_PORT = settings.DATABASE_PORT   
  6.         self.DATABASE_NAME = settings.DATABASE_NAME   
  7.         self.DATABASE_USER = settings.DATABASE_USER   
  8.         self.DATABASE_PASSWORD = settings.DATABASE_PASSWORD   
  9.   
  10.         if db:   
  11.             dbdi = settings.DATABASES[db]   
  12.             if dbdi.has_key('DATABASE_HOST'):   
  13.                 self.DATABASE_HOST = dbdi['DATABASE_HOST']   
  14.             if dbdi.has_key('DATABASE_PORT'):   
  15.                 self.DATABASE_PORT = int(dbdi['DATABASE_PORT'])   
  16.             if dbdi.has_key('DATABASE_NAME'):   
  17.                 self.DATABASE_NAME = dbdi['DATABASE_NAME']   
  18.             if dbdi.has_key('DATABASE_USER'):   
  19.                 self.DATABASE_USER = dbdi['DATABASE_USER']   
  20.             if dbdi.has_key('DATABASE_PASSWORD'):   
  21.                 self.DATABASE_PASSWORD = dbdi['DATABASE_PASSWORD']   
  22.             if dbdi.has_key('DATABASE_SEGMENT'):   
  23.                 self.DATABASE_SEGMENT = dbdi['DATABASE_SEGMENT']  


3.修改django安装文件下的django/db/backends/__init__.py文件，改完要重新安装。如果你直接修改/usr/lib/python2.5/site-packages/django/下的，则不需要。

Python代码 复制代码
  1. class BaseDatabaseWrapper(local):   
  2.     #增加构造参数，把settings传入   
  3.     def __init__(self,settings,**kwargs):   
  4.         self.connection = None  
  5.         self.queries = []   
  6.         self.options = kwargs   
  7.         self.settings = settings   
  8.     #...此处省略了代码...   
  9.     def cursor(self):   
  10.         #把传入的settings传递给子类   
  11.         cursor = self._cursor(self.settings)   
  12.         if self.settings.DEBUG:   
  13.             return self.make_debug_cursor(cursor)   
  14.         return cursor  


4.好了，一个可以传入链接参数的connection就做好了。和第一个参考链接里面的差不多，还是有点差异。处理数据库连接，有两个地方一个是QuerySet一个是insert。
Python代码 复制代码
  1. class MultiManager(models.Manager):   
  2.     #group指的是垂直分库的标识，比如blog,bbs之类的   
  3.     def __init__(self, group, *args, **kwargs):   
  4.         self.group = group   
  5.         super(MultiManager, self).__init__(*args, **kwargs)   
  6. 　　 #segment指的是用blog之下的哪个库   
  7. 　　 #比如settings.py里面的blog_0,blog_1，那么segment就可能是０和1   
  8.     def choiceConn(self,segment):   
  9.         self.segment = segment   
  10.   
  11.     def _getConn(self):   
  12.         if self.group:   
  13.             if self.segment:   
  14.                 key = self.group+'_'+str(self.segment)   
  15.             else:   
  16.                 key = self.group+‘_0’ #默认连第一个   
  17.             conn = connPool.getConn(key)   
  18.             return conn   
  19.         else:   
  20.             return None  
  21.   
  22.     def get_query_set(self):   
  23.         conn = self._getConn()   
  24.         if conn:   
  25.             query = sql.Query(self.model,conn)   
  26.             queryset = QuerySet(self.model,query)   
  27.         else:   
  28.             queryset = super(MultiManager, self).get_query_set()   
  29.         return queryset   
  30.   
  31.     def _insert(self, values, return_id=False, raw_values=False):   
  32.         conn = self._getConn()   
  33.         if conn:   
  34.             query = sql.InsertQuery(self.model, conn)   
  35.             query.insert_values(values, raw_values)   
  36.             ret = query.execute_sql(return_id)   
  37.             query.connection._commit()  


5.models的定义，也需要额外的处理，一般情况下的调用如：userMsg.objects.filter()/get()之类的，如果是水平分库，则需要指定连接到哪个数据库。因此，我定义了一个objects(seg)的方法，可以传入数据编号。同时，保存的时候，一般是这样的：usermsg.save(),如果要分库，则改为usermsg.save(seg)就可以了。
Python代码 复制代码
  1. class userMsg(models.Model):   
  2.     msgid = models.AutoField(primary_key = True)   
  3.     userid = models.IntegerField()   
  4.     message = models.CharField(max_length = 128)   
  5.     _default_manager = MultiManager('msg')  
  6.  
  7.     @staticmethod  
  8.     def objects(seg):   
  9.         log('userMsg.objects(seg)',str(seg))   
  10.         userMsg._default_manager.choiceConn(seg)   
  11.         return userMsg._default_manager   
  12.   
  13.     def choiceConn(self,seg):   
  14.         userMsg._default_manager.choiceConn(seg)  


6.views中的使用，和django的使用没有太大区别，就上面的两个方法的差异。如果不需要水平切分，就不要使用上面两个方法，仅仅设置_default_manager = MultiManager('msg')，调用save()时，默认会连msg_0；如果调用save(1)，就会连第msg_1。


经一步的思考：

1.数据库事务的处理。在多数据库的情况下，针对不同的数据库，是无法使用事务的。因此，在架构上需要考虑异常和补偿性的事务。在同一个数据库上事务的处理，需要改写transication.py，或者获取当前connection，再进行事务的处理。


2.扩容的问题。增加数据库后，会导致数据重新分布，那么就涉及到数据迁移的问题，一个办法是分布规则，考虑到扩容的问题，新的规则兼容老的规则，旧有的数据不会变化。另外一种就是，可以平滑的在库之间移动数据。这两个都是很麻烦的问题。
posted @ 2010-04-29 11:46  蛤蟆  阅读(830)  评论(0)  编辑  收藏  举报