Day3：编写ORM（第一次接触，有些复杂）
首先我们看一下ORM是什么意思
对象关系映射（英语：(Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换 。从效果上说，它其实是创建了一个可在编程语言里使用的–“虚拟对象数据库”。映射这个词用在这里非常恰当，ORM就是我们在程序代码中所操作的对象和数据库中的数据之间的一种映射关系，有了这个映射关系，我们再操作对象就相当于操作数据库。这样的特点和Java中的DAO层（数据访问层）可以说非常的相似。
访问数据库的过程为：创建数据库的连接、游标对象； 执行SQL语句； 处理异常。我们在ORM中要将SELECT, INSERT, UPDATE和DELETE这些常用操作以函数的形式封装起来。封装之后的理想状态大概是这样的
# 创建实例:
user = User(id=123, name='Michael')
# 存入数据库:
user.insert()
# 查询所有User对象:
users = User.findAll()代码很简洁，那么在封装的背后程序做了什么呢？简单来说就是：收集数据；对这些数据进行分类，识别(相对应数据库)，生成SQL语句；最后，连接数据库，并执行SQL语句进行操作。
由于我们在Web方面采用了异步的aiohttp，因此在数据操作模块中我们也要使用异步操作模式，aiomysql为MySql提供了异步操作驱动。
话不多说，下面是ORM模块的具体代码：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import asyncio, logging
import aiomysql
def log(sql, args=()): #将我们所需要了解的信息打印到log中，便于调试
logging.info('SQL: %s' % sql)
# 创建连接池,每个http请求都从连接池连接到数据库
# 使用连接池的好处是不必频繁地打开和关闭数据库连接，而是能复用就尽量复用。
# 连接池由全局变量__pool存储，缺省情况下将编码设置为utf8，自动提交事务
async def create_pool(loop, **kw):
logging.info('create database connection pool...')
global __pool
__pool = await 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
)
# 销毁连接池
async def destory_pool():
global __pool
if __pool is not None:
__pool.close()
await __pool.wait_closed()
# select语句
# SQL语句的占位符是?，而MySQL的占位符是%s，select()函数在内部自动替换。注意要始终坚持使用带参数的SQL，而不是自己拼接SQL字符串，这样可以防止SQL注入攻击。
# 使用Cursor对象执行select语句时，通过featchall()可以拿到结果集。如果传入size，则拿到指定数量的结果集。结果集是一个list，每个元素都是一个tuple，对应一行记录。
async def select(sql, args, size=None):
log(sql, args)
global __pool
async with __pool.get() as conn:
async with conn.cursor(aiomysql.DictCursor) as cur:
await cur.execute(sql.replace('?', '%s'), args or ())
if size:
rs = await cur.fetchmany(size)
else:
rs = await cur.fetchall()
logging.info('rows returned: %s' % len(rs))
return rs
# insert,update,deleta语句
# 使用Cursor对象执行insert，update，delete语句时，执行结果由rowcount返回影响的行数，就可以拿到执行结果
async def execute(sql, args, autocommit=True):
log(sql)
async with __pool.get() as conn:
if not autocommit:
await conn.begin()
try:
async with conn.cursor(aiomysql.DictCursor) as cur:
await cur.execute(sql.replace('?', '%s'), args)
affected = cur.rowcount
if not autocommit:
await conn.commit()
except BaseException as e:
if not autocommit:
await conn.rollback()
raise
finally:
conn.close()
return affected
# 用于输出**元类**中创建sql_insert语句中的占位符
def create_args_string(num):
l = []
for n in range(num):
l.append('?')
return ', '.join(l)
# 定义Field类，负责保存(数据库)表的字段名和字段类型
class Field(object):
def __init__(self, name, colunm_type, primary_key, default):
self.name = name
self.colunm_type = colunm_type
self.primary_key = primary_key
self.default = default
def __str__(self):
return '<%s, %s, %s>' % (self.__class__.__name__, self.colunm_type, self.name)
# 以下每一种Field分别代表数据库中一同不同的数据属性
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)
class IntegerField(Field):
def __init__(self, name=None, primary_key=False, default=0):
super().__init__(name, 'bigint', primary_key, default)
class FloatField(Field):
def __init__(self, name=None, primary_key=False, default=0.0):
super().__init__(name, 'real', primary_key, default)
class TextField(Field):
def __init__(self, name=None, default=None):
super().__init__(name, 'text', False, default)
#定义元类，控制Model对象的创建
class ModelMetaclass(type):
# 调用__init__方法前会调用__new__方法
# 1.当前准备创建的类的对象 2.类的名字 3.类继承的父类集合 4.类的方法集合
def __new__(cls, name, bases, attrs):
if name == 'Model': #排除掉对Model类（基类）的修改
return type.__new__(cls, name, bases, attrs)
# 如果没设置__table__属性，tablename就是类的名字
tableName = attrs.get('__table__', None) or name
logging.info('found model: %s (table: %s)' % (name, tableName))
mappings = {} #保存映射关系
fields = [] #保存除主键外的属性
primarykey = None
# 键是列名，值是field子类
for k, v in attrs.items():
if isinstance(v, Field):
logging.info(' found mapping: %s ==> %s' % (k, v))
# 把键值对存入mapping字典中
mappings[k] = v
if v.primary_key:
#找到主键
if primarykey:
raise Exception('Duplicate primary key for field: %s' % k)
primarykey = k #此列设为列表的主键
else:
fields.append(k) #保存除主键外的属性
if not primarykey:
raise Exception('Primary key not found.')
# 删除类属性
for k in mappings.keys():
attrs.pop(k) #从类属性中删除Field属性,否则，容易造成运行时错误（实例的属性会遮盖类的同名属性）
# 保存除主键外的属性名为``（运算出字符串）列表形式
escaped_fields = list(map(lambda f: '`%s`' % f, fields))
attrs['__mappings__'] = mappings # 保存属性和列的映射关系
attrs['__table__'] = tableName # 表的名字
attrs['__primary_key__'] = primarykey # 主键属性名
attrs['__fields__'] = fields # 除主键外的属性名
# 反引号和repr()函数功能一致
attrs['__select__'] = 'select `%s`, %s from `%s`' % (primarykey, ', '.join(escaped_fields), tableName)
attrs['__insert__'] = 'insert into `%s` (%s, `%s`) values (%s)' % (
tableName, ', '.join(escaped_fields), primarykey, create_args_string(len(escaped_fields) + 1))
attrs['__update__'] = 'update `%s` set %s where `%s`=?' % (
tableName, ', '.join(map(lambda f: '`%s`=?' % (mappings.get(f).name or f), fields)), primarykey)
attrs['__delete__'] = 'delete from `%s` where `%s`=?' % (tableName, primarykey)
return type.__new__(cls, name, bases, attrs)
***基类***Model
class Model(dict, metaclass=ModelMetaclass): #在参数处即指定了所依赖的元类
#也可在此处写 __metaclass__ = ModelMetaclass，与参数处效果相同
def __init__(self, **kw):
super().__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Model' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
def getValue(self, key):
#返回对象的属性,如果没有对应属性则会调用__getattr__
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
logging.debug('using default value for %s: %s' % (key, str(value)))
# 把默认属性设置进去
setattr(self, key, value)
return value
# 类方法的第一个参数是cls,而实例方法的第一个参数是self
@classmethod
@asyncio.coroutine
def findAll(cls, where=None, args=None, **kw):
' find objects by where clause. '
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)
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)
return [cls(**r) for r in rs]
@classmethod
@asyncio.coroutine
def findNumber(cls, selectedField, where=None, args=None):
' find number by select and where. '
# 将列名重命名为_num_
sql = ['select %s _num_ from `%s`' % (selectedField, cls.__table__)]
if where:
sql.append('where')
sql.append(where)
# 限制结果数量为1
rs = yield from select(' '.join(sql), args, 1)
if len(rs) == 0:
return None
return rs[0]['_num_']
@classmethod
async def find(cls, pk):
' find object by primary key. '
rs = await select('%s where `%s`=?' % (cls.__select__, cls.__primary_key__), [pk], 1)
if len(rs) == 0:
return None
return cls(**rs[0])
@asyncio.coroutine
def save(self):
args = list(map(self.getValueOrDefault, self.__fields__))
args.append(self.getValueOrDefault(self.__primary_key__))
rows = yield from execute(self.__insert__, args)
if rows != 1:
logging.warn('failed to insert record: affected rows: %s' % rows)
@asyncio.coroutine
def update(self):
args = list(map(self.getValue, self.__fields__))
args.append(self.getValue(self.__primary_key__))
rows = yield from execute(self.__update__, args)
if rows != 1:
logging.warn('failed to update by primary key: affected rows: %s' % rows)
@asyncio.coroutine
def remove(self):
args = [self.getValue(self.__primary_key__)]
rows = yield from execute(self.__delete__, args)
if rows != 1:
logging.warn('failed to remove by primary key: affected rows: %s' % rows)要实现上文中理想状态的封装，需要User类负责收集数据，并尝试归类出这些数据对应数据库表的映射关系，类如对应表的字段（包含名字、类型、是否为表的主键、默认值）等；
它的基类负责执行操作，比如数据库的存储、读取，查找等操作；
它的元类负责分类、整理收集的数据并以此创建一些类属性(如SQL语句)供基类作为参数。
ORM的编写较为复杂，但编写完成后使用接口进行调用则显得非常简单。并且ORM编写模式基本为
-Field模块
-元类MetaClass
-基类Model
有着较为固定的写法，所以我们也没必要重复造轮子，能复用尽量复用。重要的是要理解元类这块硬骨头的妙用。