HSQLDB源码阅读 （四）SQL编译（上）

上篇在Session.java中

Statement cs = parser.compileStatement(ResultProperties.defaultPropsValue)

本来服务器端完全不知道客户端想要做什么事情，是要查询某个表的数据，还是更新哪条记录，还是要创建一个表，经过parser对象的处理之后，服务器端就能明白客户端到底要做什么了。

今天，我们就来深入看parser这个对象，是怎么做的。

 

在compileStatement之前，其实先调用了reset(String sql) ，有什么作用呢？基本上就是要通知各部门准备，下一个要编译的sql变成这个，该复位的复位。——因为每一个Session对象中有一个parser对象，而不是来一个sql，new一个parser。

在ParserDDL.java中，reset如下

void reset(String sql) {
        super.reset(sql);
}

[不过这里个人感觉，只是调用super.reset(sql)的话，好像没有必要写个方法哦]

在ParserDDL的父类ParserDQL.java，reset如下：

void reset(String sql) {

        super.reset(sql);
        compileContext.reset();

        lastError = null;
    }

这里做了一个清除工作（复归没有编译的状态）

在ParserDQL的父类ParserBase.java中，reset如下：

void reset(String sql) {

        scanner.reset(sql);

        //
        parsePosition = 0;
        isCheckOrTriggerCondition = false;
        isSchemaDefinition = false;
        isRecording = false;
        recordedStatement = null;
    }

scanner.reset

public void reset(String sql) {

        sqlString = sql;
        currentPosition = 0;
        tokenPosition = 0;
        limit = sqlString.length();
        hasNonSpaceSeparator = false;
        eolPosition = -1;
        lineNumber = 1;

        token.reset();

        token.tokenType = Tokens.X_STARTPARSE;
    }

token.reset

void reset() {

        tokenString = "";
        tokenType = Tokens.X_UNKNOWN_TOKEN;
        dataType = null;
        tokenValue = null;
        namePrefix = null;
        namePrePrefix = null;
        namePrePrePrefix = null;
        charsetSchema = null;
        charsetName = null;
        fullString = null;
        lobMultiplierType = Tokens.X_UNKNOWN_TOKEN;
        isDelimiter = false;
        isDelimitedIdentifier = false;
        isDelimitedPrefix = false;
        isDelimitedPrePrefix = false;
        isDelimitedPrePrePrefix = false;
        isUndelimitedIdentifier = false;
        hasIrregularChar = false;
        isReservedIdentifier = false;
        isCoreReservedIdentifier = false;
        isHostParameter = false;
        isMalformed = false;

        //
        expression = null;
        hasColumnList = false;
    }

哎呀，终于把该复位的都复位了。为什么不直接new 一个parser对象呢？从以上也可以看到，要操作的字段也挺多，我的理解，如果new的成本比逐一复位成本要高吧。

 

裤子都脱了不能只看reset就完事了啊，真正的实质还没开始呢，下面就进入compile

Statement compileStatement(int props) {

        Statement cs = compilePart(props);

        if (token.tokenType == Tokens.X_ENDPARSE) {
            if (cs.getSchemaName() == null) {
                cs.setSchemaHsqlName(session.getCurrentSchemaHsqlName());
            }

            return cs;
        }

        throw unexpectedToken();
    }

代码不难懂，直接进入compilePart:

private Statement compilePart(int props) {

        Statement cs;

        compileContext.reset();
        setParsePosition(getPosition());

        if (token.tokenType == Tokens.X_STARTPARSE) {
            read();
        }

        //此处先省略100多行处理内容

        return cs;
    }

我们这里先不看省略的100多行，进到 read：

void read() {

        scanner.scanNext();
        //malformed：畸形的
        if (token.isMalformed) {
            int errorCode = -1;
            //错误代码处理，略
            switch (token.tokenType) {

            }

            throw Error.error(errorCode, token.getFullString());
        }

        if (isRecording) {
            Token dup = token.duplicate();

            dup.position = scanner.getTokenPosition();

            recordedStatement.add(dup);
        }
    }

这里主体工作在scanNext：

public void scanNext() {

        if (currentPosition == limit) {
            resetState();

            token.tokenType = Tokens.X_ENDPARSE;

            return;
        }

        if (scanSeparator()) {

//            token.isDelimiter = true;
        }

        if (currentPosition == limit) {
            resetState();

            token.tokenType = Tokens.X_ENDPARSE;

            return;
        }

        boolean needsDelimiter = !token.isDelimiter;

        scanToken();

        if (needsDelimiter && !token.isDelimiter) {

//            token.tokenType = Token.X_UNKNOWN_TOKEN;
        }

        if (token.isMalformed) {
            token.fullString = getPart(tokenPosition, currentPosition);
        }
    }

currentPosition == limit, limit就是指字符串的长度，表明当前位置已到最后，则当然是结束了。而scanSeparator()，则是忽略掉空格制表符等分隔符号。

所以该函数的本质内容在scanToken。

scanToken的全文内容就不在此贴了，相当长。这里我挑一些代表性的代码，贴出来：

case '[' :
                token.tokenString = Tokens.T_LEFTBRACKET;
                token.tokenType = Tokens.LEFTBRACKET;

                currentPosition++;

                token.isDelimiter = true;

                return;

这种类型，就是一个字符，代表一个token的处理过程，设置token的类型，以及字符串，然后将扫描位置往后移动。

case '<' :
                if (charAt(currentPosition + 1) == '>') {
                    token.tokenString = Tokens.T_NOT_EQUALS;
                    token.tokenType = Tokens.NOT_EQUALS;
                    currentPosition += 2;
                    token.isDelimiter = true;

                    return;
                }

                if (charAt(currentPosition + 1) == '=') {
                    token.tokenString = Tokens.T_LESS_EQUALS;
                    token.tokenType = Tokens.LESS_EQUALS;
                    currentPosition += 2;
                    token.isDelimiter = true;

                    return;
                }

                token.tokenString = Tokens.T_LESS;
                token.tokenType = Tokens.LESS;

                currentPosition++;

                token.isDelimiter = true;

                return;

这代表来另一种类型，本身单独一个字符，能作为一个token，但是如果后面跟着某些特定的字符时，又是另外的Token

 

case 'b' :
            case 'B' :
                if (charAt(currentPosition + 1) == '\'') {
                    currentPosition++;

                    scanBitString();

                    if (token.isMalformed) {
                        return;
                    }

                    token.dataType = BitType.getBitType(
                        Types.SQL_BIT,
                        ((BinaryData) token.tokenValue).bitLength(null));
                    token.tokenType = Tokens.X_VALUE;

                    return;
                }
                break;

以某些字母开头，可能会是关键字，又可能是一个普通的标识符，如bit是一种数据类型，但bxxxx，则是一个标识符。

scanIdentifierChain();
setIdentifierProperties();

在处理了所有特殊的地方之后，做为标识符读取。

Scanner.java文件行数有2500多行，功能就是将字符串分成一个个的Token（Token流）。之所以这么“庞大”，是由HSQLDB支持的SQL功能决定的：功能性包括支持的sql语句、关键字的数量、数据类型的数量，这个在scanner里需要一一区分出来。

这个过程是编译的第一步叫：词法分析。

本篇先到这里，本文主要分析了编译的准备工作，以及SQL语句词法分析过程。

[相关源码文件]

Session.java

ParserCommand.java[及其父类：ParserDDL.java、ParserDML.java、ParserDQL.java、ParserBase.java]

Scanner.java