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_querysetatomic/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 实例重复使用命中缓存,不再查库。 - 理解求值时机是排查“多查了一次”和“缓存未命中”的基础。
原理流程
- 调用
filter/exclude/order_by等只修改内部查询对象,不触碰数据库。 - 到达求值点时,ORM 把查询结构编译成 SQL 并执行。
- 结果转换为模型实例(或字典/元组)并写入缓存。
代码或图示
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 时,不同视图叠加各自条件,互不污染。
原理流程
- 调用过滤方法时,内部
Query增加条件节点。 _chain()基于当前结构生成新 QuerySet 返回。- 原实例缓存与条件不变,新实例携带累积条件等待求值。
代码或图示
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()等聚合求值不一定填充完整结果缓存。 - 理解缓存边界能解释“为什么第二次遍历没查库”与“为什么改条件后又查了一次”。
原理流程
- 求值点触发 SQL 执行,结果转换为 Python 对象列表。
- 列表挂到实例
_result_cache。 - 后续访问命中缓存;新链式实例、
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 随页码增大而变慢,切片语法本身不解决性能问题。
原理流程
- 解析切片上下界,转换为 SQL
LIMIT/OFFSET。 - 带范围切片返回惰性 QuerySet;单元素切片触发求值。
- 已缓存实例从内存列表切片,未缓存走数据库。
代码或图示
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 开销最小。- 两者都不适合在循环里逐条判断关联是否存在,应通过预取或注解聚合批量完成。
原理流程
- 代码写
if qs:触发布尔求值,框架判断是否至少一行。 exists()生成限量查询,只取 1 行标记。- 存在性结论返回,不构造完整模型实例列表。
代码或图示
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()走游标分批拉取。 - 批大小影响内存峰值与往返次数:过大内存高,过小往返多。
- 数据库游标与连接生命周期绑定,迭代期间连接保持占用。
原理流程
- 编译查询并打开数据库游标。
- 按
chunk_size一批批取回行,转换为实例依次产出。 - 消费完一批释放引用,下一批覆盖内存;不保留全量缓存。
代码或图示
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()也能减少字段读取,但返回的仍是模型实例。
原理流程
- ORM 在 SELECT 列表只取指定字段。
- 行直接组装为字典或元组,不构造模型实例。
- 结果按 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返回模型实例但延迟未取字段。
04.7.16.2-008 select_related 的 JOIN 深度与字段选择怎么控制?
一句话结论
select_related 用于外键、一对一这类单值关联:在主查询 SQL 中 JOIN 关联表并一次性取回关联对象;可传嵌套字符串 author__profile 控制 JOIN 深度,也可指定具体关联避免全量 JOIN。它不能用于多对多与反向一对多,那类关联由 prefetch_related 处理。
概念解释
- JOIN 表越多,单次查询字段与行数膨胀越明显,应只预取实际用到的关联。
select_related(None)清除父查询集继承来的预取。- 反向外键(外键在对方表)不是单值关联,
select_related不覆盖。
原理流程
- 查询编译时,
select_related关联加入 JOIN 与 SELECT 列。 - 主行取回后,ORM 按 JOIN 列填充关联实例。
- 遍历时访问已预取关联不再发额外 SQL。
代码或图示
Post.objects.select_related("author", "author__profile").filter(...)
# 只取需要的关联,避免 select_related 全深度 JOIN
常见误区
- 对多对多字段调用
select_related:不支持,应使用prefetch_related。 - 无条件预取深层链:未使用的关联也参与 JOIN,放大单次查询成本。
- 以为预取关联后反向集合也被取回:反向一对多是多值集合,需
prefetch_related。
追问
select_related支持反向一对一吗?答:一对一反向是单值,可按关系名预取(具体方向以模型关系定义为准)。- JOIN 膨胀怎么判断?答:看执行计划 JOIN 表数、返回行数与重复字段,必要时拆成预取。
- 嵌套预取字符串用什么分隔?答:双下划线
__,与字段查找语法一致。
04.7.16.2-009 prefetch_related 的两次查询与 Python 侧拼接原理是什么?
一句话结论
prefetch_related 用于多对多、反向一对多等多值关联:先查主对象集合,再按关联外键批量查出全部关联对象,最后在 Python 侧按外键值分组拼回各主对象,避免逐行查询。它产生的是“主表一次 + 关联表一次(或每类关联一次)”的固定查询数,而不是 N+1;嵌套预取会按层级增加查询次数。
概念解释
- 与
select_related的 JOIN 不同,预取是独立查询后内存拼接,关联表不参与主 SQL 笛卡尔膨胀。 - 关联对象按主对象 ID 集合
IN查询,结果在 Python 端映射回主对象。 - 预取查询集可以附加过滤、排序与字段裁剪,比默认全量关联更省。
原理流程
- 执行主查询取回主对象列表,收集其主键集合。
- 对每个预取关联执行一次批量查询,条件为主键
IN集合。 - 按关联外键分组,挂到各主对象的关联缓存上。
代码或图示
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 层就限制了关联行。
原理流程
- 构造
Prefetch,传入关系路径与定制查询集。 - 主查询后按子查询集条件批量取关联行。
- 结果按
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。
04.7.16.2-011 什么时候选 select_related,什么时候选 prefetch_related?
一句话结论
单值关联(外键、一对一)优先 select_related,一次 JOIN 取回;多值关联(多对多、反向一对多)只能 prefetch_related。判断依据是关系基数:JOIN 不会把主行翻倍的单值走 JOIN,一对多/JOIN 会产生笛卡尔膨胀的多值走独立预取。实际选择还要看关联过滤条件:需要在 SQL 层过滤关联行时,用 Prefetch 定制子查询集。
概念解释
- 选错方向会直接报错或退化为 N+1:M2M 不能
select_related,反向集合不能select_related。 - 一次查询可同时混用两者:单值关联 JOIN,多值关联批量预取。
- 关联很大且主对象少时,JOIN 成本可控;关联过滤复杂时预取更灵活。
原理流程
- 梳理视图/序列化遍历用到的每条关系及其基数。
- 单值关系加入
select_related,多值关系加入prefetch_related。 - 对需要条件过滤的多值关系,用
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下一层。 - 序列化器嵌套字段最容易漏掉跨层预取,要按输出结构逐层补齐。
原理流程
- 主对象查询取回,收集主键。
- 第一层预取按
IN批量取关联对象。 - 第二层在第一层对象集合上再批量取下一层,逐层拼接。
代码或图示
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 反复出现,条件主键逐条变化,查询数随列表长度增长。
- 序列化器、模板循环、列表接口是高发位置;批量导出尤其敏感。
- 先固定基线查询数,再优化到与列表长度无关的固定条数。
原理流程
- 打开 SQL 统计面板或在测试中断言查询数。
- 复现页面/接口,按调用栈定位触发查询的关联访问。
- 在 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()默认走数据库新查询。 - 模型方法内部访问关联:方法被循环调用时,外部预取不会自动覆盖方法内关系。
- 继承/组合导致查询集构造遗漏:基础查询集预取了,派生实例又被重新过滤。
原理流程
- 对比遍历路径与已预取关系清单,找出未覆盖的访问点。
- 检查关联集合是否被二次数据库查询过滤/排序。
- 补齐预取或改为批量注解,回归 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()可用于过滤条件、注解、更新与排序表达式。
原理流程
- 代码用
F("字段")引用列,ORM 编译为 SQL 表达式。 - 数据库执行行内运算与更新,基于提交时的当前值。
- 结果不再先经过 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组合。
原理流程
- 为每个查询条件构造
Q对象。 - 按业务逻辑用
&/|/~组合出条件树。 - 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配合使用。
原理流程
- 构造基础表达式(字段引用、算术或子查询)。
- 用
ExpressionWrapper包裹并声明output_field。 - 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,一次查询完成分组统计。
原理流程
- 为每个分支写
When(条件, then=表达式)。 - 组合进
Case,声明默认值与输出类型。 - 外层可再套
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只返回布尔,数据库优化器常能高效处理半连接。
原理流程
- 内层 QuerySet 用
OuterRef关联外层字段。 - 包成
Subquery/Exists注解到外层查询。 - 数据库执行相关子查询,结果作为外层列或条件。
代码或图示
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 过滤/聚合出结果集,应用层做规则组装与序列化。
原理流程
- 梳理用例需要的过滤、统计、排序与关联判断。
- 可声明式表达的部分编译为 SQL 表达式下推。
- 剩余业务规则在 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二次汇总。
原理流程
annotate:外层行与子查询/聚合关联,每行附加注解值。aggregate:对查询集整体计算聚合函数,返回字典。- 分组场景:
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实现(数据库侧下推)。
原理流程
values()声明分组键。annotate()把聚合函数挂到分组结果上。- 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对应 SQLCOUNT(DISTINCT ...)/SUM(DISTINCT ...)。- 空值在
Sum/Avg中按数据库规则忽略,结果可能为None。
原理流程
- 选择聚合函数与字段/表达式。
- 指定是否去重、输出类型。
- 挂到
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 之后计算,不减少输出行数。
- 数据库支持窗口函数的版本要求较高,老旧数据库需评估兼容性。
原理流程
- 选择排名或累计表达式(如
RowNumber())。 - 用
Window指定分区与排序,注解到 QuerySet。 - 数据库按分区计算窗口值,每行附加结果列。
代码或图示
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 非聚合列必须分组;排序列同理受约束。
- 聚合函数结果排序不改变分组,只影响结果行顺序。
- 多字段排序与索引顺序一致时可避免额外排序步骤。
原理流程
values()确定分组键,annotate()计算聚合。order_by列纳入 GROUP BY 或作为聚合表达式。- 数据库分组后按指定列排序输出。
代码或图示
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 条件只能引用分组列与聚合表达式,不能引用未分组普通列。
- 复杂条件可先注解中间表达式,再按别名过滤。
原理流程
values()分组,annotate()计算聚合别名。- 对别名
filter()生成 HAVING。 - 数据库先过滤行、分组聚合,再按 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 内部(如关联反向访问)使用它。
- 自定义管理器不影响数据库表结构,只改变查询入口行为。
原理流程
- 模型类属性挂载 Manager 子类实例。
- 模型类元数据记录默认管理器。
- 业务代码经
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,需在查询层显式传条件。
原理流程
- 管理器方法调用
get_queryset()取基础查询集。 - 覆写实现叠加默认过滤(如
deleted=False)。 - 上层链式方法在过滤后的查询集上继续条件与排序。
代码或图示
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 方法。
原理流程
- 定义继承
QuerySet的自定义查询集并添加方法。 - 模型属性用
MyQuerySet.as_manager()挂载管理器。 - 经管理器调用方法,内部委托给 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。
原理流程
- 查询条件与投影方法落在 QuerySet,返回新 QuerySet。
as_manager把方法提升为管理器入口。- 调用方链式叠加条件,直到终止方法求值。
代码或图示
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 文档为准)。
原理流程
- 外层进入
atomic,开启事务。 - 内层进入,创建保存点;内层操作记录在保存点之后。
- 内层正常退出释放保存点;异常回滚保存点,外层按自身结果提交或回滚。
代码或图示
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捕获断言。 - 回调内不要再开长事务或阻塞主流程,耗时任务应投递异步队列。
原理流程
- 业务代码在事务内注册回调函数。
- 事务正常提交,框架按注册顺序调用回调。
- 回调执行外部副作用;提交失败则回调不执行。
代码或图示
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 主流支持,旧版本需核对。
原理流程
- 在
atomic事务内执行带select_for_update的查询。 - 数据库对命中行加排他锁,其他事务冲突时按参数等待/报错/跳过。
- 事务提交或回滚后释放锁。
代码或图示
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 可重复读);可在数据库配置或连接层调整。隔离级别影响幻读、不可重复读与并发一致性,业务一致性要求高时需对照级别设计事务边界与重试。
概念解释
- 读已提交:只能读到其他事务已提交数据,避免脏读。
- 可重复读:同一事务内多次读同一行结果一致,靠快照或行锁保证。
- 串行化:最高隔离,并发事务串行执行,冲突重试概率上升。
原理流程
- 连接建立时按数据库默认或配置确定隔离级别。
- 事务内查询按级别读取快照/已提交数据。
- 并发写冲突由数据库锁与隔离机制处理,应用层按失败重试。
代码或图示
# 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 上下文管理器,可读性更好。
概念解释
- 保存点编号由框架维护,手动提交/回滚按编号操作。
- 保存点只能在事务内创建,无事务时调用行为按框架规则处理。
- 部分回滚后外层事务继续,已回滚部分的副作用需人工补偿。
原理流程
- 事务内调用
savepoint()获得保存点 ID。 - 子步骤失败则
savepoint_rollback撤销到该点;成功则savepoint_commit释放。 - 外层事务按整体结果提交或回滚。
代码或图示
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嵌套在请求事务内,形成保存点层级。 - 后台任务、命令、队列消费者不受请求事务包裹,需自行管理事务。
原理流程
- 中间件层开启请求事务。
- 中间件、视图、模型操作在同一事务内读写数据库。
- 正常响应提交;未捕获异常回滚,事务随请求结束关闭。
代码或图示
# 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 阻塞等待;超时后报错或跳过。
- 死锁:循环等待,数据库死锁检测器中止牺牲者,应用需重试。
- 指标:活跃事务时长、锁等待数、回滚次数、连接占用时长。
原理流程
- 数据库视图查看活跃事务、持锁与等待关系。
- 关联来源连接到请求/任务日志,定位长事务代码段。
- 检查事务内是否含外部 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取代,新模型使用约束写法。 - 索引随迁移创建/删除,大表建索引需评估锁与耗时。
原理流程
- 字段级
db_index生成单列索引声明。 - 模型
Meta.indexes定义复合/定制索引。 - 约束声明唯一规则,迁移时数据库创建对应索引与约束。
代码或图示
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)右侧列在索引中无法继续用于过滤。 - 索引顺序与查询排序方向相关,双向排序需额外索引或数据库反向扫描支持。
原理流程
- 统计高频查询的等值过滤列、范围列与排序列。
- 等值列前置,范围/排序列后置,组成复合索引。
- 执行计划核对索引命中与扫描范围,调整列顺序。
代码或图示
# 高频查询: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。
原理流程
- 列表接口确定所需展示字段。
- 查询集用
only裁剪列,索引设计覆盖这些列。 - 遍历只访问已加载字段;避免循环中触碰延迟字段。
代码或图示
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会真实执行语句(含写操作需谨慎),用于核对实际耗时与行数。
原理流程
- 构造待分析查询集,调用
explain()或explain(analyze=True)。 - 读取计划中的访问类型、索引键、扫描行数与额外步骤。
- 对照预期定位全表扫描/回表/排序瓶颈,优化后复查计划。
代码或图示
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 前缀;全文/三元索引另作方案。
原理流程
- 检查 WHERE/ORDER BY 中索引列是否被函数、运算或转换处理。
- 把表达式改写为列与常量比较(如范围区间替代函数提取)。
- 复核执行计划确认索引命中。
代码或图示
# 失效:函数包裹列
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,占用磁盘与写放大;索引过多拖慢写入、增加备份与维护成本,优化器选择计划时也可能误选。索引应按查询模式增量建立,定期清理长期未使用的索引,而非“先加上保险”。
概念解释
- 写入放大:一行变更涉及多个索引,每个索引都要更新结构。
- 磁盘与内存:索引占用存储与缓冲池空间,挤占有效数据缓存。
- 统计与计划:索引候选过多,优化器评估成本上升,偶发选错路径。
原理流程
- 梳理现有索引与实际查询匹配度。
- 识别重复前缀、长期未命中索引与冗余复合索引。
- 评估写入量与查询收益后删除冗余索引,监控写入与查询指标。
代码或图示
-- 示例:查询索引使用情况(具体视图以后端为准)
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 与迁移文件名编号维护。
原理流程
- 模型变更后运行
makemigrations,生成迁移文件与依赖声明。 - 评审迁移内容(字段默认值、可逆性、数据迁移)。
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在回滚迁移时执行;不可逆操作应明确标注。- 大数据量回填需分批处理,避免单迁移长时间锁表。
原理流程
- 空迁移或自动迁移中加入
RunPython/RunSQL操作。 - 正向函数读取历史模型快照,批量转换/回填数据。
- 回滚时执行反向函数撤销变更;不可逆操作留空并说明。
代码或图示
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(收缩)确认读取切到新结构后删除旧列/旧表。每个阶段都保持旧代码与新代码可共存部署,避免一次性删列/改列导致新旧版本不兼容。
概念解释
- 双写期同时维护新旧字段,保证回滚与灰度期间数据一致。
- 回填分批进行,控制单次事务规模与锁持有。
- 收缩阶段确认无旧代码读取旧结构后再删除,迁移顺序与部署顺序配合。
原理流程
- 扩展:新增列/表,应用写入同时维护新旧结构。
- 迁移:后台任务分批回填历史数据,对账校验一致性。
- 收缩:读取切换到新结构,观察稳定后移除旧列与旧代码路径。
代码或图示
旧结构 ── 加新列/双写 ── 回填历史 ── 读新结构 ── 删旧列
expand migrate contract
常见误区
- 直接重命名/删除列后滚动部署:旧版本实例读不到列,启动或请求报错。
- 回填未分批:大表单事务锁表,阻塞线上写入。
- 双写期只写新不写旧:回滚到旧版本时数据缺失。
追问
- 字段改名怎么零停机?答:加新列 → 双写回填 → 读切新列 → 删旧列,不直接 RenameField 上线。
- 回填期间新数据怎么保证一致?答:写入路径双写,回填只补历史行。
- 怎么校验回填完整?答:按主键区间对账、计数抽样与新旧值比对。
04.7.16.2-047 SeparateDatabaseAndState 什么时候使用?
一句话结论
SeparateDatabaseAndState(database_operations=..., state_operations=...) 把“数据库实际操作”与“模型状态记录”分离:当表由外部系统管理、使用原生 SQL 建表、或 ORM 状态与数据库结构需要不一致时使用。典型场景:对接既有外部表、手动管理的数据库对象、状态迁移只记录模型元数据而不改物理表。
概念解释
state_operations影响迁移历史中的模型状态(供后续迁移与模型一致性检查)。database_operations直接作用于物理数据库;两者可独立配置。- 普通模型变更不需要它,误用会导致状态与表结构脱节。
原理流程
- 识别表/对象不由 Django 迁移管理物理结构。
- 拆分状态操作与数据库操作:状态记录模型定义,数据库操作走原生 SQL 或留空。
- 后续迁移基于分离后的状态继续依赖。
代码或图示
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 适合长期演进的项目;新功能迁移保持独立,避免频繁压缩。
原理流程
- 拉取最新基线,发现迁移依赖分叉。
- 在其中一个迁移的
dependencies加入另一分支迁移,形成线性链。 - 大段历史迁移用
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的模型不参与迁移管理。- 检测基于模型状态与迁移历史快照的差异,手动改过库表会使状态与物理表脱节。
原理流程
- 运行
makemigrations --check --dry-run查看是否报告未生成变更。 - 核对
INSTALLED_APPS、模型继承链与managed设置。 - 必要时检查迁移历史是否已记录相同变更,或生成空迁移手动补状态。
代码或图示
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 × 复用模型估算。
- 持久连接可能持有未提交事务或陈旧快照,长空闲后需校验可用性。
原理流程
- 首次查询建立数据库连接,记录时间戳。
- 复用期内后续查询复用连接;超时或连接失效则重建。
- 请求结束不立即关闭(持久模式),连接留待下次复用。
代码或图示
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,路由器需保证相关对象落在同一库或应用层拼装。
原理流程
DATABASES声明各连接别名与参数。- 实现路由器类的三个方法,返回库别名或
None。 - 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),路由器按模型或请求特征分流;主从复制存在延迟,刚写入后立即读从库可能读到旧数据(读己之写不一致)。一致性策略:关键读后写场景强制走主库、按会话粘性路由、延迟窗口期内读主,或接受最终一致并在业务上规避。
概念解释
- 复制延迟受网络、主库压力、从库回放能力影响,毫秒到秒级不等。
- 读己之写、外部系统状态依赖、强一致统计不能依赖从库。
- 从库故障或复制中断需要监控与降级回主。
原理流程
- 写入经路由器落主库,主库同步复制到从库。
- 普通读请求路由到从库分担主库压力。
- 一致性敏感操作(创建后详情、余额查询)显式读主或等待复制追平。
代码或图示
# 一致性敏感:显式走主库
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指定库执行。
原理流程
- 构造查询集时调用
using(别名)记录目标库。 - 编译执行时从该别名取连接,绕过路由器选择。
- 结果按目标库数据返回。
代码或图示
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等)在批量路径不触发,需自行处理副作用。
原理流程
- 准备模型实例列表,赋好字段值。
- 按
batch_size分批构造多行 INSERT 执行。 - 返回插入后的实例列表;自增 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()覆盖逻辑,业务校验需前置。
原理流程
- 准备带主键与待更新字段值的实例列表。
- 按
batch_size分批,生成 UPDATE 语句定位主键。 - 提交后刷新必要字段;信号与模型保存钩子不触发。
代码或图示
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;非原子步骤在并发下有窗口。 - 唯一约束是兜底,防止并发插入重复行。
原理流程
- 按
filters查询现有对象。 - 命中则按
defaults更新(update_or_create);未命中则新建。 - 并发冲突时唯一约束抛
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 实现为准。- 模型方法依赖被延迟字段时,方法调用可能触发额外查询,需在查询层预判。
原理流程
- 视图/序列化确定列表展示所需字段集合。
- 查询集用
only限定加载字段,大字段defer。 - 遍历只访问已加载字段;若需延迟字段,提前在查询集补齐或改取整行。
代码或图示
# 列表只取概要字段
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 慢多为缺索引、回表、排序或大结果集。
原理流程
- 复现接口/页面,采集 SQL 列表与耗时。
- 区分重复小 SQL(N+1)与单条重 SQL(执行计划问题)。
- 优化后用同一工具复核查询数、扫描行数与耗时,纳入测试断言。
代码或图示
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 分页适合浅页码与跳页需求;键集分页不支持跳转到指定页。
原理流程
- 第一页按稳定排序取 N 条,记录末行排序键。
- 下一页用末行键构造小于/大于条件,索引定位后取 N 条。
- 重复推进,每页扫描行数与页码无关。
代码或图示
# 上一页末行
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 问题来自多余查询与缺索引,而非框架本身慢。
- 每一步优化都应量化前后对比:查询数、扫描行数、耗时、内存。
- 缓存是最后一层:先把数据库查询模式理顺,再挡重复读请求。
原理流程
- 采集请求 SQL 清单与耗时,归类重复小 SQL 与单条重 SQL。
- 读关联问题用预取/注解解决;写操作用批量方法。
- 核对执行计划补索引、裁剪字段;分页与大数据集改键集/流式。
- 复核指标,必要时引入读写分离、缓存与异步化。
代码或图示
查询数/慢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)