Spark SQL 底层实现原理（部分）

原文链接

1. Spark SQL架构设计

直接使用SQL的方式实现大数据的开发，它同时支持DSL以及SQL的语法风格，目前在spark的整个架构设计当中，所有的spark模块，例如SQL，SparkML，sparkGrahpx以及Structed Streaming等都是基于 Catalyst Optimization & Tungsten Execution模块之上运行，如下图所示就显示了spark的整体架构模块设计。

2. SparkSQL执行过程

• Parser: 将sql语句利用Antlr4进行词法和语法的解析
• Analyzer：主要利用 Catalog 信息将 Unresolved Logical Plan 解析成 Analyzed logical plan；
• Optimizer：利用一些 Rule (规则），将 Analyzed logical plan 解析成 Optimized Logical Plan；
• Planner：前面的 logical plan 不能被 Spark 执行，而这个过程是把 logical plan 转换成多个 physical plans，然后利用代价模型（cost model）选择最佳的 physical plan；
• Code Generation：这个过程会把 SQL 查询生成 Java 字节码。

主要步骤：

• 输入sql，dataFrame或者dataSet

• 经过Catalyst过程，生成最终我们得到的最优的物理执行计划

• parser阶段

  • 主要是通过Antlr4解析SqlBase.g4> ，所有spark支持的语法方式都是定义在sqlBase.g4里面了，生成了我们的语法解析器SqlBaseLexer.java和词法解析器SqlBaseParser.java

  • parse阶段 --> antlr4 —> 解析 —> SqlBase.g4 —> 语法解析器SqlBaseLexer.java + 词法解析器SqlBaseParser.java
    analyzer阶段
  • 使用基于Rule的规则解析以及Session Catalog来实现函数资源信息和元数据管理信息
    Analyzer 阶段 --> 使用 --> Rule + Session Catalog --> 多个rule --> 组成一个batch --> session CataLog --> 保存函数资源信息以及元数据信息等

• optimizer阶段

  • optimizer调优阶段 --> 基于规则的RBO优化rule-based optimizer --> 谓词下推 + 列剪枝 + 常量替换 + 常量累加

• planner阶段

  • 生成多个物理计划 --> 经过Cost Model进行最优选择 --> 基于代价的CBO优化 --> 最终选定得到的最优物理执行计划
  • 选定最终的物理计划，准备执行
  • 最终选定的最优物理执行计划 --> 准备生成代码去开始执行
  • 将最终得到的物理执行计划进行代码生成，提交代码去执行我们的最终任务

4. Catalyst执行过程

从上面的查询计划我们可以看得出来，我们编写的sql语句，经过多次转换，最终进行编译成为字节码文件进行执行，（注意，图是从下往上看的）其中包括以下几个重要步骤

• sql解析阶段 parse
• 生成逻辑计划 Analyzer
• sql语句调优阶段 Optimizer
• 生成物理查询计划 planner

4.1 sql解析阶段Parser

我们常见的大数据 SQL 解析都用到了Antlr，包括 Hive、Cassandra、Phoenix、Pig 以及 presto 等。能够读取、处理、执行和翻译结构化的文本或二进制文件，是当前 Java 语言中使用最为广泛的语法生成器工具。

目前最新版本的 Spark 使用的是antlr4，通过这个对 SQL 进行词法分析并构建语法树。我们可以通过github去查看spark的源码

如果需要重构sparkSQL的语法，对SqlBase.g4进行语法解析，生成相关的java类，包含

• 词法解析器SqlBaseLexer.java
• 语法解析器SqlBaseParser.java。

最终通过Lexer以及parse解析之后，生成语法树，生成语法树之后，使用AstBuilder将语法树转换成为LogicalPlan，这个LogicalPlan也被称为Unresolved LogicalPlan。

3.2 绑定逻辑计划Analyzer

在sql解析parse阶段，生成了很多未解析出来的有些关键字，这些都是属于 Unresolved LogicalPlan解析的部分。 Unresolved LogicalPlan仅仅是一种数据结构，不包含任何数据信息，例如不知道数据源，数据类型，不同的列来自哪张表等等.

Analyzer 阶段，会使用事先定义好的 Rule 以及 SessionCatalog 等信息对 Unresolved LogicalPlan 进行 transform。SessionCatalog 主要用于各种函数资源信息和元数据信息（数据库、数据表、数据视图、数据分区与函数等）的统一管理。

而Rule 是定义在 Analyzer 里面的。多个性质类似的 Rule 组成一个 Batch，而多个 Batch 构成一个 batches。这些 batches 会由 RuleExecutor 执行，先按一个一个 Batch 顺序执行，然后对 Batch 里面的每个 Rule 顺序执行。每个 Batch 会执行一次（Once）或多次（FixedPoint，由 spark.sql.optimizer.maxIterations 参数决定）

总结来看Analyzed Logical Plan主要就是干了一些这些事情

• 1、确定最终返回字段名称以及返回类型；
• 2、确定聚合函数；
• 3、确定表当中获取的查询字段；
• 4、确定过滤条件
• 5、确定join方式
• 6、确定表当中的数据来源以及分区个数

3.3 逻辑优化阶段Optimizer

这个阶段的优化器主要是基于规则的（Rule-based Optimizer，简称 RBO），而绝大部分的规则都是启发式规则，也就是基于直观或经验而得出的规则。

与前文介绍绑定逻辑计划阶段类似，这个阶段所有的规则也是实现 Rule 抽象类，多个规则组成一个 Batch，多个 Batch 组成一个 batches，同样也是在 RuleExecutor 中进行执行这里按照 Rule 执行顺序一一进行说明。

3.3.1 谓词下推

谓词下推在 SparkQL 是由 PushDownPredicate 实现的，这个过程主要将过滤条件尽可能地下推到底层，最好是数据源。

如图谓词下推将 Filter 算子直接下推到 Join 之前了，也就是在扫描 student表的时候使用条件过滤条件过滤出满足条件的数据；同时在扫描 t2 表的时候会先使用 isnotnull(id#8) && (id#8 > 50000) 过滤条件过滤出满足条件的数据。经过这样的操作，可以大大减少 Join 算子处理的数据量，从而加快计算速度

3.3.2 列裁剪

列裁剪在 Spark SQL 是由 ColumnPruning 实现的。利用列裁剪可以把那些查询不需要的字段过滤掉，使得扫描的数据量减少。

经过列裁剪后，students 表只需要查询 sno和 class 两个字段；scores 表只需要查询 sno,degree 字段。这样减少了数据的传输，而且如果底层的文件格式为列存（比如 Parquet），可以大大提高数据的扫描速度的。

3.3.3 常量替换

常量替换在 Spark SQL 是由 ConstantPropagation 实现的。也就是将变量替换成常量，

SELECT * FROM table WHERE i = 5 AND j = i + 3 
可以转换成 
SELECT * FROM table WHERE i = 5 AND j = 8。

3.3.4 常量累加

常量累加在 Spark SQL 是由 ConstantFolding 实现的。这个和常量替换类似，也是在这个阶段把一些常量表达式事先计算好。

4. SQL举例

例如执行以下SQL语句：

select 
  temp1.class, 
  sum(temp1.degree), 
  avg(temp1.degree) 
from 
  (
    SELECT 
      students.sno AS ssno, 
      students.sname, 
      students.ssex, 
      students.sbirthday, 
      students.class, 
      scores.sno, 
      scores.degree, 
      scores.cno 
    FROM 
      students 
      LEFT JOIN scores ON students.sno = scores.sno
  ) temp1 
group by 
  temp1.class

代码实现过程如下：

import java.util.Properties
import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}

//todo:利用sparksql加载mysql表中的数据
object DataFromMysqlPlan {
  def main(args: Array[String]): Unit = {
    //1、创建SparkConf对象
    val sparkConf: SparkConf = new SparkConf().setAppName("DataFromMysql").setMaster("local[2]")

    //sparkConf.set("spark.sql.codegen.wholeStage","true")
    //2、创建SparkSession对象
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()
    spark.sparkContext.setLogLevel("WARN")

    //3、读取mysql表的数据
    //3.1 指定mysql连接地址
    val url="jdbc:mysql://localhost:3306/mydb?characterEncoding=UTF-8"
    //3.2 指定要加载的表名
    val student="students"
    val score="scores"

    // 3.3 配置连接数据库的相关属性
    val properties = new Properties()

    //用户名
    properties.setProperty("user","root")
    //密码
    properties.setProperty("password","123456")

    val studentFrame: DataFrame = spark.read.jdbc(url,student,properties)
    val scoreFrame: DataFrame = spark.read.jdbc(url,score,properties)
    
    //把dataFrame注册成表
    studentFrame.createTempView("students")
    scoreFrame.createOrReplaceTempView("scores")
    
    //spark.sql("SELECT temp1.class,SUM(temp1.degree),AVG(temp1.degree) FROM (SELECT  students.sno AS ssno,students.sname,students.ssex,students.sbirthday,students.class, scores.sno,scores.degree,scores.cno  FROM students LEFT JOIN scores ON students.sno =  scores.sno ) temp1  GROUP BY temp1.class; ").show()
    val resultFrame: DataFrame = spark.sql("SELECT temp1.class,SUM(temp1.degree),AVG(temp1.degree)  FROM (SELECT  students.sno AS ssno,students.sname,students.ssex,students.sbirthday,students.class, scores.sno,scores.degree,scores.cno  FROM students LEFT JOIN scores ON students.sno =  scores.sno  WHERE degree > 60 AND sbirthday > '1973-01-01 00:00:00' ) temp1 GROUP BY temp1.class")
    
    resultFrame.explain(true)
    resultFrame.show()
    spark.stop()
  }
}