Spark-SQL解析原来如此简单

淡淡的烟草味﹌ 2022-10-20 00:56 303阅读 0赞

**关注博主微信公众号：3分钟秒懂大数据，粉丝2w+;**

如下图所示，Spark-SQL解析总体分为以下几个步骤：

*  **解析（Parser）**
 *  **绑定（Analysis）**
 *  **优化（Optimization）**
 *  **执行（Physical）**
 *  **生成RDD（RDDs）**

接下来，我们**先介绍解析部分**，对于绑定、逻辑计划的优化、物理执行计划、生成RDD后面再专门介绍。

![图片][612b7e28e514a3ad3511a13793098d0d.png]

# **Antlr4** #

![20210712134650909.png][]

最新的Spark-Sql解析模块为spark-catalyst\_2.11，通过**Antlr4**（Another Tool for Language Recognition）框架来实现。**ANTLR 是用JAVA写的语言识别工具**，它用来声明语言的语法。它的语法识别分为两个阶段：

**1.词法分析阶段 （lexical analysis) **

对应的分析程序叫做 lexer ，负责将符号（token）分组成符号类（token class or token type）

**2.解析阶段 **

根据词法，构建出一棵分析树（parse tree）或叫语法树（syntax tree）

![图片][979f1addcd0c1015934bdcbbbafb231b.png]

![20210712134714974.png][] 以下是四则运算的例子，Math.g4

![图片][d9ce5ff3eb5bffc40468e1fdb6dc8044.png]

![图片][75f0c17cc68803f2ea304a7d05120c13.png]

![20210712134753459.png][]

利用antlr4-maven-plugin插件即可完成自动编译。

![图片][e9336ae7db724a5b0bfba8cd087adf91.png]

可通过IDEA的maven插件编译，之后可在根目录\\target\\generated-sources\\antlr4\\com\\hikvs\\bigdata\\catalyst\\parser下产生以下JAVA文件：

![图片][d647c561dfaae9cedd0c295f18017db4.png]

其中MathLexer是词法分析器、MathParser是语法分析器、MathVisitor和MathBaseVisitor分别是访问者接口和访问者类。

![20210712134817973.png][]

Antlr4的遍历模式分两种：

**1.Listener（观察者模式） **

优点：通过节点监听，触发处理方法，用户不需要显示控制语法树的顺序，实现简单。

缺点：不能显示控制遍历语法树的顺序；没有返回值，需要使用map、 栈等结构在节点间传值

**2.Visitor（访问者模式） **

优点：主动遍历，用户可以显示定义遍历语法树的顺序、有返回值。

**比较两种模式，一般采用访问者模式，**可以显示控制遍历树的顺序。访问者类的作用是用于遍历整个语法树，然后进行相关操作，用户可以自己实现访问者类来 定义自己需要的功能。

public class MathVisitorTest extends MathBaseVisitor<Integer> {
         Map<String, Integer> memory = new HashMap<String, Integer>();  @Override  public Integer visitPrintExpr(MathParser.PrintExprContext ctx) {
           Integer value = visit(ctx.expr());    return value;  }  @Override  public Integer visitAssign(MathParser.AssignContext ctx) {
           String id = ctx.ID().getText();    int value = visit(ctx.expr());    memory.put(id, value);    return value;  }  @Override  public Integer visitBlank(MathParser.BlankContext ctx) {
           return super.visitBlank(ctx);  }  @Override  public Integer visitParens(MathParser.ParensContext ctx) {
           return visit(ctx.expr());  }  @Override  public Integer visitMulDiv(MathParser.MulDivContext ctx) {
           int left = visit(ctx.expr(0));    int right = visit(ctx.expr(1));    if ( ctx.op.getType() == MathParser.MUL ) return left * right;    return left / right;  }  @Override  public Integer visitAddSub(MathParser.AddSubContext ctx) {
         // TODO Auto-generatedmethod stub    int left = visit(ctx.expr(0));    int right = visit(ctx.expr(1));    if ( ctx.op.getType() == MathParser.ADD ) return left + right;    return left - right;  }  @Override  public Integer visitId(MathParser.IdContext ctx) {
           String id = ctx.ID().getText();    if ( memory.containsKey(id) ) return memory.get(id);    return 0;  }  @Override  public Integer visitInt(MathParser.IntContext ctx) {
           return Integer.valueOf(ctx.INT().getText());  }}public class Math {
         public static void main(String[] args) {
           CharStream input = CharStreams.fromString("1*(6-3)/2");    MathLexer lexer = new MathLexer(input);    CommonTokenStream tokens = new CommonTokenStream(lexer);    MathParser parser = new MathParser(tokens);    ParseTree tree = parser.prog(); // parse    MathVisitorTest vt = new MathVisitorTest();    Integer r = vt.visit(tree);    System.out.println(r.toString());  }}

![202107121348577.png][]

**1.SqlBase.g4 **

SqlBase.g4是spark-sql的语法解析文件，所属模块为spark-catalyst，SqlBase.g4位于路径\\spark2.3\\sql\\catalyst\\src\\main\\antlr4\\org\\apache\\spark\\sql\\catalyst\\parser\\SqlBase.g4。查询的部分语法如下：

![图片][62445f0d5ef39b5e9f158367162953cb.png]

![图片][4a424a4268a6d2f9e7019534c3308021.png]

**2.访问者-AstBuilder **

整个SQL解析相关的实现如下图

![图片][ddef92d58e180ebff3d46b308af07c07.png]

AstBuilder实现了SqlBaseBaseVisitor，并实现了部分visitXXX方法

class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef]{
        override def visitQuerySpecification(ctx: QuerySpecificationContext): LogicalPlan = withOrigin(ctx) {
        .......
        }
        override def visitSingleStatement(ctx: SingleStatementContext): LogicalPlan = withOrigin(ctx) {
        .......
        }
        override def visitSingleExpression(ctx: SingleExpressionContext): Expression = withOrigin(ctx) {
        .......
        }
    }

**3.Spark-SQL执行入口**

SparkSession .sql(sqlText: String)是暴露给用户的方法，用于执行sql文本。

class SparkSession private(）{
           def sql(sqlText: String): DataFrame = {
               Dataset.ofRows(self, sessionState.sqlParser.parsePlan(sqlText))    }}

visitSingleStatement为根节点开始采用递归下降的方式遍历整个语法树，解析后返回的是LogicalPlan，后面我们将介绍逻辑计划（LogicalPlan）。

override def parsePlan(sqlText: String): LogicalPlan = parse(sqlText) { parser =>
        astBuilder.visitSingleStatement(parser.singleStatement()) match {
            case plan: LogicalPlan => plan
            case _ =>
                val position = Origin(None, None)
                throw new ParseException(Option(sqlText), "Unsupported SQL statement", position, position)
        }
    }
    
    protected def parse[T](command: String)(toResult: SqlBaseParser => T): T = {
        logDebug(s"Parsing command: $command")
        val lexer = new SqlBaseLexer(new UpperCaseCharStream(CharStreams.fromString(command)))
        lexer.removeErrorListeners()
        lexer.addErrorListener(ParseErrorListener)
        val tokenStream = new CommonTokenStream(lexer)
        val parser = new SqlBaseParser(tokenStream)
        parser.addParseListener(PostProcessor)
        parser.removeErrorListeners()
        parser.addErrorListener(ParseErrorListener)
        try {
            try {
            // first, try parsing with potentially faster SLL mode
            parser.getInterpreter.setPredictionMode(PredictionMode.SLL)
            toResult(parser)
            }
            catch {
            ......
            }
        }
        catch {
        ......
        }
    }

# 逻辑计划（LogicalPlan） #

![20210712135109560.png][]

1、TreeNode

TreeNode 是Catalyst的核心类，语法树的构建都是由一个个TreeNode组成。继承关系如下：

![图片][99a64c259907acac4b172a89d08aa8b6.png]

其核心方法的作用如下:

![图片][28168f5ab086c872ac183b7df930d5fd.png]

LogicalPlan是TreeNode 的子类，作为数据结构记录了对应逻辑算子树节点的基本信息和基本操作，包括输入输出和各种处理逻辑等。

![20210712135156934.png][]

QueryPlan是LogicalPlan的直接父类，继承自TreeNode，其核心属性和方法可以分为6个部分：

**1.输入输出 **

输入或输出属性，比如Project的output方法就返回所有查询的字段信息。

override def output: Seq[Attribute] = projectList.map(_.toAttribute)

**2.基本属性 **

表示QueryPlan节点的一些基本信息，比如其中schema对应output输出属性的schema信息。

lazy val schema: StructType = StructType.fromAttributes(output)

**3.字符串**

打印QueryPlan树形结构信息。

**4.规范化 **

QueryPlan的canonicalized直接赋值为当前的QueryPlan类，sameResult方法会利用canonicalized来判断两个QueryPlan的输出结果是否相同。

**5.表达式操作 **

比如expressions会返回改节点所有表达式的列表，另外还有遍历表达式的方法transformExpressions等。

**6.约束 **

可以推导的一种过滤条件，比如“a>1”，可以推出a不能为null。

![图片][8092e3d4fc56a9c6150faf159ea1c31e.png]

![图片][2e4b85f6f9c4370a19b0f256765f4185.png]

**生成未解析逻辑计划（UnResolve LogicalPlan）**

以查询为例子来说明生成未解析逻辑计划的过程，例如执行SQL为：

![图片][0fdd076bc7b847b551be21b0c3cddf5b.png]

通过antlr4解析后得到的抽象语法树如下图所示：

![图片][58d6f19c12813a4b97c72b74d5dff382.png]

通过Asbuilder访问类对语法树进行访问，代码会执行

override def visitQuerySpecification(
      ctx: QuerySpecificationContext): LogicalPlan = withOrigin(ctx) {
        val from = OneRowRelation().optional(ctx.fromClause) {
        visitFromClause(ctx.fromClause)
      }
      withQuerySpecification(ctx, from)
    }

生成UnResolve LogicalPlan的过程如图：

![图片][29b79c137bd26b7372798e5e8ee5997b.png]

具体步骤如下：（1）简化后的流程图为：

![图片][af2b391659af59fd0368ded9f2d8a7ed.png]

**UnresolvedRelation：**对应SQL语句的from的表名，访问FromClauseContext并递归向下访问，最终匹配到TableNameContext节点时，直接根据TableNameContext 的信息生成UnresolvedRelation，构造名为from的LogicalPlan并返回。

**（2）Join：**对应SQL语句中的INNER JOIN语句，通过withJoinRelations最终构造Join(left, plan(join.right), joinType, condition)返回。包括左表、右表、关联类型、条件。

**（3）Filter：**对应SQL语句中的where语句，QuerySpecificationContext中包含了 BooleanExpressionContext类型，Asbuilder会对改子树进行递归访问，此例中碰到ComparisonContext节点，生成GreaterThan表达式，然后生成expression并返回 作为过滤条件，构造Filter(expression(ctx), plan)返回。

**（4）Project：**对应SQL语句中select对列值的选择操作，Asbuilder在访问中会获取 NamedExpressionSeqContext，并对其所有子节点对应的表达式进行转换，生成Expression列表expressions，基于expressions构造Project(namedExpressions, withFilter)返回。

其中各节点中的Expression情况如下：**下表列出了构造Filter逻辑算子树节点中的condition表达式。**根据ColumnReferenceContext节点信息生成 UnresolvedAttribute表达式。

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;">访问操作</td> 
   <td style="vertical-align:top;">Expression</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">visitColumnReference</td> 
   <td style="vertical-align:top;">UnresolvedAttribute(Seq(“age”))</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">visitIntegerLiteral</td> 
   <td style="vertical-align:top;">Literal(20, IntegerType)</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">visitComparison</td> 
   <td style="vertical-align:top;">GreaterThan(left, right)</td> 
  </tr> 
 </tbody> 
</table>

**下表列出了构造Project逻辑算子树节点中的condition表达式。**

**树形结构如下图：**

![图片][49c900ca03e519e07f5f83dc43575907.png]

**最终生成的未解析LogicalPlan为：**

![图片][e6acc67d403ec41864388df26f9fd43b.png]

![图片][5d940f435c009f7f1ada175ca2879efa.png]

Spark是如何将一个SQL语句通过Antlr4生成未解析的LogicalPlan的流程，这个LogicalPlan中的表名、函数名、字段名等都是未解析的，并没有绑定任何东西。

**接下来会进入Analyzer（分析）阶段，完成绑定操作，具体请参考下一篇文章。**

**以上就是Spark - SQL 解析第一阶段的所有内容！觉得好的，点赞，在看，分享三连击，谢谢！！！**

找各类大数据技术文章和面经，就来

<**3分钟秒懂大数据**>

随时更新互联网大数据组件内容

专为学习者提供技术博文

快和身边的小伙伴一起关注我们吧！

![图片][aea17b5dc211d895ad36f0f2bd8c67b8.png]

作者简介：逆流而上Mr李，秋招7offer, 微信公众号:3分钟秒懂大数据，粉丝：2w+

[612b7e28e514a3ad3511a13793098d0d.png]: /images/20221004/51540214357f477cbd7834e1d9c3e060.png
[20210712134650909.png]: /images/20221004/90434a2d1e5f44c49d12d2c2c24fab96.png
[979f1addcd0c1015934bdcbbbafb231b.png]: /images/20221004/e8d94ba9994c4080b09d131a12c792f5.png
[20210712134714974.png]: /images/20221004/107f5fefd65247658d6071998d8217ee.png
[d9ce5ff3eb5bffc40468e1fdb6dc8044.png]: /images/20221004/f99d9119ca7d4829a2cca0ba0ef69e93.png
[75f0c17cc68803f2ea304a7d05120c13.png]: /images/20221004/f97b6eab5d7a4f88ab974a2c74b2a7a9.png
[20210712134753459.png]: /images/20221004/e32c829c77b34552b6380e4ce6f288e9.png
[e9336ae7db724a5b0bfba8cd087adf91.png]: /images/20221004/44ed676cbf7c4246ab43d98f82736608.png
[d647c561dfaae9cedd0c295f18017db4.png]: /images/20221004/6a76e2d0449a4c5b887ba5cee840744c.png
[20210712134817973.png]: /images/20221004/16c1cd077d3f4b83b7ccdc947ce28894.png
[202107121348577.png]: /images/20221004/640461177cf748988ab19e94b47a3a76.png
[62445f0d5ef39b5e9f158367162953cb.png]: /images/20221004/b101d71c9c0242ae8324d3ddbf242ade.png
[4a424a4268a6d2f9e7019534c3308021.png]: /images/20221004/8f4a092d64a648af9a725b7ab80ca61b.png
[ddef92d58e180ebff3d46b308af07c07.png]: /images/20221004/3fb407d22eb94ad1a643b888e9076c4d.png
[20210712135109560.png]: /images/20221004/ebc20e070b80446092e8dcf1fc86e526.png
[99a64c259907acac4b172a89d08aa8b6.png]: /images/20221004/af2e0df55f5843cc88deabae8734cba7.png
[28168f5ab086c872ac183b7df930d5fd.png]: /images/20221004/13a23986711b4fceb0d39a390b8e0ff7.png
[20210712135156934.png]: /images/20221004/3363f011f4a947f9bbef775c8f20c25a.png
[8092e3d4fc56a9c6150faf159ea1c31e.png]: /images/20221004/512d85734d114e16a4b62abea56934fc.png
[2e4b85f6f9c4370a19b0f256765f4185.png]: /images/20221004/b60a1f45d91543dea4db8710318eda6e.png
[0fdd076bc7b847b551be21b0c3cddf5b.png]: /images/20221004/d9bfc1740e844672b08f63966d1a2cc4.png
[58d6f19c12813a4b97c72b74d5dff382.png]: /images/20221004/e61da28378a945ae873cb733fdf3888e.png
[29b79c137bd26b7372798e5e8ee5997b.png]: /images/20221004/44e644af2df7465aaf4bf8f763b78900.png
[af2b391659af59fd0368ded9f2d8a7ed.png]: /images/20221004/c610bac9925943e39477639c03c7972f.png
[49c900ca03e519e07f5f83dc43575907.png]: /images/20221004/a8991dfd28b64fa1a08a7c129b21b14b.png
[e6acc67d403ec41864388df26f9fd43b.png]: /images/20221004/674efd31c1f34d97b423157e32167433.png
[5d940f435c009f7f1ada175ca2879efa.png]: /images/20221004/379c44d4bb774a11a6ecfdaabfb21d45.png
[aea17b5dc211d895ad36f0f2bd8c67b8.png]: /images/20221004/977fc2faef5243c5814c1450ce09def7.png