[scode type="yellow"]本文内容已过期，请移步至“从事SQL血缘解析一年后，谈谈我对它的理解”[/scode]

上一篇介绍完了基于Antlr的sql血缘解析，这一篇我来说一说基于Calcite的

简介

Apache Calcite 是一款开源SQL解析工具, 可以将各种SQL语句解析成抽象语法语法树AST(Abstract Syntax Tree), 之后通过操作AST就可以把SQL中所要表达的算法与关系体现在具体代码之中。

calcite常用类介绍，和解析流程

calcite自定义driver、sql、优化等详解

以下两个github有不少calcite的test，可以参考，但是由于calcite版本比较老，所以一些代码已经废弃：

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有不少改动，不能完全按照它里面的思路写