上一篇介绍完了基于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有不少改动,不能完全按照它里面的思路写

最后修改:2024 年 08 月 19 日