我们知道SparkSQL最终会把API和SQL语句转换成Spark Core的RDD代码来执行。理解Spark Catalyst工作流程是非常有必要的.本文主要分享SparkSQL执行流程中的生成Unresolved Logical Plan背后的原理,希望能帮助大家更好地了解Spark Catalyst的整体执行流程.
-
Spark SQL解析流程
1、通过ANTLR对SQL进行语法词法解析,生成抽象语法树
2、将抽象的语法树解析成未解析的逻辑执行计划,也叫未绑定的逻辑执行计划
3、对有效节点进行数据类型绑定,根据Catalog对字段进行解析,生成验证后的逻辑执行计划
4、验证后的逻辑执行计划通过各种基于规则的优化策略进行深入优化
5、优化后的逻辑执行计划转换成物理执行计划
6、将物理执行计划进行优化生成RDD程序,并且提交运行
-
ANTLR4
ANTLR 是 ANother Tool for Language Recognition 的缩写，官网：ANTLR
ANTLR是一个强大的语言识别工具,它提供了一个框架,可以通过包含 Java, C++, 或 C# 动作（action）的语法描述来构造语言识别器，编译器和解释器。
ANTLR本身包含两个部分: 词法分析器(lexer)和语法分析器(parser)。词法分析阶段主要解决的关键词以及各种标识符，例如 INT、ID 等，语法分析主要是基于词法分析的结果，构造一颗语法分析树
词法分析器可以简单理解为如何将字符组成有效的单词或符号(也就是token)
语法分析器可以简单理解为将这些有效的单词,根据语法规则识别为有意义的句子
2.1 ANTLR4的IDEA开发
官网精简版计算器案例AddExpr.g4
grammar AddExpr;
// parser
stat : expr;
expr : expr op='+' expr # AddSub
| INT # int
;
//lexer
INT : [0-9]+ ;
ADD : '+' ;
IDEA开发流程
- IDEA安装ANTLR插件(注意插件的版本尽量和ANTLR Version一致)
- ANTLR Pom
<dependency>
<groupId>org.antlr</groupId>
<artifactId>antlr4-runtime</artifactId>
<version>4.10.1</version>
</dependency>
- 定义好.g4文件,右键Test Rule Stat验证G4文件是否有效
- 配置好代码生成位置
Parse Tree
2.2 访问者模式&监听者模式
- Listener模式
- Listener模式会由ANTLR提供的walker对象自动调用；在遇到不同的节点中，会调用提供的listener的不同方法
- Listener模式没有返回值，只能用一些变量来存储中间值
- Visitor模式
- visitor需要自己来指定访问特定类型的节点，在使用过程中，只需要对感兴趣的节点实现visit方法即可
- visitor模式可以自定义返回值
- visitor模式是对指定节点的访问
visitor模式 --访问者模式（扩展性好、复用性好、灵活）
以下是几篇解析访问者模式比较好理解的博客
- http://c.biancheng.net/view/1397.html
- 访问者模式 - 简书
2.3 G4文件生成代码
Spark3.2.1的SqlBase.g4文件生成代码
- SqlBaseLexer --词法分析器
- SqlBaseParser --语法分析器
- SqlBaseListener --Listener遍历接口
- SqlBaseVisitor --Visitor遍历接口
- SqlBaseBaseListener --Listener遍历实现
- SqlBaseBaseVisitor --Visitor遍历实现
-
Logical Plan
Aggregate,Filter,UnresolvedRelation本身都是都是Logical Plan
SELECT A,B,COUNT(*) AS CNT FROM TESTDATA2 WHERE A>2 GROUP BY A,B
--------unresolved logical plan--------
'Aggregate ['A, 'B], ['A, 'B, 'COUNT(1) AS CNT#0]
+- 'Filter ('A > 2)
+- 'UnresolvedRelation [TESTDATA2], [], false
SELECT A,B,COUNT(*) AS CNT FROM t1,t2 WHERE A>2 GROUP BY A,B
--------unresolved logical plan--------
'Aggregate ['A, 'B], ['A, 'B, 'COUNT(1) AS CNT#0]
+- 'Filter ('A > 2)
+- 'Join Inner
:- 'UnresolvedRelation [t1], [], false
+- 'UnresolvedRelation [t2], [], false
3.1 继承关系
顶层类TreeNode主要的子类包括QueryPlan和Expression，QueryPlan表示查询计划体系，Expression表示表达式体系，而QueryPlan的子类主要分为LogicalPlan逻辑执行计划和SparkPlan物理执行计划
3.2 LogicalPlan下比较重要的子类
- LeafNode 类型的 LogicalPlan【没有子节点逻辑计划树】
- UnresolvedRelation、OneRowRelation
- UnaryNode 类型的 Logical Plan 【具有单个子节点逻辑计划树】
- Distinct、Aggregate
- BinaryNode 类型的 LogicalPlan【具有左右子节点逻辑计划树】
- Join
-
Expression
Expression是SQL语句中的表达式,可以是Cast操作,四则运算和逻辑操作符等.在SQL语句中，除了SELECT FROM等关键字以外，其他大部分元素都可以理解为Expression
SELECT * FROM TEST WHERE A>2
这里的A,>,2 都是Expression Literal
具体见源码
case class GreaterThan(left: Expression, right: Expression)
extends BinaryComparison with NullIntolerant
-
走读源码
5.1 案例SQL
SELECT A,B FROM TESTDATA2
--------unresolved logical plan--------
'Project ['A, 'B]
+- 'UnresolvedRelation [TESTDATA2], [], false
5.2 生成的AstTree
5.3 AstBuilder.visitSingleStatement
生成unresolved logical plan源码入口
override def visitSingleStatement(ctx: SingleStatementContext): LogicalPlan = withOrigin(ctx) {
visit(ctx.statement).asInstanceOf[LogicalPlan]
}
/** * 注册上下文的来源。
* 在闭包中创建的任何 TreeNode 都将被指定为注册源。
* 此方法在完成闭包后恢复先前设置的来源。
*CurrentOrigin为TreeNode提供了一个位置，以便询问其来源的上下文。
*/
def withOrigin[T](ctx: ParserRuleContext)(f: => T): T = {
val current = CurrentOrigin.get
CurrentOrigin.set(position(ctx.getStart))
try {
f
} finally {
CurrentOrigin.set(current)
}
}
5.4 SingleStatementContext.statement
public StatementContext statement() {
//访问左节点(起始0),类型为StatementContext
return getRuleContext(StatementContext.class,0);
}
public <T extends ParseTree> T getChild(Class<? extends T> ctxType, int i) {
if (this.children != null && i >= 0 && i < this.children.size()) {
int j = -1;
Iterator i$ = this.children.iterator();
//访问指定位置&类型的节点
while(i$.hasNext()) {
ParseTree o = (ParseTree)i$.next();
if (ctxType.isInstance(o)) {
++j;
if (j == i) {
return (ParseTree)ctxType.cast(o);
}
}
}
return null;
} else {
return null;
}
}
5.5 AstBuilder.visitQuery
override def visitQuery(ctx: QueryContext): LogicalPlan = withOrigin(ctx) {
//规律:只要有有效分支,就会重写SqlBaseBaseVisit的遍历方法
//queryOrganization处理order by语法
val query = plan(ctx.queryTerm).optionalMap(ctx.queryOrganization)(withQueryResultClauses)
// Apply CTEs eg:as
query.optionalMap(ctx.ctes)(withCTE)
}
5.6 AstBuilder.visitRegularQuerySpecification
override def visitRegularQuerySpecification(
ctx: RegularQuerySpecificationContext): LogicalPlan = withOrigin(ctx) {
//select A,B;
val from = OneRowRelation().optional(ctx.fromClause) {
visitFromClause(ctx.fromClause)
}
withSelectQuerySpecification(
ctx,
ctx.selectClause,
ctx.lateralView,
ctx.whereClause,
ctx.aggregationClause,
ctx.havingClause,
ctx.windowClause,
from
)
}
5.7 AstBuilder.visitFromClause
override def visitFromClause(ctx: FromClauseContext): LogicalPlan = withOrigin(ctx) {
val from = ctx.relation.asScala.foldLeft(null: LogicalPlan) { (left, relation) =>
val right = plan(relation.relationPrimary)
//解决From A,B => 转成Join
val join = right.optionalMap(left) { (left, right) =>
if (relation.LATERAL != null) {
if (!relation.relationPrimary.isInstanceOf[AliasedQueryContext]) {
throw QueryParsingErrors.invalidLateralJoinRelationError(relation.relationPrimary)
}
LateralJoin(left, LateralSubquery(right), Inner, None)
} else {
Join(left, right, Inner, None, JoinHint.NONE)
}
}
//处理Join
withJoinRelations(join, relation)
}
//透视表
if (ctx.pivotClause() != null) {
if (!ctx.lateralView.isEmpty) {
throw QueryParsingErrors.lateralWithPivotInFromClauseNotAllowedError(ctx)
}
withPivot(ctx.pivotClause, from)
} else {
//虚拟表lateral view
ctx.lateralView.asScala.foldLeft(from)(withGenerate)
}
}
5.8 AstBuilder.visitTableName
override def visitTableName(ctx: TableNameContext): LogicalPlan = withOrigin(ctx) {
//获取表id
val tableId = visitMultipartIdentifier(ctx.multipartIdentifier)
//表别名处理
val table = mayApplyAliasPlan(ctx.tableAlias, UnresolvedRelation(tableId))
//处理抽样,这里处理结束后返回UNResolved Logical Plan
table.optionalMap(ctx.sample)(withSample)
}
5.9 AstBuilder.withSelectQuerySpecification
private def withSelectQuerySpecification(
ctx: ParserRuleContext,
selectClause: SelectClauseContext,
lateralView: java.util.List[LateralViewContext],
whereClause: WhereClauseContext,
aggregationClause: AggregationClauseContext,
havingClause: HavingClauseContext,
windowClause: WindowClauseContext,
relation: LogicalPlan): LogicalPlan = withOrigin(ctx) {
//处理Distinct语法
val isDistinct = selectClause.setQuantifier() != null &&
selectClause.setQuantifier().DISTINCT() != null
val plan = visitCommonSelectQueryClausePlan(
//底层的relation
relation,
//遍历Select ..
visitNamedExpressionSeq(selectClause.namedExpressionSeq),
lateralView,
whereClause,
aggregationClause,
havingClause,
windowClause,
isDistinct)
// Hint
selectClause.hints.asScala.foldRight(plan)(withHints)
}
5.10 AstBuilder.visitNamedExpression
override def visitNamedExpression(ctx: NamedExpressionContext): Expression = withOrigin(ctx) {
val e = expression(ctx.expression)
if (ctx.name != null) {
//别名处理
Alias(e, ctx.name.getText)()
} else if (ctx.identifierList != null) {
MultiAlias(e, visitIdentifierList(ctx.identifierList))
} else {
e
}
}
5.11 AstBuilder.visitColumnReference
override def visitColumnReference(ctx: ColumnReferenceContext): Expression = withOrigin(ctx) {
ctx.getStart.getText match {
//处理正则
//SELECT - Spark 3.3.0 Documentation
case escapedIdentifier(columnNameRegex)
if conf.supportQuotedRegexColumnName && canApplyRegex(ctx) =>
UnresolvedRegex(columnNameRegex, None, conf.caseSensitiveAnalysis)
case _ =>
UnresolvedAttribute.quoted(ctx.getText)//完成字段名提取
}
}
5.12 Count(*)在SparkSQL是怎么解析的?
实际上在Parser流程中,Spark会将Count(*)转换成Count(1),根据Parse Tree我们可以定位到源码
AstBuilder.visitFunctionCall
打
SELECT COUNT(*) FROM TESTDATA2
--------unresolved logical plan--------
'Project [unresolvedalias('count(1), None)]
+- 'UnresolvedRelation [TESTDATA2], [], false
-
小结
本文分析了Spark如何将SQL解析成Unresolved Logical Plan,可以发现G4文件生成的语法树有效节点在AstBuilder中都有重写,生成的LogicalPlan没有绑定元数据等信息.下一个阶段Analysis将会结合Catlog将这些节点解析成有类型(Typed)对象,完成绑定操作.
1842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
