罗罗编程学习记录
本页内容 展开查看

04.7.16.2 ORM 查询与数据库优化

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.16 Django 框架

覆盖范围

  • QuerySet 惰性求值、链式调用与结果缓存
  • values/values_list/iterator() 与大结果集处理
  • select_related/prefetch_related/Prefetch 预取策略与 N+1 定位
  • F/Q/ExpressionWrapper/Case When/子查询表达式
  • annotate/aggregate/分组/窗口函数
  • Manager/QuerySet.as_manager/get_queryset
  • atomic/on_commit/select_for_update/隔离级别/保存点
  • 索引设计、执行计划与索引失效
  • 迁移:makemigrations/migrate/RunPython/零停机/SeparateDatabaseAndState
  • 连接持久化、ATOMIC_REQUESTS、多库路由与读写分离
  • 批量操作、慢查询定位与深分页优化

04.7.16.2-001 QuerySet 为什么是惰性的?哪些操作触发求值?

一句话结论

构造 QuerySet(过滤、排序、关联方法)默认不发 SQL,只保存查询条件;只有在迭代、切片取值、list()/len()/bool()、count()/exists()/first()/last()、get()、序列化或 pickle 等“求值点”才生成并执行 SQL。惰性设计让多个过滤条件可以链式叠加后一次性查询,也便于复用查询集做缓存与预取规划。

概念解释

  • 每个链式方法返回新的 QuerySet,条件累积在内部查询结构中。
  • 求值后结果进入 _result_cache,同一 QuerySet 实例重复使用命中缓存,不再查库。
  • 理解求值时机是排查“多查了一次”和“缓存未命中”的基础。

原理流程

  1. 调用 filter/exclude/order_by 等只修改内部查询对象,不触碰数据库。
  2. 到达求值点时,ORM 把查询结构编译成 SQL 并执行。
  3. 结果转换为模型实例(或字典/元组)并写入缓存。

代码或图示

qs = Order.objects.filter(status="paid")   # 未查库
qs = qs.order_by("-created_at")             # 仍未查库
for o in qs:                                # 迭代触发求值,发 SQL
    print(o.no)
print(len(qs))                              # 命中缓存,不再查库

常见误区

  • 以为每次 filter 都执行一次查询:链式阶段只累积条件,最终一条 SQL。
  • 复用同一个 QuerySet 实例后又追加条件:追加条件产生新 QuerySet,不影响已缓存的旧实例。
  • 在模板或序列化器里多次遍历同一 QuerySet:第一次迭代填充缓存,后续遍历命中缓存;但若中途改了查询条件,新实例仍会查库。

追问

  • count() 会把结果全部取回来吗?答:不会,翻译成 COUNT(*) 聚合查询,不填充结果缓存。
  • exists() 怎么判断?答:SELECT 1 ... LIMIT 1,只判断是否存在行。
  • 求值缓存存在哪里?答:QuerySet 实例的 _result_cache 属性。

04.7.16.2-002 链式调用如何返回新 QuerySet 而不立即查库?

一句话结论

每个 QuerySet 方法内部调用 _chain() 复制当前查询结构,返回携带新条件的新实例;原实例及其缓存保持不变。条件以内部 Query 对象(where、order_by、select_related 等)形式累积,直到求值点才编译成 SQL。这种不可变式链式设计让查询集可以安全地作为基础查询集复用、叠加与传递。

概念解释

  • _chain() 是 Django ORM 内部方法,复制查询对象并绑定新模型类(如有)。
  • 链式方法分两类:修改查询结构的(filter/order_by)与求值/返回特殊结构的(values/iterator)。
  • 复用基础 QuerySet 时,不同视图叠加各自条件,互不污染。

原理流程

  1. 调用过滤方法时,内部 Query 增加条件节点。
  2. _chain() 基于当前结构生成新 QuerySet 返回。
  3. 原实例缓存与条件不变,新实例携带累积条件等待求值。

代码或图示

base = Article.objects.filter(status="published")
a = base.filter(category="tech")    # 新实例,不影响 base
b = base.filter(category="life")    # 新实例,base 仍只有 published 条件

常见误区

  • 以为 filter 原地修改 QuerySet:实例不可变式返回,保存返回值才生效。
  • 在循环里不断对同一变量 qs = qs.filter(...):这是正确链式写法;若忽略赋值则条件丢失。
  • 把带缓存的 QuerySet 再链式过滤:新实例不带旧缓存,会重新查库。

追问

  • _chain() 是公开 API 吗?答:不是,属于内部实现;业务代码只使用公开链式方法。
  • 两个派生 QuerySet 共享查询条件吗?答:共享复制出的结构副本,后续各自追加互不影响。
  • Manager 方法返回什么?答:通常返回新 QuerySet 或自定义 Manager,保持链式能力。

04.7.16.2-003 QuerySet 缓存(_result_cache)何时建立、何时失效?

一句话结论

求值完成后,结果列表写入 _result_cache;同一实例再次迭代、取长度、取值都读缓存,不发 SQL。缓存随实例存在:重新链式过滤得到新实例(无缓存)、调用 iterator() 不填充常规缓存、删除实例则缓存释放。查询条件变更或显式求值新实例时,旧缓存不会自动同步到新查询。

概念解释

  • 缓存建立在“结果已取回”之后,而不是构造 QuerySet 时。
  • 切片取部分结果、exists()/count() 等聚合求值不一定填充完整结果缓存。
  • 理解缓存边界能解释“为什么第二次遍历没查库”与“为什么改条件后又查了一次”。

原理流程

  1. 求值点触发 SQL 执行,结果转换为 Python 对象列表。
  2. 列表挂到实例 _result_cache。
  3. 后续访问命中缓存;新链式实例、iterator() 路径不沿用该缓存。

代码或图示

qs = Post.objects.all()
list(qs)                # 求值,填充缓存
len(qs)                 # 读缓存
qs2 = qs.filter(draft=False)  # 新实例,无缓存,再次查库

常见误区

  • 以为缓存是进程级全局缓存:它只绑定 QuerySet 实例,不同实例各有一份。
  • 大结果集依赖缓存减少重复查询:整表实例驻留内存,应改用 iterator() 分批处理。
  • 在求值后修改数据库却复用旧 QuerySet 实例:缓存仍是旧结果,需要重新查询实例。

追问

  • count() 填充结果缓存吗?答:不填充完整结果,走聚合 SQL。
  • 缓存里保存的是模型实例吗?答:默认是模型实例;values() 路径保存字典,values_list() 保存元组。
  • 怎么强制重新查库?答:重新调用管理器方法得到新 QuerySet 实例。

04.7.16.2-004 切片 QuerySet 哪些触发 SQL、哪些不触发?

一句话结论

QuerySet 支持 Python 列表切片语法:[:5]、[10:20] 这类带界限的切片通常直接翻译成 LIMIT/OFFSET 并返回新 QuerySet(未强制求值时仍惰性);取单个元素 qs[0] 会求值并返回模型实例;负数切片与不支持的切片形式会抛 TypeError。已缓存的实例切片从内存列表取,未缓存的走 SQL 限制。

概念解释

  • 切片不改变底层条件,只附加 limits/offsets。
  • qs[10:20] 返回 QuerySet,继续迭代才发 SQL;qs[10] 等价取单条。
  • 深分页场景 OFFSET 随页码增大而变慢,切片语法本身不解决性能问题。

原理流程

  1. 解析切片上下界,转换为 SQL LIMIT/OFFSET。
  2. 带范围切片返回惰性 QuerySet;单元素切片触发求值。
  3. 已缓存实例从内存列表切片,未缓存走数据库。

代码或图示

page = Order.objects.all()[20:40]   # 附加 LIMIT/OFFSET,惰性
first = Order.objects.all()[0]      # 求值返回实例
# Order.objects.all()[-1]           # 负数切片不支持,抛 TypeError

常见误区

  • 以为切片后仍是完整 QuerySet:limits 已绑定到该实例,再叠加切片会在原偏移基础上计算。
  • 用大 OFFSET 切片做深分页:扫描行数随 OFFSET 增长,需改键集分页。
  • 对已缓存结果再切片以为会查库:缓存命中,直接从内存列表取元素。

追问

  • first() 与 qs[0] 区别?答:first() 取不到返回 None,qs[0] 为空时抛 IndexError。
  • 切片能配合 order_by 吗?答:能,排序先于 limit 生效,必须有稳定排序键。
  • 数据库层面 offset 怎么计算?答:跳过前 N 行再取 M 行,N 越大扫描越多。

04.7.16.2-005 exists() 与布尔判断 if qs 有什么区别?

一句话结论

if queryset 会对 QuerySet 做布尔判断,Django 通过 exists() 机制判断是否存在行,但在部分路径下会取结果集参与判断;qs.exists() 显式发送 SELECT 1 ... LIMIT 1,只返回布尔值,不取回字段数据,也不填充结果缓存。判断“有没有”优先用 exists(),判断“有没有数据并随后使用”再迭代或取列表。

概念解释

  • 布尔判断触发 QuerySet.__bool__,内部按存在性判断处理,避免把整表实例化。
  • exists() 是语义最明确的存在性检查,SQL 开销最小。
  • 两者都不适合在循环里逐条判断关联是否存在,应通过预取或注解聚合批量完成。

原理流程

  1. 代码写 if qs: 触发布尔求值,框架判断是否至少一行。
  2. exists() 生成限量查询,只取 1 行标记。
  3. 存在性结论返回,不构造完整模型实例列表。

代码或图示

if Order.objects.filter(user=request.user).exists():
    return JsonResponse({"has_order": True})

# 循环内避免逐行 exists,改用注解
from django.db.models import Exists, OuterRef
qs = User.objects.annotate(has_order=Exists(Order.objects.filter(user=OuterRef("pk"))))

常见误区

  • 在序列化嵌套里对每个对象调用 exists():触发 N+1 存在性查询,应批量注解 Exists。
  • 用 len(qs) > 0 判断存在:取回全部实例再计数,开销远大于 exists()。
  • 以为 exists() 会复用结果缓存:它走独立限量查询,不填充常规缓存。

追问

  • exists() 填充 _result_cache 吗?答:不填充完整结果缓存。
  • 子查询里怎么判断关联存在?答:Exists(子查询) 注解到外层 QuerySet。
  • 布尔判断与 exists() 性能差异大吗?答:单条判断接近;明确语义与最小数据取回用 exists() 更稳妥。

04.7.16.2-006 iterator() 为什么能绕过缓存?chunk_size 如何影响内存?

一句话结论

iterator() 按批次从数据库游标读取模型实例,不在 QuerySet 上保留完整结果缓存;chunk_size(或 chunksize)控制每批取回的行数,批内对象驻留内存,遍历完即释放。它适合导出报表、批量处理大表等“逐条消费、不重复使用结果集”的场景;需要多次遍历同一结果集时,缓存 QuerySet 更合适。

概念解释

  • 普通 QuerySet 求值后把全部实例挂到缓存;iterator() 走游标分批拉取。
  • 批大小影响内存峰值与往返次数:过大内存高,过小往返多。
  • 数据库游标与连接生命周期绑定,迭代期间连接保持占用。

原理流程

  1. 编译查询并打开数据库游标。
  2. 按 chunk_size 一批批取回行,转换为实例依次产出。
  3. 消费完一批释放引用,下一批覆盖内存;不保留全量缓存。

代码或图示

for order in Order.objects.iterator(chunk_size=500):
    process(order)          # 逐条处理,内存峰值约一批大小

常见误区

  • 大结果集用普通 QuerySet 列表化:全量实例驻留内存,易触发内存压力。
  • 在 iterator() 遍历中再访问未预取关联:每行仍可能触发 N+1,需在查询层预取。
  • 迭代期间持有对象引用累积到列表:等于自己重建缓存,分批失去意义。

追问

  • chunk_size 默认值是多少?答:由 ORM/后端决定(待确认:Django 5.x 默认批次大小以源码为准),大批量场景显式指定更可控。
  • 异步版本是什么?答:aiterator(),配合异步 ORM 遍历。
  • 分批处理需要事务包裹吗?答:长事务持有锁与连接,应按批提交或拆分任务,避免单事务跨整表。

04.7.16.2-007 values()/values_list() 返回字典/元组,与模型实例如何取舍?

一句话结论

values(*fields) 返回字典 QuerySet,键为字段名;values_list(*fields) 返回元组 QuerySet;只取部分字段、做序列化或聚合投影时使用,数据传输与内存小于模型实例。需要调用模型方法、保存实例或访问关联属性时,仍取模型实例;字典/元组是裸数据,不带行为与关系懒加载能力。

概念解释

  • values() 可传关联字段 author__name,字典键为扁平化名称。
  • values_list(flat=True) 单字段时返回标量列表,多字段不可用 flat。
  • 投影查询配合 only() 也能减少字段读取,但返回的仍是模型实例。

原理流程

  1. ORM 在 SELECT 列表只取指定字段。
  2. 行直接组装为字典或元组,不构造模型实例。
  3. 结果按 QuerySet 惰性求值与缓存规则工作。

代码或图示

Order.objects.values("no", "amount")                       # 字典
Order.objects.values_list("no", flat=True)                 # 标量
Order.objects.values("author__name")                       # 关联字段投影

常见误区

  • 取了字典又在遍历时访问模型方法:裸数据没有方法,应在查询层取齐字段或改回实例查询。
  • values_list 多字段误用 flat=True:抛参数错误,flat 仅单字段可用。
  • 把字典结果回写保存:必须再按主键查模型实例或用 update() 字段级更新。

追问

  • values() 能取注解字段吗?答:能,注解别名作为字典键返回。
  • 字典查询还能再 filter 吗?答:能,过滤条件基于模型字段,投影只影响 SELECT。
  • 与 only() 区别?答:values 返回裸字典/元组;only 返回模型实例但延迟未取字段。

一句话结论

select_related 用于外键、一对一这类单值关联:在主查询 SQL 中 JOIN 关联表并一次性取回关联对象;可传嵌套字符串 author__profile 控制 JOIN 深度,也可指定具体关联避免全量 JOIN。它不能用于多对多与反向一对多,那类关联由 prefetch_related 处理。

概念解释

  • JOIN 表越多,单次查询字段与行数膨胀越明显,应只预取实际用到的关联。
  • select_related(None) 清除父查询集继承来的预取。
  • 反向外键(外键在对方表)不是单值关联,select_related 不覆盖。

原理流程

  1. 查询编译时,select_related 关联加入 JOIN 与 SELECT 列。
  2. 主行取回后,ORM 按 JOIN 列填充关联实例。
  3. 遍历时访问已预取关联不再发额外 SQL。

代码或图示

Post.objects.select_related("author", "author__profile").filter(...)
# 只取需要的关联,避免 select_related 全深度 JOIN

常见误区

  • 对多对多字段调用 select_related:不支持,应使用 prefetch_related。
  • 无条件预取深层链:未使用的关联也参与 JOIN,放大单次查询成本。
  • 以为预取关联后反向集合也被取回:反向一对多是多值集合,需 prefetch_related。

追问

  • select_related 支持反向一对一吗?答:一对一反向是单值,可按关系名预取(具体方向以模型关系定义为准)。
  • JOIN 膨胀怎么判断?答:看执行计划 JOIN 表数、返回行数与重复字段,必要时拆成预取。
  • 嵌套预取字符串用什么分隔?答:双下划线 __,与字段查找语法一致。

一句话结论

prefetch_related 用于多对多、反向一对多等多值关联:先查主对象集合,再按关联外键批量查出全部关联对象,最后在 Python 侧按外键值分组拼回各主对象,避免逐行查询。它产生的是“主表一次 + 关联表一次(或每类关联一次)”的固定查询数,而不是 N+1;嵌套预取会按层级增加查询次数。

概念解释

  • 与 select_related 的 JOIN 不同,预取是独立查询后内存拼接,关联表不参与主 SQL 笛卡尔膨胀。
  • 关联对象按主对象 ID 集合 IN 查询,结果在 Python 端映射回主对象。
  • 预取查询集可以附加过滤、排序与字段裁剪,比默认全量关联更省。

原理流程

  1. 执行主查询取回主对象列表,收集其主键集合。
  2. 对每个预取关联执行一次批量查询,条件为主键 IN 集合。
  3. 按关联外键分组,挂到各主对象的关联缓存上。

代码或图示

posts = Post.objects.prefetch_related("tags", "comments").all()
for p in posts:
    [t.name for t in p.tags.all()]      # 命中预取,不额外查库

常见误区

  • 以为预取只有固定两条 SQL:每类预取关联至少一条,嵌套预取按层级叠加。
  • 预取后在视图里又对关联集合 filter():这是对内存已预取结果再过滤,还是重新查库取决于写法;需要数据库过滤应在 Prefetch 子查询集里指定。
  • 预取未用到的关联:多一次批量查询与内存分组,应只预取实际遍历的关系。

追问

  • 预取结果存在哪里?答:主对象关联描述符的缓存上,再次 all() 命中缓存。
  • 反向一对多用哪个?答:prefetch_related,如文章取全部评论。
  • 预取能跨两层关系吗?答:能,通过嵌套 Prefetch 或 __ 路径声明。

04.7.16.2-010 Prefetch 对象如何自定义子查询集与 to_attr?

一句话结论

Prefetch(lookup, queryset=None, to_attr=None) 把预取关系包装成对象:queryset 可指定带过滤、排序、字段裁剪、二次预取的子查询集;to_attr 把预取结果挂到自定义属性名而不是默认关联描述符。需要“同一关系预取两份不同过滤结果”或控制关联查询条件时,使用 Prefetch。

概念解释

  • 默认挂在关系名属性上;to_attr 自定义后,访问该属性得到预取列表,原关系描述符仍可触发默认查询。
  • 子查询集自身可再 select_related/prefetch_related,形成嵌套预取链。
  • 过滤后的预取不是“全量关联再筛”,而是 SQL 层就限制了关联行。

原理流程

  1. 构造 Prefetch,传入关系路径与定制查询集。
  2. 主查询后按子查询集条件批量取关联行。
  3. 结果按 to_attr(或关系名)挂到主对象,遍历时直接读取。

代码或图示

from django.db.models import Prefetch

recent = Prefetch(
    "comments",
    queryset=Comment.objects.filter(visible=True).order_by("-created_at")[:5],
    to_attr="recent_comments",
)
posts = Post.objects.prefetch_related(recent)
for p in posts:
    p.recent_comments

常见误区

  • 子查询集里切片 [:5]:预取批量查询对关联行限量,行为受后端支持程度影响(待确认:限量预取在各数据库后端的一致性以 5.x 文档为准)。
  • 用 to_attr 后仍访问默认关系名:默认属性未预取,遍历会触发原始 N+1。
  • 在 Prefetch.queryset 里放与主对象强耦合的逻辑:子查询集应只描述关联行的过滤与投影。

追问

  • 同一关系能预取两份吗?答:能,两个 Prefetch 用不同 to_attr 分别挂结果。
  • 子查询集还能预取自己的关联吗?答:能,嵌套 prefetch_related 形成层级预取。
  • to_attr 属性类型是什么?答:关联对象列表,不是管理器或 QuerySet。

一句话结论

单值关联(外键、一对一)优先 select_related,一次 JOIN 取回;多值关联(多对多、反向一对多)只能 prefetch_related。判断依据是关系基数:JOIN 不会把主行翻倍的单值走 JOIN,一对多/JOIN 会产生笛卡尔膨胀的多值走独立预取。实际选择还要看关联过滤条件:需要在 SQL 层过滤关联行时,用 Prefetch 定制子查询集。

概念解释

  • 选错方向会直接报错或退化为 N+1:M2M 不能 select_related,反向集合不能 select_related。
  • 一次查询可同时混用两者:单值关联 JOIN,多值关联批量预取。
  • 关联很大且主对象少时,JOIN 成本可控;关联过滤复杂时预取更灵活。

原理流程

  1. 梳理视图/序列化遍历用到的每条关系及其基数。
  2. 单值关系加入 select_related,多值关系加入 prefetch_related。
  3. 对需要条件过滤的多值关系,用 Prefetch 指定子查询集。

代码或图示

Order.objects.select_related("user", "address").prefetch_related("items", "coupons")

常见误区

  • 只看“是不是外键”就选 JOIN:反向外键虽然源于外键,但对主对象是多值集合,应用预取。
  • 混用后未核对执行 SQL:应在调试工具里确认 JOIN 表数与预取查询条数,避免无效预取。
  • 关联数据只在部分分支使用:按分支条件构造查询集,避免全量预取浪费。

追问

  • 一对一关系算哪种?答:单值,select_related。
  • 跨三层关系怎么组合?答:单值层用 JOIN 链,多值层用预取,必要时嵌套 Prefetch。
  • 怎么验证选择正确?答:统计请求查询数,遍历关联时不再增长即为预取生效。

04.7.16.2-012 反向关联、多对多、嵌套预取分别怎么写?

一句话结论

反向一对多按 related_name 或小写模型名走 prefetch_related;多对多直接预取关系名;嵌套预取通过 Prefetch 子查询集内再预取下一层,或用 __ 路径声明。跨层预取的查询数随层级增长,需要逐层核对 SQL。

概念解释

  • 未设 related_name 时反向访问名为 模型名小写_set。
  • 嵌套 Prefetch:外层预取对象的 queryset 内部再 prefetch_related 下一层。
  • 序列化器嵌套字段最容易漏掉跨层预取,要按输出结构逐层补齐。

原理流程

  1. 主对象查询取回,收集主键。
  2. 第一层预取按 IN 批量取关联对象。
  3. 第二层在第一层对象集合上再批量取下一层,逐层拼接。

代码或图示

from django.db.models import Prefetch

comments = Prefetch(
    "comments",
    queryset=Comment.objects.prefetch_related("votes"),
)
articles = Article.objects.prefetch_related(comments)

常见误区

  • 只预取第一层,模板遍历第二层关联:第二层触发 N+1。
  • 嵌套预取子查询集忘记排序/过滤:下一层数据量超出预期。
  • 依赖 __ 路径自动嵌套:复杂条件仍需显式 Prefetch 对象控制。

追问

  • 多对多中间表额外字段怎么取?答:通过 through 模型实例访问,预取关系对象后再经中间表取属性。
  • 嵌套预取查询数怎么估?答:主查询 1 条,每层每个关系预取 1 条。
  • 反向关系名在哪定义?答:外键/M2M 字段的 related_name,未设置用 _set 约定名。

04.7.16.2-013 如何在代码里定位 N+1 查询?

一句话结论

常用三类手段:django-debug-toolbar 的 SQL 面板查看请求查询数与重复 SQL;测试里用 assertNumQueries 断言查询数并回归;开发期读取 connection.queries 打印每条 SQL 与耗时。定位后顺着遍历路径找未预取的关联访问,在查询层补 select_related/prefetch_related 或批量注解。

概念解释

  • N+1 的典型特征:结构相同的 SQL 反复出现,条件主键逐条变化,查询数随列表长度增长。
  • 序列化器、模板循环、列表接口是高发位置;批量导出尤其敏感。
  • 先固定基线查询数,再优化到与列表长度无关的固定条数。

原理流程

  1. 打开 SQL 统计面板或在测试中断言查询数。
  2. 复现页面/接口,按调用栈定位触发查询的关联访问。
  3. 在 ORM 查询层预取或批量注解,回归确认查询数不再随 N 增长。

代码或图示

from django.test import TestCase
from django.db import connection

class OrderListTest(TestCase):
    def test_queries(self):
        with self.assertNumQueries(3):
            list(Order.objects.select_related("user").prefetch_related("items"))

# 临时打印
print(len(connection.queries))
for q in connection.queries:
    print(q["sql"], q["time"])

常见误区

  • 只看总查询数不看重复 SQL:少量大查询与大量重复小 SQL 是不同问题,优化方向不同。
  • 在视图层逐条 select_related 补救:易漏分支,查询层一次覆盖更稳。
  • 测试数据量太小掩盖 N+1:构造多行样本,让查询数随 N 增长的现象暴露出来。

追问

  • assertNumQueries 在生产用吗?答:主要用于测试回归,生产靠 toolbar 或慢查询日志。
  • 怎么看每条 SQL 的调用来源?答:toolbar 面板提供堆栈;connection.queries 含 SQL 与耗时。
  • N+1 一定是预取问题吗?答:也可能是循环内逐条创建/更新,需区分读关联与写操作。

04.7.16.2-014 预取之后仍触发额外查询的常见原因有哪些?

一句话结论

常见原因包括:遍历了未列入预取的关系;对已预取关联集合又执行数据库端 filter()/order_by() 触发新查询;to_attr 自定义属性后误访问默认关系名;序列化器嵌套字段对应关系未预取;条件分支延迟加载关联。预取是否生效要以实际 SQL 条数为准,而不是看查询集表面写法。

概念解释

  • 内存过滤与数据库过滤不同:预取结果在 Python 侧,再 filter() 默认走数据库新查询。
  • 模型方法内部访问关联:方法被循环调用时,外部预取不会自动覆盖方法内关系。
  • 继承/组合导致查询集构造遗漏:基础查询集预取了,派生实例又被重新过滤。

原理流程

  1. 对比遍历路径与已预取关系清单,找出未覆盖的访问点。
  2. 检查关联集合是否被二次数据库查询过滤/排序。
  3. 补齐预取或改为批量注解,回归 SQL 条数。

代码或图示

# 预取了 tags,却在循环里查 comments
for p in posts:
    p.comments.filter(visible=True)   # 未预取 comments,且 filter 走数据库

常见误区

  • 以为一次 prefetch_related 覆盖所有嵌套层级:层级关系必须逐层声明。
  • 把关联缓存清空后继续遍历:刷新实例会丢失预取缓存,重新触发查询。
  • 通用列表接口与详情接口复用查询集:详情额外访问的关系在列表查询集里未预取。

追问

  • 关联集合 all() 命中缓存吗?答:预取后 all() 读内存缓存;未预取则查库。
  • 模型方法内的关联访问怎么预取?答:方法依赖的关系在外部查询集显式预取,或方法改接收已加载对象。
  • 怎么确认某条关系已预取?答:遍历前后对比 connection.queries 条数,不增长即生效。

04.7.16.2-015 F() 表达式解决什么问题?数据库侧字段运算与并发更新有什么优势?

一句话结论

F() 把模型字段引用包装成数据库表达式,让加法、减法、比较等运算在数据库侧完成,而不是先把值取到 Python 再算回写。典型用途是计数器自增、字段间比较、动态排序与并发更新:多个请求基于数据库当前值原子累加,避免“读-改-写”竞态导致的丢失更新。

概念解释

  • F("stock") - 1 翻译成 SQL 字段运算,数据库在行内计算后写回。
  • 并发场景下 Python 侧先取值再保存会覆盖他人更新;F() 让更新在数据库内原子完成。
  • F() 可用于过滤条件、注解、更新与排序表达式。

原理流程

  1. 代码用 F("字段") 引用列,ORM 编译为 SQL 表达式。
  2. 数据库执行行内运算与更新,基于提交时的当前值。
  3. 结果不再先经过 Python 对象中转,减少往返与竞态窗口。

代码或图示

from django.db.models import F

Product.objects.filter(pk=pid).update(stock=F("stock") - 1)
Order.objects.annotate(ratio=F("amount") / F("cost")).filter(ratio__gt=1)

常见误区

  • 取到模型实例后 p.stock -= 1; p.save():读-改-写存在并发覆盖,计数不准。
  • F() 结果在保存前读取:字段值仍是旧值,需刷新实例或直接用表达式查询结果。
  • 跨字段类型运算未做类型包裹:数据库类型推断可能报错,配合 ExpressionWrapper。

追问

  • F() 能参与排序吗?答:能,order_by(F("price").desc()) 等表达式排序。
  • 并发扣库存怎么保证不超卖?答:F() 原子扣减配合条件 stock__gte=1,影响行数为 0 即失败。
  • 批量 update 用 F() 还是逐条保存?答:批量表达式更新一条 SQL 完成,性能与原子性都更好。

04.7.16.2-016 Q() 对象如何组合 AND/OR/NOT?优先级与括号怎么控制?

一句话结论

Q(字段=值) 包装一个条件,支持 &(AND)、|(OR)、~(NOT)组合;多个位置参数默认 AND,关键字参数默认 AND。组合优先级按运算符与括号决定,复杂混合条件应显式用 Q 嵌套与括号分组,避免 OR 被错误并入 AND。Q() 可复用、可在视图/Service 层按条件拼装。

概念解释

  • Q(a=1) | Q(b=2) 表示 a=1 或 b=2;~Q(a=1) 表示非 a=1。
  • 混合 AND/OR 时,括号分组决定条件树结构,SQL 生成与之一致。
  • 动态搜索场景按参数有无追加 Q,最后用 reduce 组合。

原理流程

  1. 为每个查询条件构造 Q 对象。
  2. 按业务逻辑用 &/|/~ 组合出条件树。
  3. ORM 编译为对应 WHERE 子句,括号层级保留。

代码或图示

from django.db.models import Q

qs = Article.objects.filter(
    Q(status="published") & (Q(category="tech") | Q(featured=True))
)
# 动态拼装
cond = Q()
if keyword:
    cond |= Q(title__icontains=keyword)

常见误区

  • 混用关键字参数与 Q 时以为 OR 生效:位置 Q 之间与关键字参数默认 AND,OR 必须显式 |。
  • 复杂条件不加括号:AND/OR 优先级导致 SQL 与预期不符,应打印 SQL 核对。
  • 在 Q 里放跨库不可移植的原始 SQL:优先字段查找,必要时用 Q 包裹表达式。

追问

  • exclude(Q(...)) 与 ~Q(...) 等价吗?答:语义接近,exclude 对条件取反,注意嵌套条件的取反边界。
  • Q 能复用在多个查询集吗?答:能,条件对象不可变式复用。
  • 动态 OR 搜索怎么写?答:收集条件 Q 后 reduce(operator.or_, conds)。

04.7.16.2-017 ExpressionWrapper 什么时候需要使用?

一句话结论

ExpressionWrapper(expression, output_field=...) 给表达式包裹显式输出类型,解决数据库类型推断不足的问题:字段间算术、字符串拼接、条件表达式结果类型不明确时,ORM 无法自动确定 output_field,需要用 wrapper 指定(如 DecimalField、BooleanField、CharField)。不指定类型可能在编译 SQL 或结果转换时报类型错误。

概念解释

  • 表达式默认继承参与字段的类型;跨类型运算或无字段参与的表达式需要显式声明。
  • output_field 决定结果如何从数据库值转换为 Python 对象。
  • wrapper 常与 F()、Case/When、Subquery 配合使用。

原理流程

  1. 构造基础表达式(字段引用、算术或子查询)。
  2. 用 ExpressionWrapper 包裹并声明 output_field。
  3. ORM 按声明类型编译 SQL 列类型并转换结果。

代码或图示

from django.db.models import ExpressionWrapper, F, DecimalField

Order.objects.annotate(
    profit=ExpressionWrapper(
        F("amount") - F("cost"),
        output_field=DecimalField(max_digits=10, decimal_places=2),
    )
)

常见误区

  • 两个不同精度 Decimal 相减不包类型:后端类型推断失败,结果转换异常。
  • 给布尔表达式错配数值类型:条件判断结果应声明 BooleanField。
  • 重复包裹多层 wrapper:类型声明以最外层为准,保持一层即可。

追问

  • 不写 output_field 会怎样?答:简单字段运算可继承类型;推断不出时 ORM 抛配置错误或结果类型不符。
  • wrapper 能用于排序吗?答:能,注解出的表达式可参与 order_by。
  • Case/When 需要 wrapper 吗?答:Case 可直接传 output_field,混合类型分支时声明结果类型。

04.7.16.2-018 Case/When 如何做条件聚合与动态排序?

一句话结论

Case(When(条件, then=值), default=默认值, output_field=...) 在 SQL 层实现 CASE WHEN:按条件返回不同分支值。用于条件聚合(如“满足条件的金额求和”用 Sum(Case(When(...), default=0)))、动态排序、状态映射与行级分类。条件在数据库侧求值,避免把全量数据取到 Python 再分支。

概念解释

  • When 接收字段条件(Q 或关键字查找)与 then 分支值。
  • default 兜底未命中分支;output_field 统一分支结果类型。
  • 条件聚合把过滤逻辑下推到 SQL,一次查询完成分组统计。

原理流程

  1. 为每个分支写 When(条件, then=表达式)。
  2. 组合进 Case,声明默认值与输出类型。
  3. 外层可再套 Sum/Count/Avg 做条件聚合,或用于 order_by。

代码或图示

from django.db.models import Case, When, Sum, IntegerField

Order.objects.values("channel").annotate(
    paid_amount=Sum(
        Case(
            When(status="paid", then=F("amount")),
            default=0,
            output_field=IntegerField(),
        )
    )
)

常见误区

  • 分支值类型不一致又不声明 output_field:结果类型转换出错。
  • 在 then 里放 Python 侧不可序列化对象:分支值必须是字段、表达式或数据库常量。
  • 用 Case 实现复杂多段业务规则:规则过长应在 Service 层,SQL 条件保持简洁可核对。

追问

  • 条件聚合与先 filter 再聚合区别?答:条件聚合在同一分组内统计部分行;filter 会先排除整组不满足条件的行。
  • Case 能返回字符串映射吗?答:能,then="vip" 等常量,output_field=CharField。
  • 动态排序怎么写?答:order_by(Case(When(priority=1, then=0), default=1)) 表达式排序。

04.7.16.2-019 Subquery/Exists 子查询与相关子查询怎么写?

一句话结论

Subquery(查询集) 把内层查询作为外层 SQL 的标量子查询,配合 OuterRef 引用外层字段;Exists(子查询) 生成 EXISTS 相关子查询判断关联是否存在。两者都在数据库侧完成关联判断,避免先取外层再逐条查内层;适合注解存在标记、取关联最新值、批量条件判断。

概念解释

  • OuterRef("pk") 指向外层模型字段,内层查询按外层行关联。
  • 子查询返回单列单值时可注解到外层;多行结果需限制 LIMIT 1 或用聚合。
  • Exists 只返回布尔,数据库优化器常能高效处理半连接。

原理流程

  1. 内层 QuerySet 用 OuterRef 关联外层字段。
  2. 包成 Subquery/Exists 注解到外层查询。
  3. 数据库执行相关子查询,结果作为外层列或条件。

代码或图示

from django.db.models import Subquery, Exists, OuterRef

latest = Order.objects.filter(user=OuterRef("pk")).order_by("-created_at")
User.objects.annotate(
    last_order=Subquery(latest.values("no")[:1]),
    has_order=Exists(Order.objects.filter(user=OuterRef("pk"))),
)

常见误区

  • 子查询返回多行多列:标量子查询报错,需 [:1] 限量或改为聚合/预取。
  • OuterRef 层级写错:多层嵌套时引用不到正确外层,条件失效。
  • 用子查询替代 JOIN 后未看执行计划:部分数据库对子查询优化有限,必要时对比 JOIN 方案。

追问

  • Exists 与预取判断哪个快?答:存在性标记用 Exists 半连接;需要关联对象内容用预取。
  • 子查询能 update 吗?答:update 的赋值表达式可引用子查询结果,按后端支持程度使用。
  • OuterRef 跨 app 有效吗?答:有效,按字段名关联,与 app 边界无关。

04.7.16.2-020 数据库侧表达式与 Python 侧计算如何取舍?

一句话结论

能在数据库侧完成的过滤、聚合、排序、关联判断优先下推到 SQL:利用索引、减少传输行数、避免全量实例化;复杂业务规则、跨系统编排、需要对象行为的计算留在 Python 层。判断标准是:数据量大、可声明式表达的走数据库;逻辑分支多、依赖领域行为、结果不回写数据库的走应用层。

概念解释

  • 下推减少网络传输与内存占用,但 SQL 可读性与可移植性下降。
  • Python 侧计算灵活、可测试,但把行数据全部取回应用层。
  • 混合方案:SQL 过滤/聚合出结果集,应用层做规则组装与序列化。

原理流程

  1. 梳理用例需要的过滤、统计、排序与关联判断。
  2. 可声明式表达的部分编译为 SQL 表达式下推。
  3. 剩余业务规则在 Service/视图层对结果集计算,避免把原始大表搬进内存。

代码或图示

# 数据库侧:分组聚合
stats = Order.objects.values("channel").annotate(total=Sum("amount"))

# Python 侧:对聚合结果做规则组装
for row in stats:
    row["level"] = "high" if row["total"] > 10000 else "normal"

常见误区

  • 把大表全部 list() 取回后在 Python 分组:内存与传输成本高,应 values + 聚合下推。
  • 在 SQL 表达式里堆复杂业务规则:SQL 难调试、难测试,跨数据库兼容性差。
  • 过度依赖原生 SQL 替代 ORM 表达式:维护成本高,优先 ORM 可表达的表达式。

追问

  • 哪些计算不适合下推?答:调用外部服务、复杂状态机、依赖模型方法与权限上下文的规则。
  • 怎么评估下推收益?答:对比执行计划、传输行数、应用内存与耗时。
  • 跨库关联能下推吗?答:跨数据库实例无法在单条 SQL 关联,需应用层拼装。

04.7.16.2-021 annotate 与 aggregate 的区别是什么?

一句话结论

annotate 为每个外层对象附加一个聚合/表达式字段,结果仍是 QuerySet(逐行注解);aggregate 对整个查询集做汇总,返回一个字典(标量聚合结果,不再是 QuerySet)。需要“每组/每对象带统计值”用 annotate,需要“全量汇总数字”用 aggregate;配合 values() 分组时,annotate 即分组聚合。

概念解释

  • annotate 输出行数与外层对象数一致,每行多一个注解列。
  • aggregate 输出一行汇总,如总金额、订单数、平均客单价。
  • 两者可叠加:先分组 annotate,再对分组结果 aggregate 二次汇总。

原理流程

  1. annotate:外层行与子查询/聚合关联,每行附加注解值。
  2. aggregate:对查询集整体计算聚合函数,返回字典。
  3. 分组场景:values(分组字段).annotate(...) 生成 GROUP BY 结果。

代码或图示

# 逐对象注解:每个作者的文章数
Author.objects.annotate(article_count=Count("article"))

# 全量汇总:总订单数与总金额
Order.objects.aggregate(count=Count("id"), total=Sum("amount"))

常见误区

  • 把 aggregate 结果当 QuerySet 继续链式调用:返回字典,不支持过滤/排序。
  • 分组时漏 values():annotate 按模型行注解,未形成 GROUP BY。
  • 注解字段名与模型字段重名:覆盖原字段值,命名用区分别名。

追问

  • Count("article") 统计什么?答:关联文章非空数量,可加 distinct=True 去重。
  • 二次聚合怎么写?答:qs.values(...).annotate(...).aggregate(...)。
  • 注解能取关联最新一条吗?答:配合 Subquery 限量子查询实现。

04.7.16.2-022 values() 分组与 annotate 配合的分组规则是什么?

一句话结论

values("分组字段") 指定 GROUP BY 列,随后的 annotate 聚合按这些列分组计算;SELECT 列表中非聚合列必须出现在 values 分组列中。分组字段可多层,聚合别名作为字典键返回;未列入分组的字段不能直接出现在结果投影中,否则违反 SQL 分组规则。

概念解释

  • 分组查询返回字典 QuerySet,键为分组列与聚合别名。
  • 多字段分组按列顺序形成组合分组。
  • HAVING 类条件通过对注解别名再 filter 实现(数据库侧下推)。

原理流程

  1. values() 声明分组键。
  2. annotate() 把聚合函数挂到分组结果上。
  3. ORM 生成 GROUP BY 语句,非聚合列均来自分组键。

代码或图示

Order.objects.values("channel", "status").annotate(
    total=Sum("amount"), count=Count("id")
).filter(total__gt=1000)

常见误区

  • 分组后 SELECT 未分组的模型字段:SQL 语义错误,ORM 生成的查询在严格数据库上报错。
  • 分组字段顺序影响结果吗?答:组合分组语义与顺序无关,但索引利用可能受列顺序影响。
  • 对聚合别名 filter 以为是 Python 过滤:Django 编译为 HAVING 子句下推数据库。

追问

  • 分组后能排序吗?答:能,按分组列或聚合别名 order_by。
  • 怎么取每组 Top N?答:分组聚合不足,需窗口函数或子查询限量。
  • distinct() 与分组区别?答:去重行与按列聚合是不同操作,可组合使用。

04.7.16.2-023 常用聚合函数有哪些?去重怎么处理?

一句话结论

Django 提供 Count、Sum、Avg、Max、Min、StdDev、Variance 等聚合函数;Count/Sum 等支持 distinct=True 对参与聚合的值去重。聚合可放在 annotate(分组逐行)或 aggregate(全量汇总),字段参数为模型字段名或表达式。

概念解释

  • Count("field") 统计非空值数量;Count("id") 统计行数。
  • distinct=True 对应 SQL COUNT(DISTINCT ...)/SUM(DISTINCT ...)。
  • 空值在 Sum/Avg 中按数据库规则忽略,结果可能为 None。

原理流程

  1. 选择聚合函数与字段/表达式。
  2. 指定是否去重、输出类型。
  3. 挂到 annotate 或 aggregate,编译为对应 SQL 聚合。

代码或图示

from django.db.models import Count, Sum, Avg

Order.objects.aggregate(
    orders=Count("id"),
    revenue=Sum("amount"),
    avg_price=Avg("amount"),
    buyers=Count("user", distinct=True),
)

常见误区

  • Sum 空结果返回 None 而非 0:应用层需兜底默认值。
  • 关联一对多时 Count 产生重复计数:需 distinct=True 或先去重。
  • 聚合字段类型与 output_field 不匹配:Decimal 结果精度丢失,必要时显式声明。

追问

  • Count() 不传字段可以吗?答:统计行数用 Count("id") 或 Count("*") 语义等价写法(按版本支持为准)。
  • 聚合能嵌套表达式吗?答:能,参数可为 F()、Case/When 等表达式。
  • 分组计数为 0 的组出现吗?答:内连接分组不出现无关联行的组,需左连接处理。

04.7.16.2-024 窗口函数 Window/Rank/RowNumber 怎么写?

一句话结论

Django 支持窗口函数:Window(expression, partition_by=..., order_by=...) 定义窗口规范,内置 RowNumber、Rank、DenseRank、Sum/Avg 等可作为窗口表达式。用于组内排名、累计求和、取每组最新一行、同比环比等“不折叠分组行”的分析场景;结果保留每行并附加窗口计算列。

概念解释

  • partition_by 划分窗口分区,order_by 分区内排序。
  • 窗口函数在 WHERE/GROUP BY 之后计算,不减少输出行数。
  • 数据库支持窗口函数的版本要求较高,老旧数据库需评估兼容性。

原理流程

  1. 选择排名或累计表达式(如 RowNumber())。
  2. 用 Window 指定分区与排序,注解到 QuerySet。
  3. 数据库按分区计算窗口值,每行附加结果列。

代码或图示

from django.db.models import Window, RowNumber, F

Article.objects.annotate(
    rn=Window(RowNumber(), partition_by=F("category"), order_by=F("created_at").desc())
).filter(rn=1)

常见误区

  • 用分组聚合替代窗口函数:聚合折叠行,无法保留组内每行排名。
  • 窗口别名在 filter 中使用受限:部分数据库不允许 WHERE 直接引用窗口别名,需子查询包裹(待确认:具体限制以 Django 5.x 与后端数据库文档为准)。
  • 分区字段缺索引:窗口排序全表扫描,大数据集需评估性能。

追问

  • Rank 与 RowNumber 区别?答:并列时 Rank 跳号,RowNumber 强行编号,DenseRank 并列不跳号。
  • 累计求和怎么写?答:Window(Sum("amount"), partition_by=..., order_by=...)。
  • 窗口函数兼容哪些数据库?答:PostgreSQL、MySQL 8+、SQL Server 等现代版本;MySQL 5.x 不支持。

04.7.16.2-025 order_by 在聚合查询里有什么影响?

一句话结论

分组聚合查询中,order_by 引用的非聚合列通常必须出现在 GROUP BY 中,否则严格数据库拒绝执行;对聚合别名排序是合法的 HAVING/ORDER BY 表达式排序。无关排序会增加排序成本,分组结果本身不保证顺序,需要稳定输出时显式按分组列或聚合值排序。

概念解释

  • SQL 标准下 SELECT 非聚合列必须分组;排序列同理受约束。
  • 聚合函数结果排序不改变分组,只影响结果行顺序。
  • 多字段排序与索引顺序一致时可避免额外排序步骤。

原理流程

  1. values() 确定分组键,annotate() 计算聚合。
  2. order_by 列纳入 GROUP BY 或作为聚合表达式。
  3. 数据库分组后按指定列排序输出。

代码或图示

Order.objects.values("channel").annotate(
    total=Sum("amount")
).order_by("-total", "channel")

常见误区

  • 分组后按未分组的模型字段排序:违反分组规则,报错或结果不确定。
  • 依赖数据库默认返回顺序:无 order_by 时顺序不保证,分页翻页可能重复/遗漏。
  • 排序字段无索引且数据量大:排序步骤成为瓶颈,需评估索引或预聚合。

追问

  • 聚合别名能直接排序吗?答:能,ORM 编译为 ORDER BY 聚合表达式。
  • 分组查询默认有序吗?答:不保证,必须显式排序。
  • 排序与分页怎么配合?答:稳定排序键 + LIMIT/OFFSET,深分页改键集分页。

04.7.16.2-026 复杂 HAVING 条件在 ORM 里怎么写?

一句话结论

对注解出的聚合别名再调用 filter(),Django 编译为 HAVING 子句;普通 WHERE 条件在 annotate 前过滤行,HAVING 在分组后过滤组。需要“分组后统计值大于阈值”的条件用注解别名 filter;涉及多聚合组合条件时,用 Q 组合注解表达式。

概念解释

  • filter 位置影响语义:注解前是 WHERE,注解后对别名是 HAVING。
  • HAVING 条件只能引用分组列与聚合表达式,不能引用未分组普通列。
  • 复杂条件可先注解中间表达式,再按别名过滤。

原理流程

  1. values() 分组,annotate() 计算聚合别名。
  2. 对别名 filter() 生成 HAVING。
  3. 数据库先过滤行、分组聚合,再按 HAVING 保留分组。

代码或图示

from django.db.models import Count, Q

Author.objects.values("id").annotate(
    article_count=Count("article")
).filter(article_count__gte=3, ~Q(article_count__gt=10))

常见误区

  • 把 HAVING 条件写成注解前的 filter:过滤的是明细行而非分组结果,语义完全不同。
  • HAVING 引用未聚合普通列:SQL 语义错误。
  • 多层 filter 顺序混乱:应区分行过滤与组过滤,必要时拆成两段注释说明。

追问

  • WHERE 与 HAVING 执行顺序?答:WHERE 先过滤明细行,GROUP BY 聚合,HAVING 再过滤分组。
  • 能在 HAVING 里用子查询吗?答:表达式可嵌套子查询,按后端支持程度使用。
  • 分组为空的组怎么排除?答:HAVING 聚合条件天然排除不满足阈值的组。

04.7.16.2-027 默认 Manager 与自定义 Manager 是什么关系?

一句话结论

每个模型默认拥有 objects 管理器(Manager 实例),提供默认查询集;自定义 Manager 子类可追加业务查询方法、修改默认 get_queryset 过滤条件,或通过 Meta.manager/objects 替换默认管理器。Manager 是模型与 QuerySet 之间的入口层,模型类通过管理器暴露查询能力。

概念解释

  • 管理器方法返回 QuerySet 或自定义 Manager,保持链式调用能力。
  • 第一个声明的 Manager 实例是模型的“默认管理器”,Django 内部(如关联反向访问)使用它。
  • 自定义管理器不影响数据库表结构,只改变查询入口行为。

原理流程

  1. 模型类属性挂载 Manager 子类实例。
  2. 模型类元数据记录默认管理器。
  3. 业务代码经 Model.objects 或自定义管理器方法获取查询集。

代码或图示

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status="published")

    def recent(self):
        return self.get_queryset().order_by("-created_at")

class Article(models.Model):
    status = models.CharField(max_length=20)
    objects = PublishedManager()

常见误区

  • 自定义管理器过滤了默认查询集:后台、关联反向访问、admin 也会受影响,需确认是否符合预期。
  • 把纯查询逻辑写进模型实例方法:跨对象复用与链式能力差,应放管理器/QuerySet。
  • 多个管理器实例顺序颠倒:默认管理器是第一个,影响内部关联查询行为。

追问

  • 怎么保留未过滤的默认管理器?答:声明两个管理器,一个过滤一个原始,按属性名访问。
  • 管理器能创建对象吗?答:create/get_or_create 等继承自基础 Manager。
  • 自定义管理器方法能被链式继续过滤吗?答:返回 QuerySet 即可链式;返回列表则中断链式。

04.7.16.2-028 get_queryset() 如何过滤默认查询集?

一句话结论

覆写 Manager.get_queryset() 返回带默认过滤条件的 QuerySet,模型所有经该管理器的查询都先叠加这层条件;适合软删除过滤、租户隔离、状态可见性等全局默认规则。需要绕过默认过滤时,提供另一个原始管理器方法或直接使用模型底层查询入口。

概念解释

  • get_queryset 是管理器每次获取查询集的入口,链式方法基于它继续。
  • 默认过滤条件在管理器层统一,避免每个视图重复写相同 filter。
  • 隔离规则若依赖请求上下文(当前租户),管理器不能直接拿 request,需在查询层显式传条件。

原理流程

  1. 管理器方法调用 get_queryset() 取基础查询集。
  2. 覆写实现叠加默认过滤(如 deleted=False)。
  3. 上层链式方法在过滤后的查询集上继续条件与排序。

代码或图示

class ActiveManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_active=True)

class Account(models.Model):
    is_active = models.BooleanField(default=True)
    active = ActiveManager()
    objects = models.Manager()

常见误区

  • 在 get_queryset 里读取当前用户/请求:管理器无请求上下文,应在视图/Service 传入条件。
  • 默认过滤导致后台看不到被隐藏记录:admin 需使用原始管理器或单独查询。
  • 软删除过滤遗漏关联查询:反向关联使用默认管理器,需确认过滤规则一致。

追问

  • 怎么在 admin 里看到全部记录?答:admin 模型类指定 manager 或使用未过滤管理器查询。
  • get_queryset 能做排序吗?答:能,但排序作为默认规则灵活性低,建议在调用处显式排序。
  • 多个管理器各自 get_queryset 独立吗?答:独立,互不影响。

04.7.16.2-029 QuerySet.as_manager() 与多 Manager 类组合怎么用?

一句话结论

QuerySet.as_manager() 把一个自定义 QuerySet 类的方法提升为管理器方法,避免在 Manager 与 QuerySet 两处重复实现;as_manager(*manager_classes) 还可组合多个 Manager 类的方法。适合查询逻辑集中在 QuerySet、又需要经管理器入口调用的场景。

概念解释

  • 自定义 QuerySet 写业务方法,as_manager() 生成对应 Manager,方法在管理器与 QuerySet 上都可用。
  • 组合多个 Manager 类时,方法按参数顺序合并,冲突时后者覆盖。
  • 这种方式保持链式:管理器方法返回 QuerySet,继续可调用 QuerySet 方法。

原理流程

  1. 定义继承 QuerySet 的自定义查询集并添加方法。
  2. 模型属性用 MyQuerySet.as_manager() 挂载管理器。
  3. 经管理器调用方法,内部委托给 QuerySet 实现。

代码或图示

class ArticleQuerySet(models.QuerySet):
    def published(self):
        return self.filter(status="published")

    def by_category(self, name):
        return self.filter(category__name=name)

class Article(models.Model):
    objects = ArticleQuerySet.as_manager()

常见误区

  • Manager 与 QuerySet 各写一套相同方法:逻辑分叉,应集中到 QuerySet 再 as_manager。
  • 自定义 QuerySet 方法返回列表:链式中断,应返回 self 或新 QuerySet。
  • 组合 Manager 类时方法名冲突:后加入覆盖前者,需核对合并顺序。

追问

  • as_manager 生成的管理器是默认管理器吗?答:模型属性挂载的第一个管理器即默认管理器。
  • QuerySet 方法能访问管理器吗?答:QuerySet 不持有管理器引用,跨方法复用放 QuerySet 层。
  • 自定义 QuerySet 能预定义预取吗?答:能,方法内 select_related/prefetch_related 后返回。

04.7.16.2-030 Manager 方法与 QuerySet 方法如何分工,链式调用如何保留?

一句话结论

Manager 负责入口暴露与跨模型协调,QuerySet 负责可链式组合的查询条件与投影;业务查询方法优先写在 QuerySet(返回 self/新 QuerySet),经 as_manager 暴露给管理器。链式保留的关键是方法返回 QuerySet 而非列表/实例;需要返回单条对象的方法(get/first)自然结束链式。

概念解释

  • 链式方法:过滤、排序、预取、注解,返回 QuerySet。
  • 终止方法:get/first/count/exists/list,返回实例或标量。
  • Manager 层可放按用例组装多步查询的便捷方法,内部仍委托 QuerySet。

原理流程

  1. 查询条件与投影方法落在 QuerySet,返回新 QuerySet。
  2. as_manager 把方法提升为管理器入口。
  3. 调用方链式叠加条件,直到终止方法求值。

代码或图示

class OrderQuerySet(models.QuerySet):
    def paid(self):
        return self.filter(status="paid")
    def recent(self):
        return self.order_by("-created_at")

# 链式:paid().recent().first()

常见误区

  • 在管理器方法里把 QuerySet 转成列表再返回:后续无法继续过滤。
  • 把用例编排(事务、外部调用)塞进 QuerySet 方法:QuerySet 应只描述查询,编排放 Service。
  • 方法命名与内置 QuerySet 方法冲突:覆盖内置行为,排查困难。

追问

  • 怎么判断方法该放 Manager 还是 QuerySet?答:可链式组合的查询逻辑放 QuerySet;入口门面/跨模型协调放 Manager。
  • 终止方法有哪些?答:get、first、last、count、exists、aggregate、iterator 等。
  • QuerySet 方法能调用管理器方法吗?答:不直接持有管理器,复用逻辑应下沉到共享函数或 QuerySet 内部。

04.7.16.2-031 atomic 嵌套时保存点如何工作?内层回滚对外层有什么影响?

一句话结论

外层 atomic 开启数据库事务;内层再次进入 atomic 时创建保存点(SAVEPOINT)。内层异常被捕获且未传播出内层块时,只回滚到保存点,外层事务仍可继续提交;内层异常传播出内层则回滚保存点并继续向上抛。嵌套层级对应保存点层级,释放保存点在块正常退出时提交到外层事务。

概念解释

  • 保存点是事务内的部分回滚标记,不是独立事务。
  • 内层 atomic 退出时:正常则释放保存点(变更并入外层),异常则回滚到保存点。
  • 数据库不支持保存点时,嵌套行为按后端能力降级(待确认:具体降级策略以 Django 5.x 文档为准)。

原理流程

  1. 外层进入 atomic,开启事务。
  2. 内层进入,创建保存点;内层操作记录在保存点之后。
  3. 内层正常退出释放保存点;异常回滚保存点,外层按自身结果提交或回滚。

代码或图示

with transaction.atomic():
    order = Order.objects.create(...)
    try:
        with transaction.atomic():
            OrderItem.objects.create(order=order, ...)
            raise ValueError("item 失败")
    except ValueError:
        pass  # 仅回滚内层保存点,order 仍可提交

常见误区

  • 捕获内层异常后以为外层也回滚:外层未抛异常会继续提交,需显式标记回滚或重新抛出。
  • 内层块内发外部消息/写缓存:保存点回滚不撤销已发出的副作用。
  • 嵌套过深导致保存点链复杂:事务边界应按用例划分,避免无意义嵌套。

追问

  • 保存点数量有限制吗?答:受数据库后端保存点数量与深度限制,超长嵌套需评估。
  • 内层回滚后外层能读到什么?答:回滚到保存点之前的状态,内层变更已撤销。
  • atomic 能装饰函数/类方法吗?答:能,作为装饰器使用,进入即开事务。

04.7.16.2-032 on_commit 回调的注册时机、执行顺序与失败行为是什么?

一句话结论

transaction.on_commit(func) 在当前事务成功提交后执行回调;注册时若不在事务中,回调立即执行。多个回调按注册顺序执行,回调异常不会回滚已提交事务(事务早已提交),需要自行捕获与记录。典型用途:提交后发消息、清缓存、触发下游任务,避免回滚后产生脏副作用。

概念解释

  • 回调在提交成功那一刻触发,处于事务外,不能再依赖未提交数据。
  • 测试环境默认事务不提交,on_commit 不执行,需用 captureOnCommitCallbacks 捕获断言。
  • 回调内不要再开长事务或阻塞主流程,耗时任务应投递异步队列。

原理流程

  1. 业务代码在事务内注册回调函数。
  2. 事务正常提交,框架按注册顺序调用回调。
  3. 回调执行外部副作用;提交失败则回调不执行。

代码或图示

with transaction.atomic():
    order = Order.objects.create(...)
    transaction.on_commit(lambda: notify_order_created.delay(order.id))

常见误区

  • 在事务内直接发 MQ/HTTP:事务回滚后消息已发出,造成脏数据;必须 on_commit 延后。
  • 回调内访问已删除或变更的数据:提交后数据状态可能变化,回调应携带必要快照值。
  • 回调抛异常中断后续回调:框架不保证后续回调继续,关键回调要内部容错。

追问

  • 不在事务里注册 on_commit 会怎样?答:回调立即执行,不等待提交。
  • 测试怎么验证回调?答:captureOnCommitCallbacks 收集回调并手动执行断言。
  • 回调能同步做重计算吗?答:不建议,应投递异步任务,避免拖慢请求提交链路。

04.7.16.2-033 select_for_update 的加锁范围与 nowait/skip_locked/of 参数是什么?

一句话结论

select_for_update() 在事务内对查询命中的行加排他行锁,阻塞其他事务修改或锁定这些行;nowait=True 遇到锁立即报错返回、不等待,skip_locked=True 跳过被锁行返回其余行,of 指定锁定关联表(部分后端支持)。行锁只在事务内有效,提交/回滚后释放;必须在 atomic 块内使用,否则无事务语义。

概念解释

  • 排他锁防止并发更新同一行造成竞态(如扣减库存、余额)。
  • skip_locked 适合任务领取类场景:拿不到锁就跳过,不排队等待。
  • 不同数据库对 of、nowait、skip_locked 支持程度不同,MySQL/PostgreSQL 主流支持,旧版本需核对。

原理流程

  1. 在 atomic 事务内执行带 select_for_update 的查询。
  2. 数据库对命中行加排他锁,其他事务冲突时按参数等待/报错/跳过。
  3. 事务提交或回滚后释放锁。

代码或图示

from django.db import transaction

with transaction.atomic():
    product = Product.objects.select_for_update().get(pk=pid)
    if product.stock >= 1:
        product.stock -= 1
        product.save()

常见误区

  • 事务外调用 select_for_update:锁语义不成立,部分后端直接报错或忽略。
  • 多事务按不同顺序锁定多行:容易死锁,应统一加锁顺序。
  • 用 skip_locked 后假设跳过的行永久不可见:下次轮询可再领取,业务要保证幂等。

追问

  • 行锁与乐观锁区别?答:行锁阻塞等待,乐观靠版本号/时间戳冲突检测重试;高冲突用悲观锁,低冲突用乐观锁。
  • select_for_update 能锁关联表吗?答:of 参数指定,受后端支持限制(待确认:各后端支持矩阵以 5.x 文档为准)。
  • 死锁怎么产生?答:两个事务交叉持有并等待对方持有的锁,需统一锁顺序与缩短事务。

04.7.16.2-034 数据库隔离级别如何影响 Django 事务与可见性?

一句话结论

隔离级别决定事务能看到其他未提交/已提交变更的程度:读未提交、读已提交、可重复读、串行化。Django 不显式设置隔离级别时沿用数据库默认(如 PostgreSQL 读已提交、MySQL 可重复读);可在数据库配置或连接层调整。隔离级别影响幻读、不可重复读与并发一致性,业务一致性要求高时需对照级别设计事务边界与重试。

概念解释

  • 读已提交:只能读到其他事务已提交数据,避免脏读。
  • 可重复读:同一事务内多次读同一行结果一致,靠快照或行锁保证。
  • 串行化:最高隔离,并发事务串行执行,冲突重试概率上升。

原理流程

  1. 连接建立时按数据库默认或配置确定隔离级别。
  2. 事务内查询按级别读取快照/已提交数据。
  3. 并发写冲突由数据库锁与隔离机制处理,应用层按失败重试。

代码或图示

# settings.py DATABASES 中按后端配置隔离级别(示例,具体键名以后端为准)
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "OPTIONS": {"isolation_level": "read committed"},
    }
}

常见误区

  • 以为 Django 事务自动解决所有并发问题:隔离级别与锁策略仍需按业务选择。
  • 高隔离级别下盲目串行化:并发吞吐下降,冲突重试增多。
  • 跨事务读到旧快照后基于旧值更新:需加锁或乐观校验防止覆盖写。

追问

  • 怎么查看当前隔离级别?答:执行数据库查询(如 PostgreSQL SHOW transaction_isolation)。
  • 幻读在哪个级别可能出现?答:读已提交及更低级别;可重复读通常避免,串行化完全避免。
  • Django 能按连接切换级别吗?答:通过后端 OPTIONS 或连接层设置,跨库分别配置。

04.7.16.2-035 手动保存点(savepoint)在什么场景使用?

一句话结论

transaction.savepoint() 手动创建保存点,配合 savepoint_commit/savepoint_rollback 在大事务内做部分回滚;嵌套 atomic 本质就是保存点封装。当一段逻辑可能失败但不应回滚整个事务,且需要比嵌套 atomic 更细的控制时使用;常规业务优先用嵌套 atomic 上下文管理器,可读性更好。

概念解释

  • 保存点编号由框架维护,手动提交/回滚按编号操作。
  • 保存点只能在事务内创建,无事务时调用行为按框架规则处理。
  • 部分回滚后外层事务继续,已回滚部分的副作用需人工补偿。

原理流程

  1. 事务内调用 savepoint() 获得保存点 ID。
  2. 子步骤失败则 savepoint_rollback 撤销到该点;成功则 savepoint_commit 释放。
  3. 外层事务按整体结果提交或回滚。

代码或图示

from django.db import transaction

with transaction.atomic():
    sid = transaction.savepoint()
    try:
        risky_step()
        transaction.savepoint_commit(sid)
    except Exception:
        transaction.savepoint_rollback(sid)

常见误区

  • 保存点回滚后仍使用回滚前拿到的对象引用:对象状态是旧快照,需重新查询。
  • 在保存点内发出外部副作用:回滚不撤销外部消息/缓存,应延后到提交后。
  • 手动保存点层级混乱:优先嵌套 atomic,由框架管理保存点生命周期。

追问

  • 嵌套 atomic 与手动保存点等价吗?答:底层机制相同,atomic 提供上下文管理与异常处理封装。
  • 保存点能跨事务吗?答:不能,绑定当前事务连接。
  • 回滚保存点会释放后续保存点吗?答:按数据库规则,回滚到某点后其后保存点一并失效。

04.7.16.2-036 ATOMIC_REQUESTS 的事务边界与异常回滚范围是什么?

一句话结论

ATOMIC_REQUESTS=True 把每个请求包裹在一个数据库事务中:视图正常返回则提交,视图未捕获异常则回滚。事务边界覆盖请求内所有数据库操作,包括中间件与视图;适合要求“请求内数据操作要么全成功要么全回滚”的场景。代价是事务持有时间拉长,写多、外部 IO 多的请求会增加锁持有与连接占用。

概念解释

  • 事务在请求进入时开启,响应返回后提交;异常传播出请求处理则回滚。
  • 视图内自行开启的 atomic 嵌套在请求事务内,形成保存点层级。
  • 后台任务、命令、队列消费者不受请求事务包裹,需自行管理事务。

原理流程

  1. 中间件层开启请求事务。
  2. 中间件、视图、模型操作在同一事务内读写数据库。
  3. 正常响应提交;未捕获异常回滚,事务随请求结束关闭。

代码或图示

# settings.py
DATABASES = {"default": {"ATOMIC_REQUESTS": True}}

常见误区

  • 请求内调用阻塞外部服务仍持有事务:连接与锁被拉长,应把外部 IO 移出事务或用 on_commit。
  • 以为返回错误响应也会回滚:只有未捕获异常触发回滚;显式返回 4xx/5xx 响应通常正常提交。
  • 长请求批量写数据:单事务过大,应拆分批次提交或关闭请求级事务改用局部 atomic。

追问

  • ATOMIC_REQUESTS 与局部 atomic 冲突吗?答:不冲突,局部为嵌套保存点。
  • 哪些场景建议关闭?答:读多写少、长耗时请求、需要部分成功的流程。
  • 事务内发消息怎么避免脏数据?答:on_commit 延后,或关闭请求级事务后按用例控制边界。

04.7.16.2-037 长事务、死锁与锁等待如何排查?

一句话结论

长事务表现为连接长时间持有、锁等待堆积、回滚段膨胀;死锁是两个及以上事务交叉等待对方持有的锁,数据库检测后回滚其中一方。排查路径:看数据库锁等待与活跃事务视图、定位长事务来源请求/任务、检查加锁顺序与事务内外部 IO;优化方向是缩短事务边界、统一锁顺序、减少批量持有时间、必要时改乐观锁。

概念解释

  • 锁等待:事务 A 持锁,事务 B 阻塞等待;超时后报错或跳过。
  • 死锁:循环等待,数据库死锁检测器中止牺牲者,应用需重试。
  • 指标:活跃事务时长、锁等待数、回滚次数、连接占用时长。

原理流程

  1. 数据库视图查看活跃事务、持锁与等待关系。
  2. 关联来源连接到请求/任务日志,定位长事务代码段。
  3. 检查事务内是否含外部 IO、批量写、加锁顺序,逐项缩短与规范化。

代码或图示

-- PostgreSQL 示例:查看长事务与锁等待(具体视图以后端为准)
SELECT pid, state, xact_start, query FROM pg_stat_activity WHERE state <> 'idle';

常见误区

  • 出现死锁就加隔离级别:隔离级别不消除交叉锁顺序问题,统一加锁顺序才是根因。
  • 事务内调用远程接口/MQ:等待期间持续持锁,应移出事务或提交后触发。
  • 批量更新包在单事务:锁与日志量膨胀,分批提交控制单次规模。

追问

  • 死锁后应用要重试吗?答:被回滚一方应按幂等设计重试,区分可重试错误与业务失败。
  • 怎么监控长事务?答:数据库活跃事务时长指标 + 应用请求耗时与事务日志。
  • 乐观锁适合什么场景?答:冲突概率低、更新可重试、不想阻塞等待的并发写。

04.7.16.2-038 db_index、Meta.indexes、UniqueConstraint 有什么区别?

一句话结论

db_index=True 为单字段创建普通 B-tree 索引;Meta.indexes 声明复合索引、唯一索引或带条件/表达式索引(Index(fields=[...], unique=True, condition=..., expression=...));UniqueConstraint 定义唯一约束,保证列组合不重复并可纳入约束体系。单字段简单索引用 db_index,多列与定制索引用 Meta.indexes,唯一性保障用约束。

概念解释

  • 索引加速查询与排序,约束保障数据完整性;唯一约束同时具备索引作用。
  • 旧版 unique_together 已被 UniqueConstraint 取代,新模型使用约束写法。
  • 索引随迁移创建/删除,大表建索引需评估锁与耗时。

原理流程

  1. 字段级 db_index 生成单列索引声明。
  2. 模型 Meta.indexes 定义复合/定制索引。
  3. 约束声明唯一规则,迁移时数据库创建对应索引与约束。

代码或图示

class Order(models.Model):
    no = models.CharField(max_length=32, db_index=True)
    class Meta:
        indexes = [
            models.Index(fields=["status", "created_at"]),
            models.Index(fields=["user_id"], name="idx_order_user"),
        ]
        constraints = [
            models.UniqueConstraint(fields=["no"], name="uniq_order_no"),
        ]

常见误区

  • 给每列都加索引:写入放大与维护成本上升,索引应服务实际查询模式。
  • 用普通索引替代唯一约束:普通索引允许重复,唯一性必须靠约束。
  • 复合索引字段顺序与查询条件不匹配:无法利用最左前缀,索引失效。

追问

  • 唯一约束和唯一索引区别?答:约束是数据完整性规则,数据库实现常以唯一索引落地;约束可纳入元数据与迁移管理。
  • 索引能包含非索引列吗?答:部分后端支持包含列(include),按数据库能力配置。
  • 表达式索引怎么写?答:Index(fields=[...], expression=Lower("name"))(后端支持时)。

04.7.16.2-039 复合索引字段顺序如何设计?最左前缀原则是什么?

一句话结论

复合索引按字段顺序组织 B-tree,查询条件必须从索引最左列开始连续匹配才能利用索引(最左前缀);高区分度、等值过滤字段放前面,范围查询字段放后面。顺序设计依据实际 WHERE/ORDER BY 模式:等值列优先,排序列次之,避免把范围列放在等值列前面导致后续列无法利用。

概念解释

  • 最左前缀:索引 (a, b, c) 支持 a、a+b、a+b+c,不支持只按 b 或 c 查询。
  • 范围条件(>、<、LIKE)右侧列在索引中无法继续用于过滤。
  • 索引顺序与查询排序方向相关,双向排序需额外索引或数据库反向扫描支持。

原理流程

  1. 统计高频查询的等值过滤列、范围列与排序列。
  2. 等值列前置,范围/排序列后置,组成复合索引。
  3. 执行计划核对索引命中与扫描范围,调整列顺序。

代码或图示

# 高频查询:status 等值 + created_at 范围/排序
models.Index(fields=["status", "created_at"])

常见误区

  • 把范围列放第一列:后续等值列无法走最左前缀。
  • 复合索引照搬表字段声明顺序:未对照查询模式,索引利用率低。
  • 多套相似复合索引重复维护:合并重叠前缀,控制索引总数。

追问

  • 排序能用索引吗?答:排序列与索引列顺序一致且方向匹配时,可避免 filesort。
  • 区分度低的字段放前面合适吗?答:区分度低会导致索引扫描行数多,需结合后续列评估。
  • 怎么验证索引命中?答:EXPLAIN 查看 key、type、rows 与Extra 排序/过滤步骤。

04.7.16.2-040 覆盖索引与 only/defer 如何配合减少回表?

一句话结论

覆盖索引指查询所需列全部包含在索引中,数据库无需回表取主表数据;only(*fields) 只加载指定字段,defer(*fields) 延迟加载其余字段,配合覆盖索引减少读取列与回表次数。宽表大字段(文本、Blob)尤其适合 defer,列表接口只取展示字段;代价是访问延迟字段时再发一次查询。

概念解释

  • 回表:二级索引找到主键后再回主表取整行数据;覆盖索引消除这一步。
  • only 是白名单加载,defer 是黑名单延迟;两者基于字段级延迟加载。
  • 延迟字段在实例首次访问时触发额外查询,循环中访问会产生 N+1。

原理流程

  1. 列表接口确定所需展示字段。
  2. 查询集用 only 裁剪列,索引设计覆盖这些列。
  3. 遍历只访问已加载字段;避免循环中触碰延迟字段。

代码或图示

Order.objects.only("no", "amount", "created_at")
Article.objects.defer("body")  # 大字段延迟加载

常见误区

  • only 之后模板访问未加载字段:每个对象触发一次延迟查询,形成 N+1。
  • 覆盖索引列不全:看似走索引仍回表,需对照 SELECT 列核对索引包含列。
  • 宽表全字段 defer 后又需要完整对象:多次查询反而更慢,详情接口取整行更直接。

追问

  • defer 字段什么时候加载?答:实例访问该属性时发查询取回。
  • 覆盖索引对写入有影响吗?答:索引列越多写入维护成本越高,需权衡。
  • only 与 values 区别?答:only 返回模型实例并延迟字段;values 返回裸字典,不构造实例。

04.7.16.2-041 如何用 explain()/EXPLAIN ANALYZE 看执行计划?

一句话结论

QuerySet 调用 .explain() 输出数据库执行计划(访问路径、JOIN 顺序、索引、估算行数);部分后端支持 explain(analyze=True) 实际执行并给出真实耗时与行数。重点看是否命中预期索引、是否全表扫描、JOIN 顺序、临时表/排序步骤与估算行数偏差,再决定加索引、改写法或调整关联。

概念解释

  • explain() 输出格式随数据库后端不同,MySQL 用 EXPLAIN,PostgreSQL 用 EXPLAIN (...)。
  • 计划是优化器基于统计信息估算,数据分布变化后计划可能改变。
  • analyze 会真实执行语句(含写操作需谨慎),用于核对实际耗时与行数。

原理流程

  1. 构造待分析查询集,调用 explain() 或 explain(analyze=True)。
  2. 读取计划中的访问类型、索引键、扫描行数与额外步骤。
  3. 对照预期定位全表扫描/回表/排序瓶颈,优化后复查计划。

代码或图示

print(Order.objects.filter(status="paid").explain())
# PostgreSQL 实际执行分析
print(Order.objects.filter(status="paid").explain(analyze=True))

常见误区

  • 只看是否“用到索引”:还要看扫描行数与回表比例,命中索引但扫描大量行仍可能慢。
  • 测试库数据量小导致计划失真:生产相似数据量下复核计划。
  • 忽略统计信息过期:分析前更新表统计(如 ANALYZE),避免优化器误判。

追问

  • 怎么判断全表扫描?答:计划中访问类型为全序列扫描/ALL,未使用预期索引。
  • 估算行数与实际偏差大说明什么?答:统计信息过期或数据分布倾斜,需更新统计并评估索引。
  • EXPLAIN ANALYZE 有副作用吗?答:SELECT 无写入;对 UPDATE/DELETE 会真实执行,不要在生产误跑。

04.7.16.2-042 哪些写法会导致索引失效?

一句话结论

常见索引失效:对索引列做函数/运算包裹(WHERE YEAR(created_at)=...)、隐式类型转换(字符串列与数字比较)、前导通配符 LIKE '%abc'、不符合最左前缀的复合索引查询、对列做 NULL 判断方式不当、OR 连接未覆盖索引的条件。优化时把计算移到常量侧,让索引列保持裸列参与比较。

概念解释

  • 索引列被函数包裹后,索引有序性无法直接用于定位。
  • 隐式转换使比较类型不匹配,优化器放弃索引。
  • 前导通配符无法利用 B-tree 前缀;全文/三元索引另作方案。

原理流程

  1. 检查 WHERE/ORDER BY 中索引列是否被函数、运算或转换处理。
  2. 把表达式改写为列与常量比较(如范围区间替代函数提取)。
  3. 复核执行计划确认索引命中。

代码或图示

# 失效:函数包裹列
Order.objects.filter(created_at__year=2026)
# 改写:范围比较(按业务时间边界构造)
Order.objects.filter(created_at__gte=date(2026, 1, 1), created_at__lt=date(2027, 1, 1))

# 失效:前导通配符
Article.objects.filter(title__icontains="%django")

常见误区

  • 以为加了索引就一定走:写法破坏索引列后优化器只能全表扫描。
  • 多列 OR 条件部分无索引:整个查询可能放弃索引合并,需分别建索引或改写。
  • 类型不一致:外键/字符集/排序规则不匹配导致转换失效,建表时统一。

追问

  • LIKE 'abc%' 能走索引吗?答:前缀匹配可利用 B-tree 前缀,前导通配符不行。
  • 函数索引能解决函数包裹问题吗?答:后端支持表达式索引时可建对应函数索引。
  • 怎么批量发现失效查询?答:慢查询日志 + 执行计划审查,按扫描行数排序定位。

04.7.16.2-043 索引过多有什么代价?

一句话结论

每个索引都要在写入(INSERT/UPDATE/DELETE)时维护:更新索引列需同步调整 B-tree,占用磁盘与写放大;索引过多拖慢写入、增加备份与维护成本,优化器选择计划时也可能误选。索引应按查询模式增量建立,定期清理长期未使用的索引,而非“先加上保险”。

概念解释

  • 写入放大:一行变更涉及多个索引,每个索引都要更新结构。
  • 磁盘与内存:索引占用存储与缓冲池空间,挤占有效数据缓存。
  • 统计与计划:索引候选过多,优化器评估成本上升,偶发选错路径。

原理流程

  1. 梳理现有索引与实际查询匹配度。
  2. 识别重复前缀、长期未命中索引与冗余复合索引。
  3. 评估写入量与查询收益后删除冗余索引,监控写入与查询指标。

代码或图示

-- 示例:查询索引使用情况(具体视图以后端为准)
SELECT indexrelname, idx_scan FROM pg_stat_user_indexes;

常见误区

  • 单字段索引堆叠:多列查询应评估复合索引,而非每列单独建。
  • 只加索引不清理:随迭代索引只增不减,写入成本持续累积。
  • 删除索引前未核对使用统计:低扫描量可能是查询量小,需结合业务周期判断。

追问

  • 主键索引需要维护吗?答:主键通常聚簇索引,写入时同步维护,代价最高之一。
  • 索引能加快写入吗?答:不能,只加速读取与排序,写入成本随索引增加。
  • 怎么判断索引冗余?答:前缀包含关系、重复列组合与扫描统计综合判断。

04.7.16.2-044 makemigrations 与 migrate 各自做什么?迁移文件包含哪些操作?

一句话结论

makemigrations 对比模型定义与已记录迁移状态,生成描述模型变更的迁移文件(建表、加列、删列、索引、约束、重命名等操作);migrate 按依赖顺序执行未应用的迁移,更新数据库结构并记录版本。迁移文件是代码的一部分,需随模型变更提交版本库,在各环境按顺序执行。

概念解释

  • 迁移操作类:CreateModel、AddField、RemoveField、AlterField、AddIndex、AlterUniqueTogether、RenameField 等。
  • makemigrations 不连业务库也能生成文件;migrate 才真正改表结构。
  • 迁移依赖链按 app 与迁移文件名编号维护。

原理流程

  1. 模型变更后运行 makemigrations,生成迁移文件与依赖声明。
  2. 评审迁移内容(字段默认值、可逆性、数据迁移)。
  3. migrate 执行未应用迁移,更新 django_migrations 版本表。

代码或图示

python manage.py makemigrations orders
python manage.py migrate orders

常见误区

  • 改完模型不生成迁移:线上表结构与模型不一致,运行时报缺列/缺表。
  • 迁移文件不提交版本库:其他环境与部署实例结构漂移。
  • 自动迁移带破坏性删除:RemoveField 丢数据,需先数据备份或数据迁移保留。

追问

  • migrate 怎么知道哪些已执行?答:django_migrations 表记录已应用迁移名与 app。
  • 迁移能手动编辑吗?答:可调整生成文件,但依赖与操作顺序要正确,复杂数据迁移手写更可控。
  • makemigrations --empty 做什么?答:生成空迁移文件,供手写 RunPython/RunSQL。

04.7.16.2-045 RunPython/RunSQL 怎么写?回滚函数如何提供?

一句话结论

RunPython(code, reverse_code=...) 在迁移中执行 Python 数据迁移;RunSQL(sql, reverse_sql=...) 执行原始 SQL。两者都可提供反向操作以支持回滚;RunPython 内通过 apps.get_model 取历史模型快照,避免受后续模型变更影响。数据回填、字段拆分、历史数据修正应走迁移,而不是在 ready() 或视图里临时处理。

概念解释

  • 迁移中模型是历史快照:用 apps.get_model("app", "Model"),不直接 import 当前模型类。
  • reverse_code/reverse_sql 在回滚迁移时执行;不可逆操作应明确标注。
  • 大数据量回填需分批处理,避免单迁移长时间锁表。

原理流程

  1. 空迁移或自动迁移中加入 RunPython/RunSQL 操作。
  2. 正向函数读取历史模型快照,批量转换/回填数据。
  3. 回滚时执行反向函数撤销变更;不可逆操作留空并说明。

代码或图示

from django.db import migrations

def fill_slug(apps, schema_editor):
    Article = apps.get_model("articles", "Article")
    for a in Article.objects.all().iterator():
        a.slug = a.title.lower().replace(" ", "-")
        a.save()

class Migration(migrations.Migration):
    dependencies = [("articles", "0001_initial")]
    operations = [
        migrations.RunPython(fill_slug, reverse_code=migrations.RunPython.noop),
    ]

常见误区

  • 迁移里直接 import 当前模型类:后续模型变更会让历史迁移行为漂移,必须用快照模型。
  • 全量 save() 逐行更新大表:锁与日志膨胀,应分批 bulk_update 或区间提交。
  • 只写正向不考虑回滚:线上回滚迁移时报不可逆,需提供反向逻辑或明确 noop。

追问

  • RunPython 能调用 ORM 新方法吗?答:快照模型不含后续新增方法,逻辑应自包含。
  • 数据迁移与结构迁移要分开吗?答:建议拆分,先加列兼容写入,再回填,最后切换读取。
  • RunSQL 跨数据库可移植吗?答:原生 SQL 绑定后端,多后端项目优先 RunPython。

04.7.16.2-046 零停机迁移的 expand-contract 模式是什么?

一句话结论

大表结构变更不停机分三阶段:expand(兼容扩展)先加新列/新表,新旧双写;migrate(数据迁移)回填历史数据并校验;contract(收缩)确认读取切到新结构后删除旧列/旧表。每个阶段都保持旧代码与新代码可共存部署,避免一次性删列/改列导致新旧版本不兼容。

概念解释

  • 双写期同时维护新旧字段,保证回滚与灰度期间数据一致。
  • 回填分批进行,控制单次事务规模与锁持有。
  • 收缩阶段确认无旧代码读取旧结构后再删除,迁移顺序与部署顺序配合。

原理流程

  1. 扩展:新增列/表,应用写入同时维护新旧结构。
  2. 迁移:后台任务分批回填历史数据,对账校验一致性。
  3. 收缩:读取切换到新结构,观察稳定后移除旧列与旧代码路径。

代码或图示

旧结构 ── 加新列/双写 ── 回填历史 ── 读新结构 ── 删旧列
        expand          migrate        contract

常见误区

  • 直接重命名/删除列后滚动部署:旧版本实例读不到列,启动或请求报错。
  • 回填未分批:大表单事务锁表,阻塞线上写入。
  • 双写期只写新不写旧:回滚到旧版本时数据缺失。

追问

  • 字段改名怎么零停机?答:加新列 → 双写回填 → 读切新列 → 删旧列,不直接 RenameField 上线。
  • 回填期间新数据怎么保证一致?答:写入路径双写,回填只补历史行。
  • 怎么校验回填完整?答:按主键区间对账、计数抽样与新旧值比对。

04.7.16.2-047 SeparateDatabaseAndState 什么时候使用?

一句话结论

SeparateDatabaseAndState(database_operations=..., state_operations=...) 把“数据库实际操作”与“模型状态记录”分离:当表由外部系统管理、使用原生 SQL 建表、或 ORM 状态与数据库结构需要不一致时使用。典型场景:对接既有外部表、手动管理的数据库对象、状态迁移只记录模型元数据而不改物理表。

概念解释

  • state_operations 影响迁移历史中的模型状态(供后续迁移与模型一致性检查)。
  • database_operations 直接作用于物理数据库;两者可独立配置。
  • 普通模型变更不需要它,误用会导致状态与表结构脱节。

原理流程

  1. 识别表/对象不由 Django 迁移管理物理结构。
  2. 拆分状态操作与数据库操作:状态记录模型定义,数据库操作走原生 SQL 或留空。
  3. 后续迁移基于分离后的状态继续依赖。

代码或图示

migrations.SeparateDatabaseAndState(
    database_operations=[migrations.RunSQL("CREATE TABLE ...")],
    state_operations=[migrations.CreateModel("External", [])],
)

常见误区

  • 普通业务表使用分离操作:模型状态与物理表漂移,后续迁移连锁出错。
  • 只写状态操作不建表:运行时找不到物理表;只建表不记状态:后续迁移无法依赖模型。
  • 外部表结构变更后不同步状态:字段查询在 ORM 层报错。

追问

  • 只读外部表怎么建模?答:managed = False,迁移不管理建表,必要时用分离操作记录状态。
  • SeparateDatabaseAndState 能回滚吗?答:按两类操作各自的反向定义执行。
  • 什么时候不需要它?答:Django 全权管理结构的模型,走标准迁移操作即可。

04.7.16.2-048 迁移冲突如何解决?依赖链与 squash 是什么?

一句话结论

多人并行开发各自生成迁移后,依赖链分叉产生冲突;解决方式是合并迁移依赖(编辑迁移文件 dependencies 指向两条分支)或重新基于最新基线生成迁移。squashmigrations 把一串历史迁移压缩成一个迁移文件,降低依赖链长度,但压缩后的文件需谨慎处理历史数据操作与依赖关系。

概念解释

  • 迁移文件按 app 内编号排序,依赖声明跨 app 引用。
  • 冲突表现:两个迁移都依赖同一前置迁移,后续 migrate 出现分叉提示。
  • squash 适合长期演进的项目;新功能迁移保持独立,避免频繁压缩。

原理流程

  1. 拉取最新基线,发现迁移依赖分叉。
  2. 在其中一个迁移的 dependencies 加入另一分支迁移,形成线性链。
  3. 大段历史迁移用 squashmigrations 压缩,评审压缩文件后替换历史链。

代码或图示

python manage.py migrate --plan
python manage.py squashmigrations orders 0010

常见误区

  • 冲突后直接删除他人迁移:丢失结构变更,应合并依赖而非删文件。
  • squash 保留了不可逆的旧数据操作:压缩后回滚与历史兼容变复杂,需评审。
  • 压缩后未更新其他分支依赖:引用旧迁移名的分支需要改指压缩文件。

追问

  • 怎么看迁移计划?答:migrate --plan 列出待执行迁移顺序。
  • squash 后旧迁移还需要保留吗?答:已部署环境按历史链执行;新环境用压缩链,迁移策略需文档说明。
  • 迁移冲突能自动化解决吗?答:依赖合并可辅助,结构语义需人工评审。

04.7.16.2-049 模型变更后不生成迁移的常见原因有哪些?

一句话结论

常见原因:模型所在 app 未登记到 INSTALLED_APPS;修改的是抽象基类且子类未继承;字段改动只在运行时代码而非模型定义;makemigrations 排除了对应 app;迁移文件依赖状态与模型已被手动对齐;部分字段选项变更不触发迁移检测。排查顺序:确认 app 注册 → 检查模型继承 → 对比 makemigrations --check 输出 → 核对迁移历史状态。

概念解释

  • 抽象基类字段随子类模型生成迁移,基类本身不建表。
  • managed = False 的模型不参与迁移管理。
  • 检测基于模型状态与迁移历史快照的差异,手动改过库表会使状态与物理表脱节。

原理流程

  1. 运行 makemigrations --check --dry-run 查看是否报告未生成变更。
  2. 核对 INSTALLED_APPS、模型继承链与 managed 设置。
  3. 必要时检查迁移历史是否已记录相同变更,或生成空迁移手动补状态。

代码或图示

python manage.py makemigrations --check --dry-run
python manage.py makemigrations orders

常见误区

  • 改了模型字段默认值以为会自动迁移:部分选项变更需显式生成,历史数据不会自动回填。
  • app 名与目录名不一致导致注册指向错误模块:模型未被 registry 发现。
  • 手动在数据库改表后删除迁移:模型状态与物理表再次脱节,后续检测结果不可信。

追问

  • makemigrations --check 退出码含义?答:有未生成变更时非零,可用于 CI 校验模型与迁移同步。
  • 抽象模型改字段影响哪些表?答:所有继承它的具体子类模型对应表。
  • managed=False 能生成迁移吗?答:Django 不为其管理建表结构。

04.7.16.2-050 CONN_MAX_AGE 连接持久化与短连接模型如何取舍?

一句话结论

CONN_MAX_AGE 设置数据库连接复用时长:0 为每次请求后关闭连接(短连接),正数为连接在该秒数内复用(持久连接),None 为进程生命周期常驻。持久连接省去握手认证开销,但占用数据库连接;短连接释放快但每次重建有成本。高并发低延迟场景按 DB 连接上限与 worker 数量权衡,长连接需配合空闲回收与 ping 校验。

概念解释

  • 连接按线程/协程隔离,复用期内同一执行上下文复用同一连接。
  • 常驻连接在 worker 进程存活期间持有,数据库侧连接数需按 worker × 复用模型估算。
  • 持久连接可能持有未提交事务或陈旧快照,长空闲后需校验可用性。

原理流程

  1. 首次查询建立数据库连接,记录时间戳。
  2. 复用期内后续查询复用连接;超时或连接失效则重建。
  3. 请求结束不立即关闭(持久模式),连接留待下次复用。

代码或图示

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "CONN_MAX_AGE": 60,   # 60 秒内复用
        "CONN_HEALTH_CHECKS": True,
    }
}

常见误区

  • worker 数 × 持久连接超过数据库 max_connections:连接被拒绝,需下调复用或扩容 DB。
  • 长事务悬挂在持久连接上:连接不释放,占用累积,应缩短事务边界。
  • 数据库侧重启后应用持有死连接:开启健康检查或缩短最大复用期。

追问

  • CONN_MAX_AGE=0 行为?答:请求结束关闭连接,纯短连接模型。
  • 连接复用对事务有影响吗?答:事务在 atomic 边界提交/回滚,连接复用不跨事务保留未提交状态。
  • 怎么估算连接数?答:worker 进程数 × 每进程并发执行单元数 × 复用系数,不超过 DB 上限预留余量。

04.7.16.2-051 多数据库配置与 Router(db_for_read/db_for_write/db_for_relation)怎么实现?

一句话结论

DATABASES 配置多个连接别名;通过数据库路由器类决定模型读写走向哪个库:db_for_read(model, **hints) 返回读库别名,db_for_write(model, **hints) 返回写库别名,db_for_relation(model, **hints) 决定关联对象所在库;路由器列表按顺序询问,首个返回非 None 的生效。路由器在 settings 的 DATABASE_ROUTERS 注册。

概念解释

  • 路由器按模型、 hints(如实例、对象名)做路由判断,可按 app 或表分组。
  • 未被路由器覆盖的模型走 default 库。
  • 跨库关联不被 ORM 自动 join,路由器需保证相关对象落在同一库或应用层拼装。

原理流程

  1. DATABASES 声明各连接别名与参数。
  2. 实现路由器类的三个方法,返回库别名或 None。
  3. ORM 查询时按路由器链确定读写库,连接从对应别名获取。

代码或图示

class AppRouter:
    def db_for_read(self, model, **hints):
        if model._meta.app_label == "reports":
            return "replica"
        return None
    def db_for_write(self, model, **hints):
        if model._meta.app_label == "reports":
            return "replica"
        return None
    def allow_relation(self, obj1, obj2, **hints):
        return True

DATABASE_ROUTERS = ["myproject.routers.AppRouter"]

常见误区

  • 跨库对象直接关联查询:ORM 不做跨库 JOIN,需拆查询后应用层拼接。
  • 路由器只配读不配写:写入落到默认库,与预期库不一致。
  • 路由器返回空字符串而非 None:空别名被当作库名解析,报错。

追问

  • allow_migrate 方法做什么?答:控制某模型迁移是否在指定库执行,多库迁移隔离用。
  • 路由器能按请求路由吗?答:路由器不直接持有请求,可结合线程局部/hints 传递上下文,常规按 app/模型静态路由。
  • 手动指定库优先级?答:using(alias) 显式指定覆盖路由器判断。

04.7.16.2-052 读写分离在 ORM 层如何落地?复制延迟带来什么一致性问题?

一句话结论

写请求走主库(db_for_write),读请求走从库(db_for_read),路由器按模型或请求特征分流;主从复制存在延迟,刚写入后立即读从库可能读到旧数据(读己之写不一致)。一致性策略:关键读后写场景强制走主库、按会话粘性路由、延迟窗口期内读主,或接受最终一致并在业务上规避。

概念解释

  • 复制延迟受网络、主库压力、从库回放能力影响,毫秒到秒级不等。
  • 读己之写、外部系统状态依赖、强一致统计不能依赖从库。
  • 从库故障或复制中断需要监控与降级回主。

原理流程

  1. 写入经路由器落主库,主库同步复制到从库。
  2. 普通读请求路由到从库分担主库压力。
  3. 一致性敏感操作(创建后详情、余额查询)显式读主或等待复制追平。

代码或图示

# 一致性敏感:显式走主库
Order.objects.using("default").get(pk=order_id)
# 普通列表读从库
Order.objects.all()

常见误区

  • 所有读都走从库:写入后立刻详情页读到旧数据,用户感知“丢数据”。
  • 忽略复制延迟监控:从库落后增大时无告警,读到陈旧数据。
  • 从库承担写后读校验:校验结果不可靠,对账应基于主库。

追问

  • 怎么判断延迟大小?答:监控主从回放位置差、时间差,业务层可写标记表比对。
  • 会话粘性怎么实现?答:登录后一段时间内读请求路由主库,或按会话哈希固定路由。
  • 读写分离能提升写入能力吗?答:不能,写入仍在主库;只分担读压力。

04.7.16.2-053 using() 显式指定数据库与路由覆盖是什么关系?

一句话结论

QuerySet.using(alias) 在单次查询上显式指定连接别名,覆盖路由器默认判断;Model.objects.using("replica").all() 读从库,写入用 Model.objects.using("default").create(...)。批量操作、原始 SQL 也可通过 using/connection 指定库。显式指定优先级高于路由器,便于在路由规则之外做定向读写。

概念解释

  • using 只影响当前 QuerySet 实例,不改变全局路由器。
  • 事务跨库需分别管理连接,atomic 默认作用于当前连接。
  • 迁移命令可用 --database 指定库执行。

原理流程

  1. 构造查询集时调用 using(别名) 记录目标库。
  2. 编译执行时从该别名取连接,绕过路由器选择。
  3. 结果按目标库数据返回。

代码或图示

reports = Report.objects.using("replica").filter(...)
Report.objects.using("default").create(name="x")

常见误区

  • 混用路由器与 using 后预期不一致:显式指定总是覆盖路由规则,排查时先看查询是否带 using。
  • 跨库事务里只开一个 atomic:另一库连接未纳入事务,回滚不覆盖。
  • 原始 SQL 忘记取对应库连接:默认走 default,读写到错误库。

追问

  • using 能用于 bulk_create 吗?答:能,查询集上先 using 再批量写入。
  • 路由器与 using 谁优先?答:using 显式指定优先。
  • 怎么在多库间复制数据?答:分别取连接查询与写入,应用层搬运,ORM 不自动跨库迁移。

04.7.16.2-054 bulk_create 的 batch_size、ignore_conflicts 与自增 ID 限制是什么?

一句话结论

bulk_create(objects, batch_size=None, ignore_conflicts=False) 批量插入,按 batch_size 分批执行 INSERT;ignore_conflicts 冲突时跳过(依赖后端唯一约束)。限制:多数后端批量插入后不回填自增主键到对象(PostgreSQL 部分支持返回 ID,行为以后端为准);不能调用 save() 信号;字段必须已在对象上赋值;批量大小需平衡 SQL 长度与锁持有。

概念解释

  • 批量插入一条 SQL 多行,比逐条 create 往返少、速度快。
  • ignore_conflicts 对应数据库冲突忽略(ON CONFLICT/IGNORE),重复键不报错。
  • 信号(post_save 等)在批量路径不触发,需自行处理副作用。

原理流程

  1. 准备模型实例列表,赋好字段值。
  2. 按 batch_size 分批构造多行 INSERT 执行。
  3. 返回插入后的实例列表;自增 ID 回填能力受后端限制。

代码或图示

items = [OrderItem(order=o, sku=s, qty=1) for s in skus]
OrderItem.objects.bulk_create(items, batch_size=500, ignore_conflicts=True)

常见误区

  • 批量后依赖对象 id 做后续关联:ID 可能未回填,需先查回或用可填充业务键。
  • 期望 save 信号在批量时触发:不会触发,审计/消息逻辑需单独补齐。
  • 单批过大:SQL 长度超限、锁持有时间长,按数据量分批。

追问

  • bulk_create 能更新冲突行吗?答:ignore_conflicts 只跳过;需要 upsert 用 update_conflict 或数据库原生 upsert(后端支持时)。
  • 批量插入能预取关联吗?答:对象上关联字段需先赋值,批量路径不解析未加载关联。
  • 信号缺失怎么补?答:批量后按业务键查询记录,统一触发通知或审计逻辑。

04.7.16.2-055 bulk_update 的字段限制与性能边界是什么?

一句话结论

bulk_update(objects, fields, batch_size=None) 批量更新指定字段,按对象主键定位、逐行 SET 表达式分批执行;只能更新已列出的 fields,未列字段不参与 UPDATE。性能优于逐条 save(),但每条仍是独立 UPDATE 语句(非单条多行更新),超大数据量需分批并评估锁与日志;对象必须有主键,且不能触发保存信号。

概念解释

  • 更新字段名列表显式传入,避免整行覆盖。
  • 不同对象更新值不同,SQL 按行构造 CASE/赋值,批量减少 Python 往返。
  • 无法在批量路径调用模型 save() 覆盖逻辑,业务校验需前置。

原理流程

  1. 准备带主键与待更新字段值的实例列表。
  2. 按 batch_size 分批,生成 UPDATE 语句定位主键。
  3. 提交后刷新必要字段;信号与模型保存钩子不触发。

代码或图示

for item in items:
    item.qty += 1
OrderItem.objects.bulk_update(items, ["qty"], batch_size=500)

常见误区

  • 把未修改字段也列入 fields:不必要写入放大,只列实际变更字段。
  • 依赖模型 save() 内的校验/转换:批量路径不执行,需在准备实例时完成。
  • 超大批量一次性更新:锁与 undo 日志膨胀,分批并按主键区间推进。

追问

  • bulk_update 支持条件更新吗?答:按主键定位;带条件的批量更新用 filter().update(F(...)) 单条 SQL。
  • 更新后对象字段会刷新吗?答:内存对象保持设置值,数据库默认值/表达式结果需重新查询确认。
  • 与 filter().update() 怎么选?答:同条件同值用 update();逐对象不同值用 bulk_update。

04.7.16.2-056 update_or_create/get_or_create 的竞态与事务要求是什么?

一句话结论

get_or_create(**filters, defaults=None) 先查不存在则创建;update_or_create 查到更新、查不到创建。两者存在“查-建”竞态:并发下两个请求都未查到,可能重复插入或唯一约束冲突。稳妥做法:关键字段加唯一约束,在事务内调用并捕获 IntegrityError 重试;高并发 upsert 优先用数据库原生 upsert(update_conflict 等后端能力)。

概念解释

  • defaults 为新建时使用的字段值,filters 同时用于查询与唯一性判断。
  • 方法内部先 get,失败后 create;非原子步骤在并发下有窗口。
  • 唯一约束是兜底,防止并发插入重复行。

原理流程

  1. 按 filters 查询现有对象。
  2. 命中则按 defaults 更新(update_or_create);未命中则新建。
  3. 并发冲突时唯一约束抛 IntegrityError,事务内重试或走 upsert。

代码或图示

with transaction.atomic():
    obj, created = Order.objects.update_or_create(
        no=order_no,
        defaults={"status": "paid", "amount": total},
    )

常见误区

  • 不加唯一约束依赖“先查后建”:并发重复写入脏数据。
  • 捕获 IntegrityError 后不重试:冲突请求直接失败,需在事务内重新查询更新。
  • 把大对象字典塞进 defaults 且字段可变:新建与更新语义混淆,更新值应显式管理。

追问

  • get_or_create 返回什么?答:(实例, 是否创建) 元组。
  • 唯一冲突后怎么处理?答:回滚当前事务段,重新查询命中记录后更新。
  • 数据库原生 upsert 怎么用?答:Django 按后端提供 update_conflict/on_conflict 能力(待确认:具体 API 以 5.x 文档与后端支持为准)。

04.7.16.2-057 defer/only 减少字段读取的适用场景与代价是什么?

一句话结论

only 白名单加载指定字段,defer 黑名单延迟其余字段;适合宽表大字段(长文本、Blob、JSON)的列表场景,减少单次查询传输与内存。代价是访问延迟字段时再发一次查询,循环中触碰延迟字段会形成 N+1;详情页需要完整对象时直接取整行,不要过度裁剪。

概念解释

  • 延迟字段在实例首次访问时按需查询,缓存到实例上。
  • only 与 defer 可链式叠加,最终加载集合取交集/差集规则以 ORM 实现为准。
  • 模型方法依赖被延迟字段时,方法调用可能触发额外查询,需在查询层预判。

原理流程

  1. 视图/序列化确定列表展示所需字段集合。
  2. 查询集用 only 限定加载字段,大字段 defer。
  3. 遍历只访问已加载字段;若需延迟字段,提前在查询集补齐或改取整行。

代码或图示

# 列表只取概要字段
Article.objects.only("id", "title", "summary", "created_at")
# 大正文延迟到详情页加载
Article.objects.defer("body")

常见误区

  • 序列化器嵌套访问被延迟的关联/字段:每个对象补一次查询,N+1 重现。
  • 对小表宽字段反复裁剪:收益微小,增加延迟加载复杂度。
  • only 后又在同一请求多处取不同字段:多次补查,不如一次取齐。

追问

  • defer 字段会在何时加载?答:实例属性首次访问时发查询取回。
  • 与 values 怎么选?答:不需要模型方法/行为用 values 裸字典;需要实例方法用 only/defer。
  • 延迟字段能预取吗?答:关联关系用预取;单字段延迟访问按需补查。

04.7.16.2-058 慢查询如何定位:connection.queries、SQL 日志与 debug toolbar?

一句话结论

三层定位手段:开发期用 django-debug-toolbar SQL 面板看每条 SQL、耗时与重复语句;代码内读取 connection.queries(含 sql、time)统计查询数与慢语句;生产靠数据库慢查询日志与性能分析工具定位长耗时 SQL。定位后按“查询数 → 关联预取 → 索引/执行计划 → 批量改写”顺序优化,并回归查询数与耗时。

概念解释

  • connection.queries 在开启数据库查询记录后可用,测试中配合 assertNumQueries 回归。
  • 慢查询日志按执行时长阈值记录 SQL 与执行计划,是生产主要入口。
  • 重复 SQL 多为 N+1;单条大 SQL 慢多为缺索引、回表、排序或大结果集。

原理流程

  1. 复现接口/页面,采集 SQL 列表与耗时。
  2. 区分重复小 SQL(N+1)与单条重 SQL(执行计划问题)。
  3. 优化后用同一工具复核查询数、扫描行数与耗时,纳入测试断言。

代码或图示

from django.db import connection

connection.queries_log.clear()
# 执行业务
slow = [q for q in connection.queries if float(q["time"]) > 0.05]
for q in slow:
    print(q["time"], q["sql"])

常见误区

  • 只看总耗时不看查询条数:N+1 总耗时分散在大量小 SQL,单条不显眼。
  • 生产开 ORM 查询记录:connection.queries 记录有内存开销,生产依赖 DB 日志与监控。
  • 优化后不复测:索引变更、数据增长后计划可能回退,需持续监控慢查询。

追问

  • assertNumQueries 适合什么场景?答:测试中锁定列表接口查询数,防止后续改动引入 N+1。
  • 慢 SQL 从哪里取执行计划?答:数据库 EXPLAIN/EXPLAIN ANALYZE,结合慢日志定位。
  • 怎么统计重复 SQL?答:按 SQL 模板(去掉字面量参数)分组计数,识别循环生成的语句。

04.7.16.2-059 深分页 OFFSET 问题是什么?键集分页如何替代?

一句话结论

LIMIT/OFFSET 深分页时,数据库要扫描并跳过前 N 行,OFFSET 越大扫描成本越高,且新增/删除数据会导致翻页重复或遗漏。键集分页(seek pagination)用上一页最后一条的排序键作为过滤条件,配合稳定唯一排序键,直接定位下一页起点,避免扫描跳过行;适合无限滚动、大数据列表。

概念解释

  • 稳定排序必须含唯一键(如 created_at, id),否则同值行顺序不确定。
  • 键集条件:(created_at, id) < (上页末值) 形式的复合比较,配合索引定位起点。
  • OFFSET 分页适合浅页码与跳页需求;键集分页不支持跳转到指定页。

原理流程

  1. 第一页按稳定排序取 N 条,记录末行排序键。
  2. 下一页用末行键构造小于/大于条件,索引定位后取 N 条。
  3. 重复推进,每页扫描行数与页码无关。

代码或图示

# 上一页末行
last_created, last_id = last_row.created_at, last_row.id
qs = Order.objects.filter(
    Q(created_at__lt=last_created) |
    Q(created_at=last_created, id__lt=last_id)
).order_by("-created_at", "-id")[:20]

常见误区

  • 只用时间排序做键集:同秒/同毫秒多行顺序不稳,必须补唯一键。
  • 键集条件写错方向:跨页重复或遗漏数据,需按排序方向核对比较符。
  • 深分页仍用 Paginator 大 OFFSET:大数据量下接口随页码变慢,改键集或限制最大页码。

追问

  • 键集分页能跳页吗?答:不能直接跳指定页码,需游标/上一页末键推进。
  • 索引怎么配合键集?答:排序键复合索引 (created_at, id) 支撑范围定位。
  • 数据实时变化怎么避免重复?答:稳定唯一键 + 键集条件,新增行落在当前边界外不影响已翻页。

04.7.16.2-060 ORM 性能优化的完整排查顺序是什么?

一句话结论

按从低到高成本顺序排查:先统计查询条数与慢语句(定位 N+1 与重复 SQL)→ 补齐关联预取/批量注解消除逐行查询 → 检查索引与执行计划(命中索引、覆盖索引、回表、排序)→ 批量改写(bulk_create/bulk_update/条件 update)→ 优化分页与结果集大小(键集分页、only/values、流式迭代)→ 最后评估连接池、读写分离与缓存。先解决查询数量与索引,再谈架构层扩容。

概念解释

  • 大部分 ORM 问题来自多余查询与缺索引,而非框架本身慢。
  • 每一步优化都应量化前后对比:查询数、扫描行数、耗时、内存。
  • 缓存是最后一层:先把数据库查询模式理顺,再挡重复读请求。

原理流程

  1. 采集请求 SQL 清单与耗时,归类重复小 SQL 与单条重 SQL。
  2. 读关联问题用预取/注解解决;写操作用批量方法。
  3. 核对执行计划补索引、裁剪字段;分页与大数据集改键集/流式。
  4. 复核指标,必要时引入读写分离、缓存与异步化。

代码或图示

查询数/慢SQL → N+1 预取 → 索引/执行计划 → 批量写 → 分页/字段裁剪 → 连接/缓存/读写分离

常见误区

  • 一上来就加缓存或扩 worker:底层缺索引、N+1 未解决,扩容只是推迟问题。
  • 只优化单条 SQL:整体查询数未降,接口仍被多次往返拖慢。
  • 优化后不建监控与测试断言:后续迭代回归旧问题,需把查询数与慢查询纳入持续监控。

追问

  • 先优化索引还是先预取?答:先看查询数量与重复 SQL,预取消除 N+1;单条重 SQL 再看索引计划。
  • 什么情况引入读写分离?答:读压力主库承载不下,且能接受复制延迟或关键读走主库。
  • 缓存放在哪一层?答:数据库查询理顺后,在 Service/视图层挡重复读,缓存失效策略单独设计。

本节高频题

  • QuerySet 惰性求值与缓存(001、002、003)
  • 求值时机、exists 与 iterator(005、006)
  • values/values_list 投影(007)
  • select_related 与 prefetch_related 选择(008、011)
  • Prefetch 自定义子查询集与 to_attr(010)
  • N+1 定位手段(013)
  • F() 并发更新与 Q() 条件组合(015、016)
  • Case/When 条件聚合与窗口函数(018、024)
  • annotate/aggregate 与分组规则(021、022)
  • Manager 与 get_queryset/as_manager(027、028、029)
  • 嵌套事务保存点与 on_commit(031、032)
  • select_for_update 与隔离级别(033、034)
  • ATOMIC_REQUESTS 与长事务排查(036、037)
  • 索引设计、最左前缀与覆盖索引(038、039、040)
  • 执行计划与索引失效(041、042)
  • 迁移 RunPython 与零停机模式(045、046)
  • 多库路由与读写分离一致性(051、052)
  • 批量操作与 upsert 竞态(054、055、056)
  • 慢查询定位与深分页优化(058、059)