Python实现ORM

ORM即把数据库中的一个数据表给映射到代码里的一个类上，表的字段对应着类的属性。将增删改查等基本操作封装为类对应的方法，从而写出更干净和更富有层次性的代码。

以查询数据为例，原始的写法要Python代码sql混合，示例代码如下：

import MySQLdb
import os,sys

def main():
    conn=MySQLdb.connect(host="localhost",port=3306,passwd='toor',user='root')
    conn.select_db("xdyweb")
    cursor=conn.cursor()
    count=cursor.execute("select * from users")
    result=cursor.fetchmany()
    print(isinstance(result,tuple))
    print(type(result))
    print(len(result))
    for i in result:
        print(i)
        for j in i:
            print(j)
    print("row count is %s"%count)
    cursor.close()
    conn.close()

if __name__=="__main__":
    cp=os.path.abspath('.')
    sys.path.append(cp)
    main()

而我们现在想要实现的是类似这样的效果：

#查找：
u=user.get(id=1)
#添加
u=user(name='y',password='y',email='1@q.com')
u.insert()

实现思路是遍历Model的属性，得出要操作的字段，然后根据不同的操作要求（增，删，改，查）去动态生成不同的sql语句。

#coding:utf-8

#author:xudongyang

#19:25 2015/4/15

import  logging,time,sys,os,threading
import test as db
# logging.basicConfig(level=logging.INFO,format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',datefmt='%a, %d %b %Y %H:%M:%S')
logging.basicConfig(level=logging.INFO)

class Field(object):
    #映射数据表中一个字段的属性，包括字段名称，默认值，是否主键，可空，可更新，可插入，字段类型（varchar,text,Integer之类），字段顺序
    _count=0#当前定义的字段是类的第几个字段
    def __init__(self,**kw):
        self.name = kw.get('name', None)
        self._default = kw.get('default', None)
        self.primary_key = kw.get('primary_key', False)
        self.nullable = kw.get('nullable', False)
        self.updatable = kw.get('updatable', True)
        self.insertable = kw.get('insertable', True)
        self.ddl = kw.get('ddl', '')
        self._order = Field._count
        Field._count = Field._count + 1
    @property
    def default(self):
        d = self._default
        return d() if callable(d) else d

class StringField(Field):
    #继承自Field，
    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = ''
        if not 'ddl' in kw:
            kw['ddl'] = 'varchar(255)'
        super(StringField, self).__init__(**kw)

class IntegerField(Field):

    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = 0
        if not 'ddl' in kw:
            kw['ddl'] = 'bigint'
        super(IntegerField, self).__init__(**kw)
class FloatField(Field):

    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = 0.0
        if not 'ddl' in kw:
            kw['ddl'] = 'real'
        super(FloatField, self).__init__(**kw)

class BooleanField(Field):

    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = False
        if not 'ddl' in kw:
            kw['ddl'] = 'bool'
        super(BooleanField, self).__init__(**kw)

class TextField(Field):

    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = ''
        if not 'ddl' in kw:
            kw['ddl'] = 'text'
        super(TextField, self).__init__(**kw)

class BlobField(Field):

    def __init__(self, **kw):
        if not 'default' in kw:
            kw['default'] = ''
        if not 'ddl' in kw:
            kw['ddl'] = 'blob'
        super(BlobField, self).__init__(**kw)

class VersionField(Field):

    def __init__(self, name=None):
        super(VersionField, self).__init__(name=name, default=0, ddl='bigint')

def _gen_sql(table_name, mappings):
    print(__name__+'is called'+str(time.time()))
    pk = None
    sql = ['-- generating SQL for %s:' % table_name, 'create table `%s` (' % table_name]
    for f in sorted(mappings.values(), lambda x, y: cmp(x._order, y._order)):
        if not hasattr(f, 'ddl'):
            raise StandardError('no ddl in field "%s".' % n)
        ddl = f.ddl
        nullable = f.nullable
        if f.primary_key:
            pk = f.name
        sql.append(nullable and '  `%s` %s,' % (f.name, ddl) or '  `%s` %s not null,' % (f.name, ddl))
    sql.append('  primary key(`%s`)' % pk)
    sql.append(');')
    sql='
'.join(sql)
    logging.info('sql is :'+sql)
    return sql

class ModelMetaClass(type):
    #为什么__new__方法会被调用两次
    #为什么attrs.pop(k)要进行这个，而且进行了之后u.name就可以输出yy而不是一个Field对象
    def __new__(cls,name,base,attrs):
        logging.info("cls is:"+str(cls))
        logging.info("name is:"+str(name))
        logging.info("base is:"+str(base))
        logging.info("attrs is:"+str(attrs))
        print('new is called at '+str(cls)+str(time.time()))

        if name =="Model":
            return type.__new__(cls,name,base,attrs)
        mapping=dict()
        primary_key=None
        for k,v in attrs.iteritems():
            primary_key=None
            if isinstance(v,Field):
                if not v.name:
                    v.name=k
                mapping[k]=v
                #检测是否是主键
                if v.primary_key:
                    if primary_key:
                        raise TypeError("There only should be on primary_key")
                    if v.updatable:
                        logging.warning('primary_key should not be changed')
                        v.updatable=False
                    if v.nullable:
                        logging.warning('pri.. not be.null')
                        v.nullable=False
                    primary_key=v

        for k in mapping.iterkeys():
            attrs.pop(k)

        attrs['__mappings__']=mapping
        logging.info('mapping is :'+str(mapping))
        attrs['__primary_key__']=primary_key
        attrs['__sql__']=lambda self: _gen_sql(attrs['__table__'], mapping)
        return type.__new__(cls,name,base,attrs)
class ModelMetaclass(type):
    '''
    Metaclass for model objects.
    '''
    def __new__(cls, name, bases, attrs):
        # skip base Model class:
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)

        # store all subclasses info:
        if not hasattr(cls, 'subclasses'):
            cls.subclasses = {}
        if not name in cls.subclasses:
            cls.subclasses[name] = name
        else:
            logging.warning('Redefine class: %s' % name)

        logging.info('Scan ORMapping %s...' % name)
        mappings = dict()
        primary_key = None
        for k, v in attrs.iteritems():
            if isinstance(v, Field):
                if not v.name:
                    v.name = k
                logging.info('Found mapping: %s => %s' % (k, v))
                # check duplicate primary key:
                if v.primary_key:
                    if primary_key:
                        raise TypeError('Cannot define more than 1 primary key in class: %s' % name)
                    if v.updatable:
                        logging.warning('NOTE: change primary key to non-updatable.')
                        v.updatable = False
                    if v.nullable:
                        logging.warning('NOTE: change primary key to non-nullable.')
                        v.nullable = False
                    primary_key = v
                mappings[k] = v
        # check exist of primary key:
        if not primary_key:
            raise TypeError('Primary key not defined in class: %s' % name)
        for k in mappings.iterkeys():
            attrs.pop(k)
        if not '__table__' in attrs:
            attrs['__table__'] = name.lower()
        attrs['__mappings__'] = mappings
        attrs['__primary_key__'] = primary_key
        attrs['__sql__'] = lambda self: _gen_sql(attrs['__table__'], mappings)
        # for trigger in _triggers:
        #     if not trigger in attrs:
        #         attrs[trigger] = None
        return type.__new__(cls, name, bases, attrs)
class Model(dict):
    __metaclass__ = ModelMetaClass
    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

    @classmethod
    def get(cls, pk):
        '''
        Get by primary key.
        '''
        d = db.select_one('select * from %s where %s=?' % (cls.__table__, cls.__primary_key__.name), pk)
        return cls(**d) if d else None

    @classmethod
    def find_first(cls, where, *args):
        '''
        Find by where clause and return one result. If multiple results found,
        only the first one returned. If no result found, return None.
        '''
        d = db.select_one('select * from %s %s' % (cls.__table__, where), *args)
        return cls(**d) if d else None

    @classmethod
    def find_all(cls, *args):
        '''
        Find all and return list.
        '''
        L = db.select('select * from `%s`' % cls.__table__)
        return [cls(**d) for d in L]

    @classmethod
    def find_by(cls, where, *args):
        '''
        Find by where clause and return list.
        '''
        L = db.select('select * from `%s` %s' % (cls.__table__, where), *args)
        return [cls(**d) for d in L]

    @classmethod
    def count_all(cls):
        '''
        Find by 'select count(pk) from table' and return integer.
        '''
        return db.select_int('select count(`%s`) from `%s`' % (cls.__primary_key__.name, cls.__table__))

    @classmethod
    def count_by(cls, where, *args):
        '''
        Find by 'select count(pk) from table where ... ' and return int.
        '''
        return db.select_int('select count(`%s`) from `%s` %s' % (cls.__primary_key__.name, cls.__table__, where), *args)

    def update(self):
        self.pre_update and self.pre_update()
        L = []
        args = []
        for k, v in self.__mappings__.iteritems():
            if v.updatable:
                if hasattr(self, k):
                    arg = getattr(self, k)
                else:
                    arg = v.default
                    setattr(self, k, arg)
                L.append('`%s`=?' % k)
                args.append(arg)
        pk = self.__primary_key__.name
        args.append(getattr(self, pk))
        db.update('update `%s` set %s where %s=?' % (self.__table__, ','.join(L), pk), *args)
        return self

    def delete(self):
        self.pre_delete and self.pre_delete()
        pk = self.__primary_key__.name
        args = (getattr(self, pk), )
        db.update('delete from `%s` where `%s`=?' % (self.__table__, pk), *args)
        return self

    def insert(self):
        self.pre_insert and self.pre_insert()
        params = {}
        for k, v in self.__mappings__.iteritems():
            if v.insertable:
                if not hasattr(self, k):
                    setattr(self, k, v.default)
                params[v.name] = getattr(self, k)
        db.insert('%s' % self.__table__, **params)
        return self
class user(Model):
    name=StringField(name='name',primary_key=True)
    password=StringField(name='password')

def main():
    u=user(name='yy',password='yyp')

    logging.info(u.__sql__)
    logging.info(dir(u.__mappings__.values()))
    u.password='xxx'
    print(u.password)

if __name__ == '__main__':
    main()

要注意的是遍历Model属性这部分代码，利用了Python的__metaclass__实现，截断了Model的创建过程，进而对Model的属性进行遍历，具体代码见ModelMetaclass的__new__方法实现。

这是模仿廖老师的代码，[http://liaoxuefeng.com],感谢。还有两个疑问注释在了代码中，希望有看明白的人解惑。