snake_to_ai头像

Flask 实战 04:接入数据库,理解模型、CRUD 与迁移

第三篇把项目拆清楚了,但工单仍在内存里。服务一重启,刚创建的工单就没了;启动两个进程,还会得到两份互不相通的数据。

这一篇把数据写入 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

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--