1. 首页
  2. sharding-jdbc源码分析

21.sharding-jdbc源码之SQL解析-词法分析

阿飞Javaer,转载请注明原创出处,谢谢!

sharding-jdbc对SQL解析的源码主要在下图所示parsing模块中,由下图可知SQL解析主要分为两部分:lexer和parser。lexer就是本文需要分析的词法分析:

anmazhisqljiexi_cifafenxi_1.png

sharding-jdbc sql解析

SQL com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Token
/!hello,afei/ 跳过
delete (type=DELETE,literals=delete,endPosition=24)
ignore (type=IGNORE,literals=ignore,endPosition=31)
from (type=FROM,literals=from,endPosition=36)
t_user (type=IDENTIFIER,literals=t_user,endPosition=45)
where (type=WHERE,literals=where,endPosition=51)
user_id (type=IDENTIFIER,literals=user_id,endPosition=59)
= (type=EQ,literals==,endPosition=60)
? (type=QUESTION,literals=?,endPosition=61)
(type=END,literals=,endPosition=62)

分析sharding-jdbc源码的词法分析之前,先大概说一下词法分析是干嘛的,后面理解起来就会更容易,例如对于SQL:"/! hello, afei /delete ignore from `t_user` where user_id=? "而言,词法分析结果如下:

SQL com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Token
/!hello,afei/ 跳过
delete (type=DELETE,literals=delete,endPosition=24)
ignore (type=IGNORE,literals=ignore,endPosition=31)
from (type=FROM,literals=from,endPosition=36)
t_user (type=IDENTIFIER,literals=t_user,endPosition=45)
where (type=WHERE,literals=where,endPosition=51)
user_id (type=IDENTIFIER,literals=user_id,endPosition=59)
= (type=EQ,literals==,endPosition=60)
? (type=QUESTION,literals=?,endPosition=61)
(type=END,literals=,endPosition=62)

SQL解析结果初探

前面分析SQL重写的时,其测试用例代码在SQLRewriteEngineTest.java中,列举其中一个用例源码如下,assertRewriteForLimit()方法中的selectStatement就是SQL解析的结果:

  @Before
    public void setUp() {
        // 定义sharding规则
        shardingRule = new ShardingRuleMockBuilder()
                // table_x表的主键列是id
                .addGenerateKeyColumn("table_x", "id")
                // table_x和table_y是绑定表关系
                .addBindingTable("table_y").build();
        selectStatement = new SelectStatement();
        tableTokens = new HashMap<>(1, 1);
        // 逻辑表table_x对应的实际表是table_1
        tableTokens.put("table_x", "table_1");
    }

    @Test
    public void assertRewriteForLimit() {
        selectStatement.setLimit(new Limit(true));
        selectStatement.getLimit().setOffset(new LimitValue(2, -1));
        selectStatement.getLimit().setRowCount(new LimitValue(2, -1));
        selectStatement.getSqlTokens().add(new TableToken(17, "table_x"));
        selectStatement.getSqlTokens().add(new OffsetToken(33, 2));
        selectStatement.getSqlTokens().add(new RowCountToken(36, 2));
        // SelectStatement就是SQL解析的结果
        SQLRewriteEngine rewriteEngine = new SQLRewriteEngine(shardingRule, "SELECT x.id FROM table_x x LIMIT 2, 2", selectStatement);
        assertThat(rewriteEngine.rewrite(true).toSQL(tableTokens), is("SELECT x.id FROM table_1 x LIMIT 0, 4"));
    }

SQL解析分析

核心类为com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine.java,核心源码如下:

  @RequiredArgsConstructor
    public final class SQLParsingEngine {

        // 数据库类型,例如MySQL,Oracle等
        private final DatabaseType dbType;

        // 原SQL(解析前的SQL)
        private final String sql;

        // sharding分库分表规则
        private final ShardingRule shardingRule;

        public SQLStatement parse() {
        LexerEngine lexerEngine = LexerEngineFactory.newInstance(dbType, sql);
        lexerEngine.nextToken();
        SQLParser sqlParser = SQLParserFactory.newInstance(
                dbType,
                lexerEngine.getCurrentToken().getType(), shardingRule, lexerEngine);
        SQLStatement result = sqlParser.parse();
        return result;
    }

从parse()方法的结果可知,SQL解析的结果就是SQLStatement,上面的测试用例是SelectStatement,是SQLStatement的子类,关系如下图所示:

1. 得到LexerEngine

对应源码为LexerEngine lexerEngine = LexerEngineFactory.newInstance(dbType, sql);,核心实现源码如下:

  @NoArgsConstructor(access = AccessLevel.PRIVATE)
    public final class LexerEngineFactory {

        public static LexerEngine newInstance(final DatabaseType dbType, final String sql) {
            // 不同的数据库类型获取LexerEngine不一样(主要是关键词不一样),从这里可知H2和MySQL的解析完全一致
            switch (dbType) {
                case H2:
                case MySQL:
                    return new LexerEngine(new MySQLLexer(sql));
                case Oracle:
                    return new LexerEngine(new OracleLexer(sql));
                case SQLServer:
                    return new LexerEngine(new SQLServerLexer(sql));
                case PostgreSQL:
                    return new LexerEngine(new PostgreSQLLexer(sql));
                default:
                    throw new UnsupportedOperationException(String.format("Cannot support database [%s].", dbType));
            }
        }
    }

从这里可知,sharding-jdbc只支持这些数据库:H2,MySQL,Oracle,SQLServer,PostgreSQL;其他数据库如DB2是不支持的;

以Mysql数据库为例,获取MySQLLexer源码如下,可知Lexer两个主要属性为SQL和关键词字典:

  // 词法分析器的这几个属性比较重要,贯穿整个SQL解析过程
    @RequiredArgsConstructor
    public class Lexer {

        // 待解析的SQL语句
        @Getter
        private final String input;

        // 字典属性下面有解析,主要包括数据库对应的所有关键词
        private final Dictionary dictionary;

        // 解析SQL的位置偏移量
        private int offset;

        // 当前解析的token
        @Getter
        private Token currentToken;
        ... ...
    }

    public final class MySQLLexer extends Lexer {

        // MySQL词法分析器核心Dictionary的构造方法入参为MySQL所有关键词合集(可以预见各数据库的词法分析器都包含其所有SQL关键词信息),MySQL所有关键词集合包括MySQLKeyword和DefaultKeyword;其他数据库类似,例如Oracle所有关键词集合包括OracleKeyword和DefaultKeyword
        private static Dictionary dictionary = new Dictionary(MySQLKeyword.values());

        public MySQLLexer(final String input) {
            super(input, dictionary);
        }
        ... ...

2. 获取第一个token

对应的源码是lexerEngine.nextToken();,核心实现源码如下:

  public final void nextToken() {
        skipIgnoredToken();
        if (isVariableBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanVariable();
        } else if (isNCharBegin()) {
            currentToken = new Tokenizer(input, dictionary, ++offset).scanChars();
        } else if (isIdentifierBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanIdentifier();
        } else if (isHexDecimalBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanHexDecimal();
        } else if (isNumberBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanNumber();
        } else if (isSymbolBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanSymbol();
        } else if (isCharsBegin()) {
            currentToken = new Tokenizer(input, dictionary, offset).scanChars();
        } else if (isEnd()) {
            currentToken = new Token(Assist.END, "", offset);
        } else {
            currentToken = new Token(Assist.ERROR, "", offset);
        }
        offset = currentToken.getEndPosition();
    }

    // 跳过忽略的token
    private void skipIgnoredToken() {
        offset = new Tokenizer(input, dictionary, offset).skipWhitespace();
        while (isHintBegin()) {
            offset = new Tokenizer(input, dictionary, offset).skipHint();
            offset = new Tokenizer(input, dictionary, offset).skipWhitespace();
        }
        while (isCommentBegin()) {
            offset = new Tokenizer(input, dictionary, offset).skipComment();
            offset = new Tokenizer(input, dictionary, offset).skipWhitespace();
        }
    }

由这段代码可知,忽略的token主要包括:

  1. 空格,如下图所示:

    anmazhisqljiexi_cifafenxi_2.png

    SQL中的空格

  2. hint与后面的空格,例如MySQL的hint语法为/*! hint info */&quot;SELECT /*!40001 SQL_CACHE */ o.* FROM t_order o&quot;这条SQL有hint/*!40001 SQL_CACHE */;(Oracle的hint语法有所不同,通过OracleLexer.java中的isHintBegin()可知,Oracle的hint语法为/*+ hint info */);
  3. 注释与后面的空格,,参考sharding-jdbc源码可知注释语法有3种://--/*,这三种注释的处理有所不同,//--被认为是单行注释(isSingleLineCommentBegin()),sharding-jdbc会直接通过当前一整行;而/*被认为是多行注释(isMultipleLineCommentBegin()),sharding-jdbc会直接掉到*/后面,例如MySQL的注释语法为&quot; /*parse explain*/SELECT o.* FROM t_order o&quot;这条SQL有注释/*parse explain*/

判断是否为注释的源码如下:

  protected boolean isCommentBegin() {
        char current = getCurrentChar(0);
        char next = getCurrentChar(1);
        return '/' == current && '/' == next || '-' == current && '-' == next || '/' == current && '*' == next;
    }

nextToken()分析

由于接下来的SQL解析都会调用这个nextToken()方法,所以为了更好的分析SQL解析过程,接下来详细剖析它的逻辑,由其源码可知,其逻辑主要分为两个部分:

  1. 调用skipIgnoredToken()跳过忽略的token(上面已经分析了哪些属于忽略的token)
  2. 调用is***Begin()方法判断类型然后构造Token;is***Begin()主要有下面提到的这些:
  • isVariableBegin()--是否变量开头,即@,例如这种SQL:select @a from dual(连续两个@符号即@@也是可以的),其中a是一个定义的变量;select @a from dual这条SQL解析到@的时候,得到的token为{type:Literals.VARIABLE, literals:@a, endPostion:9}(这个token的endPostion就是@a后面的位置)
  • isNCharBegin()--SQLServer的特殊语法,其他数据库都不支持。例如INSERT INTO employees
    VALUES(N’29730′, N’Philippe’, N’Horsford’, 20, 1),申明字符串为nvarchar类型;
  • isIdentifierBegin() -- 是否标识符开头,即az,AZ,`,_,$;例如这种SQL:select user_id from t_user limit 1,解析select的时候,得到的token为{type:DefaultKeyword.SELECT, literals:SELECT, endPostion:6};或者这种SQL:select `user_id` from t_user limit 1,解析`user_id`的时候,得到的token为{type:Literals.IDENTIFIER, literals:`user_id`, endPostion:16}
  • isHexDecimalBegin() -- 是否16进程符号开头,即0x。例如这种SQL:select 0x21 from dual,解析0x21的时候,得到的token为{type:Literals.HEX, literals:0x21, endPostion:11}
  • isNumberBegin() -- 是否数字开头,即0~9,例如这种SQL:select ‘afei’ from t_user limit 1,limit 1这个1就是数字,解析到limit后面的1的时候,得到的token为{type:Literals.INT, literals:1, endPostion:33}
  • isSymbolBegin() -- 是否特殊符号开头,例如这种SQL:select `user_id` from t_user limit ?,,解析?的时候,得到的token为{type:Symbol.QUESTION, literals:?, endPostion:36}
  • isCharsBegin() -- 是否字符开头,即单引号或者双引号,例如这种SQL:select ‘afei’ from t_user limit 1,解析 `afei`的时候,得到的token为{type:Literals.CHARS, literals:afei, endPostion:13}
  • isEnd() -- 是否SQL尾部,判断条件是offset >= input.length(),即遍历位置offset是否到了sql(input就是sql)尾部。得到的token为{type:Assist.END, literals:"", endPostion:31}

nextToken()的解析非常重要,其调用贯穿在整个sharding-jdbc的SQL解析过程中;根据这段分析逻辑就能得出文章前面词法分析结果表格了。

3. 得到SQL解析器

对应的源码是SQLParserFactory.newInstance(dbType, lexerEngine.getCurrentToken().getType(), shardingRule, lexerEngine)lexerEngine.getCurrentToken().getType()就是上面解析得到的第一个token的类型,核心实现源码如下:

  @NoArgsConstructor(access = AccessLevel.PRIVATE)
    public final class SQLParserFactory {

        public static SQLParser newInstance(final DatabaseType dbType, final TokenType tokenType, final ShardingRule shardingRule, final LexerEngine lexerEngine) {
            // 第一个token类型一定是默认关键词,否则抛出异常。构造这种异常很简单,只需要定义的SQL以MySQLKeyword中的关键词开头即可,例如"show create table t_order o"
            if (!(tokenType instanceof DefaultKeyword)) {
                throw new SQLParsingUnsupportedException(tokenType);
            }
            // 根据第一个token类型得到具体解析器,且第一个token一定是:select,insert,update,delete,create,alter,drop,truncate中的一个,否则会抛出SQLParsingUnsupportedException异常。构造这种异常很简单,只需要定义的sql以DefaultKeyword中的关键词开头,且不是下面枚举的关键词即可,例如"DATABASE SELECT o.* FROM t_order o"
            switch ((DefaultKeyword) tokenType)  {
                // 从这里可知,为什么前面要调用lexerEngine.nextToken()获取第一个token,SQLParserFactory根据这个token才能确实哪种类型的SQL解析器
                case SELECT:
                    return SelectParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case INSERT:
                    return InsertParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case UPDATE:
                    return UpdateParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case DELETE:
                    return DeleteParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case CREATE:
                    return CreateParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case ALTER:
                    return AlterParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case DROP:
                    return DropParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                case TRUNCATE:
                    return TruncateParserFactory.newInstance(dbType, shardingRule, lexerEngine);
                default:
                    throw new SQLParsingUnsupportedException(lexerEngine.getCurrentToken().getType());
            }
        }
    }

从上面的代码可知,得到的SQL解析器的一些主要属性有:

  1. 数据库类型dbType;
  2. 分库分表规则shardingRule;
  3. 词法分析器引擎lexerEngine;

lexerEngine的属性为Lexer lexer,它的一些核心属性在上面有分析过:SQL语句input,包含SQL关键词的字典dictionary,SQL解析位置偏移量offset,当前解析得到的词令currentToken;

4. SQL解析

这篇文章分析了sharding-jdbc中SQL解析的准备工作,下一篇文章将详细分析insert(增),delete(删),update(改),select(查),等SQL语句的解析过程;

作者:阿飞的博客

来源:https://www.jianshu.com/p/3c6138b0426d


JS中文网,Javascriptc中文网是中国领先的新一代开发者社区和专业的技术媒体,一个帮助开发者成长的社区,是给开发者用的 Hacker News,技术文章由为你筛选出最优质的干货,其中包括:Android、iOS、前端、后端等方面的内容。目前已经覆盖和服务了超过 300 万开发者,你每天都可以在这里找到技术世界的头条内容。

本文著作权归作者所有,如若转载,请注明出处

转载请注明:文章转载自「 Java极客技术学习 」https://www.javajike.com

标题:21.sharding-jdbc源码之SQL解析-词法分析

链接:https://www.javajike.com/article/1877.html

« 22.sharding-jdbc源码之INSERT解析
18. sharding-jdbc源码之复杂路由实现»

相关推荐

QR code