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 parameters) {
        List 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 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 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 sqlSegments = extractorEngine.extract(ast);
        Map 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 的数据结构


image.png

你可能感兴趣的:(sharding-jdbc 执行流程源码分析-sql 解析)