基于Calcite的SQL血缘解析思路
[scode type="yellow"]本文内容已过期，请移步至“从事SQL血缘解析一年后，谈谈我对它的理解”[/scode]
上一篇介绍完了基于Antlr的sql血缘解析，这一篇我来说一说基于Calcite的
简介
Apache Calcite 是一款开源SQL解析工具, 可以将各种SQL语句解析成抽象语法语法树AST(Abstract Syntax Tree), 之后通过操作AST就可以把SQL中所要表达的算法与关系体现在具体代码之中。
以下两个github有不少calcite的test，可以参考，但是由于calcite版本比较老，所以一些代码已经废弃：
基本使用
我们直入正题：
解析
我们先将sql语句解析为语法树，根节点为SqlNode（你可以类比为antlr的RuleText）
SqlNode.getKind()可以获得当前节点是哪种节点，例如SELECT、INSERT、JOIN、AS等等
如果你会看antlr的解析树，其实你debug SqlNode的结构时其实差不多，都是一级一级往下找
先上代码：
依赖
<dependency>
<groupId>org.apache.calcite</groupId>
<artifactId>calcite-core</artifactId>
<version>1.29.0</version>
</dependency>SqlNode
网上很多的写法例如ConfigBuilder这种已经废弃了，尽量参考calcite源码中SqlParseTest中的方法：
@Test
public void testnormal() throws Exception{
String sql = "select a from t1";
SqlParser sqlParser = getSqlParser(sql, null);
SqlNode sqlNode = sqlParser.parseStmt();
System.out.println(sqlNode.toString());
}
public SqlParser getSqlParser(String sql, SqlDialect sqlDialect) {
return getSqlParser(new SourceStringReader(sql), getTransform(sqlDialect));
}
protected SqlParser getSqlParser(Reader source,
UnaryOperator<SqlParser.Config> transform) {
final SqlParser.Config configBuilder =
SqlParser.config()
.withParserFactory(parserImplFactory());
final SqlParser.Config config = transform.apply(configBuilder);
return SqlParser.create(source, config);
}
private static UnaryOperator<SqlParser.Config> getTransform(SqlDialect dialect) {
return dialect == null ? UnaryOperator.identity() : dialect::configureParser;
}
protected SqlParserImplFactory parserImplFactory() {
return SqlParserImpl.FACTORY;
}递归遍历SqlNode
这里只举个例子：
public static List<String> getDependencies(SqlNode sqlNode, List<String> result) throws SqlParseException {
if (sqlNode.getKind() == JOIN) {
SqlJoin sqlKind = (SqlJoin) sqlNode;
System.out.println("-----join");
getDependencies(sqlKind.getLeft(), result);
getDependencies(sqlKind.getRight(), result);
}
if (sqlNode.getKind() == IDENTIFIER) {
System.out.println("-----identifier");
result.add(sqlNode.toString());
}
if (sqlNode.getKind() == INSERT) {
SqlInsert sqlKind = (SqlInsert) sqlNode;
System.out.println("-----insert");
getDependencies(sqlKind.getSource(), result);
}
if (sqlNode.getKind() == SELECT) {
SqlSelect sqlKind = (SqlSelect) sqlNode;
System.out.println("-----select");
getDependencies(sqlKind.getFrom(), result);
}
if (sqlNode.getKind() == AS) {
SqlBasicCall sqlKind = (SqlBasicCall) sqlNode;
System.out.println("----as");
getDependencies(sqlKind.getOperandList().get(0), result);
}
if (sqlNode.getKind() == UNION) {
SqlBasicCall sqlKind = (SqlBasicCall) sqlNode;
System.out.println("----union");
getDependencies(sqlKind.getOperandList().get(0), result);
getDependencies(sqlKind.getOperandList().get(1), result);
}
if (sqlNode.getKind() == ORDER_BY) {
SqlOrderBy sqlKind = (SqlOrderBy) sqlNode;
System.out.println("----order_by");
getDependencies(sqlKind.getOperandList().get(0), result);
}
return result;
}第一次传入的sqlNode就是很节点，这里的result集合是记录源表表名的，这里建议大家去打个断点debug一下sqlNode，往里面扒一扒，你就能搞明白calcite构建sqlNode的一个逻辑了
所以这里要强调的是，Calcite对SqlNode的构建是一个递归的构建，我们对sqlNode语法树的解析是一个从外到内、从左向右的一个先序深度遍历，这点和antlr不同，要额外注意。（这一块也确实比较费脑子）
校验
以上只是对一条sql一个基本解析，并没有校验，对于select *这种我们无法得知 里的内容，所以校验阶段就是根据已经有的元数据去校验该sql语句是否合法（表、字段名存不存在），最重要的一点是它会把 替换为该表的所有字段名，之后我们再重复上述解析即可：
public class TestOne {
public static class TestSchema {
public final Triple[] rdf = {new Triple("s", "p", "o")};
}
public static void main(String[] args) {
SchemaPlus schemaPlus = Frameworks.createRootSchema(true);
//给schema T中添加表
schemaPlus.add("T", new ReflectiveSchema(new TestSchema()));
Frameworks.ConfigBuilder configBuilder = Frameworks.newConfigBuilder();
//设置默认schema
configBuilder.defaultSchema(schemaPlus);
FrameworkConfig frameworkConfig = configBuilder.build();
SqlParser.ConfigBuilder paresrConfig = SqlParser.configBuilder(frameworkConfig.getParserConfig());
//SQL 大小写不敏感
paresrConfig.setCaseSensitive(false).setConfig(paresrConfig.build());
Planner planner = Frameworks.getPlanner(frameworkConfig);
SqlNode sqlNode;
RelRoot relRoot = null;
try {
//parser阶段
sqlNode = planner.parse("select \"a\".\"s\", count(\"a\".\"s\") from \"T\".\"rdf\" \"a\" group by \"a\".\"s\"");
//validate阶段
planner.validate(sqlNode);
//获取RelNode树的根
relRoot = planner.rel(sqlNode);
} catch (Exception e) {
e.printStackTrace();
}
RelNode relNode = relRoot.project();
System.out.print(RelOptUtil.toString(relNode));
}
}
public class Triple {
public String s;
public String p;
public String o;
public Triple(String s, String p, String o) {
super();
this.s = s;
this.p = p;
this.o = o;
}
}Meta接口
除了我们自己手动递归sqlNode以外，我们也可以通过Meta接口下的相关API来获取sql的血缘：
（待补充）
自定义sql解析
这个主要是针对原有parse.jj中可能并没有处理我们特殊sql语句的关键字，我们需要对其扩展补充，来实现自定义sql解析，具体可以看我们最上面放的连接，calcite-test里有现成的自定义解析sql代码，但是要注意最新的calcite-core有不少改动，不能完全按照它里面的思路写