parser.java

一个用java写的开源的数据库系统

        if (iToken == Expression.NOT) {
            int type = iToken;

            read();

            return new Expression(type, readCondition(), null);
        } else if (iToken == Expression.EXISTS) {
            int type = iToken;

            read();
            readThis(Expression.OPEN);
            Trace.check(iToken == Expression.SELECT, Trace.UNEXPECTED_TOKEN);

            Expression s = new Expression(parseSelect());

            read();
            readThis(Expression.CLOSE);

            return new Expression(type, s, null);
        } else {
            Expression a   = readConcat();
            boolean    not = false;

            if (iToken == Expression.NOT) {
                not = true;

                read();
            }

            if (iToken == Expression.LIKE) {
                read();

                Expression b      = readConcat();
                char       escape = 0;

                if (sToken.equals("ESCAPE")) {
                    read();

                    Expression c = readTerm();

                    Trace.check(c.getType() == Expression.VALUE,
                                Trace.INVALID_ESCAPE);

                    String s = (String) c.getValue(Types.VARCHAR);

                    if (s == null || s.length() < 1) {
                        throw Trace.error(Trace.INVALID_ESCAPE, s);
                    }

                    escape = s.charAt(0);
                }

                a = new Expression(Expression.LIKE, a, b);

                a.setLikeEscape(escape);
            } else if (iToken == Expression.BETWEEN) {
                read();

                Expression l = new Expression(Expression.BIGGER_EQUAL, a,
                                              readConcat());

                readThis(Expression.AND);

                Expression h = new Expression(Expression.SMALLER_EQUAL, a,
                                              readConcat());

                a = new Expression(Expression.AND, l, h);
            } else if (iToken == Expression.IN) {
                int type = iToken;

                read();
                readThis(Expression.OPEN);

                Expression b = null;

                if (iToken == Expression.SELECT) {
                    b = new Expression(parseSelect());

                    read();
                } else {
                    tTokenizer.back();

                    Vector v = new Vector();

                    while (true) {
                        v.addElement(getValue(Types.VARCHAR));
                        read();

                        if (iToken != Expression.COMMA) {
                            break;
                        }
                    }

                    b = new Expression(v);
                }

                readThis(Expression.CLOSE);

                a = new Expression(type, a, b);
            } else {
                Trace.check(!not, Trace.UNEXPECTED_TOKEN);

                if (Expression.isCompare(iToken)) {
                    int type = iToken;

                    read();

                    return new Expression(type, a, readConcat());
                }

                return a;
            }

            if (not) {
                a = new Expression(Expression.NOT, a, null);
            }

            return a;
        }
    }

    /**
     *  Method declaration
     *
     * @param  type
     * @throws  SQLException
     */
    private void readThis(int type) throws SQLException {
        Trace.check(iToken == type, Trace.UNEXPECTED_TOKEN);
        read();
    }

    /**
     *  Method declaration
     *
     * @return
     * @throws  SQLException
     */
    private Expression readConcat() throws SQLException {

        Expression r = readSum();

        while (iToken == Expression.STRINGCONCAT) {
            int        type = Expression.CONCAT;
            Expression a    = r;

            read();

            r = new Expression(type, a, readSum());
        }

        return r;
    }

    /**
     *  Method declaration
     *
     * @return
     * @throws  SQLException
     */
    private Expression readSum() throws SQLException {

        Expression r = readFactor();

        while (true) {
            int type;

            if (iToken == Expression.PLUS) {
                type = Expression.ADD;
            } else if (iToken == Expression.NEGATE) {
                type = Expression.SUBTRACT;
            } else {
                break;
            }

            Expression a = r;

            read();

            r = new Expression(type, a, readFactor());
        }

        return r;
    }

    /**
     *  Method declaration
     *
     * @return
     * @throws  SQLException
     */
    private Expression readFactor() throws SQLException {

        Expression r = readTerm();

        while (iToken == Expression.MULTIPLY || iToken == Expression.DIVIDE) {
            int        type = iToken;
            Expression a    = r;

            read();

            r = new Expression(type, a, readTerm());
        }

        return r;
    }

    /**
     *  Method declaration
     *
     * @return
     * @throws  SQLException
     */
    private Expression readTerm() throws SQLException {

        Expression r = null;

        if (iToken == Expression.COLUMN) {
            String name = sToken;

            r = new Expression(sTable, sToken);

            read();

            if (iToken == Expression.OPEN) {
                Function f = new Function(dDatabase.getAlias(name), cSession);
                int      len = f.getArgCount();
                int      i   = 0;

                read();

                if (iToken != Expression.CLOSE) {
                    while (true) {
                        f.setArgument(i++, readOr());

                        if (iToken != Expression.COMMA) {
                            break;
                        }

                        read();
                    }
                }

                readThis(Expression.CLOSE);

                r = new Expression(f);
            }
        } else if (iToken == Expression.NEGATE) {
            int type = iToken;

            read();

            r = new Expression(type, readTerm(), null);
        } else if (iToken == Expression.PLUS) {
            read();

            r = readTerm();
        } else if (iToken == Expression.OPEN) {
            read();

            r = readOr();

            if (iToken != Expression.CLOSE) {
                throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
            }

            read();
        } else if (iToken == Expression.VALUE) {
            r = new Expression(iType, oData);

            read();
        } else if (iToken == Expression.SELECT) {
            r = new Expression(parseSelect());

            read();
        } else if (iToken == Expression.MULTIPLY) {
            r = new Expression(sTable, null);

            read();
        } else if (iToken == Expression.IFNULL
                   || iToken == Expression.CONCAT) {
            int type = iToken;

            read();
            readThis(Expression.OPEN);

            r = readOr();

            readThis(Expression.COMMA);

            r = new Expression(type, r, readOr());

            readThis(Expression.CLOSE);
        } else if (iToken == Expression.CASEWHEN) {
            int type = iToken;

            read();
            readThis(Expression.OPEN);

            r = readOr();

            readThis(Expression.COMMA);

            Expression thenelse = readOr();

            readThis(Expression.COMMA);

            // thenelse part is never evaluated; only init
            thenelse = new Expression(type, thenelse, readOr());
            r        = new Expression(type, r, thenelse);

            readThis(Expression.CLOSE);
        } else if (iToken == Expression.CONVERT) {
            int type = iToken;

            read();
            readThis(Expression.OPEN);

            r = readOr();

            readThis(Expression.COMMA);

            int t = Column.getTypeNr(sToken);

            r = new Expression(type, r, null);

            r.setDataType(t);
            read();
            readThis(Expression.CLOSE);
        } else if (iToken == Expression.CAST) {
            read();
            readThis(Expression.OPEN);

            r = readOr();

            Trace.check(sToken.equals("AS"), Trace.UNEXPECTED_TOKEN, sToken);
            read();

            int t = Column.getTypeNr(sToken);

            r = new Expression(Expression.CONVERT, r, null);

            r.setDataType(t);
            read();
            readThis(Expression.CLOSE);
        } else {
            throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
        }

        return r;
    }

    /**
     *  Method declaration
     *
     * @throws  SQLException
     */

// fredt@users 20020130 - patch 497872 by Nitin Chauhan
// reordering for speed
    private void read() throws SQLException {

        sToken = tTokenizer.getString();

        if (tTokenizer.wasValue()) {
            iToken = Expression.VALUE;
            oData  = tTokenizer.getAsValue();
            iType  = tTokenizer.getType();
        } else if (tTokenizer.wasName()) {
            iToken = Expression.COLUMN;
            sTable = null;
        } else if (tTokenizer.wasLongName()) {
            sTable = tTokenizer.getLongNameFirst();
            sToken = tTokenizer.getLongNameLast();

            if (sToken.equals("*")) {
                iToken = Expression.MULTIPLY;
            } else {
                iToken = Expression.COLUMN;
            }
        } else if (sToken.length() == 0) {
            iToken = Expression.END;
        } else if (sToken.equals(",")) {
            iToken = Expression.COMMA;
        } else if (sToken.equals("=")) {
            iToken = Expression.EQUAL;
        } else if (sToken.equals("<>") || sToken.equals("!=")) {
            iToken = Expression.NOT_EQUAL;
        } else if (sToken.equals("<")) {
            iToken = Expression.SMALLER;
        } else if (sToken.equals(">")) {
            iToken = Expression.BIGGER;
        } else if (sToken.equals("<=")) {
            iToken = Expression.SMALLER_EQUAL;
        } else if (sToken.equals(">=")) {
            iToken = Expression.BIGGER_EQUAL;
        } else if (sToken.equals("AND")) {
            iToken = Expression.AND;
        } else if (sToken.equals("OR")) {
            iToken = Expression.OR;
        } else if (sToken.equals("NOT")) {
            iToken = Expression.NOT;
        } else if (sToken.equals("IN")) {
            iToken = Expression.IN;
        } else if (sToken.equals("EXISTS")) {
            iToken = Expression.EXISTS;
        } else if (sToken.equals("BETWEEN")) {
            iToken = Expression.BETWEEN;
        } else if (sToken.equals("+")) {
            iToken = Expression.PLUS;
        } else if (sToken.equals("-")) {
            iToken = Expression.NEGATE;
        } else if (sToken.equals("*")) {
            iToken = Expression.MULTIPLY;
            sTable = null;    // in case of ASTERIX
        } else if (sToken.equals("/")) {
            iToken = Expression.DIVIDE;
        } else if (sToken.equals("||")) {
            iToken = Expression.STRINGCONCAT;
        } else if (sToken.equals("(")) {
            iToken = Expression.OPEN;
        } else if (sToken.equals(")")) {
            iToken = Expression.CLOSE;
        } else if (sToken.equals("SELECT")) {
            iToken = Expression.SELECT;
        } else if (sToken.equals("IS")) {
            sToken = tTokenizer.getString();

            if (sToken.equals("NOT")) {
                iToken = Expression.NOT_EQUAL;
            } else {
                iToken = Expression.EQUAL;

                tTokenizer.back();
            }
        } else if (sToken.equals("LIKE")) {
            iToken = Expression.LIKE;
        } else if (sToken.equals("COUNT")) {
            iToken = Expression.COUNT;
        } else if (sToken.equals("SUM")) {
            iToken = Expression.SUM;
        } else if (sToken.equals("MIN")) {
            iToken = Expression.MIN;
        } else if (sToken.equals("MAX")) {
            iToken = Expression.MAX;
        } else if (sToken.equals("AVG")) {
            iToken = Expression.AVG;
        } else if (sToken.equals("IFNULL")) {
            iToken = Expression.IFNULL;
        } else if (sToken.equals("CONVERT")) {
            iToken = Expression.CONVERT;
        } else if (sToken.equals("CAST")) {
            iToken = Expression.CAST;
        } else if (sToken.equals("CASEWHEN")) {
            iToken = Expression.CASEWHEN;

// fredt@users 20020215 - patch 514111 by fredt
        } else if (sToken.equals("CONCAT")) {
            iToken = Expression.CONCAT;
        } else {
            iToken = Expression.END;
        }
    }
}