Flask：数据库管理

为什么不使用SQL语句，而使用ORM框架管理数据库？首先，在python程序中嵌入原生SQL语句，不方便维护，ORM框架使用面向对象思想，使用较方便；第二，如果更换底层数据库引擎，ORM框架不需要修改代码。ORM框架也有其弊端，如有一定的性能损耗，且高级查询编写复杂，有一定的学习成本。

1、配置数据库链接

Flask-SQLAlchemy 中，数据库使用 URL 指定。一般开发环境使用SQLite，生产环境使用MySQL，使用MySQL时，还需要再安装相应的依赖包。

几种最流行的数据库引擎使用的 URL 格式：

数据库引擎	URL
MySQL	mysql://username:password@hostname/database
SQLite（Linux，macOS）	sqlite:////absolute/path/to/database
SQLite（Windows）	sqlite:///c:/absolute/path/to/database

配置数据库：

app.config['SQLALCHEMY_DATABASE_URI'] ='sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# SQLALCHEMY_TRACK_MODIFICATIONS 参数决定是否追踪对象的修改，SQLAlchemy建议配置此变量，不然会有警告。

2、定义模型

模型这个术语表示应用使用的持久化实体。在ORM中，模型一般是一个表示数据表的类，类的实例对应一条记录，类中的属性对应于数据库表中的列。

所以模型定义，类似原生SQL的CREATE TABLE语句：

class Role(db.Model):
    # 定义表名
    __tablename__ = 'roles'

    # 定义字段
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)

    def __repr__(self):
        return '<Role %r>' % self.name

常用列类型与列选项：https://www.cnblogs.com/adamans/articles/9815040.html

3、关系

关系型数据库的表和表之间需要建立“一对多”，“多对一”和“一对一”的关系，这样才能够按照应用程序的逻辑来组织和存储数据。在关系型数据库中，关系是通过主键和外键来维护，其中外键既可以通过数据库来约束，也可以不设置约束，仅依靠应用程序的逻辑来保证，这里讨论使用数据库来约束的情况。

3.1 一对多

例如角色和用户是一对多关系，一个用户只对用一个角色，而一个角色可以对应多个用户：

class Role(db.Model):
    # ...
    users = db.relationship('User', backref='role')

class User(db.Model):
    # ...
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

添加到 User 模型中的 role_id 列被定义为外键，就是这个外键建立起了关系。传给 db.ForeignKey() 的参数 'roles.id' 表明，这列的值是 roles 表中相应行的 id值。

添加到 Role 模型中的 users 属性代表这个关系的面向对象视角，对于一个 Role 类的实例，其 users 属性将返回与角色相关联的用户组成的列表。db.relationship() 的第一个参数表明这个关系的另一端是哪个模型，backref 参数向 User 模型中添加一个 role 属性，从而定义反向关系。通过 User 实例的这个属性可以获取对应的 Role 模型对象，而不用再通过 role_id 外键获取。

3.2 一对一

一对一关系可以用前面介绍的一对多关系表示，但调用 db.relationship() 时要把 uselist 属性设为 False，把“多”变成“一”。

3.3 多对一

多对一关系从“多”这一侧看，就是一对多关系，对调两个表即可。

3.4 多对多

上述关系至少都有一侧是单个实体，所以记录之间的联系通过外键实现，让外键指向那个实体。但是，可能两侧都是“多”的关系，如有学生表和课程表，学生可能选多个课程，课程也可能被多个学生选。这种时候一般使用第三张表（即关联表）来表示关系：

class c(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String)
    classes = db.relationship('Class',
                              secondary=registrations,
                              backref=db.backref('students', lazy='dynamic'),
                              lazy='dynamic')

class Class(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String)

registrations = db.Table('registrations',
    db.Column('student_id', db.Integer, db.ForeignKey('students.id')),
    db.Column('class_id', db.Integer, db.ForeignKey('classes.id'))
)

多对多关系仍使用定义一对多关系的 db.relationship()方法定义，但在多对多关系中，必须把 secondary 参数设为关联表。多对多关系可以在任何一个类中定义，backref参数会处理好关系的另一侧。关联表就是一个简单的表，不是模型，SQLAlchemy 会自动接管这个表。

Student中classes 关系使用列表语义，这样处理多对多关系特别简单：

# 查看Student实例所选课程、Class实例被选情况
>>> s.classes.all()
>>> c.students.all()

# 增加课程
>>> s.classes.append(c)
>>> db.session.add(s)
>>> db.session.commit()

# 取消选课
>>> s.classes.remove(c)
>>> db.session.add(c)
>>> db.session.commit()

关联表使用db.Table类定义

指定了lazy='dynamic' 参数，所以关系两侧返回的查询都可接受额外的过滤器

3.5 自引用

多对多有种特殊情况，即关系中的两侧都在同一个表中，这种关系称为自引用关系。如用户表之间的关注关系，

4、数据库操作

对数据库的改动通过数据库会话管理，在 Flask-SQLAlchemy 中，数据库会话由 db.session 表示。调用 db.session.commit()提交事务，db.session.rollback() 回滚事务。

① 创建表、删除表

db.create_all()
db.drop_all()

② CREATE

admin_role = Role(name='Admin')
db.session.add(admin_role)
db.session.add_all([admin_role, mod_role])
db.session.commit()

③ UPDATE

admin_role.name = 'Administrator'
db.session.add(admin_role)
db.session.commit()

④ DELETE

db.session.delete(mod_role)
db.session.commit()

⑤ READ

<模型类>.query.＜过滤方法>.<查询方法>

User.query.all()
User.query.filter_by(role=user_role).all()
Role.query.filter_by(name='User').first()
# 查看查询API...

5、文档

sqlalchemy中文文档：https://www.osgeo.cn/sqlalchemy/

sqlalchemy英文文档：https://docs.sqlalchemy.org/

flask-sqlalchemy文档：http://www.pythondoc.com/flask-sqlalchemy/index.html