# ch05 · 数据库存储：SQLAlchemy、迁移

> 来源：教材配套 PPT《第五章 使用数据库存储内容.pptx》，共 82 页。本节只摘录**知识点与关键文字**，图取自 PPT 原页。

## 第 1 页 · 讲师：谢福财

- 讲师：谢福财
- Flask课程——
- **第五章**
- 使用数据库存储内容

![第1页图](media/ch05/slide01_img1.png)

## 第 2 页 · 掌握控制台与Flask交互的方法

- 掌握控制台与Flask交互的方法
- 掌握Flask-SQLAlchemy数据库
- 框架的基本使用方法
- 掌握Flask-Migrate对数据库
- 进行迁移的方法
- 学习目标

![第2页图](media/ch05/slide02_img1.png)

## 第 3 页 · Flask-SQLAlchemy

- Flask-SQLAlchemy
- SQL数据库简介
- Flask-Script
- Flask-Migrate
- 小结

## 第 4 页 · SQL数据库简介

- SQL数据库简介
- 01

## 第 5 页 · 概念介绍

- 概念介绍
- SQL数据库是什么？
- 结构化查询语言（Structured Query Language，SQL）专门为了数据库查询而设计，用于存取数据，查询、更新和管理数据库。
- SQL数据库通常是一种关系数据库，这种数据库通常会将数据存储在一个个数据表（表格）中。数据表的每一个字段（表格列）都是固定的，每一个对象的数据都映射到数据表的每一条记录（表格行）中。

## 第 6 页 · 概念介绍

- 概念介绍
- 为什么要用SQL数据库？
- 提供用户注册、文章发布等功能的网站都需要存储数据，在需要存储数据的情况下便需要使用数据库。通常情况下，数据库将按照一定规则来存储数据，这些规则使得数据变得规范化，相较于文件、目录方式存储更便于管理，且大部分的主流数据库在Flask中都具备完善的解决方案。

## 第 7 页 · 概念解释

- 概念解释
- 后面主要用ORM框架对数据库操作，不直接使用SQL语句。所以不对sql的基础语句做过多讲解。
- 为什么不直接用SQL语句呢，原因在于，在以往的学习sql的内容时，实现每一个需求都需要建立一条SQL语句。实际项目通常由很多个模块组合在一起，假设每一个模块都跟一个单独的数据表关联，那么则需要为每一个模块编写多条基本的增、删、改、查语句，不便于维护。
- 虽然Python对这些SQL语句进行封装并将其作为函数使用。这种做法虽然减少了SQL语句的编写量，但不便于进行复杂操作，且存在显著的安全性问题，容易被SQL注入。
- 这时，使用对象关系映射（Object Relational Mapping，ORM）框架可以很好地解决这个问题。
- ORM框架可以将数据映射到对象当中，且对SQL语句的生成进行了高度的封装，能满足绝大部分的常见需求，要实现数据的增、删、改、查，仅需操作相应对象的属性即可。
- 接下来，本章将基于Flask-SQLAlchemy（ORM框架），以SQLite数据库为例，对数据库操作进行讲解。

## 第 8 页 · 依赖安装

- 依赖安装
- 安装SQLiteStudio
- SQLiteStudio是一款开源免费的SQLite数据库可视化工具，简单易用。读者可以在SQLiteStudio的官网中下载SQLiteStudio，如下图所示。

![第8页图](media/ch05/slide08_img1.png)

![第8页图](media/ch05/slide08_img2.png)

## 第 9 页 · 依赖安装

- 依赖安装
- 下载完成后，保持默认选项设置进行安装即可，如下图所示。
- SQLiteStudio是一款开源免费的SQLite数据库可视化工具，简单易用。读者可以在SQLiteStudio的官网中下载SQLiteStudio，如下图所示。

![第9页图](media/ch05/slide09_img1.png)

![第9页图](media/ch05/slide09_img2.png)

## 第 10 页 · 依赖安装

- 依赖安装
- 安装完场后如下图所示。后面会用这个工具进行数据展示。

![第10页图](media/ch05/slide10_img1.png)

## 第 11 页 · Flask-Script

- Flask-Script
- 02

## 第 12 页 · “

- “
- Flask-Script 是 Flask 框架的一个扩展，它提供了一个命令行工具，用于在 Flask 应用中管理和运行各种命令。它可以帮助开发者执行一系列任务，如启动开发服务器、数据库迁移、数据库初始化、脚本运行等，而不必在终端中手动输入 Python 代码。
- 什么是Flask-Script？
- ”
- 概念介绍

## 第 13 页 · 安装依赖

- 安装依赖
- 与安装Flask的操作一致，打开命令提示符窗口，输入以下命令。
- pip install flask-script==2.0.6
- 执行上述命令之后，能看到“Successfully installed…”提示信息，没有提示红色的报错信息，即安装成功，此时，Flask-Script的依赖包便安装完成了，如下图所示。

![第13页图](media/ch05/slide13_img1.png)

## 第 14 页 · 托管应用

- 托管应用
- 在之前编写的例子中，只要执行app.py文件，Flask应用就开始运行了，无法进行其他操作。如果需要为应用添加启动选项，如添加命令用于清除缓存、添加管理员等其他操作，则需要使用Flask-Script中的Manager对应用进行托管。
- Manager可以根据用户输入的启动选项（命令）进行不同的操作，在注册命令之前，需要对Manager进行初始化。代码如下所示。
- from flask import Flask
from flask_script import Manager
 
app = Flask(__name__)
 
# ……其他初始化代码（Bootstrap等其他内容）……
 
# ……视图函数代码……
 
# 使用flask_script提供的Manager()对app进行托管
manager = Manager(app)
 
if __name__ == '__main__':
      # 将原来直接运行app的代码更改为从manager运行
      manager.run()

## 第 15 页 · 托管应用

- 托管应用
- 以下是通过命令行启动的步骤。
- （1）获取项目所在位置，将鼠标指针指向项目位置，单击鼠标右键，在快捷菜单中选择“Copy Path”选项，复制路径，如下图所示。

![第15页图](media/ch05/slide15_img1.png)

## 第 16 页 · 托管应用

- 托管应用
- （2）打开命令提示符窗口，输入“cd [路径]”，如下图所示，此处的[路径]可以通过粘贴命令得到，如果项目所在盘符不为“C:”，如项目部署于D盘，则需要输入“D:”后再操作。

![第16页图](media/ch05/slide16_img1.png)

## 第 17 页 · 托管应用

- 托管应用
- （3）输入“python app.py”可启动对应的Flask项目，如下图所示。
- 此时可以看到，不加参数启动会输出帮助信息，同时，图中的“positional arguments”下的内容在默认情况下是可以被执行的命令。shell命令可以进入交互Shell，而runserver命令的作用则相当于平时单击按钮运行应用。

![第17页图](media/ch05/slide17_img1.png)

## 第 18 页 · 托管应用

- 托管应用
- 在前面的操作中，常有需要在命令提示符窗口中操作的过程。在PyCharm中，为了简化操作，可以单击“Terminal”按钮快速打开命令提示符窗口
- 使用此方法打开命令提示符窗口将直接进入项目目录，推荐使用该方法

![第18页图](media/ch05/slide18_img1.png)

## 第 19 页 · 注册命令

- 注册命令
- 在前面的操作中，介绍了如何通过Flask-Script提供的Manager托管应用，这个小节演示如何注册命令，并通过命令完成与应用的交互。以下是一段简单的演示代码。
- # 注册命令到manager
@manager.command
def test():
     print('这是一个测试用的命令')
- 与视图函数相似，此处使用manager.command装饰器对test()函数进行修饰，轻而易举地完成了命令的注册。

## 第 20 页 · 注册命令

- 注册命令
- 效果如下图所示。
- 如果要实现其他业务逻辑，仅需要将代码修改成相应的代码即可。
- shell示例图

![第20页图](media/ch05/slide20_img1.png)

![第20页图](media/ch05/slide20_img2.png)

## 第 21 页 · 创建交互Shell

- 创建交互Shell
- 在前面的例子中，使用Manager托管应用之后，如果不加参数运行，可在命令列表中见到shell命令。当执行shell命令之后，将会进入当前项目环境的Python交互Shell。运行交互Shell之后可以见到左边的输入提示变成了“>>>”，此时可以输入Python代码。
- 但在这个环境中，仅包含了Flask应用实例，不带其他上下文环境变量。如果需要访问其他内容进行交互，则需要为Shell实例添加上下文环境变量。代码如下所示。
- from flask_script import Manager, Shell
- app = Flask(__name__)
- manager = Manager(app)
- # 此处users变量需要在Shell环境中直接访问
- users = ['Bill', 'Hunter', 'Carlos']
- # 该函数用于创建Shell上下文，将对象注册到Shell（类似于环境变量）
- def make_shell_context():
- return dict(
- users=users,
- )
- manager.add_command("shell", Shell(make_context=make_shell_context))

## 第 22 页 · 创建交互Shell

- 创建交互Shell
- 此时在Shell环境中即可直接访问users变量，如下图所示。

![第22页图](media/ch05/slide22_img1.png)

## 第 23 页 · Flask-SQLAlchemy

- Flask-SQLAlchemy
- 03

## 第 24 页 · “

- “
- SQLAlchemy是Python下非常好的ORM框架，支持使用MySQL、PostgreSQL、SQLite等主流数据库。Flask-SQLAlchemy基于SQLAlchemy对Flask进行了适配，使其在Flask下的使用变得简单。
- 什么是Flask-SQLAlchemy？
- ”
- 概念介绍

## 第 25 页 · 安装依赖

- 安装依赖
- 与安装Flask的操作一致，打开命令提示符窗口，输入以下命令。
- pip install flask-sqlalchemy==2.4.1
- 执行上述命令之后，能看到“Successfully installed…”提示信息，没有提示红色的报错信息，即安装成功，此时，Flask-SQLAlchemy的依赖包便安装完成了，如下图所示。

![第25页图](media/ch05/slide25_img1.png)

## 第 26 页 · 建立模型

- 建立模型
- 在建立模型之前，需要对客户需求进行分析。
- 假设现在需要实现一个简单的文章发布系统，用户可以在其中发布文章，管理用户可管理（增、删、改、查）所有文章。此处可以将以上需求分解为“用户模块”与“文章模块”，然后为各个模块设计相应的模型。
- 如果需要实现基本的登录功能，则用户模型需要拥有“用户名”“密码”这些属性。用户还可以作为管理员，为了区分普通用户和管理员，用户模型还需要拥有“是否为管理员”属性。另外，用户需要创建文章时用户模型便需要使用“id”属性与文章模型进行关联。用户模型的结构如表如下表所示。

## 第 27 页 · 建立模型

- 建立模型
- 与用户模型同理，根据功能将文章模型所需的属性提炼出来。
- 文章模型的结构如表下表所示

## 第 28 页 · 建立模型

- 建立模型
- 完成了模型的设计就需要把它转化为代码，我们首先要初始化Flask-SQLAlchemy，代码如下。
- from flask_sqlalchemy import SQLAlchemy
import os
 
# 设置数据库存储位置
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
# flask_sqlalchemy 初始化代码
db = SQLAlchemy(app)
db.init_app(app)
- 在Flask-SQLAlchemy中，通常情况下，所有模型都需要继承自“db.Model”。
- SQLAlchemy 默认会追踪对象的修改并发送信号，但在大多数情况下，这可能不是必需的。通过将 SQLALCHEMY_TRACK_MODIFICATIONS 设置为 False，可以关闭对修改的追踪。

## 第 29 页 · 建立模型

- 建立模型
- 接着是用户模型和文章模型的定义。代码如下
- class UserModel(db.Model):
- __tablename__ = 'user'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- class ArticleModel(db.Model):
- __tablename__ = 'article'
- id = db.Column(db.INTEGER, primary_key=True)
- title = db.Column(db.VARCHAR)
- content = db.Column(db.VARCHAR)

## 第 30 页 · 建立模型

- 建立模型
- 模型类定义完成后开始初始化数据库文件。此时需要使用5.2.4小节介绍的交互Shell进行操作，需要注册交互模型、SQLAlchemy实例（即db对象）到Shell上下文环境中。关键代码如下。
- def make_shell_context():
- return dict(
- db=db,
- UserModel=UserModel,
- ArticleModel=ArticleModel,
- )
- #主要就是创建Shell上下文，将对象注册到Shell（类似于环境变量），只需要在初始化flask-sqlalchemy代码后定义两个模型，接着初始化数据库文件就好了。

## 第 31 页 · 建立模型

- 建立模型
- 在命令提示符窗口（终端）中执行以下代码。
- python app.py shell
- 进去了shell后再执行以下代码。
- # 根据已加载的模型创建相应数据表
- db.create_all()
- 此时，项目目录中将会创建一个名为“data.sqlite”的数据库文件，如下图所示。

![第31页图](media/ch05/slide31_img1.png)

## 第 32 页 · 建立模型

- 建立模型
- 使用可视化工具查看该数据库中user表和article表的表结构，如下图所示。

![第32页图](media/ch05/slide32_img1.png)

## 第 33 页 · 建立模型

- 建立模型
- 使用可视化工具查看该数据库中user表和article表的表结构，如下图所示。
- 模型及相应的数据表建立完成后，就到了数据操作的讲解。

![第33页图](media/ch05/slide33_img1.png)

## 第 34 页 · 数据操作

- 数据操作
- 前文提到数据库操作主要通过SQL语句进行，而SQLAlchemy提供了将数据映射到对象中的操作方式。这样的方式使得对数据的操作变得简单，使用者无须学习SQL语法即可完成数据操作。就简单来讲就是学习用SQLAlchemy来实现增删查改
- 接下来的操作将在交互Shell中进行，首先需要在命令提示符窗口中启动Shell

## 第 35 页 · 数据操作

- 数据操作
- 1．添加数据
- 在添加数据之前，需要创建相应的对象。以用户模型为例，实际上，添加用户到数据表中，即用户注册。
- 以下是代码（交互Shell）演示。
- # 创建用户对象
user_1 = UserModel(
     username='admin',
     password='123456',
     is_admin=True,
)
 
user_2 = UserModel(
     username='user',
     password='123456',
     is_admin=False,
)
- 到这里还没有把数据存放到数据库中，只是单纯创建了。

## 第 36 页 · 数据操作

- 数据操作
- 对象创建之后，并没有立刻存放到数据库中。接下来需要将用户对象添加到数据操作会话中，由SQLAlchemy解析会话中各对象相应的操作，并将操作提交到数据库中执行。代码如下。
- # 将用户对象添加到数据操作队列
- db.session.add(user_1)
- db.session.add(user_2)
- # 提交更改到数据库
- db.session.commit()
- 完成以上操作以后，就可以在数据库中查询到相应的数据，效果如下图所示。

![第36页图](media/ch05/slide36_img1.png)

## 第 37 页 · 数据操作

- 数据操作
- 2．查询数据
- 前面使用可视化工具可以方便地查看所有的数据，但如果需要在Python中获取相应的用户数据，则需要通过模型类查询来实现。如果要实现用户登录，便只需要将用户输入数据与数据库中查询到的用户数据进行比较，正确则登录成功，反之登录失败。

## 第 38 页 · 数据操作

- 数据操作
- 以下是模型类查询的代码（交互Shell）演示。
- # 获取所有用户对象
- users = UserModel.query.all()
- print(users)
- # 获取所有符合条件的用户对象
- users = UserModel.query.filter_by(is_admin=True).all()
- print(users)
- # 获取所有符合条件的用户对象的数量
- num = UserModel.query.filter_by(is_admin=True).count()
- print(num)
- # 获取一个符合条件的用户对象
- user = UserModel.query.filter(UserModel.id > 1).first()
- print(user)
- 以上是一些常见的查询方法，运行结果如下所示。
- [<UserModel 1>, <UserModel 2>]
- [<UserModel 1>]
- 1
- <UserModel 2>

## 第 39 页 · 数据操作

- 数据操作
- 输出模型对象无法展示其包含的数据，要展示模型对象包含的数据，输出模型对象相应的属性即可，在Shell中的运行结果如下所示。
- >>> print(user.id)
- 2
- >>> print(user.username)
- user
- >>> print(user.password)
- 123456
- >>> print(user.is_admin)
- False

## 第 40 页 · 数据操作

- 数据操作
- 逐个属性输出数据始终不便于操作，为了更方便进行接下来的数据展示操作，在此建立一个模型基类，用于重写模型输出时的格式（可选操作）。
- 定义模型基类要分几个步骤，首先是定义所有模型的基类是什么，然后要定义模型的初始化方法，再然后就是定义对象要输出的格式。那么我们先按照定义模型的基类为始，接着是定义模型初始化方法，代码如下：
- # 定义所有模型的基类
- class BaseModel(Model):
- # 声明 query 属性的类型，以获得代码提示补全
- query: BaseQuery
- # 定义模型初始化方法
- def __init__(self, **kwargs):
- # 将参数传入父类初始化方法
- super(BaseModel, self).__init__(**kwargs)
- 这个 __init__ 方法是模型基类的初始化方法。它通过调用父类的初始化方法来传递参数。

## 第 41 页 · 数据操作

- 数据操作
- 最后是定义输出格式，代码如下所示。
- # 定义对象输出格式，方便输出预览
      def __repr__(self):
           fields = [] 	
           # 获取对象原始数据
           for k, v in self.__dict__.items():
                 # 只输出相关属性
                 if k[0] != '_':
                        # 防止模型关联后无限递归
                        if isinstance(v, BaseModel):
                               fields.append('%s=<%s ...>' % (k, v.__class__.__ name__))
                        elif isinstance(v, str):
                               fields.append("%s='%s'" % (k, v))
                        else:
                               fields.append('%s=%a' % (k, v))
        
           # 拼接显示结果
           result = '<%s %s>' % (self.__class__.__name__,' '.join(fields))
           return result
- 在 __repr__ 方法中，这部分代码遍历对象的属性和属性值，并根据不同情况构建输出的字段。如果属性值是另一个继承自 BaseModel 的对象，它会显示对象类型和占位符。如果属性值是字符串，它会显示属性名和字符串值。否则，它会使用 %a 格式显示属性名和属性值。

## 第 42 页 · 数据操作

- 数据操作
- 然后修改各模型的继承，例如为用户模型添加模型基类的继承。代码如下。
- class UserModel(db.Model, BaseModel):
- __tablename__ = 'user'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- 然后再执行前面的查询代码，可以得出以下结果。
- [<UserModel username='admin' password='123456' is_admin=True id=1>, <UserModel username='user' password='123456' is_admin=False id=2>]
- [<UserModel username='admin' password='123456' is_admin=True id=1>]
- 1
- <UserModel username='user' password='123456' is_admin=False id=2>
- 这样可以在一定程度上更方便地查看模型中所包含的数据。

## 第 43 页 · 数据操作

- 数据操作
- 3．修改数据
- 修改数据的操作建立于查询数据的基础之上。获取到模型对象后，为对象属性进行赋值，再将模型对象加入数据操作队列，执行提交进行改动即可。代码如下所示。
- 在数据库查询的结果如下图所示。
- # 获取id为2 的用户对象，并提交更改到数据库
- user = UserModel.query.get(2)  # type: UserModel
- user.password = 'admin'
- user.is_admin = True
- db.session.add(user)
- db.session.commit()

![第43页图](media/ch05/slide43_img1.png)

## 第 44 页 · 数据操作

- 数据操作
- 4．删除数据
- 删除数据的操作亦是建立于查询数据基础之上的，在获取到模型对象后，将模型对象加入数据操作队列，执行提交进行改动即可。不同之处在于删除使用delete()方法进行操作。代码如下所示。
- 在数据库查询的结果如下图所示。
- # 获取特定id的用户对象，并将其从数据库中删除
- user_1 = UserModel.query.get(1)  # type: UserModel
- user_2 = UserModel.query.get(2)  # type: UserModel
- db.session.delete(user_1)
- db.session.delete(user_2)
- db.session.commit()

![第44页图](media/ch05/slide44_img1.png)

## 第 45 页 · 高级查询

- 高级查询
- 高级查询可以获取特定位置/数量的数据、对数据进行排序、字符串包含判断，以及复合条件查询（and/or）的操作。
- 这一块简单讲书上的例子，其他就不细说。大家感兴趣可以把其他例子的结果也输出出来看一看。
- 首先使用之前创建的文章模型进行演示。在操作之前，需要添加一些测试数据，在交互Shell中执行以下代码。
- # 快速添加5 个测试用的文章模型
- for i in range(5):
- article = ArticleModel(title='文章_%d' % i, content='This is article_%d.' % i)
- db.session.add(article)
- article = ArticleModel(title='测试文章1', content='Hello World!')
- db.session.add(article)
- article = ArticleModel(title='测试文章2', content='Hello Flask!')
- db.session.add(article)
- db.session.commit()

## 第 46 页 · 高级查询

- 高级查询
- 执行后的效果如数据库内容如下图所示。

![第46页图](media/ch05/slide46_img1.png)

## 第 47 页 · 高级查询

- 高级查询
- 这里执行第一个查询代码，代码如下
- # 从第 3 个对象（索引从 0 开始）开始，获取所有数据
- articles = ArticleModel.query.offset(2).all()
- print(articles)
- 查询效果图如下所示。
- 大家感兴趣可以把书本其他的查询也执行一边看看效果如何。

![第47页图](media/ch05/slide47_img1.png)

## 第 48 页 · 模型关联

- 模型关联
- 一提到数据库，就会想到表关联，那么SQLAlchemy也是一样的，拿前面的章节举例，建立了两个模型：一个是用户模型，另一个是文章模型。
- 我们知道在网站使用流程中，文章由用户创建，即每一个文章对象都会对应一个作者；可以根据文章作者找到对应的用户，也可以根据特定的用户查询到与之对应的文章。
- 那么如果想实现以上效果的话，仅需为这两个模型建立外键关联。
- 一个是在文章模型代码中添加外键（作者id），一个是反向关联属性（用户模型中定义）

## 第 49 页 · 模型关联

- 模型关联
- 首先是文章模型代码中添加外键（作者id），代码如下。
- class ArticleModel(db.Model, BaseModel):
      __tablename__ = 'article'
 
      id = db.Column(db.INTEGER, primary_key=True)
      title = db.Column(db.VARCHAR)
      content = db.Column(db.VARCHAR)
 
      # 此处根据作者（用户）id与文章模型进行外键关联
      # 作者（用户）id不为主键，为了保证查询效率，需要为字段建立索引（index=True）
      author_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), index=True)
 
      # 在UserModel中建立一对多关联时，为ArticleModel添加了反向关联属性
      # 此处为ArticleModel声明author属性类型，以便于IDE进行识别
      author: UserModel

## 第 50 页 · 模型关联

- 模型关联
- 其次是在用户模型中建立反向关联，代码如下。
- class UserModel(db.Model, BaseModel):
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- # 建立一对多映射关系（uselist=True）
- # 为了便于IDE识别变量类型，此处声明articles类型为list
- articles: list = db.relationship('ArticleModel', backref='author', uselist=True)

## 第 51 页 · 模型关联

- 模型关联
- 此时，模型结构相较于之前的数据表发生了改变，需要重新创建数据表，并添加相关测试数据。代码如下。
- # 重建所有已加载模型的数据表
- db.drop_all()
- db.create_all()
- # 创建用户对象
- user_1 = UserModel(
- username='admin',
- password='123456',
- is_admin=True,
- )
- user_2 = UserModel(
- username='user',
- password='123456',
- is_admin=False,
- )
- # 将用户对象提交到数据操作队列
- db.session.add(user_1)
- db.session.add(user_2)
- # 提交更改到数据库
- db.session.commit()

## 第 52 页 · 模型关联

- 模型关联
- 接下来就是用两种不同的方式添加文章，（交互Shell）代码如下。
- # 根据用户模型关联属性进行文章添加
- user_1 = UserModel.query.get(1)  # type: UserModel
- user_1.articles.append(ArticleModel(title='文章_1', content='no message.'))
- db.session.add(user_1)
- # 根据文章模型反向关联属性与用户进行关联并添加文章
- user_2 = UserModel.query.get(2)
- article = ArticleModel(title='文章_2', content='no message.')
- article.author = user_2
- db.session.add(article)
- db.session.commit()
- 两种方式的区别有两点，1、关联属性的方向；2、赋值方式
- 关联属性的方向： 第一种方式是通过用户模型的关联属性向文章模型添加数据。第二种方式是通过文章模型的反向关联属性向用户模型添加数据。
- 赋值方式： 第一种方式通过列表的 append 方法将文章实例添加到用户的关联属性中。第二种方式通过直接赋值将用户实例赋给文章的反向关联属性。

## 第 53 页 · 模型关联

- 模型关联
- 优缺点：
- **第一种方式：**
- 优点：代码简洁，直观地通过关联属性添加数据。
- 缺点：如果关联属性的列表较长，添加多个文章可能会导致多次数据库查询，效率较低。
- **第二种方式：**
- 优点：可以在不加载整个关联属性列表的情况下，直接将用户与文章关联。适用于关联属性较大的情况。
- 缺点：代码稍微复杂，需要设置反向关联属性。
- 根据具体需求，可以选择适合应用程序和数据模型的添加方式。如果关联属性较小且不太频繁变动，第一种方式可能更为直观和便捷。如果关联属性较大或需要更高的效率，第二种方式可能更适合。

## 第 54 页 · 模型关联

- 模型关联
- 在数据库里的效果图如下所示。

![第54页图](media/ch05/slide54_img1.png)

## 第 55 页 · 模型关联

- 模型关联
- 然后在shell中展示文章模型数据。代码如下所示。
- >>> print(user_1.articles)
- [<ArticleModel id=1 content='no message.' author_id=1 title='文章_1'>]
- >>> article = user_2.articles[0]
- >>> print(article)
- <ArticleModel title='文章_2' content='no message.' author_id=2 id=2 author=<UserModel ...>>
- >>> print(article.author)
- <UserModel username='user' password='123456' is_admin=False id=2 articles=[<ArticleModel title='\u6587\u7ae0_2' content='no message.' author_id=2 id=2 author=<UserModel ...>>]>
- 以上便是用户模型与文章模型简单的一对多关联的实现。此时，再来回顾前面所设计的用户模型，这个模型仅包含了用户名、密码、是否为管理员3个基本属性（字段），这个模型其实仅用于用户账号验证。

## 第 56 页 · 模型关联

- 模型关联
- 在开发的情况中，难免会遇到需要增加需求，需要扩展数据库的关联信息。我们还可以用一种方法，一对一关联。
- 如果现在需要对每一个用户添加一个对应的性别、介绍等多项信息，我们可以创建用户信息模型，并与用户模型进行一对一关联实现。这样做可以在不修改用户模型的情况下，为用户扩展信息展示功能。
- 用户模型类定义的代码如下
- class UserInfoModel(db.Model, BaseModel):
      __tablename__ = 'user_info'
 
      # 由于在UserModel中建立了映射关系，在 backref 参数中使用 "user" 属性进行反向关联
      # 为了便于代码编写，需要在此处声明关联属性类型
      user: UserModel
 
      # 设置外键，根据UserModel的id字段进行关联
      user_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), primary_key=True)
      sex = db.Column(db.INTEGER)
      introduce = db.Column(db.TEXT)

## 第 57 页 · 模型关联

- 模型关联
- 用户信息模型建立完成后，需要在用户模型中建立反向关联，代码如下所示。
- class UserModel(db.Model, BaseModel):
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- # 建立一对一映射关系（uselist=False）
- # backref 参数用于在 UserInfoModel 的 "user" 属性中建立反向关联
- # cascade 参数用于关联模型操作，如删除 UserModel 对象时，同时删除相应的 UserInfoModel 对象
- info = db.relationship('UserInfoModel', backref='user', uselist=False, cascade='all')

## 第 58 页 · 模型关联

- 模型关联
- 接下来通过3种不同方式创建用户并设置用户信息，以下是代码（交互Shell）演示。
- # 由于前面建立了新的模型，所以在操作数据前需要创建相应数据表
db.create_all()
- # 与使用普通方式创建模型一致，在构造参数中关联信息模型
user_3 = UserModel(
      username='test',
      password='123456',
      is_admin=False,
      info=UserInfoModel(sex=1, introduce='This is user 3.'),
)
- 首先是第一种，代码如下所示。
- 优点： 这种方式直接在用户模型的构造函数中传递了关联信息模型的实例，代码简洁，一次性完成了模型之间的关联。
- 缺点： 如果需要构建多个用户并分别关联不同的信息模型，需要多次重复这种方式，可能不够灵活。

## 第 59 页 · 模型关联

- 模型关联
- # 创建用户模型后，通过设置属性关联用户信息模型
- user_4 = UserModel(
- username='master',
- password='123456',
- is_admin=False,
- )
- user_4.info = UserInfoModel(sex=1, introduce='This is user 4.')
- 接着是第二种，代码如下所示。
- 优点： 这种方式先创建了用户模型，然后通过设置属性的方式关联信息模型，更加灵活，可以在不同时间点建立关联。
- 缺点： 需要额外的代码来设置属性，相对于第一种方式稍微繁琐一些。

## 第 60 页 · 模型关联

- 模型关联
- 最后是第三种，代码如下所示。
- # 创建用户信息模型后，通过反向关联的方式关联用户模型
- user_5 = UserModel(
- username='slave',
- password='123456',
- is_admin=False,
- )
- UserInfoModel(sex=2, introduce='This is user 5.').user = user_5
- 优点： 这种方式创建了信息模型，并通过反向关联的方式将用户模型与信息模型关联，也具有一定的灵活性。
- 缺点： 可能相对不太直观，需要了解数据库模型之间的关系，不如前两种方式容易理解。

## 第 61 页 · 模型关联

- 模型关联
- 然后就是需要把用户添加的信息传递到数据库里面。代码如下所示。数据库的内容如下图所示。
- db.session.add(user_3)
- db.session.add(user_4)
- db.session.add(user_5)
- db.session.commit()
- 由于以前创建的用户并没有关联用户信息，故此处的用户信息数据表不包含admin用户与user用户的信息。以上便是模型一对一关联的实现。

![第61页图](media/ch05/slide61_img1.png)

![第61页图](media/ch05/slide61_img2.png)

## 第 62 页 · 模型关联

- 模型关联
- 对于前面三种添加用户信息的方法，选择哪种方法取决于具体需求和代码的清晰度。第一种方法适合一次性建立模型关联，第二种方法适合在不同时间点建立关联，第三种方法则具有一定的灵活性，但可能需要更多的了解数据库模型的关系。在实际应用中，可以根据需求选择最适合的方式。

## 第 63 页 · 数据分页功能

- 数据分页功能
- 数据分页显示是一个很常见的功能。例如之前所设计的文章模型，当文章数量达到一定程度（例如10篇）时，便不再适合在单个页面中展示，这时便需要用到数据分页显示功能，每一页加载部分数据。
- 当然，像这种常见需求，Flask-SQLAlchemy与Flask-Bootstrap都已经实现好了，只要引入相应功能并使用即可。以下是数据分页功能视图函数的代码。
- @app.route('/paginator')
def paginator():
     # 每页显示3篇文章
     pagination = ArticleModel.query.paginate(per_page=3)
     return render_template('paginator.html', pagination=pagination)
- ArticleModel.query：这是通过 SQLAlchemy 数据库模型创建的查询对象，它用于查询文章模型 (ArticleModel) 的数据库表。
- paginate(per_page=3)：这是对查询结果进行分页的操作。per_page=3 意味着每页显示 3 篇文章。这将返回一个分页对象 (pagination)，其中包含了当前页的文章数据以及分页信息。

## 第 64 页 · 数据分页功能

- 数据分页功能
- 模板页面的代码如下。部分内容解释如右所示。
- {% extends 'bootstrap/base.html' %}
- {# 从Flask-Bootstrap引入分页功能 #}
- {% import 'bootstrap/pagination.html' as pagi %}
- {% block title %}数据分页显示{% endblock %}
- {% block body %}
- <div class="container">
- {% for item in pagination.items %}
- <h1>{{ item.title }}</h1>
- <p>{{ item.content | safe }}</p>
- {% endfor %}
- {# 根据pagination（分页）对象渲染分页按钮 #}
- {{ pagi.render_pagination(pagination) }}
- </div>
- {% endblock %}
- **1、使用了Flask-Bootstrap的pagination.html里面的**
- 分页控件。
- 2、{% for item in pagination.items %} 和 {% endfor %}：这是一个循环块，用于迭代分页对象 (pagination) 中的每个项目。在这个循环中，模板将渲染每篇文章的标题和内容。
- 3、<h1>{{ item.title }}</h1> 和 <p>{{ item.content | safe }}</p>：这些是用于显示文章标题和内容的模板变量。{{ item.title }} 和 {{ item.content | safe }} 分别表示当前文章对象 (item) 的标题和内容。| safe 过滤器用于确保内容以原样渲染，而不是将其解释为 HTML。
- 4、{{ pagi.render_pagination(pagination) }}：这一行代码调用 Flask-Bootstrap 提供的 render_pagination 函数来渲染分页控件。这个函数接受分页对象 (pagination) 作为参数，并生成分页按钮，允许用户浏览不同的页数。

## 第 65 页 · 数据分页功能

- 数据分页功能
- 效果图如下所示。

![第65页图](media/ch05/slide65_img1.png)

## 第 66 页 · Flask-Migrate

- Flask-Migrate
- 04

## 第 67 页 · “

- “
- Flask-Migrate 是一个 Flask 扩展，用于管理 Flask Web 应用程序中的数据库迁移（migration）。数据库迁移是一种重要的技术，用于在开发过程中管理数据库模型的变化，包括创建新的表、修改表结构、添加或删除列等。
- 什么是Flask-Migrate？
- ”
- 概念介绍

## 第 68 页 · “

- “
- 具体来说，Flask-Migrate 主要用于以下用途：
- 1、数据库模型的版本控制： Flask-Migrate 允许您在应用程序的不同版本之间跟踪数据库模型的变化。每次您修改数据库模型时，您都可以创建一个新的迁移版本。
- 2、数据库迁移的自动生成： Flask-Migrate 可以自动生成数据库迁移脚本，这些脚本包含了数据库模型变化的详细说明，包括添加、修改或删除表，以及更新表的结构。
- 3、应用数据库迁移： 使用 Flask-Migrate，您可以轻松地将数据库模型的变化应用到数据库中。这样，您可以在开发过程中保持数据库模型与应用的同步，而不会丢失已有的数据。
- 4、回滚迁移： 如果需要，您还可以回滚迁移，即撤销之前的迁移操作，以恢复到之前的数据库状态。
- Flask-Migrate的用途是什么？
- ”
- 概念介绍

## 第 69 页 · 安装依赖

- 安装依赖
- 与安装Flask的操作一致，打开命令提示符窗口，输入以下命令。
- pip install flask-migrate==2.5.2
- 执行上述命令之后，能看到“Successfully installed…”提示信息，没有提示红色的报错信息，即安装成功，此时，Flask-Migrate的依赖包便安装完成了如下图所示。

![第69页图](media/ch05/slide69_img1.png)

## 第 70 页 · 基本操作

- 基本操作
- 在使用Flask-Migrate之前，需要在Flask-Script提供的Manager对象中添加指令（MigrateCommand），以下是代码演示。
- from flask_migrate import Migrate, MigrateCommand
# 创建migrate对象并添加db（数据库migrate）指令
migrate = Migrate(app, db)
migrate.init_app(app, render_as_batch=True)
manager.add_command('db', MigrateCommand)
- migrate = Migrate(app, db)：这一行创建了一个 Migrate 对象，并将应用实例 app 和数据库实例 db 传递给它。Migrate 对象用于管理数据库迁移。
- migrate.init_app(app, render_as_batch=True)：这一行初始化了 Migrate 对象，并将应用实例 app 传递给它。render_as_batch=True 表示将迁移操作批量渲染，这是一个性能优化选项。初始化后，Migrate 对象将与应用关联，以便在应用中执行数据库迁移。
- manager.add_command('db', MigrateCommand)：这一行将 MigrateCommand 命令添加到 Flask-Script（或 Flask-CLI）的管理命令中。'db' 是命令的名称，可以在终端中使用该名称来执行数据库迁移命令。

## 第 71 页 · 基本操作

- 基本操作
- 此时，在命令提示符窗口中执行“python app.py”就可以见到新增了一条名为“db”的指令，如下图所示。

![第71页图](media/ch05/slide71_img1.png)

## 第 72 页 · 基本操作

- 基本操作
- 在使用Flask-Migrate后，不再需要通过“db.create_all()”或“db.drop_all()”命令，可直接对数据库进行操作。通常情况下，所有对数据表的更改操作都可以通过Flask-Migrate进行。
- 由于在此之前使用“db”对象创建了数据库，在演示Flask-Migrate的相关操作前需要删除数据库文件，如图下图所示。在删除文件之前，需要关闭数据可视化工具，如SQLiteStudio。

![第72页图](media/ch05/slide72_img1.png)

## 第 73 页 · 基本操作

- 基本操作
- 接下来的操作将在命令提示符窗口中进行。
- 首先是初始化数据库迁移仓库，使用init子命令进行。
- C:\Users\User\PycharmProjects\db_inter_active>python app.py db init
- Creating directory C:\Users\User\PycharmProjects\db_inter_active\ migrations ...  done
- Creating directory C:\Users\User\PycharmProjects\db_inter_active\ migrations\versions ...  done
- Generating C:\Users\User\PycharmProjects\db_inter_active\migrations\ alembic.ini ...  done
- Generating C:\Users\User\PycharmProjects\db_inter_active\migrations\ env.py ...  done
- Generating C:\Users\User\PycharmProjects\db_inter_active\migrations\ README ...  done
- Generating C:\Users\User\PycharmProjects\db_inter_active\migrations\ script.py.mako ...  done
- Please edit configuration/connection/logging settings in 'C:\\Users\\User\\PycharmProjects\\db_inter_active\\migrations\\alembic.ini' before proceeding.

## 第 74 页 · 基本操作

- 基本操作
- 在命令执行完成后，项目目录中将会出现一个新的目录（migrations），这个目录便是数据库迁移仓库，接下来将会用于保存所有版本的数据库改动脚本，如下图所示。

![第74页图](media/ch05/slide74_img1.png)

## 第 75 页 · 基本操作

- 基本操作
- 在数据库迁移仓库创建完成之后，需要初始化数据库、检测数据库改动，并使用Flask-Migrate生成数据库来创建/更新脚本。
- C:\Users\User\PycharmProjects\db_inter_active>python app.py db migrate
- INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
- INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
- INFO  [alembic.autogenerate.compare] Detected added table 'user'
- INFO  [alembic.autogenerate.compare] Detected added table 'article'
- INFO  [alembic.autogenerate.compare] Detected added index 'ix_article_ author_id' on '['author_id']'
- INFO  [alembic.autogenerate.compare] Detected added table 'user_info'
- Generating C:\Users\User\PycharmProjects\db_inter_active\migrations\ versions\db4e71e843b1_.py ...  done
- 以上命令执行完成以后，并没有马上应用到数据库中，可以在“migrations\versions”目录下找到对应的数据库改动脚本，如果有定制化需求，可以直接修改数据库改动脚本文件。

## 第 76 页 · 基本操作

- 基本操作
- 由于生成的脚本篇幅较长，故此处以简略方式展示。
- # ……此处省略脚本信息……
- def upgrade():
- # ……此处省略生成的数据库升级脚本……
- def downgrade():
- # ……此处省略生成的数据库降级脚本……
- 由生成的数据库改动脚本可见，Flask-Migrate不但支持对数据库进行升级，还支持对数据库进行降级。
数据库改动脚本生成以后，便可以对数据库进行升、降级操作。此处先使用数据可视化工具浏览当前数据库的情况，如下图所示。

![第76页图](media/ch05/slide76_img1.png)

## 第 77 页 · 基本操作

- 基本操作
- 由于还没应用升级脚本，所以此时数据库只有由Flask-Migrate创建的alembic_version版本记录表。接下来进行升级操作。
- C:\Users\User\PycharmProjects\db_inter_active>python app.py db upgrade
- INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
- INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
- INFO  [alembic.runtime.migration] Running upgrade  -> db4e71e843b1, empty message
- 此时再查看数据库，便会发现书本5.3.2小节中定义模型对应的数据表都被自动生成了，同时版本记录表中的版本号更新到了对应的版本，如下图所示。

![第77页图](media/ch05/slide77_img1.png)

## 第 78 页 · 基本操作

- 基本操作
- 如果接下来要对模型进行修改，如添加字段等，仅需要在命令提示符窗口中重复执行以下操作即可。
- # 检测并生成数据库改动脚本
- python app.py db migrate
- # 应用数据库升级操作
- python app.py db upgrade
- 如果需要对数据库进行降级，只需要执行以下命令即可。
- # 应用数据库降级操作
- python app.py db downgrade

## 第 79 页 · 小结

- 小结
- 05

## 第 80 页 · 小结

- 小结
- 本章介绍了Flask中对数据库的基本操作。
- 学习了在控制台对Flask交互的方式：Flask Shell
- 学习了Flask-SQLAlchemy 的基本使用方法：
- **1、初始化SQLAlchemy**
- **2、定义模型**
- **3、数据库操作：增删查改**
- 学习了Flask-Migrate数据库迁移：
- **1、创建迁移：python app.py db migrate**
- **2、应用迁移：python app.py db upgrade**
- **3、回滚迁移：python app.py db downgrade**

## 第 81 页 · 课后作业

- 课后作业
- 今日作业
- 课后习题5.6
- 选做（定义一个数据库模型（例如，Book），包括书名、作者等字段。
- 配置数据库连接，并在应用中初始化 SQLAlchemy。
- 创建一个路由，显示所有书籍的列表。
- 使用 SQLAlchemy 查询从数据库中检索书籍列表，并在模板中渲染。
- 创建一个页面，允许用户添加新的书籍到数据库。
- 实现表单验证，确保用户提供的信息有效。）

![第81页图](media/ch05/slide81_img1.jpg)

## 第 82 页 · 谢谢聆听

- 谢谢聆听
