sharding-jdbc 执行流程源码分析-sql 解析

上一篇分析了 sharding-jdbc 的初始化流程，从本篇开始分析执行流程，执行流程包括
（1）sql 解析
（2）sql 提取
（3）sql 路由
（4）sql 替换
（5）sql 执行
本篇主要分析 sql 解析,基于 4.0.1 ，Sharding jdbc 在 1.5.0.M1 正式发布时，将 SQL 解析引擎从 Druid 替换成了自研的，自研的引擎仅解析分片上下文，对于 SQL 采用"半理解"理念，进一步提升性能和兼容性，同时降低了代码复杂度, 而在 4.0.1 中 sql 解析引擎是 antlr4, 的优势是通用型较好，更加易于扩展。在 Sharding jdbc 发型版本中 sql 解析部分改动是频繁的，但都朝着，兼容性、扩展性方向发展。

因为本篇第一次讲执行，所以要先看一下执行阶段的入口

1、执行阶段一般用 orm 框架作为数据库操作的发起方，无论jdbc或 orm，第一步都是获取数据库连接 Connection，然后根据 Connection 创建 Statement 然后用 Statement.execute 执行 sql 语句

@Getter
public class ShardingDataSource extends AbstractDataSourceAdapter {
    ...略
    //执行阶段
    @Override
    public final ShardingConnection getConnection() {
        return new ShardingConnection(getDataSourceMap(), runtimeContext, TransactionTypeHolder.get());
    }
}
//根据 Connection 创建 Statement
@Getter
public final class ShardingConnection extends AbstractConnectionAdapter {
    @Override
    public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency) throws SQLException {
        return new ShardingPreparedStatement(this, sql, resultSetType, resultSetConcurrency);
    }
}

承接 orm，执行 sql 的入口

1、清除上一次执行时候的缓存，这里有点疑惑，因为orm每次执行的时候都会创建一个新的 PreparedStatement 为啥这边还要有缓存呢？
2、解析 sql 并且生成新的sql：包括sql 解析、sql 提取、sql 路由、sql 改写。
3、初始化执行器，将 sql 分组执行，并行或串行执行。

   //ShardingPreparedStatement
   // 承接 orm ，执行sql 的入口
    @Override
    public boolean execute() throws SQLException {
        try {
            //清除上一次执行时候的缓存
            clearPrevious();
            //解析 sql 并且生成新的sql
            shard();
            //初始化执行器，将 sql 分组执行
            initPreparedStatementExecutor();
            //执行 sql 并行或串行，如果是本地链接(非分布式事务) 那么如果不是自动提交那么，那么并行执行
            return preparedStatementExecutor.execute();
        } finally {
            clearBatch();
        }
    }

解析 sql 并且生成新的sql：包括sql 解析、sql 提取、sql 路由、sql 改写。

1、获取 sql 执行时候的参数
2、sql 解析、sql 提取、sql 路由
3、sql 改写
4、打印 sql 日志

    //ShardingPreparedStatement.java
    private void shard() {
        sqlRouteResult = shardingEngine.shard(sql, getParameters());
    }
    //BaseShardingEngine.java
    public SQLRouteResult shard(final String sql, final List<Object> parameters) {
        List<Object> clonedParameters = cloneParameters(parameters);
        //词法分析解析 sql 并且根据分片策略，找到真实表
        SQLRouteResult result = executeRoute(sql, clonedParameters);
        //改写sql ，如果是 Hint 仅仅是分库那么不需要改写sql
        result.getRouteUnits().addAll(HintManager.isDatabaseShardingOnly() ? convert(sql, clonedParameters, result) : rewriteAndConvert(sql, clonedParameters, result));
        boolean showSQL = shardingProperties.getValue(ShardingPropertiesConstant.SQL_SHOW);
        if (showSQL) {
            boolean showSimple = shardingProperties.getValue(ShardingPropertiesConstant.SQL_SIMPLE);
            SQLLogger.logSQL(sql, showSimple, result.getSqlStatementContext(), result.getRouteUnits());
        }
        return result;
    }

获取 sql 执行时候的参数

ShardingPreparedStatement 的父类 AbstractShardingPreparedStatementAdapter 覆盖了 Statement 的设置参数的方法，所以可以通过 getParameters() 获得参数列表

    //AbstractShardingPreparedStatementAdapter  覆盖了 Statement 的设置参数的方法
    @Override
    public final void setByte(final int parameterIndex, final byte x) {
        setParameter(parameterIndex, x);
    }
    //将参数保存到 parameters 集合中
    private void setParameter(final int parameterIndex, final Object value) {
        if (parameters.size() == parameterIndex - 1) {
            parameters.add(value);
            return;
        }
        for (int i = parameters.size(); i <= parameterIndex - 1; i++) {
            parameters.add(null);
        }
        parameters.set(parameterIndex - 1, value);
    }

sql 解析、sql 提取、sql 路由

   //PreparedStatementRoutingEngine.java
   public SQLRouteResult route(final List<Object> parameters) {
        if (null == sqlStatement) {
            //解析 sql 并且根据 sql 语句的类型返回对应的 Statement
            sqlStatement = shardingRouter.parse(logicSQL, true);
        }
        //路由
        return masterSlaveRouter.route(shardingRouter.route(logicSQL, parameters, sqlStatement));
    }

然后再看一下执行阶段所涉及到的类的 uml 图

image.png

sql 解析的入口是在路由阶段获取 sqlStatement 的时候调用的

   //ShardingRouter.java
   public SQLStatement parse(final String sql, final boolean useCache) {
        ParsingHook parsingHook = new SPIParsingHook();
        parsingHook.start(sql);
        try {
            //用 antlr 词法分析解析 sql
            SQLStatement result = parse0(sql, useCache);
            parsingHook.finishSuccess(result);
            return result;
            // CHECKSTYLE:OFF
        } catch (final Exception ex) {
            // CHECKSTYLE:ON
            parsingHook.finishFailure(ex);
            throw ex;
        }
    }
   //ShardingRouter.java
   private SQLStatement parse0(final String sql, final boolean useCache) {
        //是否用缓存中已解析好的结果
        if (useCache) {
            Optional<SQLStatement> cachedSQLStatement = cache.getSQLStatement(sql);
            if (cachedSQLStatement.isPresent()) {
                return cachedSQLStatement.get();
            }
        }
        // ParseRuleRegistry.getInstance() 获取定的一些规范，和配置信息
        SQLStatement result = new SQLParseKernel(ParseRuleRegistry.getInstance(), databaseTypeName, sql).parse();
        if (useCache) {
            cache.put(sql, result);
        }
        return result;
    }

第一次解析 sql 的时候需要初始化 sql 解析规则、提取规则，这个在上一章讲过了。
SQLParseKernel.parse() 方法进行 sql 解析

1、解析 sql 封装成抽象语法数
2、根据抽象语法树提取封装成 SQLSegment 这步就是所谓的 sql 提取，下节将

    public SQLStatement parse() {
        //获取数据库解析工具,并且执行解析生成语法树
        SQLAST ast = parserEngine.parse();
        //根据语法树提可以提取的部分
        Collection<SQLSegment> sqlSegments = extractorEngine.extract(ast);
        Map<ParserRuleContext, Integer> parameterMarkerIndexes = ast.getParameterMarkerIndexes();
        return fillerEngine.fill(sqlSegments, parameterMarkerIndexes.size(), ast.getSqlStatementRule());
    }

1、解析 sql 封装成抽象语法数

1、根据数据库类型获取对应的 sql 语法分析器，此处在第一次执行sql 语句的时候已经根据 java spi 机制，拿到了SQLParserEntry.class 集合
2、执行解析并且获取根节点
3、如果遇到了没能匹配任何规则,无法转换为 token （sql 没有按照定义的规则来），那么进行忽略不符合规则的后边的字符。
4、parseTree.getClass().getSimpleName 名字是在 DMLStatement.g4 文件中定义的规则名字加 Context ,查找 sql-statement-rule-definition.xml 定义的 SelectStatement

    public SQLAST parse() {
        SQLParser sqlParser = SQLParserFactory.newInstance(databaseTypeName, sql);
        ParseTree parseTree;
        try {
            ((Parser) sqlParser).setErrorHandler(new BailErrorStrategy());
            ((Parser) sqlParser).getInterpreter().setPredictionMode(PredictionMode.SLL);
            parseTree = sqlParser.execute().getChild(0);
        } catch (final ParseCancellationException ex) {
            //不符合规则的 sql 处理
            ((Parser) sqlParser).reset();
            ((Parser) sqlParser).setErrorHandler(new DefaultErrorStrategy());
            ((Parser) sqlParser).getInterpreter().setPredictionMode(PredictionMode.LL);
            parseTree = sqlParser.execute().getChild(0);
        }
        if (parseTree instanceof ErrorNode) {
            throw new SQLParsingException(String.format("Unsupported SQL of `%s`", sql));
        }
        SQLStatementRule rule = parseRuleRegistry.getSQLStatementRule(databaseTypeName, parseTree.getClass().getSimpleName());
        if (null == rule) {
            throw new SQLParsingException(String.format("Unsupported SQL of `%s`", sql));
        }
        return new SQLAST((ParserRuleContext) parseTree, getParameterMarkerIndexes((ParserRuleContext) parseTree), rule);
    }

根据数据库类型获取 SQLParser sql 语法解析器 SQLParserFactory.newInstance

    public static SQLParser newInstance(final String databaseTypeName, final String sql) {
        for (SQLParserEntry each : NewInstanceServiceLoader.newServiceInstances(SQLParserEntry.class)) {
            if (each.getDatabaseTypeName().equals(databaseTypeName)) {
                return createSQLParser(sql, each);
            }
        }
        throw new UnsupportedOperationException(String.format("Cannot support database type '%s'", databaseTypeName));
    }
    //antlr 相关的类
    @SneakyThrows
    private static SQLParser createSQLParser(final String sql, final SQLParserEntry parserEntry) {
        //根据 sql 创建词法分析器
        Lexer lexer = parserEntry.getLexerClass().getConstructor(CharStream.class).newInstance(CharStreams.fromString(sql));
        return parserEntry.getParserClass().getConstructor(TokenStream.class).newInstance(new CommonTokenStream(lexer));
    }

antlr ParseTree 的数据结构