前言

上文ShardingSphere-JDBC入门实战中对ShardingSphere-JDBC如何应用做了简略介绍，接下来打算从源码层面对数据分片做更加具体的介绍，整个数据分片会通过一个简单的流程包含：解析、路由、改写、执行、归并这几个子流程，每个子流程都有对应的引擎来解决，本文重点剖析子流程中的解析引擎。

分片流程

在介绍解析引擎之前，咱们对各个子流程做一个简略的介绍；咱们能够设想一下大略要通过几个流程；首先用户操作的都是逻辑表，最终是要被替换成物理表的，所以须要对SQL进行解析，其实就是了解SQL；而后就是依据分片路由算法，应该路由到哪个表哪个库；接下来须要生成实在的SQL，这样SQL能力被执行；生成的SQL可能有多条，每条都要执行；最初把多条执行的后果进行归并，返回后果集；整个流程大抵如下(来自官网)：

由 SQL 解析 => 执行器优化 => SQL 路由 => SQL 改写 => SQL 执行 => 后果归并的流程组成；每个子流程都有专门的引擎：

  • SQL解析：分为词法解析和语法解析。 先通过词法解析器将 SQL 拆分为一个个不可再分的单词。再应用语法解析器对 SQL 进行了解，并最终提炼出解析上下文。 解析上下文包含表、选择项、排序项、分组项、聚合函数、分页信息、查问条件以及可能须要批改的占位符的标记；
  • 执行器优化：合并和优化分片条件，如 OR 等；
  • SQL路由：依据解析上下文匹配用户配置的分片策略，并生成路由门路；目前反对分片路由和播送路由；
  • SQL改写：将 SQL 改写为在实在数据库中能够正确执行的语句。SQL 改写分为正确性改写和优化改写；
  • SQL执行：通过多线程执行器异步执行；
  • 后果归并：将多个执行后果集归并以便于通过对立的 JDBC 接口输入。后果归并包含流式归并、内存归并和应用装璜者模式的追加归并这几种形式。

本文重点剖析SQL解析局部，然而在剖析之前咱们须要大抵理解其中的ANTLR外围组件；

对于ANTLR

ANTLR (Another Tool for Language Recognition) 是一个弱小的解析器的生成器，能够用来读取、解决、执行或翻译结构化文本或二进制文件。他被宽泛用来构建语言，工具和框架。ANTLR能够从语法上来生成一个能够构建和遍历解析树的解析器。

ANTLR官网地址：https://www.antlr.org

ANTLR由两局部组成：

  • 将用户自定义语法翻译成Java中的解析器/词法分析器的工具，对应antlr-complete.jar；
  • 解析器运行时须要的环境库文件，对应antlr-runtime.jar；

ANTLR语法

ANTLR默认是一个已.g4结尾的文件，一个语法定义文件一般来说有一个通用的构造如下：

/** Optional javadoc style comment */ grammar Name; ① options {...} import ... ; tokens {...} channels {...} // lexer only @actionName {...} rule1 // parser and lexer rules, possibly intermingled ... ruleN

  • grammar：语法名称，必须和文件名统一；能够蕴含前缀lexer和parser，如下所示：

    lexer grammar MySqlLexer;parser grammar MySqlParser;

  • options：能够在语法和规定元素级别指定许多选项，grammar能够蕴含：superClass、language、tokenVocab、TokenLabelType、contextSuperClass等，比方

    options { tokenVocab=MySqlLexer; }
  • import：将一个语法宰割成多个逻辑上的、可复用的块，有点相似超类；

  • tokens：为那些没有关联词法规则的grammar来定义tokens的类型；

    // explicitly define keyword token types to avoid implicit definition warningstokens { BEGIN, END, IF, THEN, WHILE } @lexer::members { // keywords map used in lexer to assign token typesMap<String,Integer> keywords = new HashMap<String,Integer>() {{    put("begin", KeywordsParser.BEGIN);    put("end", KeywordsParser.END);    ...}};}

  • channels：只有lexer(词法剖析)的grammar能力蕴含自定义的channels，比方：

    channels {  WHITESPACE_CHANNEL,  COMMENTS_CHANNEL}

以上channels能够在lexer(词法剖析)规定中像枚举一样应用：

WS : [ \r\t\n]+ -> channel(WHITESPACE_CHANNEL) ;
  • actionName：目前只有两个定义的命名操作（针对Java指标）在语法规定之外应用：header和members；前者在识别器类定义之前将代码注入到生成的识别器类文件中，后者将代码作为字段和办法注入到识别器类定义中。

  • rule：规定能够分为：Lexer Rules和Parser Rules；规定格局如下所示：

    ```ruleName : alternative1 | ... | alternativeN ;```

Lexer Rules：名称以大写字母结尾；

Parser Rules：名称以小写字母结尾；

更多参考官网文档：https://github.com/antlr/antlr4/blob/master/doc/index.md

ANTLR应用

配置环境

首先须要去官网下载antlr-complete.jar文件，我这里应用的版本是：4.7.2；而后须要配置CLASSPATH：

.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;E:\antlr\antlr-4.7.2-complete.jar

检测一下是否胜利：

E:\antlr>java org.antlr.v4.ToolANTLR Parser Generator  Version 4.7.2 -o ___              specify output directory where all output is generated -lib ___            specify location of grammars, tokens files -atn                generate rule augmented transition network diagrams ......

语法文件

咱们须要依据ANTLR提供的语法定义本人的语法文件，比方Hello.g4如下所示：

// Define a grammar called Hellogrammar Hello;r  : 'hello' ID ;         // match keyword hello followed by an identifierID : [a-z]+ ;             // match lower-case identifiersWS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines

解决语法文件

应用ANTLR执行如下命令：

E:\antlr>java -jar antlr-4.7.2-complete.jar Hello.g4

会在当前目录下生成如下一堆文件：

HelloParser.javaHelloLexer.javaHelloListener.javaHelloBaseListener.javaHelloLexer.tokensHello.tokensHelloLexer.interpHello.interp

测试

首先须要编译下面生成的java类：

E:\antlr>javac Hello*.java

通过如下命令，展现树形图形：

E:\antlr>java org.antlr.v4.gui.TestRig Hello  r -guihello zhaohui^Z

注：最初的结尾unix应用ctrl+D，windows应用ctrl+Z；

插件形式

除了以上形式还能够间接在IDE中应用插件，各种IDE的插件地址能够间接在官网查看：

插件地址：https://www.antlr.org/tools.html

解决语法文件

在Hello.g4文件上右击“Configure Antlr...”，如下所示：

其中几个比拟重要的配置包含：生成文件输入的地位、生成类指定的包名、语法树遍历的模式；

语法树遍历的模式其中能够配置两种模式：listener模式和visitor模式

测试

同样应用Hello.g4语法文件，在IDEA中，关上Hello.g4右击"Test Rule"，ANTLR视图显示如下：

代码实现

有了以上的测试就能够应用代码来获取Parse tree，进行遍历；看上面一个简略的实例：

public class HelloDemo {    public static void main(String[] args) {        CharStream input = CharStreams.fromString("hello zhaohui");        HelloLexer lexer = new HelloLexer(input);        CommonTokenStream tokens = new CommonTokenStream(lexer);        HelloParser parser = new HelloParser(tokens);        ParseTree tree = parser.r();        System.out.println(tree.toStringTree(parser));    }}

输入后果如下：

(r hello zhaohui)

解析引擎

解析过程分为词法解析和语法解析。 词法解析器用于将 SQL拆解为不可再分的原子符号，称为Token。并依据不同数据库方言所提供的字典，将其归类为关键字，表达式，字面量和操作符。 再应用语法解析器将词法解析器的输入转换为形象语法树。

从3.0.x 版本开始，应用ANTLR 来做词法解析器，每种反对的数据库都有本人的方言，针对每种数据库都有各自的解析器；通过下面的理解咱们能够通过ANTLR来主动生成须要的解析器，前提是咱们有Lexer和Parser文件；

语法文件

ANTLR在Github上提供了各种数据的语法文件，门路如下：

文件门路：https://github.com/antlr/grammars-v4/tree/master/sql

以Mysql为例，蕴含了两个文件：

MySqlLexer.g4MySqlParser.g4

这样就能够通过相干工具生成须要的解析类了，在shardingsphere-sql-parser-mysql中能够发现主动生成类(autogen)：

当然咱们也能够在IDEA中做一个简略的测试，输出一条常见的查问SQL：

SELECT * FROM ORDER WHERE USER_ID=111;

生成的树结构如下所示：

解析引擎

ShardingSphere-JDBC提供的解析引擎类为：SQLParserEngine，次要的一个外围办法如下：

private SQLStatement parse0(final String sql, final boolean useCache) {        if (useCache) {            Optional<SQLStatement> cachedSQLStatement = cache.getSQLStatement(sql);            if (cachedSQLStatement.isPresent()) {                return cachedSQLStatement.get();            }        }        ParseTree parseTree = new SQLParserExecutor(databaseTypeName, sql).execute().getRootNode();        SQLStatement result = (SQLStatement) ParseTreeVisitorFactory.newInstance(databaseTypeName, VisitorRule.valueOf(parseTree.getClass())).visit(parseTree);        if (useCache) {            cache.put(sql, result);        }        return result;    }

两个参数别离是：逻辑SQL、是否应用缓存；返回值为SQLStatement；首先会进行是否应用缓存的判断，接下来就是要害的两步：逻辑SQL转换为ParseTree、拜访ParseTree获取SQLStatement；

转换ParseTree

要转换SQL为ParseTree，首先须要获取Parser，而获取Parser须要获取Lexer，写法其实和下面的HelloDemo差不多：

private static SQLParser createSQLParser(final String sql, final SQLParserConfiguration configuration) {        Lexer lexer = (Lexer) configuration.getLexerClass().getConstructor(CharStream.class).newInstance(CharStreams.fromString(sql));        return configuration.getParserClass().getConstructor(TokenStream.class).newInstance(new CommonTokenStream(lexer));    }

不同的数据类型会获取不同的Lexer和SQLParser；ShardingSphere-JDBC提供了多种数据库反对；

  • Lexer：MySQLLexer，OracleLexer，PostgreSQLLexer，SQL92Lexer，SQLServerLexer；
  • SQLParser：MySqlParser，OracleParser，PostgreSQLParser，SQL92Parser，SQLServerParser；

以上类其实都是对主动生成类的包装，以MysqlParser为例：

public final class MySQLParser extends MySQLStatementParser implements SQLParser {        public MySQLParser(final TokenStream input) {        super(input);    }        @Override    public ASTNode parse() {        return new ParseASTNode(execute());    }}

执行MySQLParser的parser办法，其实调用的是主动生成类MySQLStatementParser中的execute办法；

获取SQLStatement

有了ParseTree接下来就须要遍历树获取SQLStatement，ShardingSphere-JDBC默认应用的遍历形式是visitor形式；通过visitor对形象语法树遍历结构域模型，通过域模型(SQLStatement)去提炼分片所需的上下文，并标记有可能须要改写的地位，同样每种数据库都要提供各自的visitor，目前反对的数据库包含：

visitor：MySQLVisitor，OracleVisitor，PostgreSQLVisitor，SQL92Visitor，SQLServerVisitor；

SQLStatement

通过visitor生成对应的SQLStatement，不同的SQL生成的SQLStatement是不同的，大体能够分为这么几类：

  • DALStatement：全称Data Access Layer，数据库拜访层，包含show databases、tables等；
  • DMLStatement：全称Data Manipulation Language，数据库操作语言，包含增删改查等；
  • DCLStatement：全称Data Control Language，数据库管制语言，包含受权，传授管制等；
  • DDLStatement：全称Data Definition Language，数据库定义语言，包含创立、批改、删除表等；
  • RLStatement：全称Replication，包含主从复制等；
  • TCLStatement：全称Transaction Control Language，事务管制语言，包含设置保留点，回滚等；

关上对应数据库的语法文件，能够发现外面有对应的规定，如MySqlParser：

sqlStatement    : ddlStatement | dmlStatement | transactionStatement    | replicationStatement | preparedStatement    | administrationStatement | utilityStatement    ;

以上每种类型都提供了本人的visitor：

DALVisitor、DCLVisitor、DDLVisitor、DMLVisitor、RLVisitor、TCLVisitor

DMLStatement

以最常见的查问SQL为例，生成的是一个DMLStatement，常见的子类有：

DMLStatement：CallStatement、DeleteStatement、DoStatement、InsertStatement、ReplaceStatement、SelectStatement、UpdateStatement；

对应的语法文件也有对应关系：

dmlStatement    : selectStatement | insertStatement | updateStatement    | deleteStatement | replaceStatement | callStatement    | loadDataStatement | loadXmlStatement | doStatement    | handlerStatement    ;

以上每种操作类型都须要在对应的Visitor中进行重载，以Mysql为例对应的DMLVisitor为MySQLDMLVisitor，相干select语句的办法重载，访问者模式遍历之后生成SelectStatement；

 @Override    public ASTNode visitSelect(final SelectContext ctx) {        // TODO :Unsupported for withClause.        SelectStatement result = (SelectStatement) visit(ctx.unionClause());        result.setParameterCount(getCurrentParameterIndex());        return result;    }        @SuppressWarnings("unchecked")    @Override    public ASTNode visitSelectClause(final SelectClauseContext ctx) {        SelectStatement result = new SelectStatement();        result.setProjections((ProjectionsSegment) visit(ctx.projections()));        if (null != ctx.selectSpecification()) {            result.getProjections().setDistinctRow(isDistinct(ctx));        }        if (null != ctx.fromClause()) {            CollectionValue<TableReferenceSegment> tableReferences = (CollectionValue<TableReferenceSegment>) visit(ctx.fromClause());            for (TableReferenceSegment each : tableReferences.getValue()) {                result.getTableReferences().add(each);            }        }        if (null != ctx.whereClause()) {            result.setWhere((WhereSegment) visit(ctx.whereClause()));        }        if (null != ctx.groupByClause()) {            result.setGroupBy((GroupBySegment) visit(ctx.groupByClause()));        }        if (null != ctx.orderByClause()) {            result.setOrderBy((OrderBySegment) visit(ctx.orderByClause()));        }        if (null != ctx.limitClause()) {            result.setLimit((LimitSegment) visit(ctx.limitClause()));        }        if (null != ctx.lockClause()) {            result.setLock((LockSegment) visit(ctx.lockClause()));        }        return result;    }
SelectStatement

查问SQL对应SelectStatement，局部代码如下：

public final class SelectStatement extends DMLStatement {        private ProjectionsSegment projections;    private final Collection<TableReferenceSegment> tableReferences = new LinkedList<>();    private WhereSegment where;    private GroupBySegment groupBy;    private OrderBySegment orderBy;    private LimitSegment limit;    private SelectStatement parentStatement;    private LockSegment lock;}

能够发现外面蕴含了很多Segment，每个Segment其实就是整个SQL的一部分，下面这些关键字是不是都很相熟，都是在查问语句中会呈现的；其余类型这里就不贴代码了，依据每种类型生成各自的Segment；最初将SQLStatement包装成上下文SQLStatementContext给上游的路由引擎应用；

同样语法文件也有对应关系：

selectStatement    : querySpecification lockClause?                                #simpleSelect    | queryExpression lockClause?                                   #parenthesisSelect    | querySpecificationNointo unionStatement+        (          UNION unionType=(ALL | DISTINCT)?          (querySpecification | queryExpression)        )?        orderByClause? limitClause? lockClause?                     #unionSelect    | queryExpressionNointo unionParenthesis+        (          UNION unionType=(ALL | DISTINCT)?          queryExpression        )?        orderByClause? limitClause? lockClause?                     #unionParenthesisSelect    ;

总结

本文重点介绍了整个分片流程中的解析流程，整个解析的外围就是ANTLR，如果理解了ANTLR的相干语法，以及遍历形式，那解析引擎根本没什么难度了，ANTLR官网文档还是比拟全面的，有趣味的能够去细读；下文持续剖析分片的路由机制。

参考

https://shardingsphere.apache...

感激关注

能够关注微信公众号「回滚吧代码」，第一工夫浏览，文章继续更新；专一Java源码、架构、算法和面试。