目录
Flask-SQLAlchemy
Flask-SQLAlchemy使用起来非常有趣，对于基本应用程序来说非常简单，并且适用于大型应用程序。
安装
pip install flask-sqlalchemy
配置
Flask-SQLAlchemy存在以下的配置值，Flask-SQLAlchemy从主Flask配置中加载这些值，可以通过各种方式进行填充。请注意，在创建引擎后其中一些内容无法修改，因此需要确保尽早的进配置，并且不要在运行时对其进行修改。
| 配置名称 | 介绍 |
|---|---|
| SQLALCHEMY_DATABASE_URI | 将要被用于数据库链接的URI。 例如: mysql://username:password@server/db mysql+pymysql://root:123456@localhost:3306/TTC |
| SQLALCHEMY_BINDS | 一个将会绑定多种数据库的字典。 更多详细信息请看官文 绑定多种数据库. |
| SQLALCHEMY_ECHO | 如果设置为True，SQLAlchemy会将记录所有标准错误声明，这对调试非常有用。 |
| SQLALCHEMY_RECORD_QUERIES | 可以用于禁用或启用查询记录的显示 。 查询记录会自动的在调试或测试模式下进行 。 |
| SQLALCHEMY_NATIVE_UNICODE | 可以用来启用或禁用本地对 unicode 的支持。 |
| SQLALCHEMY_POOL_SIZE | 数据库池的大小。 默认与数据库引擎的值相同 (通常为 5) |
| SQLALCHEMY_POOL_TIMEOUT | 指定池的连接超时（以秒为单位）。 |
| SQLALCHEMY_POOL_RECYCLE | 自动循环连接的秒数。这是MySQL所必须的，默认情况下，闲置8小时后会删除连接。如果使用MySQL，SQLAlchemy会自动将其设置为2小时，一些后端可能使用不同的默认超时值。 |
| SQLALCHEMY_MAX_OVERFLOW | 控制连接池达到最大大小后还可以创建的连接数，当这些附加连接返回到连接池时，它们将会被断开并丢弃。 |
| SQLALCHEMY_TRACK_MODIFICATIONS | 如果设置为True，Flask-SQLAlchemy将跟踪对对象的修改，并发出信号。默认值为None，他可以启用跟踪功能，但会发出警告，表明它在将来会被默认禁用。这需要额外的内存，如果不需要，应该禁用。 |
下面对SQLAlchemy进行配置
app.py
from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__) # 创建一个Flask app对象
# 数据库链接的配置，此项必须，格式为（数据库+驱动://用户名:密码@数据库主机地址:端口/数据库名称）
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123456@localhost:3306/flask_ttc'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # 跟踪对象的修改，在本例中用不到调高运行效率，所以设置为False
db = SQLAlchemy(app=app) # 为哪个Flask app对象创建SQLAlchemy对象，赋值为db
manager = Manager(app=app) # 初始化manager模块
@app.route('/')
def hello_world():
reutrn 'Hello World!'
if __name__ == '__main__':
manager.run() # 运行服务器
声明模型
这里的模型就的我们口中通常说的MTV中Model，显然app.py 中用@app.route()装饰器装饰的就是View了，Templates中存在的html模板文件就的我们的T了。
这里简单的写一个Model
models.py
from app import db # 导入app文件中的SQLAlchemy对象
class Student(db.Model): # 继承SQLAlchemy.Model对象，一个对象代表了一张表
s_id= db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True) # id 整型，主键，自增，唯一
s_name = db.Column(db.String(20)) # 名字 字符串长度为20
s_age = db.Column(db.Integer, default=20) # 年龄 整型，默认为20
__tablename__ = 'student' # 该参数可选，不设置会默认的设置表名，如果设置会覆盖默认的表名
def __init__(self, name, age): # 初始化方法，可以对对象进行创建
self.s_name = name
self.s_age = age
def __repr__(self): # 输出方法，与__str__类似，但是能够重现它所代表的对象
return '<Student %r, %r, %r>' % (self.s_id, self.s_name, self.sage)
列的类型是Column的第一个参数。可以直接指定他们，也可以的调用他们以进一步的指定他们的长度。以下类型是最常见的：
| 类型 | 介绍 |
|---|---|
| Integer | 一个整数 |
| String(size) | 一个字符串，并可以设置它的最大长度 |
| Text | 更长的unicode文本 |
| DateTime | 通过Python的datetime对象来表示时间日期 |
| Float | 存储一个浮点数 |
| Boolean | 存储一个布尔值 |
| PickleType | 存储一个序列化（ Pickle ）后的Python对象 |
| LargeBinary | 存储巨大长度的二进制数据 |
我们可以通过交互式的环境来创建数据库中的表
>>> from app import db # 引入SQLAlchemy
>>> from models import * # 映入加载了model的SQLAlchemy对象，db
>>> db.create_all() # 创建表
这样数据库中就已经存在student表了
增删改查（CURD）
这些操作都可以通过SQL语句来实现
sql = 'select * from student;'
stus = db.session.execute(sql)
插入(Create)
# 插入一条
stu = Student('TTC', 22)
db.session.add(stu)
db.session.commit()
# 如果添加的对象是列表，使用db.session.add_all(list)
stus = []
db.session.add_all(stus)
db.session.commit()
删除(Delete)
stu = Student.query.get(1) # 需要删除的对象
db.session.delete(stu) # 删除
db.session.commit() # 提交事务
修改(Update)
stu = Student.query.get(1) # 需要修改的对象
stu.s_age = 18 # 修改值
db.session.commit() # 提交
选择(Select)
过滤查询
stu = Student.query.filter(s_name='TTC').first()
# 如果查询一个不存在的会返回一个None
用主键查询
stu = Student.query.get(1) # 主键查询
比较查询
# __lt__ 小于 __le__小于等于 __gt__ 大于 __ge__ 大于等于
Student.query.filter(Student.s_age.__lt__(16)) # 小于16岁
Student.query.filter(Student.s_age.__le__(16)) # 小于等于16岁
Student.query.filter(Student.s_age.__gt__(16)) # 大于16岁
Student.query.filter(Student.s_age.__ge__(16)) # 大于等于16岁
In 查询
# 使用in_方法获取与列表中值相匹配的值
Student.query.filter(Student.s_age.in_([16, 17, 18, 19, 20]))
排序
Student.query.order_by('s_age') # 按年龄排序，默认升序，在前面加-号为降序'-s_age'
限制条数和从第几条开始
Student.query.filter(s_age=18).offset(2).limit(3) # 跳过二条开始查询，限制输出3条
多条件查询
Student.query.filter(Student.s_age == 18, Student.s_name == 'TTC')
# 也可以通过and_并且 or_或者 not_非 的方法来进行查询
Student.query.filter(and_(Student.s_age == 18, Student.s_name == 'TTC'))
Student.query.filter(or_(Student.s_age == 18, Student.s_name == 'TTC'))
Student.query.filter(not_(Student.s_age == 18, Student.s_name == 'TTC'))
模型关系
一对多(one-to-many)关系
最常见的关系就是一对多的关系。因为关系在它们建立之前就已经声明，可以使用字符串来指代还没有创建的类。
比如班级和学生的关系即为一对多的关系，一个班级对应多名学生。
models.py
from app import db
class Grade(db.Model):
"""班级表"""
g_id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 班级id
g_name = db.Column(db.String(20)) # 班级名称
g_desc = db.Column(db.String(100)) # 描述
students = db.relationship('Student', backref='grade', lazy=True) # 关系
__tablename__ = 'grade' # 表名
def __init__(self, name, desc): # 初始化方法
self.g_name = name # 名称
self.g_desc = desc # 描述
def __repr__(self): # 输出方法，显示对象内容
return '<Grade %r, %r, %r>' % (self.g_id, self.g_name, self.g_desc)
class Student(db.Model):
"""学生表"""
s_id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 学生ID
s_name = db.Column(db.String(20)) # 学生姓名
s_age = db.Column(db.Integer, default=20) # 学生年龄
g_id = db.Column(db.Integer, db.ForeignKey('grade.g_id')) # 外键
__tablename__ = 'student' # 表名
def __init__(self, name, age, g_id): # 初始化方法
self.s_name = name # 姓名
self.s_age = age # 年龄
self.g_id = g_id # 班级ID
def __repr__(self): # 输出方法，显示对象内容
return '<Student %r, %r, %r>' % (self.s_id, self.s_name, self.s_age)
通过学生获取班级
g_id = Student.query.get(12).grade.g_id
通过班级获取学生
stus = Grade.query.get(2).students
一对一（one-to-one）关系
需要使用一对一的关系，和一对多的关系的写法是一样的，只是在relationship中有一个参数不同，需要将uselist=Flase，这样两个表之间的关系就变成了一对一的关系。其参数的含义就是不使用列表，两个表之间只有一条对应一条的关联。
多对多（many-to-many）关系
如果想使用多对多关系，需要定义一一个用于关系的辅助表，对于这个辅助表，建议不使用模型，而是采用一个实际的表：
我们接着之前的写，加入学生(Student)和课程(Course)的关系
from app import db # 引入模块
class Student(db.Model):
"""学生表"""
s_id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 学生ID
s_name = db.Column(db.String(20)) # 学生姓名
s_age = db.Column(db.Integer, default=20) # 学生年龄
g_id = db.Column(db.Integer, db.ForeignKey('grade.g_id')) # 班级ID
__tablename__ = 'student' # 学生表
def __init__(self, name, age, g_id): # 初始化方法
self.s_name = name # 名称
self.s_age = age # 年龄
self.g_id = g_id # 班级ID
def __repr__(self): # 格式化输出显示对象中的值
return '<Student %r, %r, %r>' % (self.s_id, self.s_name, self.s_age)
# 辅助表 记录学生表和课程表的多对多关系
sc = db.Table('sc', # 表名
db.Column('s_id', db.Integer, db.ForeignKey('student.s_id'), primary_key=True),
db.Column('c_id', db.Integer, db.ForeignKey('course.c_id'), primary_key=True)
)
class Course(db.Model):
"""课程表"""
c_id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 课程的ID
c_name = db.Column(db.String(20)) # 课程名称
students = db.relationship('Student', secondary=sc, backref='courses') # 与学生表的关系
# secondary指定副表名称
def __init__(self, name): # 初始化方法
self.c_name = name # 课程名
def __repr__(self): # 格式化输出显示对象中的值
return '<Course %r, %r >' % (self.c_id, self.c_name)
多对多关系的数据插入方式
stu = Student.query.get(s_id) # 获取学生对象
cou = Course.query.get(c_id) # 获取课程对象
# 方式一
cou.students.append(stu) # 建立学生和课程的关系
db.session.add(cou) # 为会话添加事务
# 方式二
stu.courses.append(cou)
db.session.add(stu)
# 方式一和方式二等效
db.session.commit() # 提交事务
多对多关系的数据删除方式
stu = Student.query.get(s_id)
cou = Course.query.get(c_id)
# 方式一
cou.students.remove(stu)
# 方式二
stu.students.remove(cou)
# 方式一和方式二等效
db.session.commit()
多对多关系互相查询
通过学生查课程
cous = Student.query.get(s_id).courses
通过课程查学生
stus = Course.query.get(c_id).students