Python ORM封装
import sys import asyncio import logging logging.basicConfig(level=logging.INFO) # 一次使用异步 处处使用异步 import aiomysql def log(sql,args=()): logging.info('SQL:%s' %sql) @asyncio.coroutine def create_pool(loop, **kw): #这里的**kw是一个dict logging.info(' start creating database connection pool') global __pool # 理解这里的yield from 是很重要的 #dict有一个get方法，如果dict中有对应的value值，则返回对应于key的value值，否则返回默认值，例如下面的host，如果dict里面没有 #'host',则返回后面的默认值，也就是'localhost' #这里有一个关于Pool的连接，讲了一些Pool的知识点，挺不错的，点击打开链接，下面这些参数都会讲到，以及destroy__pool里面的 #wait_closed() __pool=yield from aiomysql.create_pool( host=kw.get('host','localhost'), port=kw.get('port',3306), user=kw['user'], password=kw['password'], db=kw['db'], charset=kw.get('charset','utf8'), autocommit=kw.get('autocommit',True), #默认自动提交事务，不用手动去提交事务 maxsize=kw.get('maxsize',10), minsize=kw.get('minsize',1), loop=loop ) @asyncio.coroutine def destroy_pool(): global __pool if __pool is not None : __pool.close() #关闭进程池,The method is not a coroutine,就是说close()不是一个协程，所以不用yield from yield from __pool.wait_closed() #但是wait_close()是一个协程，所以要用yield from,到底哪些函数是协程，上面Pool的链接中都有 # 我很好奇为啥不用commit 事务不用提交么？我觉得是因为上面再创建进程池的时候，有一个参数autocommit=kw.get('autocommit',True) # 意思是默认会自动提交事务 @asyncio.coroutine def select(sql, args, size=None): log(sql,args) global __pool # 666 建立游标 # -*- yield from 将会调用一个子协程，并直接返回调用的结果 # yield from从连接池中返回一个连接， 这个地方已经创建了进程池并和进程池连接了，进程池的创建被封装到了create_pool(loop, **kw) with (yield from __pool) as conn: #使用该语句的前提是已经创建了进程池，因为这句话是在函数定义里面，所以可以这样用 cur = yield from conn.cursor(aiomysql.DictCursor) #A cursor which returns results as a dictionary. yield from cur.execute(sql.replace('?', '%s'), args) if size: rs = yield from cur.fetchmany(size) #一次性返回size条查询结果，结果是一个list，里面是tuple else: rs = yield from cur.fetchall() #一次性返回所有的查询结果 yield from cur.close() #关闭游标，不用手动关闭conn，因为是在with语句里面，会自动关闭，因为是select，所以不需要提交事务(commit) logging.info('rows have returned %s' %len(rs)) return rs #返回列表查询结果，里面的元素是tuple # 封装INSERT, UPDATE, DELETE # 语句操作参数一样，所以定义一个通用的执行函数，只是操作参数一样，但是语句的格式不一样 # 返回操作影响的行号 # 我想说的是 知道影响行号有个叼用 @asyncio.coroutine def execute(sql,args, autocommit=True): log(sql) global __pool with (yield from __pool) as conn: try: # 因为execute类型sql操作返回结果只有行号，不需要dict cur = yield from conn.cursor() # 顺便说一下 后面的args 别掉了 掉了是无论如何都插入不了数据的 yield from cur.execute(sql.replace('?', '%s'), args)#把所有的问号替换成占位符 yield from conn.commit() #这里为什么还要手动提交数据 affected_line=cur.rowcount yield from cur.close() print('execute : ', affected_line) except BaseException as e: raise return affected_line # 这个函数主要是把查询字段计数 替换成sql识别的? # 比如说：insert into `User` (`password`, `email`, `name`, `id`) values (?,?,?,?) 看到了么 后面这四个问号 def create_args_string(num): lol=[] for n in range(num): lol.append('?') return (','.join(lol)) # 定义Field类，负责保存(数据库)表的字段名和字段类型 class Field(object): # 表的信息包含字段名字、类型、是否为表的主键和默认值 def __init__(self, name, column_type, primary__key, default): self.name = name self.column_type=column_type self.primary_key=primary__key self.default=default def __str__(self): # 返回 表名字 字段名 和字段类型 return "<%s , %s , %s>" %(self.__class__.__name__, self.name, self.column_type) # 定义数据库中五个存储类型 class StringField(Field): def __init__(self, name=None, primary_key=False, default=None, ddl='varchar(100)'): super().__init__(name,ddl,primary_key,default) # 布尔类型不可以作为主键 class BooleanField(Field): def __init__(self, name=None, default=False): super().__init__(name,'Boolean',False, default) # 不知道这个column type是否可以自己定义 先自己定义看一下 class IntegerField(Field): def __init__(self, name=None, primary_key=False, default=0): super().__init__(name, 'int', primary_key, default) class FloatField(Field): def __init__(self, name=None, primary_key=False,default=0.0): super().__init__(name, 'float', primary_key, default) class TextField(Field): def __init__(self, name=None, default=None): super().__init__(name,'text',False, default) # class Model(dict,metaclass=ModelMetaclass): # -*-定义Model的元类 # 所有的元类都继承自type # ModelMetaclass元类定义了所有Model基类(继承ModelMetaclass)的子类实现的操作 # -*-ModelMetaclass的工作主要是为一个数据库表映射成一个封装的类做准备： # ***读取具体子类(user)的映射信息 # 创造类的时候，排除对Model类的修改 # 在当前类中查找所有的类属性(attrs)，如果找到Field属性，就将其保存到__mappings__的dict中，同时从类属性中删除Field(防止实例属性遮住类的同名属性) # 将数据库表名保存到__table__中 # 完成这些工作就可以在Model中定义各种数据库的操作方法 # metaclass是类的模板，所以必须从`type`类型派生： class ModelMetaclass(type): # __new__控制__init__的执行，所以在其执行之前 # cls:代表要__init__的类，此参数在实例化时由Python解释器自动提供(例如下文的User和Model) # name:类名 # bases：代表继承父类的集合 # attrs：类的方法及属性的集合 def __new__(cls, name, bases, attrs): # 如果类名是Model,不做修改直接返回.排除model 是因为要排除对model类的修改 if name=='Model': return type.__new__(cls, name, bases, attrs) # 获取table名称 为啥获取table名称 至于在哪里我也是不明白握草 table_name=attrs.get('__table__', None) or name #r如果存在表名，则返回表名，否则返回 name logging.info('found table: %s (table: %s) ' %(name,table_name )) # 获取Field所有主键名和Field mappings=dict() fields=[] #field保存的是除主键外的属性名 primaryKey=None # 这个k是表示字段名 for k, v in attrs.items(): if isinstance(v, Field):#判断v是否是Field的实例 logging.info('Found mapping %s===>%s' %(k, v)) # 注意mapping的用法 mappings[k] = v if v.primary_key: logging.info('fond primary key %s'%k) # 这里很有意思 当第一次主键存在primaryKey被赋值 后来如果再出现主键的话就会引发错误 if primaryKey: raise RuntimeError('Duplicated key for field') #一个表只能有一个主键，当再出现一个主键的时候就报错 primaryKey=k # 也就是说主键只能被设置一次 else: fields.append(k) if not primaryKey: #如果主键不存在也将会报错，在这个表中没有找到主键，一个表只能有一个主键，而且必须有一个主键 raise RuntimeError('Primary key not found!') # w下面位字段从类属性中删除Field 属性 for k in mappings.keys(): attrs.pop(k) # 保存除主键外的属性为''列表形式 # 将除主键外的其他属性变成`id`, `name`这种形式，关于反引号``的用法，可以参考点击打开链接 escaped_fields=list(map(lambda f:'`%s`' %f, fields)) # 保存属性和列的映射关系 attrs['__mappings__']=mappings # 保存表名 attrs['__table__']=table_name #这里的tablename并没有转换成反引号的形式 # 保存主键名称 attrs['__primary_key__']=primaryKey # 保存主键外的属性名 attrs['__fields__']=fields # 构造默认的增删改查 语句 attrs['__select__']='select `%s`, %s from `%s` '%(primaryKey,', '.join(escaped_fields), table_name) attrs['__insert__'] = 'insert into `%s` (%s, `%s`) values (%s) ' %(table_name, ', '.join(escaped_fields), primaryKey, create_args_string(len(escaped_fields)+1)) attrs['__update__']='update `%s` set %s where `%s` = ?' % (table_name, ', '.join(map(lambda f:'`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey) attrs['__delete__']='delete from `%s` where `%s`=?' %(table_name, primaryKey) return type.__new__(cls, name, bases, attrs) # 定义ORM所有映射的基类：Model # Model类的任意子类可以映射一个数据库表 # Model类可以看作是对所有数据库表操作的基本定义的映射 # 基于字典查询形式 # Model从dict继承，拥有字典的所有功能，同时实现特殊方法__getattr__和__setattr__，能够实现属性操作 # 实现数据库操作的所有方法，定义为class方法，所有继承自Model都具有数据库操作方法 class Model(dict,metaclass=ModelMetaclass): def __init__(self, **kw): #感觉这里去掉__init__的声明也是代码结果是没影响的 super(Model,self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError("'Model' object have no attribution: %s"% key) def __setattr__(self, key, value): self[key] =value def getValue(self, key): # 这个是默认内置函数实现的,如果没有key则返回None return getattr(self, key, None) def getValueOrDefault(self, key): value=getattr(self, key , None) if value is None: field = self.__mappings__[key] if field.default is not None: #callable方法用来检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用, 如果不可被调用,则value=field.default value = field.default() if callable(field.default) else field.default logging.info('using default value for %s : %s ' % (key, str(value))) setattr(self, key, value) return value @classmethod # 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 @asyncio.coroutine def find_all(cls, where=None, args=None, **kw): sql = [cls.__select__] if where: sql.append('where') sql.append(where) if args is None: args = [] orderBy = kw.get('orderBy', None) if orderBy: sql.append('order by') sql.append(orderBy) # dict 提供get方法 指定放不存在时候返回后学的东西 比如a.get('Fuck',None) limit = kw.get('limit', None) if limit is not None: sql.append('limit') if isinstance(limit, int): sql.append('?') args.append(limit) elif isinstance(limit, tuple) and len(limit) ==2: sql.append('?,?') args.extend(limit) else: raise ValueError('Invalid limit value : %s ' % str(limit)) rs = yield from select(' '.join(sql),args) #返回的rs是一个元素是tuple的list return [cls(**r) for r in rs] # **r 是关键字参数，构成了一个cls类的列表，其实就是每一条记录对应的类实例 @classmethod @asyncio.coroutine def findNumber(cls, selectField, where=None, args=None): '''find number by select and where.''' sql = ['select %s __num__ from `%s`' %(selectField, cls.__table__)] if where: sql.append('where') sql.append(where) rs = yield from select(' '.join(sql), args, 1) if len(rs) == 0: return None return rs[0]['__num__'] @classmethod @asyncio.coroutine def find(cls, primarykey): '''find object by primary key''' #rs是一个list，里面是一个dict rs = yield from select('%s where `%s`=?' %(cls.__select__, cls.__primary_key__), [primarykey], 1) if len(rs) == 0: return None return cls(**rs[0]) #返回一条记录，以dict的形式返回，因为cls的夫类继承了dict类 @classmethod @asyncio.coroutine def findAll(cls, **kw): rs = [] if len(kw) == 0: rs = yield from select(cls.__select__, None) else: args=[] values=[] for k, v in kw.items(): args.append('%s=?' % k ) values.append(v) print('%s where %s ' % (cls.__select__, ' and '.join(args)), values)#若不理解请查看join()函数 rs = yield from select('%s where %s ' % (cls.__select__, ' and '.join(args)), values) return rs @asyncio.coroutine def save(self): args = list(map(self.getValueOrDefault, self.__fields__)) print('save:%s' % args) args.append(self.getValueOrDefault(self.__primary_key__)) rows = yield from execute(self.__insert__, args) if rows != 1: print(self.__insert__) logging.warning('failed to insert record: affected rows: %s' %rows) @asyncio.coroutine def update(self): #修改数据库中已经存入的数据 args = list(map(self.getValue, self.__fields__)) #获得的value是User2实例的属性值，也就是传入的name，email，password值 args.append(self.getValue(self.__primary_key__)) rows = yield from execute(self.__update__, args) if rows != 1: logging.warning('failed to update record: affected rows: %s'%rows) @asyncio.coroutine def delete(self): args = [self.getValue(self.__primary_key__)] rows = yield from execute(self.__delete__, args) if rows != 1: logging.warning('failed to delete by primary key: affected rows: %s' %rows) if __name__=="__main__":#一个类自带前后都有双下划线的方法，在子类继承该类的时候，这些方法会自动调用，比如__init__ class User2(Model): #虽然User类乍看没有参数传入，但实际上，User类继承Model类，Model类又继承dict类，所以User类的实例可以传入关键字参数 id = IntegerField('id',primary_key=True) #主键为id， tablename为User，即类名 name = StringField('name') email = StringField('email') password = StringField('password') #创建异步事件的句柄 loop = asyncio.get_event_loop() #创建实例 @asyncio.coroutine def test(): yield from create_pool(loop=loop, host='localhost', port=3306, user='root', password='Limin123?', db='test') #user = User2(id=2, name='Tom', email='slysly759@gmail.com', password='12345') r = yield from User2.findAll() print(r) #yield from user.save() #ield from user.update() #yield from user.delete() # r = yield from User2.find(8) # print(r) # r = yield from User2.findAll() # print(1, r) # r = yield from User2.findAll(name='sly') # print(2, r) yield from destroy_pool() #关闭pool loop.run_until_complete(test()) loop.close() if loop.is_closed(): sys.exit(0)
拆解
class Field(object): def __init__(self,name,column_type,primary_key,default): self.name = name self.column_type = column_type self.primary_key = primary_key self.default = default #print(self,name,column_type,primary_key,default) def __str__(self): return '<%s,%s,%s>' %(self.__class__.__name__,self.column_type,self.name) class StringField(Field): def __init__(self,name=None,primary_key=False,default=None,ddl='varchar(100)'): super().__init__(name,ddl,primary_key,default) #print(self,name,ddl,primary_key,default) def create_args_string(num): lol=[] for n in range(num): lol.append('?') return (','.join(lol)) # 元类,创建一个新的类,然后返回 class ModelMetaclass(type): def __new__(cls,name,bases,attrs): #print(bases,'\n') if name == 'Model': return type.__new__(cls,name,bases,attrs) tableName = attrs.get('__table__',None) or name mappings = dict() fields = [] primaryKey = None #print(attrs) for k,v in attrs.items(): if isinstance(v,Field): mappings[k] = v if v.primary_key: if primaryKey: raise RuntimeError('key aready exist') primaryKey = k else: fields.append(k) #print(fields) print(mappings) if not primaryKey: raise RuntimeError('Primary key not found!') for k in mappings.keys(): attrs.pop(k) escaped_fields = list(map(lambda f: '`%s`' % f, fields)) print(escaped_fields,fields) attrs['__mappings__'] = mappings # 保存属性和列的映射关系 attrs['__table__'] = tableName attrs['__primary_key__']=primaryKey attrs['__fields__']=fields attrs['__select__']='select `%s`, %s from `%s`' %(primaryKey,', '.join(escaped_fields),tableName) attrs['__insert__']='insert into `%s` (%s) values (%s)' %(tableName,', '.join(escaped_fields),create_args_string(len(escaped_fields))) attrs['__update__']='update `%s` set %s where `%s` = ?' % (tableName, ', '.join(map(lambda f:'`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey) print(mappings.get('name').default) return type.__new__(cls, name, bases, attrs) class Model(dict,metaclass=ModelMetaclass): __metaclass__ = ModelMetaclass def __init__(self,**kw): super(Model,self).__init__(**kw) #super().__init__(**kw) def __getattr__(self,key): try: return self[key] except KeyError: raise AttributeError("'%s' instatnce has no attribute '%s'" %(self.__class__.__name__,key)) def __setattr__(self,key,value): self[key] = value def getValue(self,key): return getattr(self,key,None) def getValueOrDefault(self, key): value = getattr(self,key,None) if value is None: field = self.__mappings__[key] if field.default is not None: value = field.default() if callable(field.default) else field.default setattr(self, key, value) return value @classmethod def filter(cls,where='',**kwargs): sql = 'select * from %s %s' %(cls.__table__,'where %s' %where if where else '') print(sql) def findAll(cls, **kw): rs = [] if len(kw) == 0: #rs = yield from select(cls.__select__, None) print(kw) else: args=[] values=[] for k, v in kw.items(): #args.append('%s=?' % k ) args.append('%s=%s' % (k,v) ) values.append(v) #print(args, values) print('%s where %s ' % (cls.__select__, ' and '.join(args))) print('%s where %s ' % (cls.__select__, ' and '.join(args)), values) #rs = yield from select('%s where %s ' % (cls.__select__, ' and '.join(args)), values) rs = '%s where %s ' % (cls.__select__, ' and '.join(args)) return rs def save(self): args = list(map(self.getValueOrDefault,self.__fields__)) print(self.__fields__) print('save:%s' % args) #args.append(self.getValueOrDefault(self.__primary_key__)) sql = self.__insert__ print(sql.replace('?','%s'),args) if __name__ == '__main__': class User(Model): __table__ = 'users' __database__ = 'test3' id = StringField('id',primary_key=True,ddl='varchar(50)') passwd = StringField('passwd',ddl='varchar(50)',default='pwd123') name = StringField('name',ddl='varchar(50)',default='lin') u = User(passwd='123',name='linyouyi') #u.filter(where='name="lin" passwd=123') #u.findAll(name='lin',passwd='123') u.save()
