        <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;
    }

}