2. Day 3 - 编写ORM
    4. 阅读: 221299
    5. 在一个Web App中，所有数据，包括用户信息、发布的日志、评论等，都存储在数据库中。在awesome-python3-webapp中，我们选择MySQL作为数据库。
    7. Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象，然后执行SQL语句，最后处理异常，清理资源。这些访问数据库的代码如果分散到各个函数中，势必无法维护，也不利于代码复用。
    9. 所以，我们要首先把常用的SELECT、INSERT、UPDATE和DELETE操作用函数封装起来。
    11. 由于Web框架使用了基于asyncio的aiohttp，这是基于协程的异步模型。在协程中，不能调用普通的同步IO操作，因为所有用户都是由一个线程服务的，协程的执行速度必须非常快，才能处理大量用户的请求。而耗时的IO操作不能在协程中以同步的方式调用，否则，等待一个IO操作时，系统无法响应任何其他用户。
    13. 这就是异步编程的一个原则：一旦决定使用异步，则系统每一层都必须是异步，“开弓没有回头箭”。
    15. 幸运的是aiomysql为MySQL数据库提供了异步IO的驱动。
    17. 创建连接池
    19. 我们需要创建一个全局的连接池，每个HTTP请求都可以从连接池中直接获取数据库连接。使用连接池的好处是不必频繁地打开和关闭数据库连接，而是能复用就尽量复用。
    21. 连接池由全局变量__pool存储，缺省情况下将编码设置为utf8，自动提交事务：
    23. @asyncio.coroutine
    24. def create_pool(loop, **kw):
    25.     logging.info('create database connection pool...')
    26.     global __pool
    27.     __pool = yield from aiomysql.create_pool(
    28.         host=kw.get('host', 'localhost'),
    29.         port=kw.get('port', 3306),
    30.         user=kw['user'],
    31.         password=kw['password'],
    32.         db=kw['db'],
    33.         charset=kw.get('charset', 'utf8'),
    34.         autocommit=kw.get('autocommit', True),
    35.         maxsize=kw.get('maxsize', 10),
    36.         minsize=kw.get('minsize', 1),
    37.         loop=loop
    38.     )
    39. Select
    41. 要执行SELECT语句，我们用select函数执行，需要传入SQL语句和SQL参数：
    43. @asyncio.coroutine
    44. def select(sql, args, size=None):
    45.     log(sql, args)
    46.     global __pool
    47.     with (yield from __pool) as conn:
    48.         cur = yield from conn.cursor(aiomysql.DictCursor)
    49.         yield from cur.execute(sql.replace('?', '%s'), args or ())
    50.         if size:
    51.             rs = yield from cur.fetchmany(size)
    52.         else:
    53.             rs = yield from cur.fetchall()
    54.         yield from cur.close()
    55.         logging.info('rows returned: %s' % len(rs))
    56.         return rs
    57. SQL语句的占位符是?，而MySQL的占位符是%s，select()函数在内部自动替换。注意要始终坚持使用带参数的SQL，而不是自己拼接SQL字符串，这样可以防止SQL注入攻击。
    59. 注意到yield from将调用一个子协程（也就是在一个协程中调用另一个协程）并直接获得子协程的返回结果。
    61. 如果传入size参数，就通过fetchmany()获取最多指定数量的记录，否则，通过fetchall()获取所有记录。
    63. Insert, Update, Delete
    65. 要执行INSERT、UPDATE、DELETE语句，可以定义一个通用的execute()函数，因为这3种SQL的执行都需要相同的参数，以及返回一个整数表示影响的行数：
    67. @asyncio.coroutine
    68. def execute(sql, args):
    69.     log(sql)
    70.     with (yield from __pool) as conn:
    71.         try:
    72.             cur = yield from conn.cursor()
    73.             yield from cur.execute(sql.replace('?', '%s'), args)
    74.             affected = cur.rowcount
    75.             yield from cur.close()
    76.         except BaseException as e:
    77.             raise
    78.         return affected
    79. execute()函数和select()函数所不同的是，cursor对象不返回结果集，而是通过rowcount返回结果数。
    81. ORM
    83. 有了基本的select()和execute()函数，我们就可以开始编写一个简单的ORM了。
    85. 设计ORM需要从上层调用者角度来设计。
    87. 我们先考虑如何定义一个User对象，然后把数据库表users和它关联起来。
    89. from orm import Model, StringField, IntegerField
    91. class User(Model):
    92.     __table__ = 'users'
    94.     id = IntegerField(primary_key=True)
    95.     name = StringField()
    96. 注意到定义在User类中的__table__、id和name是类的属性，不是实例的属性。所以，在类级别上定义的属性用来描述User对象和表的映射关系，而实例属性必须通过__init__()方法去初始化，所以两者互不干扰：
    98. # 创建实例:
    99. user = User(id=123, name='Michael')
    100. # 存入数据库:
    101. user.insert()
    102. # 查询所有User对象:
    103. users = User.findAll()
    104. 定义Model
    106. 首先要定义的是所有ORM映射的基类Model：
    108. class Model(dict, metaclass=ModelMetaclass):
    110.     def __init__(self, **kw):
    111.         super(Model, self).__init__(**kw)
    113.     def __getattr__(self, key):
    114.         try:
    115.             return self[key]
    116.         except KeyError:
    117.             raise AttributeError(r"'Model' object has no attribute '%s'" % key)
    119.     def __setattr__(self, key, value):
    120.         self[key] = value
    122.     def getValue(self, key):
    123.         return getattr(self, key, None)
    125.     def getValueOrDefault(self, key):
    126.         value = getattr(self, key, None)
    127.         if value is None:
    128.             field = self.__mappings__[key]
    129.             if field.default is not None:
    130.                 value = field.default() if callable(field.default) else field.default
    131.                 logging.debug('using default value for %s: %s' % (key, str(value)))
    132.                 setattr(self, key, value)
    133.         return value
    134. Model从dict继承，所以具备所有dict的功能，同时又实现了特殊方法__getattr__()和__setattr__()，因此又可以像引用普通字段那样写：
    136. >>> user['id']
    137. 123
    138. >>> user.id
    139. 123
    140. 以及Field和各种Field子类：
    142. class Field(object):
    144.     def __init__(self, name, column_type, primary_key, default):
    145.         self.name = name
    146.         self.column_type = column_type
    147.         self.primary_key = primary_key
    148.         self.default = default
    150.     def __str__(self):
    151.         return '<%s, %s:%s>' % (self.__class__.__name__, self.column_type, self.name)
    152. 映射varchar的StringField：
    154. class StringField(Field):
    156.     def __init__(self, name=None, primary_key=False, default=None, ddl='varchar(100)'):
    157.         super().__init__(name, ddl, primary_key, default)
    158. 注意到Model只是一个基类，如何将具体的子类如User的映射信息读取出来呢？答案就是通过metaclass：ModelMetaclass：
    160. class ModelMetaclass(type):
    162.     def __new__(cls, name, bases, attrs):
    163.         # 排除Model类本身:
    164.         if name=='Model':
    165.             return type.__new__(cls, name, bases, attrs)
    166.         # 获取table名称:
    167.         tableName = attrs.get('__table__', None) or name
    168.         logging.info('found model: %s (table: %s)' % (name, tableName))
    169.         # 获取所有的Field和主键名:
    170.         mappings = dict()
    171.         fields = []
    172.         primaryKey = None
    173.         for k, v in attrs.items():
    174.             if isinstance(v, Field):
    175.                 logging.info('  found mapping: %s ==> %s' % (k, v))
    176.                 mappings[k] = v
    177.                 if v.primary_key:
    178.                     # 找到主键:
    179.                     if primaryKey:
    180.                         raise RuntimeError('Duplicate primary key for field: %s' % k)
    181.                     primaryKey = k
    182.                 else:
    183.                     fields.append(k)
    184.         if not primaryKey:
    185.             raise RuntimeError('Primary key not found.')
    186.         for k in mappings.keys():
    187.             attrs.pop(k)
    188.         escaped_fields = list(map(lambda f: '`%s`' % f, fields))
    189.         attrs['__mappings__'] = mappings # 保存属性和列的映射关系
    190.         attrs['__table__'] = tableName
    191.         attrs['__primary_key__'] = primaryKey # 主键属性名
    192.         attrs['__fields__'] = fields # 除主键外的属性名
    193.         # 构造默认的SELECT, INSERT, UPDATE和DELETE语句:
    194.         attrs['__select__'] = 'select `%s`, %s from `%s`' % (primaryKey, ', '.join(escaped_fields), tableName)
    195.         attrs['__insert__'] = 'insert into `%s` (%s, `%s`) values (%s)' % (tableName, ', '.join(escaped_fields), primaryKey, create_args_string(len(escaped_fields) + 1))
    196.         attrs['__update__'] = 'update `%s` set %s where `%s`=?' % (tableName, ', '.join(map(lambda f: '`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey)
    197.         attrs['__delete__'] = 'delete from `%s` where `%s`=?' % (tableName, primaryKey)
    198.         return type.__new__(cls, name, bases, attrs)
    199. 这样，任何继承自Model的类（比如User），会自动通过ModelMetaclass扫描映射关系，并存储到自身的类属性如__table__、__mappings__中。
    201. 然后，我们往Model类添加class方法，就可以让所有子类调用class方法：
    203. class Model(dict):
    205.     ...
    207.     @classmethod
    208.     @asyncio.coroutine
    209.     def find(cls, pk):
    210.         ' find object by primary key. '
    211.         rs = yield from select('%s where `%s`=?' % (cls.__select__, cls.__primary_key__), [pk], 1)
    212.         if len(rs) == 0:
    213.             return None
    214.         return cls(**rs[0])
    215. User类现在就可以通过类方法实现主键查找：
    217. user = yield from User.find('123')
    218. 往Model类添加实例方法，就可以让所有子类调用实例方法：
    220. class Model(dict):
    222.     ...
    224.     @asyncio.coroutine
    225.     def save(self):
    226.         args = list(map(self.getValueOrDefault, self.__fields__))
    227.         args.append(self.getValueOrDefault(self.__primary_key__))
    228.         rows = yield from execute(self.__insert__, args)
    229.         if rows != 1:
    230.             logging.warn('failed to insert record: affected rows: %s' % rows)
    231. 这样，就可以把一个User实例存入数据库：
    233. user = User(id=123, name='Michael')
    234. yield from user.save()
    235. 最后一步是完善ORM，对于查找，我们可以实现以下方法：
    237. findAll() - 根据WHERE条件查找；
    239. findNumber() - 根据WHERE条件查找，但返回的是整数，适用于select count(*)类型的SQL。
    241. 以及update()和remove()方法。
    243. 所有这些方法都必须用@asyncio.coroutine装饰，变成一个协程。
    245. 调用时需要特别注意：
    247. user.save()
    248. 没有任何效果，因为调用save()仅仅是创建了一个协程，并没有执行它。一定要用：
    250. yield from user.save()
    251. 才真正执行了INSERT操作。
    253. 最后看看我们实现的ORM模块一共多少行代码？累计不到300多行。用Python写一个ORM是不是很容易呢？
    255. 参考源码
    257. day-03