Flask-数据模型操作

这篇讲什么

  • 这篇只讲查询这一层:query 的常用取法(get / first / all / count / get_or_404)、filter 条件对照表、order_by、paginate 分页。
  • 模型关系部分写一对多、多对多与中间表、backref 反向取,以及 lazy 七个取值的差别(含 dynamic 返回 AppenderQuery 那个坑)。
  • 建库、CRUD、字段类型、迁移在《Flask-邮件发送和数据模型》里已经写全,这里不重复;SQLAlchemy 2.x 的 select() 写法另给了一段对照。

准备工程

  • 这一篇只讲查询和模型关系。建库、CRUD、字段类型、迁移这些基础在 Flask-邮件发送和数据模型 里已经写全,这里只把示例工程摆出来复用。

  • 本机版本:Flask 3.1.3 + Flask-SQLAlchemy 3.1.1 + SQLAlchemy 2.1.8。

    app.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import os
    from flask import Flask
    from flask_sqlalchemy import SQLAlchemy

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


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


    class Course(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20), unique=True)
  • 老笔记这段用的是 flask_script.Manager 和 manager.run(),那套已经不能用;建表也要放进应用上下文:

    app.py
    1
    2
    with app.app_context():
    db.create_all()

各种查询操作

  • Model.query 是 Flask-SQLAlchemy 提供的快捷入口,本机实测这些方法都还在:

    方法 作用 实测结果
    get(主键) 按主键取一条 'xiaoming'
    get_or_404(主键) 取不到就抛 404 命中同上,取不到 NotFound(HTTP 404)
    all() 全部取出 ['xiaoming', 'xiaohua']
    first() 第一条对象 'xiaoming'
    first_or_404() 第一条,空则 404 'xiaoming'
    count() 计数 2
    filter(...) 条件过滤 见下一节
    filter_by(name='x') 关键字条件 ['xiaohua']
    order_by(...) 排序 id.desc() 得 ['xiaohua', 'xiaoming']
    limit(n) / offset(n) 截取结果集 offset(1).limit(1) 得 ['xiaohua']
    paginate(page, per_page) 分页 见「分页」一节
  • Query.get() 已经是遗留 API:实测调用它会有 LegacyAPIWarning(SQLAlchemy 2.0 起弃用),新写法是 db.session.get(Model, 主键):

    app.py
    1
    2
    stu = db.session.get(Student, 1)     # 推荐
    stu = Student.query.get(1) # 还能用,但会发 LegacyAPIWarning
  • 2.x 风格的查询用 select(),实测三种取法:

    app.py
    1
    2
    3
    4
    5
    from sqlalchemy import select

    rows = db.session.execute(select(Student).where(Student.name == 'xiaoming')).scalars().all()
    rows = db.session.scalars(select(Student)).all()
    total = db.session.scalar(select(func.count()).select_from(Student))
    1
    2
    3
    session.execute(select().where()) -> ['xiaoming']
    db.session.scalars(select(Student)).all() -> ['xiaoming', 'xiaohua']
    db.session.scalar(select(func.count()).select_from(Student)) -> 2
  • 老笔记把 paginate 写成「项目中讲解」,其实它是最常用的一个,单独放在下面一节。

分页

  • paginate() 返回一个 Pagination 对象,属性和方法实测如下(page=1, per_page=1,共 2 条):

    1
    2
    page=1  total=2  pages=2  has_prev=False  has_next=True  items=['xiaoming']
    p.next().items -> ['xiaohua']
    app.py
    1
    2
    3
    4
    5
    @app.route('/students/')
    def students():
    page = request.args.get('page', 1, type=int)
    p = Student.query.order_by(Student.id).paginate(page=page, per_page=10)
    return render_template('students.html', p=p)
    templates/students.html
    1
    2
    3
    4
    5
    6
    7
    8
    <ul>
    {% for s in p.items %}<li>{{ s.name }}</li>{% endfor %}
    </ul>
    <div>
    {% if p.has_prev %}<a href="{{ url_for('students', page=p.prev_num) }}">上一页</a>{% endif %}
    第 {{ p.page }} / {{ p.pages }} 页
    {% if p.has_next %}<a href="{{ url_for('students', page=p.next_num) }}">下一页</a>{% endif %}
    </div>
  • page 要从查询串取并转成 int,实测 paginate(page=0) 会 IndexError,所以自己夹一个下限。

  • 常用字段:items / page / per_page / total / pages / has_prev / has_next / prev_num / next_num,翻页方法是 prev() / next()。

filter条件

  • 下表全部在本机 SQLite 上跑过,库里数据是 xiaoming / xiaohua / a1 / a2 / b1(id 依次 1…5):

    写法 作用 实测结果
    Student.id > 2 大于 ['a1', 'a2', 'b1']
    Student.id.__gt__(2) 同上的显式方法 ['a1', 'a2', 'b1']
    Student.id >= 2 大于等于 ['xiaohua', 'a1', 'a2', 'b1']
    Student.name == 'a1' 等于 ['a1']
    Student.name != 'a1' 不等于 ['xiaoming', 'xiaohua', 'a2', 'b1']
    Student.id.between(2, 4) 闭区间 ['xiaohua', 'a1', 'a2']
    Student.name.in_(('a1', 'a2')) 在集合内 ['a1', 'a2']
    Student.name.notin_(('a1', 'a2')) 不在集合内 ['xiaoming', 'xiaohua', 'b1']
    contains('a') 包含子串 ['xiaoming', 'xiaohua', 'a1', 'a2']
    startswith('a') 前缀 ['a1', 'a2']
    endswith('1') 后缀 ['a1', 'b1']
    like('a%') 模糊 ['a1', 'a2']
    notlike('a%') 模糊取反 ['xiaoming', 'xiaohua', 'b1']
    ~Student.name.like('a%') 同上,2.x 推荐写法 ['xiaoming', 'xiaohua', 'b1']
  • 老笔记写的 startwith / endwidth 是拼错的,实际方法是 startswith / endswith;notin_ 结尾有下划线,notlike 也还在(hasattr 为 True),但 SQLAlchemy 2.x 更推荐 ~col.like(...),实测两者结果一致。

  • 逻辑组合:

    app.py
    1
    2
    3
    4
    5
    6
    from sqlalchemy import and_, not_, or_

    User.query.filter(User.id > 2, User.age > 17) # 逗号就是 and_
    User.query.filter(and_(User.id > 2, User.age > 17))
    User.query.filter(or_(User.name == 'a1', User.name == 'b1'))
    User.query.filter(not_(User.id > 2))

    实测:逗号写法和 and_() 结果完全相同(['a1', 'a2']),or_ 得 ['a1', 'b1'],not_ 得 ['xiaoming', 'xiaohua']。

  • 判空写 is_(None) / is_not(None),别写 == None:

    app.py
    1
    2
    3
    Student.query.filter(Student.remark.is_(None)).all()
    Student.query.filter(Student.remark.is_not(None)).all()
    Student.query.filter(Student.remark == None).count() # noqa: E711
    1
    2
    3
    is_(None)   -> ['xiaohua']
    is_not(None) -> ['xiaoming']
    == None -> 也能跑(条数 1),但 SQLAlchemy 会发警告,读起来也不像条件
  • 聚合与分组:

    app.py
    1
    2
    3
    db.session.execute(select(Article.sid, func.count()).group_by(Article.sid)).all()
    db.session.query(Student.name, func.count(Article.id)).join(
    Article, Article.sid == Student.id).group_by(Student.name).all()

    实测两种都得到 [(1, 2)] / [('xiaoming', 2)]。

模型关系

一对多

  • 「多」的那侧加外键,「一」的那侧加 relationship,需要反查时用 backref:

    app.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20), unique=True)
    articles = db.relationship('Article', backref=db.backref('stu', lazy=True), lazy='dynamic')


    class Article(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(30), unique=True)
    content = db.Column(db.Text)
    sid = db.Column(db.Integer, db.ForeignKey('student.id'))
  • 实测:Student.articles 的类型是 AppenderQuery,Article.stu 直接给出那个学生对象('xiaoming')。relationship 和 backref 都只存在于 Python 侧,数据表里没有对应列。

一对一

  • 在一对多的基础上加 uselist=False:

    app.py
    1
    2
    3
    4
    5
    6
    7
    8
    class Student(db.Model):
    profile = db.relationship('Profile', backref='stu', uselist=False)


    class Profile(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    realname = db.Column(db.String(20))
    sid = db.Column(db.Integer, db.ForeignKey('student.id'))
  • 实测 Student.profile 的类型直接是 Profile(不是列表),取值 student.profile.realname -> '小明';反向 profile.stu.name -> 'xiaoming'。

多对多

  • 需要一张中间表,用 secondary 指过去;中间表不用写模型类:

    app.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    xuanke = db.Table('xuankebiao',
    db.Column('student_id', db.Integer, db.ForeignKey('student.id')),
    db.Column('course_id', db.Integer, db.ForeignKey('course.id')))


    class Student(db.Model):
    courses = db.relationship('Course', secondary=xuanke,
    backref=db.backref('students', lazy='dynamic'),
    lazy='dynamic')
  • 实测选课与反查:

    1
    2
    3
    学生选了 ['语文', '数学']
    语文课有 ['xiaoming'] 人选
    中间表内容 -> [(1, 1), (1, 2)]
  • 增删选课用 add() / remove(),lazy='dynamic' 的关系上 append() 实测也能用,三种写法都要 commit():

    app.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    xiaohua = Student.query.filter_by(name='xiaohua').first()
    yuwen = Course.query.filter_by(name='语文').first()

    xiaohua.courses.add(yuwen)
    db.session.commit()

    xiaohua.courses.remove(yuwen)
    db.session.commit()

    xiaohua.courses.append(math) # dynamic 关系上 append 有效
    db.session.commit()
    1
    2
    3
    add() + commit 之后 xiaohua 的课 -> ['语文']
    remove() + commit 之后 -> []
    append() + commit 之后 -> ['数学']
  • 老笔记里 s.courses.remove(c) 之后只写了 db.session.add(s) 没 commit,在这个工程里靠 COMMIT_ON_TEARDOWN 蒙对了,那个配置早就不生效。实测不 commit 时数据只在当前 session 里看得见,rollback() 之后那条选课直接没了:

    1
    2
    add(语文) 之后不 commit,同一个 session 查 -> ['数学', '语文']
    rollback() 之后 -> ['数学']

lazy 的取值

  • 老笔记这段解释有两处笔误('joined'False),实测 SQLAlchemy 2.1 支持的取值是:

    取值 含义
    select 默认,首次访问属性时发一条 SELECT
    joined 关联查询时一起 JOIN 出来,适合一对一/少量多
    subquery 用子查询一次性取完,避免 N+1
    dynamic 不加载,返回一个可继续过滤的查询对象
    raise 不自动加载,访问就报错,强制你显式取
    unload 加载时把这侧排除掉
    write_only 只能通过 session.add() 等写操作维护,不能直接读
  • lazy='dynamic' 的代价实测很具体:.all() 和迭代都正常,但 len(articles) 直接 TypeError: object of type 'AppenderQuery' has no len(),要数量得用 .count()。老笔记那句「在一的那侧数据加载时不能使用」说的就是这件事。

拓展

  • 复制虚拟环境这件事已经不需要 virtualenvwrapper 了:conda 用 conda env export -n 源 -f environment.yml 再 conda env create -f environment.yml,uv 用 uv venv + uv sync。四种方案的对照和实测数据见 Flask-基本入门 的「配置虚拟环境」。

参考

本文结束 感谢您的阅读
正在加载今日诗词....