第三篇把项目拆清楚了,但工单仍在内存里。服务一重启,刚创建的工单就没了;启动两个进程,还会得到两份互不相通的数据。
这一篇把数据写入 SQLite。我们不仅完成增删改查,还会先创建一张旧表、写入旧工单,再增加优先级字段,验证数据能否保留下来。
核心主题:用 SQLAlchemy 操作持久化数据,用迁移管理表结构的变化。
目标读者:已理解前篇的应用工厂、Blueprint 和请求上下文,准备为 Flask 接口接入数据库的开发者。 SQL 用到哪里解释到哪里,无需先学完 ORM。
1. 本篇交付与行为变化
保留健康检查、列表筛选、单条查询和创建接口,新增:
| 请求 | 用途 | 成功响应 |
|---|---|---|
PATCH /api/tickets/3 | 只修改传入的字段 | 200,返回修改后的工单 |
DELETE /api/tickets/3 | 删除工单 | 204,没有响应正文 |
迁移后的工单包含:
{"id": 3, "title": "修复导出", "status": "open", "priority": "normal"}
priority 是新增字段,只允许 low、normal、high,默认 normal。原来的标题和状态校验保留;部分更新不为缺省字段补默认值,避免把未修改的状态覆盖掉。
三项变化需要提前说明:
- 工厂不再自动创建两条样本,也不自动创建数据库表。
- 数据由数据库文件保存,多个应用连接同一个文件就会看到同一份数据。
- 返回对象新增
priority;原有 URL、错误结构及创建成功的 201、Location保留。
应用实例隔离与数据库隔离是两回事。测试若要隔离数据,就给不同应用配置不同数据库。
2. 独立目录与依赖
实际验证环境:macOS、Python 3.13.13、Flask 3.1.3、SQLAlchemy 2.0.36、SQLite 3.51.2。锁定依赖要求 Python 3.10 及以上。命令适用于 macOS / Linux 的 bash、zsh。
创建目录:
mkdir flask-database
在编辑器中打开它,并打开该目录的终端。文件结构如下:
flask-database/
├── requirements.txt
├── ticket_app/
│ ├── __init__.py
│ ├── extensions.py
│ ├── models.py
│ ├── api.py
│ ├── validation.py
│ └── errors.py
├── migrations/
│ ├── alembic.ini
│ ├── env.py
│ ├── script.py.mako
│ └── versions/
│ ├── 0001_create_tickets.py
│ └── 0002_add_priority.py
├── legacy_demo.py
├── verify.py
└── exercise_app.py
这是本篇独立运行目录,按本文建立文件即可。第三篇的内存 store.py 不再参与运行。
创建并激活虚拟环境:
python3 -m venv .venv
source .venv/bin/activate
创建 requirements.txt:
Flask==3.1.3
Flask-SQLAlchemy==3.1.1
SQLAlchemy==2.0.36
Flask-Migrate==4.1.0
alembic==1.14.1
Werkzeug==3.1.8
Jinja2==3.1.6
click==8.4.1
itsdangerous==2.2.0
blinker==1.9.0
MarkupSafe==3.0.3
Mako==1.4.3
typing_extensions==4.16.0
安装:
python -m pip install -r requirements.txt
Flask-SQLAlchemy 管理应用中的数据库连接和会话;SQLAlchemy 提供模型、查询与 SQL 操作;Flask-Migrate 把 Alembic 的迁移能力接到 Flask 命令行。SQLite 由 Python 自带驱动访问,本地不需要启动数据库服务。
3. 声明扩展与模型
扩展先声明,再绑定应用
创建 ticket_app/extensions.py:
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
# 先声明扩展,再由工厂绑定应用,避免模型反向导入具体 app。
db = SQLAlchemy(model_class=Base)
migrate = Migrate()
模块中的 db 是扩展对象,不是已经连上某个数据库的单一连接。工厂稍后调用 init_app(),根据当前应用的配置初始化引擎等状态。
模型只导入扩展,不导入具体应用,延续第三篇的依赖方向。
模型描述表,不会自行建表
创建 ticket_app/models.py:
from sqlalchemy import CheckConstraint, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from .extensions import db
class Ticket(db.Model):
__tablename__ = "tickets"
__table_args__ = (
CheckConstraint("length(title) BETWEEN 1 AND 80", name="ck_tickets_title"),
CheckConstraint("status IN ('open', 'done')", name="ck_tickets_status"),
CheckConstraint("priority IN ('low', 'normal', 'high')", name="ck_tickets_priority"),
{"sqlite_autoincrement": True},
)
id: Mapped[int] = mapped_column(Integer, primary_key=True)
title: Mapped[str] = mapped_column(String(80), nullable=False)
status: Mapped[str] = mapped_column(String(10), nullable=False, server_default="open")
priority: Mapped[str] = mapped_column(
String(10), nullable=False, server_default="normal")
def to_dict(self):
return {
"id": self.id, "title": self.title,
"status": self.status, "priority": self.priority,
}
Ticket 对应 tickets 表,一个实例通常对应一条记录。Mapped 和 mapped_column() 是 SQLAlchemy 2.x 的声明方式,分别表达属性类型与列定义。
nullable=False 禁止 SQL 的 NULL,不能替代“空字符串无效”的业务规则。SQLite 也不会因为写了 String(80) 就自动限制字符串长度,所以这里额外加了命名的 CHECK 约束。
HTTP 校验提供清楚的错误提示,数据库约束守住最终的数据边界。二者各有用途;数据库的长度约束并不替代 Python 对首尾空白的规范化。
server_default 是数据库侧的默认值。它既能用于未指定字段的插入,也让新增的非空字段为旧记录补上值。
编号交给数据库分配。本篇开启 SQLite 的 AUTOINCREMENT,避免删除最大编号后重用已经提交过的编号;它有额外开销,也不保证编号连续。
这些声明目前只产生模型元数据。修改 Python 类不会自动修改已有表。
4. 输入校验:区分创建与部分更新
创建 ticket_app/validation.py:
from flask import abort, request
VALID_STATUSES = ("open", "done")
VALID_PRIORITIES = ("low", "normal", "high")
def validate_ticket(payload, partial=False):
if not isinstance(payload, dict) or not payload:
abort(400, description="JSON 顶层必须是非空对象")
if set(payload) - {"title", "status", "priority"}:
abort(400, description="只允许 title、status 和 priority 字段")
fields = {}
if not partial or "title" in payload:
title = payload.get("title")
if not isinstance(title, str):
abort(400, description="title 必须是字符串")
title = title.strip()
if not 1 <= len(title) <= 80:
abort(400, description="title 去除首尾空白后长度必须为 1—80")
if "\x00" in title:
abort(400, description="title 不能包含空字符")
fields["title"] = title
for name, allowed, default in (
("status", VALID_STATUSES, "open"),
("priority", VALID_PRIORITIES, "normal"),
):
if partial and name not in payload:
continue
value = payload.get(name, default)
if not isinstance(value, str) or value not in allowed:
abort(400, description=f"{name} 只允许 {'、'.join(allowed)}")
fields[name] = value
return fields
def read_status_filter():
if set(request.args) - {"status"}:
abort(400, description="列表查询只允许 status 参数")
values = request.args.getlist("status")
if len(values) > 1:
abort(400, description="status 参数不能重复")
if not values:
return None
if values[0] not in VALID_STATUSES:
abort(400, description="status 查询值只允许 open 或 done")
return values[0]
创建时,标题必填,状态和优先级可以采用默认值。部分更新时,只返回用户明确传入的字段。标题还明确拒绝空字符 \x00,避免 SQLite 的字符串长度处理与 Python 校验产生差异。
例如只传 {"priority":"high"},就不能顺便把原来 done 的状态补成 open。空对象和未知字段仍返回 400。
5. 数据库版 CRUD 接口
创建 ticket_app/api.py:
from flask import Blueprint, abort, jsonify, request, url_for
from werkzeug.exceptions import BadRequest
from .extensions import db
from .models import Ticket
from .validation import read_status_filter, validate_ticket
tickets_bp = Blueprint("tickets", __name__, url_prefix="/api")
def read_json_body():
if not request.is_json:
abort(415)
try:
return request.get_json()
except BadRequest:
abort(400, description="请求体不是合法 JSON")
def save_ticket(ticket):
# flush 获取数据库生成的编号;提交前取好返回数据,避免提交后额外查询。
db.session.flush()
payload = ticket.to_dict()
db.session.commit()
return payload
@tickets_bp.get("/tickets")
def list_tickets():
status = read_status_filter()
statement = db.select(Ticket).order_by(Ticket.id)
if status is not None:
statement = statement.where(Ticket.status == status)
items = [ticket.to_dict() for ticket in db.session.scalars(statement)]
return jsonify({"items": items, "total": len(items)})
@tickets_bp.get("/tickets/<int:ticket_id>")
def get_ticket(ticket_id):
return jsonify(db.get_or_404(Ticket, ticket_id).to_dict())
@tickets_bp.post("/tickets")
def create_ticket():
ticket = Ticket(**validate_ticket(read_json_body()))
db.session.add(ticket)
payload = save_ticket(ticket)
response = jsonify(payload)
response.status_code = 201
response.headers["Location"] = url_for(
"tickets.get_ticket", ticket_id=payload["id"])
return response
@tickets_bp.patch("/tickets/<int:ticket_id>")
def update_ticket(ticket_id):
fields = validate_ticket(read_json_body(), partial=True)
ticket = db.get_or_404(Ticket, ticket_id)
for name, value in fields.items():
setattr(ticket, name, value)
return jsonify(save_ticket(ticket))
@tickets_bp.delete("/tickets/<int:ticket_id>")
def delete_ticket(ticket_id):
db.session.delete(db.get_or_404(Ticket, ticket_id))
db.session.commit()
return "", 204
查询什么时候执行
db.select(Ticket) 构造查询语句;调用 db.session.scalars(statement) 才执行查询,得到模型对象。筛选条件成为 SQL 的 WHERE 条件,值通过参数绑定传入,没有拼接用户输入。
db.get_or_404() 按主键查找,不存在时返回 404。列表没有匹配数据则返回 200 和空列表,延续前篇约定。
本篇列表仍一次读取全部匹配记录,适用于小样本。分页、索引和查询计划在下一篇展开。
add、flush、commit 不等价
| 操作 | 含义 |
|---|---|
session.add() | 把新对象纳入会话管理 |
session.flush() | 将待处理的修改发送到数据库,仍在当前事务里 |
session.commit() | 提交事务,使修改完成 |
session.rollback() | 回滚当前事务,恢复会话可继续使用的状态 |
add() 不表示数据已经持久化。查询也可能触发自动 flush,所以不要把“没调用 commit”误认为“还没发出 SQL”。
创建时显式 flush,才能取得数据库生成的编号。我们在提交前生成返回字典,提交成功后才返回 201;这样也避免默认提交后属性过期带来的额外读取。
部分更新先校验完整输入,再修改对象。setattr() 使用的字段已经过白名单限制,不能让客户端任意修改 id 等属性。
删除返回 204,正文必须为空。此处更新还没有状态流转、权限或并发版本检查;这些规则在后续对应篇加入。
6. 错误回滚与工厂初始化
创建 ticket_app/errors.py:
from flask import current_app, jsonify
from sqlalchemy.exc import SQLAlchemyError
from werkzeug.exceptions import HTTPException, InternalServerError
from .extensions import db
ERROR_CODES = {
400: "invalid_request", 404: "not_found", 405: "method_not_allowed",
413: "payload_too_large", 415: "unsupported_media_type", 500: "internal_error",
}
ERROR_MESSAGES = {
404: "请求的资源不存在", 405: "此资源不支持该请求方法",
415: "请使用 application/json 或 application/*+json",
500: "服务器内部错误",
}
def handle_http_error(error):
status = error.code or 500
message = ERROR_MESSAGES.get(status, error.description)
if status == 413:
message = f"请求体超过 {current_app.config['MAX_CONTENT_LENGTH']} 字节"
response = error.get_response()
response.set_data(jsonify({"error": {
"code": ERROR_CODES.get(status, "http_error"), "message": message,
}}).get_data())
response.content_type = "application/json"
return response
def handle_database_error(error):
# flush 或 commit 失败后,回滚使会话退出失败事务状态。
db.session.rollback()
current_app.logger.exception("数据库操作失败")
return handle_http_error(InternalServerError())
def register_error_handlers(app):
app.register_error_handler(HTTPException, handle_http_error)
app.register_error_handler(SQLAlchemyError, handle_database_error)
数据库异常先回滚,再记录故障,向客户端返回通用 500。输入校验失败仍是 400;不能把数据库连接故障说成用户参数错误,也不能把任意约束异常都认定为业务冲突。
在 HTTP 请求之外直接操作数据库,比如命令行脚本,应用的 HTTP 错误处理器不会替你处理异常,需要显式管理事务。
创建 ticket_app/__init__.py:
from pathlib import Path
from uuid import uuid4
from flask import Flask, g, jsonify
from .api import tickets_bp
from .errors import register_error_handlers
from .extensions import db, migrate
def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
TESTING=False, ENV_NAME="development", MAX_CONTENT_LENGTH=1024,
SQLALCHEMY_DATABASE_URI="sqlite:///tickets.db",
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
app.config.from_prefixed_env(prefix="TICKETS")
if test_config is not None:
app.config.from_mapping(test_config)
limit = app.config["MAX_CONTENT_LENGTH"]
if type(limit) is not int or limit <= 0:
raise ValueError("MAX_CONTENT_LENGTH 必须是正整数")
if app.config["ENV_NAME"] not in ("development", "testing", "production"):
raise ValueError("ENV_NAME 只允许 development、testing 或 production")
Path(app.instance_path).mkdir(parents=True, exist_ok=True)
app.json.ensure_ascii = False
db.init_app(app)
migration_dir = str(Path(__file__).resolve().parent.parent / "migrations")
migrate.init_app(app, db, directory=migration_dir)
register_error_handlers(app)
app.register_blueprint(tickets_bp)
@app.before_request
def assign_request_id():
g.request_id = uuid4().hex
@app.after_request
def attach_request_id(response):
response.headers["X-Request-ID"] = g.request_id
return response
@app.get("/health")
def health():
return jsonify({"status": "ok"})
return app
在 Flask-SQLAlchemy 3.x 中,sqlite:///tickets.db 的相对文件路径以 app.instance_path 为基准,本结构下位于项目的 instance/tickets.db,不是任意终端当前目录。
绝对文件路径采用 sqlite:////绝对路径 形式;后面的测试脚本用 URI 前缀加绝对路径构造它。
db.session 按应用上下文管理。正常请求结束时,扩展移除会话、释放其占用的连接资源;引擎仍可能保留空闲连接用于复用,不意味着每次都关闭整个连接池。读取配置与数据库状态的脚本仍需 app.app_context()。
工厂只初始化扩展,不调用 create_all(),不执行迁移。create_all() 也不能把已有表自动升级成新结构。生产启动不得自动执行 DDL,结构变更必须先审查并显式执行。
7. 迁移文件:模型的变化必须落实到数据库
本文直接提供完整迁移目录,不要再执行 flask db init。0001 建旧表,0002 增加优先级;运行时模型是最终版本。
迁移配置与运行环境
创建 migrations/alembic.ini:
[alembic]
script_location = migrations
创建 migrations/env.py:
from alembic import context
from flask import current_app
database = current_app.extensions["migrate"].db
# 本篇包含 SQLite 批量改表,仅提供连接真实数据库的在线迁移。
if context.is_offline_mode():
raise RuntimeError("本篇迁移不支持 --sql 离线模式")
def skip_empty_revision(migration_context, revision, directives):
# 只过滤自动比较产生的空脚本,不拦截手工的数据迁移。
if getattr(migration_context.config.cmd_opts, "autogenerate", False):
if directives and directives[0].upgrade_ops.is_empty():
directives.clear()
print("未检测到结构变化,未生成迁移。")
with database.engine.connect() as connection:
context.configure(
connection=connection,
target_metadata=database.metadata,
compare_type=True,
compare_server_default=True,
render_as_batch=True,
process_revision_directives=skip_empty_revision,
)
with context.begin_transaction():
context.run_migrations()
Alembic 从当前应用取得数据库连接和模型元数据,再执行版本链。回调过滤自动比较生成的空脚本,避免没有结构变化也增加版本。这里是单数据库、在线模式的配置,不适用于多数据库迁移或直接导出离线 SQL。
创建 migrations/script.py.mako,它是后续生成迁移文件的模板:
"""${message}"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
0001:只有标题和状态的旧表
创建 migrations/versions/0001_create_tickets.py:
from alembic import op
import sqlalchemy as sa
revision = "0001"
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
op.create_table(
"tickets",
sa.Column("id", sa.Integer(), primary_key=True),
sa.Column("title", sa.String(80), nullable=False),
sa.Column("status", sa.String(10), nullable=False, server_default="open"),
sa.CheckConstraint("length(title) BETWEEN 1 AND 80", name="ck_tickets_title"),
sa.CheckConstraint("status IN ('open', 'done')", name="ck_tickets_status"),
sqlite_autoincrement=True,
)
def downgrade():
op.drop_table("tickets")
0002:补上优先级,保留已有记录
创建 migrations/versions/0002_add_priority.py:
from alembic import op
import sqlalchemy as sa
revision = "0002"
down_revision = "0001"
branch_labels = None
depends_on = None
def upgrade():
# 默认值补齐旧记录;批量改表处理 SQLite 的 ALTER TABLE 限制。
with op.batch_alter_table("tickets", table_kwargs={"sqlite_autoincrement": True}) as batch:
batch.add_column(sa.Column(
"priority", sa.String(10), nullable=False, server_default="normal"))
batch.create_check_constraint(
"ck_tickets_priority", "priority IN ('low', 'normal', 'high')")
def downgrade():
with op.batch_alter_table("tickets", table_kwargs={"sqlite_autoincrement": True}) as batch:
batch.drop_constraint("ck_tickets_priority", type_="check")
batch.drop_column("priority")
down_revision 把两个版本连接起来。数据库的 alembic_version 表记录已应用的版本,不负责保存工单内容。
SQLite 支持的 ALTER TABLE 操作有限,批量模式在需要时通过创建替代表、复制数据、替换旧表完成修改。本次默认值让旧记录获得 normal,CHECK 约束继续限制后续写入。
降级到 0001 会丢失优先级字段及其值;降到基础版本会删除整张工单表。能写出 downgrade() 不代表能恢复被丢弃的业务数据,不能把降级当作备份。
SQLite 的 DDL 事务行为与驱动有关,不要假定整个迁移失败时必然完整回滚。真实变更要先备份、在副本验证,再显式执行;本篇只在独立演练数据库中操作。
8. 走一遍“旧库写入 → 升级 → 启动”
先只执行第一条迁移:
python -m flask --app ticket_app db upgrade 0001
此时表还没有 priority,最终模型查询会引用不存在的列,所以暂时不要启动业务服务。
创建 legacy_demo.py:
from sqlalchemy import inspect, text
from ticket_app import create_app
from ticket_app.extensions import db
def main():
app = create_app()
with app.app_context():
columns = {column["name"] for column in inspect(db.engine).get_columns("tickets")}
if columns != {"id", "title", "status"}:
raise RuntimeError("请先把空数据库迁移到 0001,再运行旧数据演练")
with db.engine.begin() as connection:
if connection.scalar(text("SELECT count(*) FROM tickets")):
raise RuntimeError("演练需要空表,请勿对已有业务数据重复运行")
connection.execute(text(
"INSERT INTO tickets (title, status) VALUES (:title, :status)"),
[{"title": "导出报表失败", "status": "open"},
{"title": "更新登录页文案", "status": "done"}])
print("已在旧表写入两条记录,接下来执行 0002 迁移。")
db.engine.dispose()
if __name__ == "__main__":
main()
执行:
python legacy_demo.py
python -m flask --app ticket_app db upgrade
python -m flask --app ticket_app db current
这个脚本刻意使用旧表字段的参数化 SQL,避免最终模型读取尚未存在的列。engine.begin() 正常退出时提交,异常退出时回滚。
最后的版本应为 0002。启动:
python -m flask --app ticket_app run --host 127.0.0.1 --port 8000
在第二个终端查询:
curl -i http://127.0.0.1:8000/api/tickets
应得到原来的两条工单,编号、标题、状态保留,优先级都为 normal。
如果只想启动一个全新空库,可以直接执行 db upgrade 到最终版本,不运行旧数据演练。重复执行升级不会重新插入样本;演练脚本只用于空的 0001 表。
后续如何生成新的迁移
将来修改模型后,可以生成候选脚本:
python -m flask --app ticket_app db migrate -m "说明本次结构变更"
这个命令比较数据库与模型,有差异时生成候选脚本,不会执行升级。没有差异时,本文配置会提示“未检测到结构变化,未生成迁移”。自动生成也不能可靠判断所有重命名和数据回填意图,必须检查生成内容、补充必要的数据处理,再显式运行 db upgrade。
本篇两个迁移文件已经提供,无需为了复现再生成一遍。
9. 验证 CRUD 与重启后的数据
在另一个终端创建:
curl -i -X POST http://127.0.0.1:8000/api/tickets \
-H 'Content-Type: application/json' \
--data '{"title":"修复导出","priority":"high"}'
按前面空库演练的顺序,返回 201、Location: /api/tickets/3 和新工单。已有库的编号可能不同,应以实际响应为准。
只更新标题:
curl -i -X PATCH http://127.0.0.1:8000/api/tickets/3 \
-H 'Content-Type: application/json' \
--data '{"title":"修复月报导出"}'
返回 200,优先级仍为 high,不会被缺省值覆盖。
停止服务器,再用原命令启动:
python -m flask --app ticket_app run --host 127.0.0.1 --port 8000
curl -i http://127.0.0.1:8000/api/tickets/3
记录和修改后的标题应该仍在,这才验证了数据来自数据库,而不是进程内列表。
再试非法更新:
curl -i -X PATCH http://127.0.0.1:8000/api/tickets/3 \
-H 'Content-Type: application/json' \
--data '{"title":"不应写入","priority":"urgent"}'
返回 400,再查询时标题仍是“修复月报导出”。因为所有字段校验完才修改对象,不会先写一半。
删除:
curl -i -X DELETE http://127.0.0.1:8000/api/tickets/3
curl -i http://127.0.0.1:8000/api/tickets/3
分别返回 204 和 404。
输入校验失败不写入,数据库提交失败需要回滚;但若提交已经成功,随后连接中断或响应发送失败,不能靠 rollback 撤销已经提交的记录。网络超时后重试 POST 仍可能创建重复工单。
同一 SQLite 文件可以被多个进程访问,但写入竞争仍受锁限制。它与多进程不共享的内存列表不同,也不能被当作高并发数据库来无限加 worker。
10. 可重复的迁移与接口校验
创建 verify.py。它在系统临时目录里建立测试数据库,显式执行迁移,不接触你的演练数据。
from pathlib import Path
from tempfile import TemporaryDirectory
from flask_migrate import upgrade
from sqlalchemy import inspect, text
from sqlalchemy.exc import IntegrityError
from ticket_app import create_app
from ticket_app.extensions import db
from ticket_app.models import Ticket
MIGRATIONS = str(Path(__file__).resolve().parent / "migrations")
def verify_migration(app):
with app.app_context():
upgrade(directory=MIGRATIONS, revision="0001")
assert "priority" not in {
column["name"] for column in inspect(db.engine).get_columns("tickets")}
# 用旧表字段写入,避免最终模型查询尚未存在的 priority。
with db.engine.begin() as connection:
connection.execute(text(
"INSERT INTO tickets (title, status) VALUES (:title, :status)"),
{"title": "迁移前的工单", "status": "open"})
upgrade(directory=MIGRATIONS)
ticket = db.session.get(Ticket, 1)
assert ticket.title == "迁移前的工单" and ticket.priority == "normal"
def verify_api(app):
with app.test_client() as client:
created = client.post("/api/tickets", json={"title": " 修复导出 "})
assert created.status_code == 201
ticket = created.get_json()
assert ticket["title"] == "修复导出" and ticket["priority"] == "normal"
location = created.headers["Location"]
assert client.get(location).get_json() == ticket
updated = client.patch(location, json={"priority": "high"})
assert updated.status_code == 200
assert updated.get_json()["priority"] == "high"
assert updated.get_json()["title"] == ticket["title"]
for payload in ({}, [], {"title": " "}, {"priority": "urgent"}, {"id": 99}):
response = client.patch(location, json=payload)
assert response.status_code == 400
assert response.get_json()["error"]["code"] == "invalid_request"
assert client.get(location).get_json()["priority"] == "high"
assert client.get("/api/tickets?status=open").get_json()["total"] == 2
assert client.get("/api/tickets?status=open&status=done").status_code == 400
assert client.post("/api/tickets", data="{}").status_code == 415
assert client.post("/api/tickets", data="{",
content_type="application/json").status_code == 400
assert client.post("/api/tickets", data=" " * 1025,
content_type="application/json").status_code == 413
assert client.put(location, json={"title": "未实现 PUT"}).status_code == 405
deleted = client.delete(location)
assert deleted.status_code == 204 and deleted.data == b""
assert client.get(location).status_code == 404
with app.app_context():
# 绕过 HTTP 校验,验证数据库约束与失败后的显式回滚。
db.session.add(Ticket(title="", status="open", priority="normal"))
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
else:
raise AssertionError("数据库应拒绝空标题")
assert db.session.scalar(db.select(db.func.count()).select_from(Ticket)) == 1
if __name__ == "__main__":
with TemporaryDirectory(prefix="flask-04-") as directory:
database_file = Path(directory) / "test.db"
app = create_app({
"TESTING": True,
"SQLALCHEMY_DATABASE_URI": "sqlite:///" + database_file.as_posix(),
})
try:
verify_migration(app)
verify_api(app)
print("验证通过:旧数据迁移、CRUD、非法输入、数据库约束与回滚。")
finally:
with app.app_context():
db.engine.dispose()
执行:
python verify.py
全部断言通过后打印验证通过,不要使用会移除 assert 的 -O 模式。
最后一段故意绕过 HTTP 校验,向数据库写空标题。数据库应拒绝它;显式回滚后还能正常查询,说明会话没有停留在失败事务状态。
这里使用数据库文件而不是纯内存 SQLite,既方便迁移,也避免把不同连接的内存生命周期问题混进初学示例。
11. 小改造:让数据库计算统计值
第三篇通过遍历列表统计待处理数量。现在增加统计 Blueprint,让数据库直接计算总数和待处理数,避免把全部工单读到 Python。
创建 exercise_app.py:
from flask import Blueprint, jsonify
from sqlalchemy import case, func, select
from ticket_app import create_app as create_base_app
from ticket_app.extensions import db
from ticket_app.models import Ticket
stats_bp = Blueprint("stats", __name__, url_prefix="/api")
@stats_bp.get("/stats")
def ticket_stats():
statement = select(
func.count(Ticket.id).label("total"),
func.coalesce(func.sum(case((Ticket.status == "open", 1), else_=0)), 0).label("open_count"),
)
result = db.session.execute(statement).one()
return jsonify({"total": result.total, "open": result.open_count})
def create_app(test_config=None):
app = create_base_app(test_config)
app.register_blueprint(stats_bp)
return app
case() 把待处理记录计为 1,其余计为 0,再用 SUM 求和。空表的 SUM 可能是 NULL,因此用 coalesce() 转成 0;COUNT 则返回 0。
execute().one() 取得一行统计结果。这里需要两个聚合字段,所以使用 execute(),而不是只取每行第一个值的 scalars()。
停止原服务,启动练习:
python -m flask --app exercise_app run --host 127.0.0.1 --port 8000
curl -i http://127.0.0.1:8000/api/stats
练习使用同一个数据库文件,不会重新初始化样本。只保留最初两条记录时,应返回 {"total":2,"open":1};其他情况下,以实际数据为准。
12. 本篇收尾
持久化需要同时管好两件事:业务修改通过事务提交,表结构变化通过迁移执行。模型描述结构,会话管理对象和事务,迁移让实际数据库跟上代码版本。
你现在应当能解释:为什么 add 不等于保存,为什么 flush 后还可以回滚,为什么给模型加字段却不迁移会报错。也能通过重启服务和旧库升级验证数据确实保留下来。
下一篇处理工单变多后的列表查询:分页、组合筛选、稳定排序和索引,并查看生成的 SQL,判断查询是否真的有效。
系列导航:上一篇:拆开项目 · 14 篇大纲 · 配套运行目录 · 下一篇:《列表接口做实:分页、筛选、排序与索引》(待编写)
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/weixin_43674738/article/details/170927262



