Django数据库分表

Page content

Django ORM没有提供默认的分表功能,给访问分表的数据库带来的不变。那么Django分表怎么实现呢?

分析Django ORM

在实现具体的方案之前,我们先看看Django ORM是如何访问数据表的。

Django中,数据库访问的逻辑基本上是在Queryset中完成的。假设我们有如下一个User Model

class User(models.Model):
    user_id = models.IntegerField()
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)

    class Meta:
        db_table = 'user'

当根据user_id查询用户数据时,比如:User.objects.filter(user_id=10).first()

其中的objects就是models.Manager,我们看看Manager的源码:

class Manager(BaseManager.from_queryset(QuerySet)):
    pass

from_queryset的源码如下

    @classmethod
    def from_queryset(cls, queryset_class, class_name=None):
        if class_name is None:
            class_name = '%sFrom%s' % (cls.__name__, queryset_class.__name__)
        return type(class_name, (cls,), {
            '_queryset_class': queryset_class,
            **cls._get_queryset_methods(queryset_class),
        })

这里可以看出Manager是对QuerySet的一个包装。QuerySet是最终要转换为SQL的一个中间层,这其实就是ORM的核心功能,把Model操作转换为SQL语句的部分。

所以当我们调用User.objects()的时候,就已经决定了要访问的数据表了。

实际访问哪个表是由models.Model中的内部类class Meta中的db_table字段决定的。

简单方案-穷举Model类分表

有了上面背景知识,假如我们要根据user_id给user表分三个表。在Django models里如何支持呢?最直接的思路就是声明三个User Model,然后在Meta类中,指定不同的db_table。在查询的时候,根据user_id返回具体的Model。

实现方法如下:

class User(models.Model):
    user_id = models.IntegerField(primary_key=True)
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)


class User0(User):

    class Meta:
        db_table = 'user_0'


class User1(User):

    class Meta:
        db_table = 'user_1'


class User2(User):

    class Meta:
        db_table = 'user_2'


user_model_map = {
    0: User0,
    1: User1,
    2: User2,
}

table_num = 3


def get_user_db_model(user_id):
    key = user_id % table_num
    return user_model_map[key]

然后,在实际查询时,先获取user model,再根据user_id查询数据。

def get_user_by_id(user_id):
    db_model = models.get_user_db_model(user_id)
    user = db_model.objects.get(user_id=user_id)
    return model_to_dict(user)

这样就可以支持访问分表的数据库了。

但是,聪明的大家都能看出来,要是user分100个表,甚至1000个表的时候怎么办呢?难道定义1000个User类?

Python这么牛逼的语言,怎么可以这么糟蹋呢?下面继续探究一下更好的方法吧。

改进方案-动态创建Model

既然不通过复制粘贴来定义1000个类,那么就需要动态去创建这1000个类。

学过Java的同学都知道反射,Java的框架和ORM必然是用到反射的,需要动态处理一些类信息。而Python作为一门动态语言,天生就支持Java 反射里各种黑科技的功能,对,我们不需要反射,原生Python已经自带了。

下面看看在Django里怎样去动态创建我们需要的1000个User类。

from django.db import models

TABLE_NUM = 3


class User(models.Model):
    @classmethod
    def get_user_db_model(cls, user_id=None):
        suffix = user_id % TABLE_NUM
        table_name = 'user_%s' % suffix
        if table_name in cls._user_model_dict:
            return cls._user_model_dict[table_name]

        class Meta:
            db_table = table_name

        attrs = {
            '__module__': cls.__module__,
            'Meta': Meta,
        }

        user_db_model = type(str('User_%s' % suffix), (cls,), attrs)
        cls._user_model_dict[table_name] = user_db_model
        return user_db_model

    _user_model_dict = {}
    user_id = models.IntegerField()
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)

    class Meta:
        abstract = True

嗯,看起来不错,我们已经不需要用复制粘贴来定义1000个类了,而且实现同样的功能代码短了不少。

依然可通过如下的方式获取数据:

db_model = User.get_user_db_model(user_id)
user = db_model.objects().get(user_id=user_id)

但是这里还有优化的空间,因为每次查询我们都创建了一个User Model对象,岂不是很浪费资源,那这些对象可以复用嘛?

改进-动态创建+本地缓存

怎么复用呢?自然是用字典把已经创建过的Model缓存下来,虽然这会消耗一部分本地内存,但为了提高性能还是值得的。

from django.db import models

TABLE_NUM = 3

class User(models.Model):
    @classmethod
    def get_user_db_model(cls, user_id=None):
        suffix = user_id % TABLE_NUM
        table_name = 'user_%s' % suffix
        if table_name in cls._user_model_dict:
            return cls._user_model_dict[table_name]

        class Meta:
            db_table = table_name

        attrs = {
            '__module__': cls.__module__,
            'Meta': Meta,
        }

        user_db_model = type(str('User%s' % suffix), (cls,), attrs)
        cls._user_model_dict[table_name] = user_db_model
        return user_db_model

    _user_model_dict = {}
    
    user_id = models.IntegerField(primary_key=True)
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)
    
    class Meta:
        abstract = True

我们定义了一个私有变量_user_model_dict,以table_name作为key,model对象作为值,把已经创建的Model类都缓存下来。

但到了这里还是有点麻烦。

  1. 这里获取db_model,在访问数据库时,还是没有直接objects.get()来的方便。

    db_model = User.get_user_db_model(user_id)
    user = db_model.objects().get(user_id=user_id)
    

    VS

    user = User.objects().get(user_id=user_id)
    
  2. 我们的分表只支持了User一个表,其他表分表还得再写一个get_xx_db_model,可不可以做的更通用些呢?

改进-Hack Model类的创建

针对上面的问题,可以hack Django Model的创建,在动态创建生成Model类时修改一些属性,把分表需要的信息填充进去。我们可以创建一个基类来实现动态创建的功能,不仅支持User Model分表,还能方便的让X ModelY Model通过继承也支持分表。

from django.db import models


class Object:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)


def _model_new(cls, *args, **kwargs):
    return cls(*args, **kwargs)


class ShardModel(object):
    """
    ShardModel support table horizontal partition.
    """
    _shard_db_models = {}

    def __new__(cls, *args, **kwargs):
        shard_key = kwargs.pop('shard_key', 0) % cls.Config.table_num
        model_name = cls.__name__
        model_name += '_%s' % shard_key

        model_class = cls._shard_db_models.get(model_name)
        if model_class is not None:
            return model_class

        # Deep copy attrs
        attrs = dict()
        attrs.update(cls.__dict__)
        if 'objects' in attrs:
            attrs['objects'] = attrs['objects'].__class__()

        # Set table name with shard_key
        meta = Object(**cls.Meta.__dict__)
        meta.db_table = meta.db_table % shard_key

        attrs['Meta'] = meta
        attrs['new'] = classmethod(_model_new)

        # Create model class dynamically
        model_class = type(model_name, tuple([models.Model] + list(cls.__bases__[1:])), attrs)
        cls._shard_db_models[model_name] = model_class
        return model_class

   
class User(ShardModel):
    user_id = models.IntegerField()
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)

    class Config:
        table_num = 3

    class Meta:
        app_label = 'default'
        db_table = 'user_%s'

通过继承ShardModelUser类就具备的自动分表的功能。在views中可通过如下方法获取user info:

def get_user_info(request):
    user_id = int(request.GET.get('user_id'))
    user = models.User(shard_key=user_id).objects.get(user_id=user_id)
    return HttpResponse(json.dumps(model_to_dict(user)))

配置好Django urls,在浏览器访问http://127.0.0.1:8000/user/get?user_id=32,得到下面的结果:

{
  "user_name": "test32",
  "password": "test32",
  "user_id": 32,
  "id": 1
}

nice, it works!

如果我们有一个Book表也需要分表,这样只需要简单的继承就行了。

class Book(ShardModel):
    book_id = models.IntegerField()
    book_name = models.CharField(max_length=256)
    book_author = models.CharField(max_length=256)

这样我们就通过层层深入,不断改进我们的方案,得到了一个比较优雅实现Django分表的方法。

本文由 络壳 原创或整理,转载请注明出处