Examples with Pair com.alibaba.cobar.parser.util.Pair used on opensource projects

Example 6 with Pair

use of com.alibaba.cobar.parser.util.Pair in project cobar by alibaba.

the class MySQLDMLInsertParser method onDuplicateUpdate.

/**
     * @return null for not exist
     */
private List<Pair<Identifier, Expression>> onDuplicateUpdate() throws SQLSyntaxErrorException {
    if (lexer.token() != KW_ON) {
        return null;
    }
    lexer.nextToken();
    matchIdentifier("DUPLICATE");
    match(KW_KEY);
    match(KW_UPDATE);
    List<Pair<Identifier, Expression>> list;
    Identifier col = identifier();
    match(OP_EQUALS, OP_ASSIGN);
    Expression expr = exprParser.expression();
    if (lexer.token() == PUNC_COMMA) {
        list = new LinkedList<Pair<Identifier, Expression>>();
        list.add(new Pair<Identifier, Expression>(col, expr));
        for (; lexer.token() == PUNC_COMMA; ) {
            lexer.nextToken();
            col = identifier();
            match(OP_EQUALS, OP_ASSIGN);
            expr = exprParser.expression();
            list.add(new Pair<Identifier, Expression>(col, expr));
        }
        return list;
    }
    list = new ArrayList<Pair<Identifier, Expression>>(1);
    list.add(new Pair<Identifier, Expression>(col, expr));
    return list;
}

Example 7 with Pair

use of com.alibaba.cobar.parser.util.Pair in project cobar by alibaba.

the class MySQLDMLParserTest method testGroupBy.

public void testGroupBy() throws SQLSyntaxErrorException {
    String sql = "group by c1 asc, c2 desc  , c3 with rollup";
    MySQLLexer lexer = new MySQLLexer(sql);
    MySQLDMLParser parser = getDMLParser(lexer);
    GroupBy groupBy = parser.groupBy();
    String output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC), new Pair<Expression, SortOrder>(new Identifier(null, "c2"), SortOrder.DESC), new Pair<Expression, SortOrder>(new Identifier(null, "c3"), SortOrder.ASC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1, c2 DESC, c3 WITH ROLLUP", output);
    sql = "group by c1 asc, c2 desc  , c3 ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    groupBy = parser.groupBy();
    output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC), new Pair<Expression, SortOrder>(new Identifier(null, "c2"), SortOrder.DESC), new Pair<Expression, SortOrder>(new Identifier(null, "c3"), SortOrder.ASC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1, c2 DESC, c3", output);
    sql = "group by c1   ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    groupBy = parser.groupBy();
    output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1", output);
    sql = "group by c1 asc  ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    groupBy = parser.groupBy();
    output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1", output);
    sql = "group by c1 desc  ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    groupBy = parser.groupBy();
    output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.DESC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1 DESC", output);
    sql = "group by c1 with rollup  ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    groupBy = parser.groupBy();
    output = output2MySQL(groupBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC)), groupBy.getOrderByList());
    Assert.assertEquals("GROUP BY c1 WITH ROLLUP", output);
}

Example 8 with Pair

use of com.alibaba.cobar.parser.util.Pair in project cobar by alibaba.

the class MySQLDMLParserTest method testOrderBy.

public void testOrderBy() throws SQLSyntaxErrorException {
    String sql = "order by c1 asc, c2 desc  , c3 ";
    MySQLLexer lexer = new MySQLLexer(sql);
    MySQLDMLParser parser = getDMLParser(lexer);
    OrderBy orderBy = parser.orderBy();
    String output = output2MySQL(orderBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC), new Pair<Expression, SortOrder>(new Identifier(null, "c2"), SortOrder.DESC), new Pair<Expression, SortOrder>(new Identifier(null, "c3"), SortOrder.ASC)), orderBy.getOrderByList());
    Assert.assertEquals("ORDER BY c1, c2 DESC, c3", output);
    sql = "order by c1   ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    orderBy = parser.orderBy();
    output = output2MySQL(orderBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC)), orderBy.getOrderByList());
    Assert.assertEquals("ORDER BY c1", output);
    sql = "order by c1 asc  ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    orderBy = parser.orderBy();
    output = output2MySQL(orderBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.ASC)), orderBy.getOrderByList());
    Assert.assertEquals("ORDER BY c1", output);
    sql = "order by c1 desc  ";
    lexer = new MySQLLexer(sql);
    parser = getDMLParser(lexer);
    orderBy = parser.orderBy();
    output = output2MySQL(orderBy, sql);
    ListUtil.isEquals(ListUtil.createList(new Pair<Expression, SortOrder>(new Identifier(null, "c1"), SortOrder.DESC)), orderBy.getOrderByList());
    Assert.assertEquals("ORDER BY c1 DESC", output);
}

Example 9 with Pair

use of com.alibaba.cobar.parser.util.Pair in project cobar by alibaba.

the class MySQLExprParser method startedFromIdentifier.

/**
     * last token consumed is {@link MySQLToken#IDENTIFIER}, MUST NOT be
     * <code>null</code>
     */
private Expression startedFromIdentifier(final String consumed, String consumedUp) throws SQLSyntaxErrorException {
    Expression tempExpr;
    Expression tempExpr2;
    List<Expression> tempExprList;
    String tempStr;
    StringBuilder tempSb;
    boolean tempGroupDistinct;
    switch(lexer.token()) {
        case PUNC_DOT:
            for (tempExpr = new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst); lexer.token() == PUNC_DOT; ) {
                switch(lexer.nextToken()) {
                    case IDENTIFIER:
                        tempExpr = new Identifier((Identifier) tempExpr, lexer.stringValue(), lexer.stringValueUppercase()).setCacheEvalRst(cacheEvalRst);
                        lexer.nextToken();
                        break;
                    case OP_ASTERISK:
                        lexer.nextToken();
                        return new Wildcard((Identifier) tempExpr).setCacheEvalRst(cacheEvalRst);
                    default:
                        throw err("expect IDENTIFIER or '*' after '.', but is " + lexer.token());
                }
            }
            return tempExpr;
        case LITERAL_BIT:
            if (consumed.charAt(0) != '_') {
                return new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst);
            }
            tempStr = lexer.stringValue();
            lexer.nextToken();
            return new LiteralBitField(consumed, tempStr).setCacheEvalRst(cacheEvalRst);
        case LITERAL_HEX:
            if (consumed.charAt(0) != '_') {
                return new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst);
            }
            LiteralHexadecimal hex = new LiteralHexadecimal(consumed, lexer.getSQL(), lexer.getOffsetCache(), lexer.getSizeCache(), charset);
            lexer.nextToken();
            return hex.setCacheEvalRst(cacheEvalRst);
        case LITERAL_CHARS:
            if (consumed.charAt(0) != '_') {
                return new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst);
            }
            tempSb = new StringBuilder();
            do {
                lexer.appendStringContent(tempSb);
            } while (lexer.nextToken() == LITERAL_CHARS);
            return new LiteralString(consumed, tempSb.toString(), false).setCacheEvalRst(cacheEvalRst);
        case PUNC_LEFT_PAREN:
            consumedUp = Identifier.unescapeName(consumedUp);
            switch(functionManager.getParsingStrategy(consumedUp)) {
                case GET_FORMAT:
                    // GET_FORMAT({DATE|TIME|DATETIME},
                    // {'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'})
                    lexer.nextToken();
                    int gfi = matchIdentifier("DATE", "TIME", "DATETIME", "TIMESTAMP");
                    match(PUNC_COMMA);
                    Expression getFormatArg = expression();
                    match(PUNC_RIGHT_PAREN);
                    switch(gfi) {
                        case 0:
                            return new GetFormat(GetFormat.FormatType.DATE, getFormatArg);
                        case 1:
                            return new GetFormat(GetFormat.FormatType.TIME, getFormatArg);
                        case 2:
                        case 3:
                            return new GetFormat(GetFormat.FormatType.DATETIME, getFormatArg);
                    }
                    throw err("unexpected format type for GET_FORMAT()");
                case CAST:
                    lexer.nextToken();
                    tempExpr = expression();
                    match(KW_AS);
                    Pair<String, Pair<Expression, Expression>> type = type4specialFunc();
                    match(PUNC_RIGHT_PAREN);
                    Pair<Expression, Expression> info = type.getValue();
                    if (info != null) {
                        return new Cast(tempExpr, type.getKey(), info.getKey(), info.getValue()).setCacheEvalRst(cacheEvalRst);
                    } else {
                        return new Cast(tempExpr, type.getKey(), null, null).setCacheEvalRst(cacheEvalRst);
                    }
                case POSITION:
                    lexer.nextToken();
                    tempExprList = new ArrayList<Expression>(2);
                    tempExprList.add(expression());
                    match(KW_IN);
                    tempExprList.add(expression());
                    match(PUNC_RIGHT_PAREN);
                    return new Locate(tempExprList).setCacheEvalRst(cacheEvalRst);
                case SUBSTRING:
                    lexer.nextToken();
                    tempExprList = new ArrayList<Expression>(3);
                    tempExprList.add(expression());
                    match(PUNC_COMMA, KW_FROM);
                    tempExprList.add(expression());
                    switch(lexer.token()) {
                        case PUNC_COMMA:
                        case KW_FOR:
                            lexer.nextToken();
                            tempExprList.add(expression());
                        default:
                            match(PUNC_RIGHT_PAREN);
                    }
                    return new Substring(tempExprList).setCacheEvalRst(cacheEvalRst);
                case ROW:
                    lexer.nextToken();
                    tempExprList = expressionList(new LinkedList<Expression>());
                    return new RowExpression(tempExprList).setCacheEvalRst(cacheEvalRst);
                case TRIM:
                    Direction direction;
                    switch(lexer.nextToken()) {
                        case KW_BOTH:
                            lexer.nextToken();
                            direction = Direction.BOTH;
                            break;
                        case KW_LEADING:
                            lexer.nextToken();
                            direction = Direction.LEADING;
                            break;
                        case KW_TRAILING:
                            lexer.nextToken();
                            direction = Direction.TRAILING;
                            break;
                        default:
                            direction = Direction.DEFAULT;
                    }
                    if (direction == Direction.DEFAULT) {
                        tempExpr = expression();
                        if (lexer.token() == KW_FROM) {
                            lexer.nextToken();
                            tempExpr2 = expression();
                            match(PUNC_RIGHT_PAREN);
                            return new Trim(direction, tempExpr, tempExpr2).setCacheEvalRst(cacheEvalRst);
                        }
                        match(PUNC_RIGHT_PAREN);
                        return new Trim(direction, null, tempExpr).setCacheEvalRst(cacheEvalRst);
                    }
                    if (lexer.token() == KW_FROM) {
                        lexer.nextToken();
                        tempExpr = expression();
                        match(PUNC_RIGHT_PAREN);
                        return new Trim(direction, null, tempExpr).setCacheEvalRst(cacheEvalRst);
                    }
                    tempExpr = expression();
                    match(KW_FROM);
                    tempExpr2 = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Trim(direction, tempExpr, tempExpr2).setCacheEvalRst(cacheEvalRst);
                case AVG:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        tempGroupDistinct = true;
                        lexer.nextToken();
                    } else {
                        tempGroupDistinct = false;
                    }
                    tempExpr = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Avg(tempExpr, tempGroupDistinct).setCacheEvalRst(cacheEvalRst);
                case MAX:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        tempGroupDistinct = true;
                        lexer.nextToken();
                    } else {
                        tempGroupDistinct = false;
                    }
                    tempExpr = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Max(tempExpr, tempGroupDistinct).setCacheEvalRst(cacheEvalRst);
                case MIN:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        tempGroupDistinct = true;
                        lexer.nextToken();
                    } else {
                        tempGroupDistinct = false;
                    }
                    tempExpr = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Min(tempExpr, tempGroupDistinct).setCacheEvalRst(cacheEvalRst);
                case SUM:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        tempGroupDistinct = true;
                        lexer.nextToken();
                    } else {
                        tempGroupDistinct = false;
                    }
                    tempExpr = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Sum(tempExpr, tempGroupDistinct).setCacheEvalRst(cacheEvalRst);
                case COUNT:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        lexer.nextToken();
                        tempExprList = expressionList(new LinkedList<Expression>());
                        return new Count(tempExprList).setCacheEvalRst(cacheEvalRst);
                    }
                    tempExpr = expression();
                    match(PUNC_RIGHT_PAREN);
                    return new Count(tempExpr).setCacheEvalRst(cacheEvalRst);
                case GROUP_CONCAT:
                    if (lexer.nextToken() == KW_DISTINCT) {
                        lexer.nextToken();
                        tempGroupDistinct = true;
                    } else {
                        tempGroupDistinct = false;
                    }
                    for (tempExprList = new LinkedList<Expression>(); ; ) {
                        tempExpr = expression();
                        tempExprList.add(tempExpr);
                        if (lexer.token() == PUNC_COMMA) {
                            lexer.nextToken();
                        } else {
                            break;
                        }
                    }
                    boolean isDesc = false;
                    List<Expression> appendedColumnNames = null;
                    // order by
                    tempExpr = null;
                    // literalChars
                    tempStr = null;
                    switch(lexer.token()) {
                        case KW_ORDER:
                            lexer.nextToken();
                            match(KW_BY);
                            tempExpr = expression();
                            if (lexer.token() == KW_ASC) {
                                lexer.nextToken();
                            } else if (lexer.token() == KW_DESC) {
                                isDesc = true;
                                lexer.nextToken();
                            }
                            for (appendedColumnNames = new LinkedList<Expression>(); lexer.token() == PUNC_COMMA; ) {
                                lexer.nextToken();
                                appendedColumnNames.add(expression());
                            }
                            if (lexer.token() != KW_SEPARATOR) {
                                break;
                            }
                        case KW_SEPARATOR:
                            lexer.nextToken();
                            tempSb = new StringBuilder();
                            lexer.appendStringContent(tempSb);
                            tempStr = LiteralString.getUnescapedString(tempSb.toString());
                            match(LITERAL_CHARS);
                            break;
                    }
                    match(PUNC_RIGHT_PAREN);
                    return new GroupConcat(tempGroupDistinct, tempExprList, tempExpr, isDesc, appendedColumnNames, tempStr).setCacheEvalRst(cacheEvalRst);
                case CHAR:
                    lexer.nextToken();
                    return functionChar();
                case CONVERT:
                    lexer.nextToken();
                    return functionConvert();
                case EXTRACT:
                    lexer.nextToken();
                    return extract();
                case TIMESTAMPDIFF:
                    lexer.nextToken();
                    return timestampdiff();
                case TIMESTAMPADD:
                    lexer.nextToken();
                    return timestampadd();
                case _ORDINARY:
                    return ordinaryFunction(consumed, consumedUp);
                case _DEFAULT:
                    return new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst);
                default:
                    throw err("unexpected function parsing strategy for id of " + consumed);
            }
        default:
            return new Identifier(null, consumed, consumedUp).setCacheEvalRst(cacheEvalRst);
    }
}

Example 10 with Pair

use of com.alibaba.cobar.parser.util.Pair in project cobar by alibaba.

the class MySQLExprParser method caseWhenExpression.

/**
     * first <code>CASE</code> has been consumed
     */
private Expression caseWhenExpression() throws SQLSyntaxErrorException {
    Expression comparee = null;
    if (lexer.token() != KW_WHEN) {
        comparee = expression();
    }
    List<Pair<Expression, Expression>> list = new LinkedList<Pair<Expression, Expression>>();
    for (; lexer.token() == KW_WHEN; ) {
        lexer.nextToken();
        Expression when = expression();
        match(KW_THEN);
        Expression then = expression();
        if (when == null || then == null)
            throw err("when or then is null in CASE WHEN expression");
        list.add(new Pair<Expression, Expression>(when, then));
    }
    if (list.isEmpty()) {
        throw err("at least one WHEN ... THEN branch for CASE ... WHEN syntax");
    }
    Expression elseValue = null;
    switch(lexer.token()) {
        case KW_ELSE:
            lexer.nextToken();
            elseValue = expression();
        default:
            matchIdentifier("END");
    }
    return new CaseWhenOperatorExpression(comparee, list, elseValue).setCacheEvalRst(cacheEvalRst);
}