代码如上

一. 安装

$ pip install flask-sqlalchemy

二. 配置

配置选项列表 :

SQLALCHEMY_NATIVE_UNICODE | 可以用于显式禁用原生 unicode 支持。当使用 不合适的指定无编码的数据库默认值时，这对于 一些数据库适配器是必须的（比如 Ubuntu 上某些版本的 PostgreSQL ）。|
| SQLALCHEMY_POOL_SIZE | 数据库连接池的大小。默认是引擎默认值（通常 是 5 ） |
| SQLALCHEMY_POOL_TIMEOUT | 设定连接池的连接超时时间。默认是 10 。 |
| SQLALCHEMY_POOL_RECYCLE | 多少秒后自动回收连接。这对 MySQL 是必要的， 它默认移除闲置多于 8 小时的连接。注意如果 使用了 MySQL ， Flask-SQLALchemy 自动设定这个值为 2 小时。|

app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URIapp.config["SQLALCHEMY_COMMIT_ON_TEARDOWN"] = True/False  # 每次请求结束后都会自动提交数据库中的变动.app.config[""] =app.config[""] =app.config[""] =app.config[""] =DATABASE_URI :mysql : mysql://username:password@hostname/databasepgsql : postgresql://username:password@hostname/databasesqlite(linux)  : sqlite:////absolute/path/to/databasesqlite(windows) : sqlite:///c:/absolute/path/to/database

三. 初始化示例

from flask import Flaskfrom flask_sqlalchemy import SQLAlchemybase_dir = os.path.abspath(os.path.dirname(__file__))app = Flask(__name__)app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///' + os.path.join(base_dir, 'data.sqlite')app.config["SQLALCHEMY_COMMIT_ON_TEARDOWN"] = Truedb = SQLAlchemy(app)

四. 定义模型

模型 表示程序使用的持久化实体. 在 ORM 中, 模型一般是一个 Python 类, 类中的属性对应数据库中的表.

Flaks-SQLAlchemy 创建的数据库实例为模型提供了一个基类以及一些列辅助类和辅助函数, 可用于定义模型的结构.

db.Model    # 创建模型,db.Column   # 创建模型属性.

模型属性类型 :

常用 SQLAlchemy 列选项

Flask-SQLAlchemy 要求每个模型都要定义主键, 这一列通常命名为 id .

示例 :

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 '' % self.nameclass User(db.Model):__tablename__ = 'users'id = db.Column(db.Integer, primary_key=True)username = db.Column(db.String(64), unique=True, index=True)def __repr__(self):          """非必须, 用于在调试或测试时, 返回一个具有可读性的字符串表示模型."""return '' % self.username

五. 关系

关系型数据库使用关系把不同表中的行联系起来.

常用 SQLAlchemy 关系选项 :

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'))  # 外键关系.###############db.ForeignKey('roles.id') : 外键关系,Role.users = db.relationship('User', backref='role') : 代表 外键关系的 面向对象视角. 对于一个 Role 类的实例, 其 users 属性将返回与角色相关联的用户组成的列表.db.relationship() 第一个参数表示这个关系的另一端是哪个模型.backref 参数, 向 User 模型添加了一个 role 数据属性, 从而定义反向关系.  这一属性可替代 role_id 访问 Role 模型, 此时获取的是模型对象, 而不是外键的值.

2) 多对多

最复杂的关系类型, 需要用到第三章表, 即 关联表 , 这样多对多关系可以分解成原表和关联表之间的两个一对多关系.

查询多对多关系分两步 : 遍历两个关系来获取查询结果.

代码示例:

registrations = db.Table("registrations",db.Column("student_id", db.Integer, db.ForeignKey("students.id")),db.Column("class_id", db.Integer, db.ForeignKey("classes.id")))class Student(db.Model):__tablename__ = "students"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):__tablename__ = "classes"id = db.Column(db.Integer, primary_key=True)name = db.Column(db.String)

多对多关系仍然使用定义一对多关系的 db.relationship() 方法进行定义, 但在多对多关系中, 必须把 secondary 参数设为 关联表.

多对多关系可以在任何一个类中定义, backref 参数会处理好关系的另一侧.

关联表就是一个简单的表, 不是模型, SQLAlchemy 会自动接管这个表.

classes 关系使用列表语义, 这样处理多对多关系比较简单.

Class 模型的 students 关系有 参数 db.backref() 定义. 这个关系还指定了 lazy 参数, 所以, 关系两侧返回的查询都可接受额外的过滤器.

自引用关系
自引用关系可以理解为 多对多关系的特殊形式 : 多对多关系的两边由两个实体变为 一个实体.

高级多对多关系
使用多对多关系时, 往往需要存储所联两个实体之间的额外信息. 这种信息只能存储在关联表中. 对用户之间的关注来说, 可以存储用户关注另一个用户的日期, 这样就能按照时间顺序列出所有关注者.

为了能在关系中处理自定义的数据, 必须提升关联表的地位, 使其变成程序可访问的模型.

关注关联表模型实现:

class Follow(db.Model):__tablename__ = "follows"follower_id = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True)followed_id = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True)timestamp = db.Column(db.DateTime, default=datetime.utcnow)# SQLAlchemy 不能直接使用这个关联表, 因为如果这个做程序就无法访问其中的自定义字段. 相反的, 要把这个多对多关系的左右两侧拆分成两个基本的一对多关系, 而且要定义成标准的关系.

使用两个一对多关系实现的多对多关系:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class User(UserMixin, db.Model):
    # ...
    followd = db.relationship("Follow",
                              foreign_keys=[Follow.follower_id],
                              backref=db.backref("follower", lazy="joined"),
                              lazy="dynamic",
                              cascade="all, delete-orphan")
    followrs = db.relationship("Follow",
                              foreign_keys=[Follow.followed_id],
                              backref=db.backref("followed", lazy="joined"),
                              lazy="dynamic",
                              cascade="all, delete-orphan")

# 这段代码中, followed 和 follower 关系都定义为 单独的 一对多关系. 
# 注意: 为了消除外键歧义, 定义关系是必须使用可选参数 foreign_keys 指定的外键. 而且 db.backref() 参数并不是指定这两个关系之间的引用关系, 而是回引 Follow 模型. 回引中的 lazy="joined" , 该模式可以实现立即从连接查询中加载相关对象.
# 这两个关系中, user 一侧设定的 lazy 参数作用不一样. lazy 参数都在 "一" 这一侧设定, 返回的结果是 "多" 这一侧中的记录. dynamic 参数, 返回的是查询对象.
# cascade 参数配置在父对象上执行的操作相关对象的影响. 比如, 层叠对象可设定为: 将用户添加到数据库会话后, 要自定把所有关系的对象都添加到会话中. 删除对象时, 默认的层叠行为是把对象联结的所有相关对象的外键设为空值. 但在关联表中, 删除记录后正确的行为是把执行该记录的实体也删除, 因为这样才能有效销毁联结. 这就是 层叠选项值 delete-orphan 的作用. 设为 all, delete-orphan 的意思是启动所有默认层叠选项, 并且还要删除孤儿记录.

3) 一对一

可以看做特殊的 一对多 关系. 但调用 db.relationship() 时 要把 uselist 设置 False, 把 多变为 一 .

4) 多对一

将 一对多 关系,反过来即可, 也是 一对多关系.

六. 数据库操作

1) 创建数据库及数据表

创建数据库

db.create_all()

示例 :
$ python myflask.py shell
> from myflask import db
> db.create_all()

如果使用 sqlite , 会在 SQLALCHEMY_DATABASE_URI 指定的目录下 多一个文件, 文件名为该配置中的文件名.

如果数据库表已经存在于数据库中, 那么 db.create_all() 不会创建或更新这个表.

更新数据库
方法一 :
先删除, 在创建 –> 原有数据库中的数据, 都会消失.

> db.drop_all()> db.create_all()