TOC
Intro
lazy_mysql 是一个非常简单易用，用来操作 MySQL 的 Python 第三方库。它基于 MySQL-python 之上提供了四个常用对象，分别是：
- Engine : 负责连接数据库，执行 SQL 语句。
- Pool : 数据库连接池，负责管理 Engine 对象。
- Table : 该对象映射到数据表。
- Column : 该对象映射到数据表字段。
Dependencies
- Python 2.6 - 2.7
- MySQLdb-python 1.2.3+
Installation
从 GitHub 下载。
git clone https://github.com/hendiko/lazy_mysql.git
或者直接下载 lazy_mysql.py 文件，将 lazy_mysql.py 文件放到项目中任意可导入目录均可。
Tutorial
1. 建立数据库连接
使用 Engine 对象连接数据库。
from lazy_mysql import Engine, Pool, Table, Column
engine = Engine('localhost', 'test', 'root', 'root')
如果要应付多线程多并发连接，可使用 Pool 对象来管理数据库连接，Pool 的作用是提供一个连接池，用以管理多个 Engine 对象。
pool = Pool('localhost', 'test', 'root', 'root', pool_size=4, extras=4)
2. 建立 Table 类
新建一个 Table 对象来映射数据表，只需要新建一个类继承自 Table 类。
class Schedule(Table):
def __init__(self, table_name='schedule', _engine=engine, *columns):
super(Schedule, self).__init__(table_name, _engine, *columns)
self.schedule_id = Column('scheduleId')
self.task_id = Column('taskId')
self.task_name = Column('taskName')
self.status = Column('status')
_engine 参数可以接收一个 Engine 或 Pool 实例对象。
在初始化中定义数据表字段，你可以只初始化部分字段而非全部字段，Column 对象代表一个字段对象，实例化一个 Column 字段仅需要传入一个字段名称，Column 对象不会检查字段类型及合法性。
3. Select 操作
# 实例化一个数据表对象。
s = Schedule()
# SELECT * FROM schedule LIMIT 1;
s.select().go()
# SELECT * FROM schedule;
s.select().limit().go()
# SELECT taskName, status FROM schedule WHERE (taskId=1) LIMIT 1;
s.select(s.task_name, s.status).where(schedule.task_id == 1).go()
# SELECT DISTINCT taskName FROM schedule WHERE (scheduleId=1) GROUP BY taskName ORDER BY taskId DESC LIMIT 1, 4;
s.select(s.task_name).where(s.schedule_id == 1).distinct().order(s.task_id, desc=True).group_by(s.task_name).limit(1, 4).go()
# SELECT * FROM schedule WHERE (scheduleId=1 AND taskId=2) OR (taskId=2) AND (taskName='query') LIMIT 1;
s.select().where(s.schedule_id == 1, s.task_id == 3).where(s.task_id == 2).where_and(s.task_name == "query").go()
4. Insert 操作
# INSERT INTO schedule SET taskName='query';
s.insert(**{s.task_name.name: 'query'}).go()
# 或者
s.insert(taskName="query").go()
5. Update 操作
# UPDATE schedule SET taskName='query2' WHERE (scheduleId=5) LIMIT 1;
s.update(**{s.task_name.name: "query2"}).where(s.schedule_id == 5).go()
# 或者
s.update(taskName="query2").where(s.schedule_id == 5).go()
6. Delete 操作
# DELETE FROM schedule WHERE (scheduleId=5) LIMIT 1;
s.delete().where(s.schedule_id == 5).go()
7. Count 操作
# SELECT COUNT(DISTINCT scheduleId) AS X FROM schedule WHERE (scheduleId>2) LIMIT 1;
s.count(s.schedule_id, distinct=True).where(s.schedule_id > 2).go()
API
1. Engine
Engine 对象负责数据库连接，执行 SQL 语句。
1.1. _init_(self, host, schema, user, pw, port=3306, charset='utf8', cursor_class='dict', autocommit=True, debug=True, *args, **kwargs):
- host: 数据库主机
- schema: 数据库名称。
- user: 用户名。
- pw: 密码。
- port: 端口。
- charset: 字符集。
- cursor_class: 游标类型，默认值为 'dict'，其他均返回 tuple 类型的结果集。
- autocommit: 自动提交。
- debug: 调试模式，若为真，则打印 SQL 语句。
- args: 其他 MySQLdb.connect() 参数。
- kwargs: 其他 MySQLdb.connect() 参数。
1.2. affected_rows
执行 SQL 语句影响的数据表行数。
1.3. last_executed
最后一次成功执行的 SQL 语句。
1.4. cursor_class
数据库连接游标类型。如果 cursor_class='dict'，则使用 DictCursor，否则使用 Cursor。
1.5. connect(self, cursor_class=None)
返回 Connection 对象，连接数据库，如果 cursor_class 为 None，则使用默认的 self.cursor_class 属性进行连接。
1.6. close(self)
关闭 Connection 对象。
2. Pool
2.1. _init_(self, host, schema, user, pw, port=3306, charset='utf8', cursor_class='dict', autocommit=True, debug=True, pool_size=2, extras=4, wait_time=5, *args, **kwargs):
初始化连接池，用以管理 Engine 对象。Pool 内部有一个保存 Engine 对象的队列 self.pool。Pool 允许在连接池外额外创建一些 Engine 对象用以应付超出预期的请求数量。
Pool 初始化参数与 Engine 初始化参数大部分相同。
- pool_size: 设置连接池大小。
- extras: 当连接池满时，允许额外创建的 Engine 对象最大数量。
- wait_time: 当连接池为空时，等待获取 Engine 的超时时间。
2.2. count
当前所有 Engine 对象数量。
2.3. put(self, engine=None)
回收 Engine 对象到连接池。
2.4. get(self)
从连接池申请 Engine 对象。
2.5. spawn_engine(self):
创建新的 Engine 对象。
3. Column
数据库字段对象。
3.1. _init_(self, name)
参数 name 为数据库字段名称。
3.2. like(self, other)
实现 SQL LIKE 语句。
3.3. in_(self, *other)
实现 SQL IN 语句。
3.4. between(self, floor, ceil)
实现 SQL BETWEEN 语句。
3.5. is_null(self, boolean=True)
实现 SQL IS NULL 或 IS NOT NULL 语句。
4. Table
4.1. _init_(self, table_name, _engine=None, *columns)
实例化 Table 对象。
- table_name: 数据表名称。
- _engine: 支持传入 Engine 或 Pool 对象。
4.2. add_column(self, *columns)
向 Table 添加字段属性。
4.3. remove_column(self, *columns)
从 Table 删除字段属性。
4.4. binding_engine(self, engine)
重新绑定数据表的 engine 属性，参数 engine 支持传入 Engine 或 Pool 对象。
4.5. select(self, *columns)
执行 SELECT 语句。
4.6. insert(self, **assignments)
执行 INSERT 语句。
4.7. update(self, **assignments)
执行 UPDATE 语句。
4.8 delete(self)
执行 DELETE 语句。
4.9. count(self, column=None, distinct=None)
执行 COUNT 语句。