Spark SQL 执行流程

写的先Join,为何先过滤?

章节

  • 0:00 开场
  • 0:34 一句话回答
  • 0:54 多入口 · 一条流水线
  • 1:45 五阶段全景
  • 2:15 阶段一 · 解析
  • 2:58 阶段二 · 分析
  • 3:50 阶段三 · 逻辑优化
  • 7:04 阶段四 · 物理计划
  • 8:34 阶段五 · 代码生成
  • 10:09 Tungsten 内存管理
  • 10:40 补充一 · AQE
  • 11:52 补充二 · 对比 Hive
  • 13:00 补充三 · 看执行计划
  • 13:46 全流程串讲
  • 14:22 面试回答模板
  • 15:18 高频追问
  • 17:42 回到开头

文稿

开场

你写的是先 Join 再过滤,Spark 真正执行的,却是先过滤再 Join。你写的 SQL 只是一份需求,具体怎么执行,Spark 会自己重新编排。可被问到 Spark SQL 的执行流程,大部分人只能说出「Catalyst 优化器」几个字。面试官一追问就卡住:Catalyst 具体做了哪些优化?逻辑计划和物理计划有什么区别?Tungsten 的代码生成,又是怎么回事?这期按 Spark 3.5 的源码和官方文档,把这条编译流水线从头走一遍。

一句话回答

一句话回答:Spark SQL 要经过五个阶段,才真正开始执行。解析、分析、逻辑优化、物理计划、代码生成。核心思想是:不管你用 SQL 还是 DataFrame,都走同一条优化流水线。机器帮你重排、精简、编译,往往比你手写的代码还快。

多入口 · 一条流水线

先搞清楚一个关键问题:SQL 和 DataFrame,最后其实是一样的。同一个需求,按城市汇总某天的订单数值,可以写成 SQL,也可以写成 DataFrame API。两种写法进入 Catalyst 后,变成同一棵逻辑计划树,走完全相同的优化和执行路径。就像点菜,不管用中文、英文还是指菜单,后厨收到的都是同一张标准小票。这就是 Spark SQL 最重要的设计:多入口,一条流水线。常见说法是 Dataset 也完全一样,这里要纠正:Dataset 的 lambda 写法不一样。filter 里传一个 Scala 函数,Catalyst 看不懂函数内部,只能把每行反序列化成对象,再调用它。这样条件推不到数据源,也做不了列裁剪。想吃到全部优化,就尽量用列表达式。

五阶段全景

下面用一条真实的业务 SQL 跟踪全程:订单表 Join 用户表,只要某一天、数值大于 0 的订单。再按城市汇总 GMV,倒序取前 10。它依次经过 Parser、Analyzer、Optimizer、Planner 和代码生成,最后交给 Spark Core 执行。顺便纠正一个常见误解:Catalyst 不只是第三步的优化器。它是一整套树变换框架,解析、分析、逻辑优化、物理计划,都建在它上面。

阶段一 · 解析

阶段一,解析。Spark 用 ANTLR4,把 SQL 文本解析成一棵未解析的逻辑计划。「未解析」是说:它知道你要 Join、过滤、分组,但不知道表在哪、列是什么类型。这棵树的根是 Limit 10,往下是排序、聚合、过滤、Join,最底下是两张表。orders 和 users 被标成 UnresolvedRelation:Parser 只知道你写了这个名字,还没查它存不存在。DataFrame API 不经过 SQL 解析,直接构造这棵树,从下一步开始和 SQL 汇合。就像老师把答题卡按题号整理成表格,但还没核对学号和姓名是不是真的。

阶段二 · 分析

阶段二,分析。Analyzer 拿着这棵树去查 Catalog,也就是 Spark 的元数据目录。它做五件事。第一,解析表名:确认 orders 存在,拿到列名、类型和分区信息。第二,解析列名:确认 amount 在 orders 表里。第三,解析函数:确认 SUM 是合法的聚合函数。第四,隐式类型转换:Join 两边一个 INT 一个 BIGINT,自动加 Cast。第五,星号展开:SELECT 星号展开成所有具体列名。处理完,每个节点都有了完整类型:不再是某个叫 amount 的东西,而是 orders 表里类型为 DECIMAL 的 amount 列。查一张不存在的表,报 AnalysisException,就是在这一步抛出的。Spark 3.5 里,它的错误类叫 TABLE_OR_VIEW_NOT_FOUND。

阶段三 · 逻辑优化

阶段三,逻辑优化,这是最核心的一步。Optimizer 对逻辑计划做一系列等价变换:结果不变,执行代价更低。每条优化规则就是一个函数:输入一棵树,输出一棵新树。多条规则组成一个 Batch,反复执行,直到计划不再变化,这叫不动点。Spark 3.5 默认最多迭代 100 轮,到上限也会停。绝大多数规则是基于规则的 RBO,只有 Join 重排这类依赖统计信息的,才属于基于代价的 CBO。第一条,谓词下推。你写的 SQL 里,过滤条件在 Join 后面。按字面执行:一亿行订单先和一百万用户 Join,Join 完才过滤,最后只剩 27 万行。Catalyst 把 dt 的条件推到 Join 下面:先把一亿行过滤到 27 万,再去 Join。数字是示意:订单表存了一年,一天大约 27 万行,Join 的输入少了 99% 以上。下推还不止一层:dt 如果是分区字段,物理计划会做分区裁剪,其他日期的目录根本不读。amount 大于 0 这种条件,还能作为 PushedFilters 交给 Parquet,用文件里的统计信息跳过整块数据。第二条,列裁剪。orders 表有 50 列,这条 SQL 只用到其中 3 列。列裁剪把不需要的列从计划里删掉,一直删到最底层的 Scan,只读需要的列。配合 Parquet、ORC 这种列式存储,没用到的列在磁盘上直接跳过。列式存储前面专题讲过。50 列只读 3 列,IO 大致只剩一成左右,具体还要看各列的大小。第三条,常量折叠。条件里用 concat 把几段字符串拼成一个日期。Catalyst 在编译期就把它算好,直接变成一个日期常量,运行时不再每行拼一次。第四条,布尔简化。status 等于 paid,或者 true,这个括号恒为真。恒真的条件被直接消掉,最后只剩 amount 大于 0。第五条,Join 重排,这是 CBO 的典型用法。三表 Join:订单一亿行,商品一百万行,城市一千行,只要一线城市。常见说法是小表先 Join,中间结果就小。这不准确:订单 Join 城市是外键关联,Join 完还是一亿行。真正让中间结果变小的,是带过滤的 Join:城市先过滤到一线,订单 Join 它之后只剩约两千万行。再 Join 商品表,输入就从一亿降到两千万。CBO 用行数、大小、列基数,估算每种顺序的代价,挑最低的。前提是 cbo.enabled 和 joinReorder.enabled 两个开关都打开,它们默认都是关的。而且参与 Join 的每张表,都要先收集统计信息。再补两条常用规则。子查询消除:IN 子查询改写成 Left Semi Join,避免嵌套执行。合并相邻 Filter:多个 Filter 合成一个,减少计划树的深度。七条规则汇总:Join 重排属于 CBO,其余六条都属于 RBO。Catalyst 就像审题高手:重排答题顺序、删掉废步骤、提前算好常数,答案不变,做题快得多。

阶段四 · 物理计划

阶段四,物理计划。逻辑计划说做什么,物理计划说怎么做。同一个逻辑 Join,有好几种物理实现,SparkPlanner 用一组策略,为每个逻辑算子选物理算子。最典型的就是 Join。Join 策略前面专题讲过,这里只看结论。一侧小于广播阈值,默认 10MB,选 BroadcastHashJoin:小表广播到每个 Executor,不用 Shuffle。两侧都大,选 SortMergeJoin:两边按 Join Key Shuffle、排序,再归并。ShuffledHashJoin 也要 Shuffle,但默认偏好 SortMergeJoin,它很少被选上。非等值 Join 走 BroadcastNestedLoopJoin;没有 Join 条件,就是笛卡尔积,最慢。这里纠正一个流传很广的说法:SparkPlanner 生成多个候选物理计划,再用代价模型挑最优。Spark 3.5 的源码里,其实是直接取第一个计划,注释写着:以后再实现挑选最优。Join 怎么选,靠的是策略里的优先级,加上大小阈值,而不是一个通用的代价模型。选完算子,还有一组准备规则:在需要重新分区的地方插入 Exchange,也就是 Shuffle。再把能融合的算子,包进 WholeStageCodegen。最后,物理计划变成 RDD 的 DAG,按 Shuffle 切成 Stage,交给 Spark Core 调度。Shuffle 前面专题讲过。逻辑计划像导航规划从 A 到 B,物理计划是具体走高速还是国道、在哪个路口转弯。

阶段五 · 代码生成

阶段五,代码生成。先看传统的 Volcano 模型。每个算子是一个迭代器,上层不停调用下层的 next 方法,一次拉一行。一行数据从 Scan 走到 Project,要经过好几次虚函数调用。虚函数调用开销不小:要动态查找方法、切换栈帧,编译器也很难内联优化。四个算子、一亿行,就是四亿次调用,中间数据还在内存里来回读写,CPU 缓存频繁失效。Whole-Stage CodeGen 的做法是:把一段能连起来的算子融合起来。比如 Scan、Filter、Project、局部聚合,合成一段 Java 代码。这段代码就是一个紧凑的 while 循环,所有操作都内联在里面,没有虚函数调用。Spark 用 Janino 在运行时把它编译成字节码,热点代码再由 JIT 编译成机器码。融合之后,中间数据尽量留在 CPU 寄存器里,循环结构对分支预测和缓存也很友好。融合只到 Exchange 这类管道断点为止,Shuffle 两边是不同的代码生成段。想看生成的代码,就执行 EXPLAIN CODEGEN,或者 DataFrame 的 explain,模式传 codegen。常见说法是比 Volcano 快 2 到 10 倍,这是基准测试的量级,实际收益看查询,聚合和扫描密集的最明显。也别说这是 Spark 独有:这个思路来自 HyPer 数据库 2011 年的论文,Impala、Trino 也都做代码生成。Volcano 像每个工人传一个零件就喊一声「下一个」;代码生成是把所有工序合成一台机器,零件进去,成品出来。

Tungsten 内存管理

Tungsten 还做了另一件事:内存管理。数据不再存成一个个 Java 对象,而是 UnsafeRow 这种紧凑的二进制格式,省掉对象头和指针的开销。Spark 通过 Unsafe API,直接按内存地址读写这些数据。常被说成「堆外内存,不归 GC 管」,要纠正:堆外是可选的,offHeap.enabled 默认是 false。默认情况下,Tungsten 在堆内申请大块内存页;GC 压力下降,主要是因为对象数量大幅减少。

补充一 · AQE

补充一:AQE,自适应查询执行。Catalyst 的优化,都发生在执行之前。可过滤后剩多少、数据怎么分布,只有跑起来才知道。AQE 前面专题讲过,这里串进主线。AQE 是 Spark 3.0 推出的,3.2 起默认开启:每个 Stage 跑完拿到 Shuffle 统计,再重新优化后面的计划。三个核心能力。第一,合并过小的 Shuffle 分区,减少 Task 数和调度开销。第二,动态切换 Join 策略:运行时发现一侧小于阈值,把 SortMergeJoin 换成 BroadcastHashJoin。第三,处理倾斜:一个分区既大于中位数的 5 倍、又大于 256MB,就拆成多个子任务并行。参数要注意两点。advisoryPartitionSizeInBytes 默认 64MB,可 parallelismFirst 默认是 true,合并分区时并不按 64MB。它优先保并行度,只守住 1MB 的最小分区;官方建议把它设成 false。AQE 自己的广播阈值没有默认值,不设就沿用普通广播阈值 10MB。传统优化像出发前定好路线就不改;AQE 像边开车边看实时路况,前面堵了就改道。

补充二 · 对比 Hive

补充二:Spark SQL 和 Hive SQL,执行流程的本质区别。Hive 更像翻译器,把 SQL 翻译成 MapReduce 或 Tez 任务;Spark SQL 自带执行引擎。入口上,Hive 只有 SQL;Spark 有 SQL、DataFrame、Dataset 三种。优化器上,Hive 用 Calcite 做 CBO,从 Hive 1.1 起默认开启,不只是可选。Spark 是 Catalyst,加上运行时的 AQE。执行上,Spark 有全阶段代码生成;Hive 没有,但有向量化执行,Tez 也能在运行时调整 Reduce 并行度。中间结果上,常说 Spark 内存优先,这不准确:Spark 的 Shuffle 数据,同样写本地磁盘。真正的区别是:MapReduce 多个 Job 之间要落 HDFS。Spark 一个 Job 里多个 Stage 连着跑,还能把数据缓存在内存。元数据上,Hive 必须有 Metastore;Spark 的 Catalog 可以接 Hive Metastore,也可以独立使用。一句话:Hive 是翻译官加外包团队,Spark SQL 是翻译官加自有团队,再加实时质检。

补充三 · 看执行计划

补充三:怎么看执行计划。EXPLAIN 一共有五种输出。默认只看物理计划;EXTENDED 依次给出解析、分析、优化后的逻辑计划,和物理计划。CODEGEN 看生成的代码;COST 在有统计信息时,显示逻辑计划和每一步的大小、行数。FORMATTED 是 3.0 新增的,分两段:先是带编号的计划概要,再是每个节点的详情,下推的条件都在这里。开了 AQE,EXPLAIN 显示的是初始计划,isFinalPlan 等于 false。最终计划要等执行之后,到 Spark UI 的 SQL 页看。面试里说一句:我平时用 explain formatted 看计划,再到 Spark UI 对最终计划,面试官就知道你真调过优。

全流程串讲

把整条流水线串起来。SQL、DataFrame、Dataset,先由 Parser 或 API 生成未解析的逻辑计划。Analyzer 查 Catalog 绑定表、列、类型;Optimizer 做谓词下推、列裁剪、常量折叠、Join 重排。Planner 选物理算子、插入 Shuffle;代码生成把每段算子融合编译。最后由 Spark Core 按 Job、Stage、Task 执行。Catalog 给分析和优化提供 Schema 和统计信息;AQE 在执行过程中,按真实数据回头改计划。

面试回答模板

面试这样答。Spark SQL 的执行经过五个阶段,核心是 Catalyst 和 Tungsten。首先是解析:用 ANTLR4 把 SQL 转成未解析的逻辑计划;DataFrame 直接构造计划,最终进入同一条流水线。然后是分析:查 Catalog 绑定表名、列名和类型,得到完整的逻辑计划。第三是逻辑优化:规则优化做谓词下推、列裁剪、常量折叠,代价优化做 Join 重排。这些规则按 Batch 组织,反复迭代到不动点。第四是物理计划:为每个逻辑算子选物理实现。比如 Join 选 BroadcastHashJoin,还是 SortMergeJoin。最后是代码生成:把多个算子融合成一段 Java 代码编译执行,消掉 Volcano 模型的虚函数调用。Spark 3.0 之后还有 AQE,运行时根据真实数据,合并分区、切换 Join 策略、处理倾斜。

高频追问

追问一:Catalyst 的规则是怎么组织的?按 Batch 组织。每个 Batch 有一组规则和一个执行策略。Once 只跑一次;FixedPoint 反复跑,直到不再变化或到达上限。谓词下推、列裁剪、常量折叠,在同一个 Batch 里反复迭代,因为规则之间会相互激活。谓词下推后,可能暴露新的列裁剪机会;列裁剪后,又可能让常量折叠生效。只跑一次,就会错过这些连锁优化。你也可以通过 SparkSessionExtensions,注入自己的优化规则,处理特定业务场景。追问二:Whole-Stage CodeGen 为什么快?三个原因。第一,消除虚函数调用,所有操作内联进一个 while 循环。第二,紧凑的循环让数据和代码都留在 CPU 缓存里。第三,JIT 再把热点代码编译成本地机器码。但它不是万能的:字段数超过 100,或者生成的方法超过约 64KB 字节码,这一段就不做全阶段代码生成。Python UDF 这类不支持代码生成的算子,也会切断融合,退回逐个算子执行。确认是否生效:在 Spark UI 的 SQL 页找 WholeStageCodegen 节点。explain 里算子前带星号和编号的,就是被融合的。追问三:CBO 需要做什么准备?CBO 依赖表和列的统计信息;没有统计信息,Join 重排就不会触发,只剩规则优化。ANALYZE TABLE 加 COMPUTE STATISTICS,收集表的行数和大小;加 NOSCAN,只算大小。加 FOR COLUMNS,收集列级统计:最大值、最小值、空值数量、不同值个数。收集统计本身有开销,建议只对经常查询的核心大表定期 ANALYZE,小表和临时表不用。追问四:AQE 动态切换 Join 策略,具体怎么工作?编译期估计两张表都是 1GB,Planner 选了 SortMergeJoin,两边都要 Shuffle。第一批 Stage 跑完,AQE 发现右表过滤后只有 5MB,低于阈值,就把后续计划改成 BroadcastHashJoin。要纠正一个说法:这时两边的 Shuffle 已经写完了,并不能跳过。省下的是两边的排序,以及用本地读 Shuffle 文件代替跨网络拉取,所以官方说它不如一开始就规划成广播。阈值要设合理:太大,广播过大的表可能 OOM;太小,又会错过优化。

回到开头

回到开头:你写的是先 Join 再过滤,Spark 却先过滤再 Join。因为 SQL 只是需求:解析成树、绑定元数据、等价改写、选物理算子、编译成代码。跑起来以后,AQE 还会按真实数据再改一次。

看完去做题