Java 类java.sql.SQLSyntaxErrorException 实例源码

/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1);
    SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2");
    SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}

public RouteResultset routeSystemInfo(SchemaConfig schema, int sqlType,
        String stmt, RouteResultset rrs) throws SQLSyntaxErrorException {
    switch(sqlType){
    case ServerParse.SHOW:// if origSQL is like show tables
        return analyseShowSQL(schema, rrs, stmt);
    case ServerParse.SELECT://if origSQL is like select @@
        if(stmt.contains("@@")){
            return analyseDoubleAtSgin(schema, rrs, stmt);
        }
        break;
    case ServerParse.DESCRIBE:// if origSQL is meta SQL, such as describe table
        int ind = stmt.indexOf(' ');
        stmt = stmt.trim();
        return analyseDescrSQL(schema, rrs, stmt, ind + 1);
    }
    return null;
}

/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1);
    SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2");
    SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}

/**
 * tableRule tag:
 * <tableRule name="sharding-by-month">
 * <rule>
 * <columns>create_date</columns>
 * <algorithm>partbymonth</algorithm>
 * </rule>
 * </tableRule>
 *
 * @param root
 * @throws SQLSyntaxErrorException
 */
private void loadTableRules(Element root) throws SQLSyntaxErrorException {
    NodeList list = root.getElementsByTagName("tableRule");
    for (int i = 0, n = list.getLength(); i < n; ++i) {
        Node node = list.item(i);
        if (node instanceof Element) {
            Element e = (Element) node;
            String name = e.getAttribute("name");
            if (StringUtil.isEmpty(name)) {
                throw new ConfigException("name is null or empty");
            }
            if (tableRules.containsKey(name)) {
                throw new ConfigException("table rule " + name + " duplicated!");
            }
            NodeList ruleNodes = e.getElementsByTagName("rule");
            int length = ruleNodes.getLength();
            if (length > 1) {
                throw new ConfigException("only one rule can defined :" + name);
            }
            //rule has only one element now. Maybe it will not contains one rule in feature
            //RuleConfig:rule->function
            RuleConfig rule = loadRule((Element) ruleNodes.item(0));
            tableRules.put(name, new TableRuleConfig(name, rule));
        }
    }
}

private RuleConfig loadRule(Element element) throws SQLSyntaxErrorException {
    Element columnsEle = ConfigUtil.loadElement(element, "columns");
    String column = columnsEle.getTextContent();
    if (StringUtil.isEmpty(column)) {
        throw new ConfigException("no rule column is found");
    }
    String[] columns = SplitUtil.split(column, ',', true);
    if (columns.length > 1) {
        throw new ConfigException("table rule coulmns has multi values:" +
                columnsEle.getTextContent());
    }
    Element algorithmEle = ConfigUtil.loadElement(element, "algorithm");
    String algorithmName = algorithmEle.getTextContent();

    if (StringUtil.isEmpty(algorithmName)) {
        throw new ConfigException("algorithm is null or empty");
    }
    AbstractPartitionAlgorithm algorithm = functions.get(algorithmName);
    if (algorithm == null) {
        throw new ConfigException("can't find function of name :" + algorithmName);
    }
    return new RuleConfig(column.toUpperCase(), algorithmName, algorithm);
}

@Override
public SQLStatement parserSQL(String originSql) throws SQLSyntaxErrorException {
    SQLStatementParser parser = new MySqlStatementParser(originSql);

    /**
     * thrown SQL SyntaxError if parser error
     */
    try {
        List<SQLStatement> list = parser.parseStatementList();
        if (list.size() > 1) {
            throw new SQLSyntaxErrorException("MultiQueries is not supported,use single query instead ");
        }
        return list.get(0);
    } catch (Exception t) {
        LOGGER.info("routeNormalSqlWithAST", t);
        if (t.getMessage() != null) {
            throw new SQLSyntaxErrorException(t.getMessage());
        } else {
            throw new SQLSyntaxErrorException(t);
        }
    }
}

/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1);
    SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2");
    SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}

@Test
public void hasIpv6_falseWhenKnownSQLState() throws SQLException {
  SQLSyntaxErrorException sqlException = new SQLSyntaxErrorException(
      "Unknown column 'zipkin_annotations.endpoint_ipv6' in 'field list'",
      "42S22", 1054);
  DataSource dataSource = mock(DataSource.class);

  // cheats to lower mock count: this exception is really thrown during execution of the query
  when(dataSource.getConnection()).thenThrow(
      new DataAccessException(sqlException.getMessage(), sqlException));

  Boolean result = MySQLStorage.builder()
      .executor(Runnable::run)
      .datasource(dataSource)
      .build().hasIpv6.get();

  assertThat(result).isFalse();
}

/**
 * This returns false instead of failing when the SQLState code doesn't imply the column is
 * missing. This is to prevent zipkin from crashing due to scenarios we haven't thought up, yet.
 * The root error goes into the log in this case.
 */
@Test
public void hasIpv6_falseWhenUnknownSQLState() throws SQLException {
  SQLSyntaxErrorException sqlException = new SQLSyntaxErrorException(
      "java.sql.SQLSyntaxErrorException: Table 'zipkin.zipkin_annotations' doesn't exist",
      "42S02", 1146);
  DataSource dataSource = mock(DataSource.class);

  // cheats to lower mock count: this exception is really thrown during execution of the query
  when(dataSource.getConnection()).thenThrow(
      new DataAccessException(sqlException.getMessage(), sqlException));

  Boolean result = MySQLStorage.builder()
      .executor(Runnable::run)
      .datasource(dataSource)
      .build().hasIpv6.get();

  assertThat(result).isFalse();
}

@Test
public void hasDependencies_missing() throws SQLException {
  SQLSyntaxErrorException sqlException = new SQLSyntaxErrorException(
      "SQL [select count(*) from `zipkin_dependencies`]; Table 'zipkin.zipkin_dependencies' doesn't exist\n"
          + "  Query is : select count(*) from `zipkin_dependencies`",
      "42S02", 1146);
  DataSource dataSource = mock(DataSource.class);

  // cheats to lower mock count: this exception is really thrown during execution of the query
  when(dataSource.getConnection()).thenThrow(
      new DataAccessException(sqlException.getMessage(), sqlException));

  Boolean result = MySQLStorage.builder()
      .executor(Runnable::run)
      .datasource(dataSource)
      .build().hasPreAggregatedDependencies.get();

  assertThat(result).isFalse();
}

/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1);
    SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2");
    SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}

/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1);
    SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2");
    SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}

public void execute(String sql, int type) {
    if (!TimoServer.getInstance().isOnline()) {
        writeErrMessage(ErrorCode.ER_ACCESS_DENIED_ERROR, "Timo-server is offline");
        return;
    }
    Database database = checkDB();
    if (database == null) {
        return;
    }
    Outlets out = null;
    try {
        out = Router.route(database, sql, this.getCharset(), type);
    } catch (SQLSyntaxErrorException e) {
        String msg = e.getMessage();
        writeErrMessage(ErrorCode.ER_PARSE_ERROR,
                msg == null ? e.getClass().getSimpleName() : msg);
        return;
    }
    chooseSession(out, type);
    session.execute(out, type);
}

/**
 * @return index of expected token, start from 0
 * @throws SQLSyntaxErrorException if no token is matched
 */
protected int matchIdentifier(String... expectTextUppercase) throws SQLSyntaxErrorException {
    if (expectTextUppercase == null || expectTextUppercase.length <= 0)
        throw new IllegalArgumentException("at least one expect token");
    if (lexer.token() != MySQLToken.IDENTIFIER) {
        throw err("expect an id");
    }
    String id = lexer.stringValueUppercase();
    for (int i = 0; i < expectTextUppercase.length; ++i) {
        if (id == null ? expectTextUppercase[i] == null : id.equals(expectTextUppercase[i])) {
            lexer.nextToken();
            return i;
        }
    }
    throw err("expect " + expectTextUppercase);
}

/**
 * @param quoteMode if false: first <code>0x</code> has been skipped; if true: first
 *        <code>x'</code> has been skipped
 */
protected void scanHexaDecimal(boolean quoteMode) throws SQLSyntaxErrorException {
    offsetCache = curIndex;
    for (; CharTypes.isHex(ch); scanChar());

    sizeCache = curIndex - offsetCache;
    // if (sizeCache <= 0) {
    // throw err("expect at least one hexdigit");
    // }
    if (quoteMode) {
        if (ch != '\'') {
            throw err("invalid char for hex: " + ch);
        }
        scanChar();
    } else if (CharTypes.isIdentifierChar(ch)) {
        scanIdentifierFromNumber(offsetCache - 2, sizeCache + 2);
        return;
    }

    token = MySQLToken.LITERAL_HEX;
}

/**
 * first <code>@@</code> is included
 */
protected void scanSystemVariable() throws SQLSyntaxErrorException {
    if (ch != '@' || sql[curIndex + 1] != '@') throw err("first char must be @@");
    offsetCache = curIndex + 2;
    sizeCache = 0;
    scanChar(2);
    if (ch == '`') {
        for (++sizeCache;; ++sizeCache) {
            if (scanChar() == '`') {
                ++sizeCache;
                if (scanChar() != '`') {
                    break;
                }
            }
        }
    } else {
        for (; CharTypes.isIdentifierChar(ch); ++sizeCache) {
            scanChar();
        }
    }
    updateStringValue(sql, offsetCache, sizeCache);
    token = MySQLToken.SYS_VAR;
}

/**
 * @return null if there is no hint
 */
private List<IndexHint> hintList() throws SQLSyntaxErrorException {
    IndexHint hint = hint();
    if (hint == null)
        return null;
    List<IndexHint> list;
    IndexHint hint2 = hint();
    if (hint2 == null) {
        list = new ArrayList<IndexHint>(1);
        list.add(hint);
        return list;
    }
    list = new LinkedList<IndexHint>();
    list.add(hint);
    list.add(hint2);
    for (; (hint2 = hint()) != null; list.add(hint2))
        ;
    return list;
}

/**
 * @return argument itself if there is no union
 */
protected DMLQueryStatement buildUnionSelect(DMLSelectStatement select)
        throws SQLSyntaxErrorException {
    if (lexer.token() != KW_UNION) {
        return select;
    }
    DMLSelectUnionStatement union = new DMLSelectUnionStatement(select);
    for (; lexer.token() == KW_UNION;) {
        lexer.nextToken();
        boolean isAll = false;
        switch (lexer.token()) {
            case KW_ALL:
                isAll = true;
            case KW_DISTINCT:
                lexer.nextToken();
                break;
            default:
                break;
        }
        select = selectPrimary();
        union.addSelect(select, isAll);
    }
    union.setOrderBy(orderBy()).setLimit(limit());
    return union;
}

@Test
public void testInsertSQLWithAutoIncrement() throws SQLSyntaxErrorException {
    Identifier columnAutoIncrementColumn = new Identifier(null, "id");
    String sql = null;
    SQLStatement ast = null;
    DMLInsertStatement parsInf = null;
    sql = "insert into table1(name1,name2,id)  values ('1','2',10) ";
    ast = SQLParserDelegate.parse(sql);
    parsInf = (DMLInsertStatement) (ast);
    enrichAutoIncrementColumn(columnAutoIncrementColumn, parsInf);

    StringBuilder sb = new StringBuilder();
    OutputVisitor visitor = new OutputVisitor(sb, false);
    parsInf.accept(visitor);
    System.out.println(sb.toString());
    Assert.assertEquals("table1".toUpperCase(), parsInf.getTable().getIdTextUpUnescape());
    Assert.assertNotNull(parsInf.getColumnNameList());
}

private String getStringValue() throws SQLSyntaxErrorException {
    String name;
    switch (lexer.token()) {
        case IDENTIFIER:
            name = Identifier.unescapeName(lexer.stringValue());
            lexer.nextToken();
            return name;
        case LITERAL_CHARS:
            name = lexer.stringValue();
            name = LiteralString.getUnescapedString(name.substring(1, name.length() - 1));
            lexer.nextToken();
            return name;
        default:
            throw err("unexpected token: " + lexer.token());
    }
}

public MySQLLexer(char[] sql) throws SQLSyntaxErrorException{
    if ((this.sbuf = sbufRef.get()) == null) {
        this.sbuf = new char[1024];
        sbufRef.set(this.sbuf);
    }
    if (CharTypes.isWhitespace(sql[sql.length - 1])) {
        this.sql = sql;
    } else {
        this.sql = new char[sql.length + 1];
        System.arraycopy(sql, 0, this.sql, 0, sql.length);
    }
    this.eofIndex = this.sql.length - 1;
    this.sql[this.eofIndex] = MySQLLexer.EOI;
    scanChar();
    nextToken();
}

/**
 * first <code>'('</code> has been consumed. At least one element. Consume
 * last ')' after invocation <br/>
 * <code>'(' expr (',' expr)* ')'</code>
 */
private List<Expression> expressionList(List<Expression> exprList) throws SQLSyntaxErrorException {
    for (;;) {
        Expression expr = expression();
        exprList.add(expr);
        switch (lexer.token()) {
            case PUNC_COMMA:
                lexer.nextToken();
                break;
            case PUNC_RIGHT_PAREN:
                lexer.nextToken();
                return exprList;
            default:
                throw err("unexpected token: " + lexer.token());
        }
    }
}

protected List<RowExpression> rowList() throws SQLSyntaxErrorException {
    List<RowExpression> valuesList;
    List<Expression> tempRowValue = rowValue();
    if (lexer.token() == PUNC_COMMA) {
        valuesList = new LinkedList<RowExpression>();
        valuesList.add(new RowExpression(tempRowValue));
        for (; lexer.token() == PUNC_COMMA;) {
            lexer.nextToken();
            tempRowValue = rowValue();
            valuesList.add(new RowExpression(tempRowValue));
        }
    } else {
        valuesList = new ArrayList<RowExpression>(1);
        valuesList.add(new RowExpression(tempRowValue));
    }
    return valuesList;
}

private Expression anyAllExpression() throws SQLSyntaxErrorException {
    QueryExpression subquery = null;
    switch (lexer.token()) {
        case KW_ALL:
            lexer.nextToken();
            match(PUNC_LEFT_PAREN);
            subquery = subQuery();
            match(PUNC_RIGHT_PAREN);
            return new SubqueryAllExpression(subquery).setCacheEvalRst(cacheEvalRst);
        default:
            int matchIndex = equalsIdentifier("SOME", "ANY");
            if (matchIndex < 0) {
                return bitOrExpression(null, null);
            }
            String consumed = lexer.stringValue();
            String consumedUp = lexer.stringValueUppercase();
            if (lexer.nextToken() == PUNC_LEFT_PAREN) {
                lexer.nextToken();
                subquery = subQuery();
                match(PUNC_RIGHT_PAREN);
                return new SubqueryAnyExpression(subquery).setCacheEvalRst(cacheEvalRst);
            }
            return bitOrExpression(consumed, consumedUp);
    }
}

/**
 * <code>higherExpr ( ('+'|'-') higherExpr)+</code>
 */
private Expression arithmeticTermOperatorExpression(String consumed, String consumedUp)
        throws SQLSyntaxErrorException {
    Expression temp;
    for (Expression expr = arithmeticFactorOperatorExpression(consumed, consumedUp);;) {
        switch (lexer.token()) {
            case OP_PLUS:
                lexer.nextToken();
                temp = arithmeticFactorOperatorExpression(null, null);
                expr = new ArithmeticAddExpression(expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            case OP_MINUS:
                lexer.nextToken();
                temp = arithmeticFactorOperatorExpression(null, null);
                expr = new ArithmeticSubtractExpression(expr, temp)
                        .setCacheEvalRst(cacheEvalRst);
                break;
            default:
                return expr;
        }
    }
}

/**
 * <code>higherExpr ('^' higherExpr)+</code>
 */
private Expression bitXORExpression(String consumed, String consumedUp)
        throws SQLSyntaxErrorException {
    Expression temp;
    for (Expression expr = unaryOpExpression(consumed, consumedUp);;) {
        switch (lexer.token()) {
            case OP_CARET:
                lexer.nextToken();
                temp = unaryOpExpression(null, null);
                expr = new BitXORExpression(expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            default:
                return expr;
        }
    }
}

/**
 * <code>higherExpr ( ('+'|'-') higherExpr)+</code>
 */
private Expression arithmeticTermOperatorExpression(String consumed, String consumedUp)
                                                                                       throws SQLSyntaxErrorException {
    Expression temp;
    for (Expression expr = arithmeticFactorOperatorExpression(consumed, consumedUp);;) {
        switch (lexer.token()) {
            case OP_PLUS:
                lexer.nextToken();
                temp = arithmeticFactorOperatorExpression(null, null);
                expr = new ArithmeticAddExpression(expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            case OP_MINUS:
                lexer.nextToken();
                temp = arithmeticFactorOperatorExpression(null, null);
                expr = new ArithmeticSubtractExpression(expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            default:
                return expr;
        }
    }
}

private Expression anyAllExpression() throws SQLSyntaxErrorException {
    QueryExpression subquery = null;
    switch (lexer.token()) {
        case KW_ALL:
            lexer.nextToken();
            match(PUNC_LEFT_PAREN);
            subquery = subQuery();
            match(PUNC_RIGHT_PAREN);
            return new SubqueryAllExpression(subquery).setCacheEvalRst(cacheEvalRst);
        default:
            int matchIndex = equalsIdentifier("SOME", "ANY");
            if (matchIndex < 0) {
                return bitOrExpression(null, null);
            }
            String consumed = lexer.stringValue();
            String consumedUp = lexer.stringValueUppercase();
            if (lexer.nextToken() == PUNC_LEFT_PAREN) {
                lexer.nextToken();
                subquery = subQuery();
                match(PUNC_RIGHT_PAREN);
                return new SubqueryAnyExpression(subquery).setCacheEvalRst(cacheEvalRst);
            }
            return bitOrExpression(consumed, consumedUp);
    }
}

/**
 * @return never empty. upper-case if id format. <code>"alias1" |"`al`ias1`" | "'alias1'" | "_latin1'alias1'"</code>
 */
protected String as() throws SQLSyntaxErrorException {
    if (lexer.token() == KW_AS) {
        lexer.nextToken();
    }
    StringBuilder alias = new StringBuilder();
    boolean id = false;
    if (lexer.token() == IDENTIFIER) {
        alias.append(lexer.stringValueUppercase());
        id = true;
        lexer.nextToken();
    }
    if (lexer.token() == LITERAL_CHARS) {
        if (!id || id && alias.charAt(0) == '_') {
            alias.append(lexer.stringValue());
            lexer.nextToken();
        }
    }
    return alias.length() > 0 ? alias.toString() : null;
}

public MySQLLexer(char[] sql) throws SQLSyntaxErrorException {
    if ((this.sbuf = sbufRef.get()) == null) {
        this.sbuf = new char[1024];
        sbufRef.set(this.sbuf);
    }
    if (CharTypes.isWhitespace(sql[sql.length - 1])) {
        this.sql = sql;
    } else {
        this.sql = new char[sql.length + 1];
        System.arraycopy(sql, 0, this.sql, 0, sql.length);
    }
    this.eofIndex = this.sql.length - 1;
    this.sql[this.eofIndex] = MySQLLexer.EOI;
    scanChar();
    nextToken();
}

/**
 * <code>higherPRJExpr ( ('AND'|'&&') higherPRJExpr )*</code>
 * 
 * @throws SQLSyntaxErrorException
 */
private Expression logicalAndExpression() throws SQLSyntaxErrorException {
    LogicalAndExpression and = null;
    for (Expression expr = logicalNotExpression();;) {
        switch (lexer.token()) {
            case OP_LOGICAL_AND:
            case KW_AND:
                lexer.nextToken();
                if (and == null) {
                    and = new LogicalAndExpression();
                    and.setCacheEvalRst(cacheEvalRst);
                    and.appendOperand(expr);
                    expr = and;
                }
                Expression newExpr = logicalNotExpression();
                and.appendOperand(newExpr);
                break;
            default:
                return expr;
        }
    }
}

private String getStringValue() throws SQLSyntaxErrorException {
    String name;
    switch (lexer.token()) {
        case IDENTIFIER:
            name = Identifier.unescapeName(lexer.stringValue());
            lexer.nextToken();
            return name;
        case LITERAL_CHARS:
            name = lexer.stringValue();
            name = LiteralString.getUnescapedString(name.substring(1, name.length() - 1));
            lexer.nextToken();
            return name;
        default:
            throw err("unexpected token: " + lexer.token());
    }
}

public void testSavepint() throws SQLSyntaxErrorException {
    String sql = "  savepoint 123e123e";
    MySQLMTSParser parser = new MySQLMTSParser(new MySQLLexer(sql));
    MTSSavepointStatement savepoint = parser.savepoint();
    String output = output2MySQL(savepoint, sql);
    Assert.assertEquals("SAVEPOINT 123e123e", output);
    Assert.assertEquals("123e123e", savepoint.getSavepoint().getIdText());

    sql = "  savepoint SAVEPOINT";
    parser = new MySQLMTSParser(new MySQLLexer(sql));
    savepoint = parser.savepoint();
    output = output2MySQL(savepoint, sql);
    Assert.assertEquals("SAVEPOINT SAVEPOINT", output);
    Assert.assertEquals("SAVEPOINT", savepoint.getSavepoint().getIdText());

    sql = "  savepoInt `select`";
    parser = new MySQLMTSParser(new MySQLLexer(sql));
    savepoint = parser.savepoint();
    output = output2MySQL(savepoint, sql);
    Assert.assertEquals("SAVEPOINT `select`", output);
    Assert.assertEquals("`select`", savepoint.getSavepoint().getIdText());
}

/**
 * reload schema
 * 
 * @return
 * @throws SQLSyntaxErrorException
 */
public SQLStatement reload() throws SQLSyntaxErrorException {
    lexer.nextToken();

    switch (lexer.token()) {
    // case EOF:
    // return new
    // MTSRollbackStatement(MTSRollbackStatement.CompleteType.UN_DEF);
        case KW_SCHEMA:
            lexer.nextToken();

            match(EOF);
            return new ReloadSchema();

        default:
            throw err("unrecognized complete type: " + lexer.token());
    }
}

protected List<RowExpression> rowList() throws SQLSyntaxErrorException {
    List<RowExpression> valuesList;
    List<Expression> tempRowValue = rowValue();
    if (lexer.token() == PUNC_COMMA) {
        valuesList = new LinkedList<RowExpression>();
        valuesList.add(new RowExpression(tempRowValue));
        for (; lexer.token() == PUNC_COMMA;) {
            lexer.nextToken();
            tempRowValue = rowValue();
            valuesList.add(new RowExpression(tempRowValue));
        }
    } else {
        valuesList = new ArrayList<RowExpression>(1);
        valuesList.add(new RowExpression(tempRowValue));
    }
    return valuesList;
}

public MySQLLexer(char[] sql) throws SQLSyntaxErrorException{
    if ((this.sbuf = sbufRef.get()) == null) {
        this.sbuf = new char[1024];
        sbufRef.set(this.sbuf);
    }
    if (CharTypes.isWhitespace(sql[sql.length - 1])) {
        this.sql = sql;
    } else {
        this.sql = new char[sql.length + 1];
        System.arraycopy(sql, 0, this.sql, 0, sql.length);
    }
    this.eofIndex = this.sql.length - 1;
    this.sql[this.eofIndex] = MySQLLexer.EOI;
    scanChar();
    nextToken();
}

private List<Pair<Expression, String>> selectExprList() throws SQLSyntaxErrorException {
    Expression expr = exprParser.expression();
    String alias = as();
    List<Pair<Expression, String>> list;
    if (lexer.token() == PUNC_COMMA) {
        list = new LinkedList<Pair<Expression, String>>();
        list.add(new Pair<Expression, String>(expr, alias));
    } else {
        list = new ArrayList<Pair<Expression, String>>(1);
        list.add(new Pair<Expression, String>(expr, alias));
        return list;
    }
    for (; lexer.token() == PUNC_COMMA; list.add(new Pair<Expression, String>(expr, alias))) {
        lexer.nextToken();
        expr = exprParser.expression();
        alias = as();
    }
    return list;
}

public DMLDeleteStatement(boolean lowPriority, boolean quick, boolean ignore, List<Identifier> tableNameList,
                          TableReferences tableRefs, Expression whereCondition) throws SQLSyntaxErrorException{
    this.lowPriority = lowPriority;
    this.quick = quick;
    this.ignore = ignore;
    if (tableNameList == null || tableNameList.isEmpty()) {
        throw new IllegalArgumentException("argument 'tableNameList' is empty");
    } else if (tableNameList instanceof ArrayList) {
        this.tableNames = tableNameList;
    } else {
        this.tableNames = new ArrayList<Identifier>(tableNameList);
    }
    if (tableRefs == null) {
        throw new IllegalArgumentException("argument 'tableRefs' is null");
    }
    this.tableRefs = tableRefs;
    this.whereCondition = whereCondition;
    this.orderBy = null;
    this.limit = null;
}

private TableReference tableFactor() throws SQLSyntaxErrorException {
    String alias = null;
    switch (lexer.token()) {
        case PUNC_LEFT_PAREN:
            lexer.nextToken();
            Object ref = trsOrQuery();
            match(PUNC_RIGHT_PAREN);
            if (ref instanceof QueryExpression) {
                alias = as();
                return new SubqueryFactor((QueryExpression) ref, alias);
            }
            return (TableReferences) ref;
        case IDENTIFIER:
            Identifier table = identifier();
            alias = as();
            List<IndexHint> hintList = hintList();
            return new TableRefFactor(table, alias, hintList);
        default:
            throw err("unexpected token for tableFactor: " + lexer.token());
    }
}

/**
 * <code>higherExpr ( ('&lt;&lt;'|'&gt;&gt;') higherExpr)+</code>
 */
private Expression bitShiftExpression(String consumed, String consumedUp) throws SQLSyntaxErrorException {
    Expression temp;
    for (Expression expr = arithmeticTermOperatorExpression(consumed, consumedUp);;) {
        switch (lexer.token()) {
            case OP_LEFT_SHIFT:
                lexer.nextToken();
                temp = arithmeticTermOperatorExpression(null, null);
                expr = new BitShiftExpression(false, expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            case OP_RIGHT_SHIFT:
                lexer.nextToken();
                temp = arithmeticTermOperatorExpression(null, null);
                expr = new BitShiftExpression(true, expr, temp).setCacheEvalRst(cacheEvalRst);
                break;
            default:
                return expr;
        }
    }
}