parser.java

纯Java的数据库

                r = readOr();

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

                read();

                break;
            }
            case Expression.VALUE : {
                r = new Expression(iType, oData);

                read();

                break;
            }
            case Expression.PARAM : {
                r = new Expression(Types.NULL, null, true);

                parameters.add(r);
                read();

                break;
            }
            case Expression.SELECT : {
                SubQuery sq = parseSubquery(0, null, false, Expression.SELECT);

                r = new Expression(sq);

                read();

                break;
            }
            case Expression.ANY :
            case Expression.ALL : {
                r = parseAllAnyPredicate();

//                read();
                break;
            }
            case Expression.MULTIPLY : {
                r = new Expression(sSchema, sTable, (String) null);

                read();

                break;
            }
            case Expression.CASEWHEN :
                return readCaseWhenExpression();

            case Expression.CASE :
                return readCaseExpression();

            case Expression.NULLIF :
                return readNullIfExpression();

            case Expression.COALESCE :
            case Expression.IFNULL :
                return readCoalesceExpression();

            case Expression.SEQUENCE :
                return readSequenceExpression();

            case Expression.CAST :
            case Expression.CONVERT :
                return readCastExpression();

            case Expression.EXTRACT :
                return readExtractExpression();

            case Expression.TRIM :
                return readTrimExpression();

            case Expression.POSITION :
                return readPositionExpression();

            case Expression.SUBSTRING :
                return readSubstringExpression();

            default :
                if (Expression.isAggregate(iToken)) {
                    return readAggregate();
                } else {
                    throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
                }
        }

        return r;
    }

    /**
     * reads a CASE .. WHEN expression
     */
    Expression readCaseExpression() throws HsqlException {

        int        type      = Expression.CASEWHEN;
        Expression r         = null;
        Expression predicand = null;

        read();

        if (iToken != Expression.WHEN) {
            predicand = readOr();
        }

        Expression leaf = null;

        while (true) {
            Expression casewhen = parseCaseWhen(predicand);

            if (r == null) {
                r = casewhen;
            } else {
                leaf.setRightExpression(casewhen);
            }

            leaf = casewhen.getRightExpression();

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

        if (iToken == Expression.ELSE) {
            readThis(Expression.ELSE);

            Expression elsexpr = readOr();

            leaf.setRightExpression(elsexpr);
        }

        readThis(Expression.ENDWHEN);

        return r;
    }

    /**
     * Reads part of a CASE .. WHEN  expression
     */
    private Expression parseCaseWhen(Expression r) throws HsqlException {

        readThis(Expression.WHEN);

        Expression condition;

        if (r == null) {
            condition = readOr();
        } else {
            condition = new Expression(Expression.EQUAL, r, readOr());
        }

        readThis(Expression.THEN);

        Expression current = readOr();
        Expression alternatives = new Expression(Expression.ALTERNATIVE,
            current, new Expression(Types.NULL, null));
        Expression casewhen = new Expression(Expression.CASEWHEN, condition,
                                             alternatives);

        return casewhen;
    }

    /**
     * reads a CASEWHEN expression
     */
    private Expression readCaseWhenExpression() throws HsqlException {

        int        type = iToken;
        Expression r    = null;

        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(Expression.ALTERNATIVE, thenelse, readOr());
        r        = new Expression(type, r, thenelse);

        readThis(Expression.CLOSE);

        return r;
    }

    /**
     * Reads a CAST or CONVERT expression
     */
    private Expression readCastExpression() throws HsqlException {

        boolean isConvert = iToken == Expression.CONVERT;

        read();
        readThis(Expression.OPEN);

        Expression r = readOr();

        if (isConvert) {
            readThis(Expression.COMMA);
        } else {
            readThis(Expression.AS);
        }

        int     typeNr    = Types.getTypeNr(sToken);
        int     length    = 0;
        int     scale     = 0;
        boolean hasLength = false;

        if (Types.acceptsPrecisionCreateParam(typeNr)
                && tokenizer.isGetThis(Token.T_OPENBRACKET)) {
            length    = tokenizer.getInt();
            hasLength = true;

            if (Types.acceptsScaleCreateParam(typeNr)
                    && tokenizer.isGetThis(Token.T_COMMA)) {
                scale = tokenizer.getInt();
            }

            tokenizer.getThis(Token.T_CLOSEBRACKET);
        }

        if (typeNr == Types.FLOAT && length > 53) {
            throw Trace.error(Trace.NUMERIC_VALUE_OUT_OF_RANGE);
        }

        if (typeNr == Types.TIMESTAMP) {
            if (!hasLength) {
                length = 6;
            } else if (length != 0 && length != 6) {
                throw Trace.error(Trace.NUMERIC_VALUE_OUT_OF_RANGE);
            }
        }

        if (r.isParam()) {
            r.setDataType(typeNr);
        }

        r = new Expression(r, typeNr, length, scale);

        read();
        readThis(Expression.CLOSE);

        return r;
    }

    /**
     * reads a Column or Function expression
     */
    private Expression readColumnExpression() throws HsqlException {

        String     name = sToken;
        Expression r    = new Expression(sTable, name, wasQuoted);

        read();

        if (iToken == Expression.OPEN) {
            String   javaName = database.getJavaName(name);
            Function f        = new Function(name, javaName, false);

            session.check(javaName);

            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 {
            String javaName = (String) simpleFunctions.get(name);

            if (javaName != null) {
                Function f = new Function(name, javaName, true);

                r = new Expression(f);
            }
        }

        return r;
    }

    /**
     * reads a CONCAT expression
     */
    private Expression readConcatExpression() throws HsqlException {

        int type = iToken;

        read();
        readThis(Expression.OPEN);

        Expression r = readOr();

        readThis(Expression.COMMA);

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

        readThis(Expression.CLOSE);

        return r;
    }

    /**
     * Reads a NULLIF expression
     */
    private Expression readNullIfExpression() throws HsqlException {

        // turn into a CASEWHEN
        read();
        readThis(Expression.OPEN);

        Expression r = readOr();

        readThis(Expression.COMMA);

        Expression thenelse = new Expression(Expression.ALTERNATIVE,
                                             new Expression(Types.NULL, null),
                                             r);

        r = new Expression(Expression.EQUAL, r, readOr());
        r = new Expression(Expression.CASEWHEN, r, thenelse);

        readThis(Expression.CLOSE);

        return r;
    }

    /**
     * Reads a COALESE or IFNULL expression
     */
    private Expression readCoalesceExpression() throws HsqlException {

        Expression r = null;

        // turn into a CASEWHEN
        read();
        readThis(Expression.OPEN);

        Expression leaf = null;

        while (true) {
            Expression current = readOr();

            if (leaf != null && iToken == Expression.CLOSE) {
                readThis(Expression.CLOSE);
                leaf.setLeftExpression(current);

                break;
            }

            Expression condition = new Expression(Expression.IS_NULL, current,
                                                  null);
            Expression alternatives = new Expression(Expression.ALTERNATIVE,
                new Expression(Types.NULL, null), current);
            Expression casewhen = new Expression(Expression.CASEWHEN,
                                                 condition, alternatives);

            if (r == null) {
                r = casewhen;
            } else {
                leaf.setLeftExpression(casewhen);
            }

            leaf = alternatives;

            readThis(Expression.COMMA);
        }

        return r;
    }

    /**
     * Reads an EXTRACT expression
     */
    private Expression readExtractExpression() throws HsqlException {

        read();
        readThis(Expression.OPEN);

        String name = sToken;

        // must be an accepted identifier
        if (!Expression.SQL_EXTRACT_FIELD_NAMES.contains(name)) {
            throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
        }

        readToken();
        readThis(Expression.FROM);

        // the name argument is DAY, MONTH etc.  - OK for now for CHECK constraints
        Function f = new Function(name, database.getJavaName(name), false);

        f.setArgument(0, readOr());
        readThis(Expression.CLOSE);

        return new Expression(f);
    }

    /**
     * Reads a POSITION expression
     */
    private Expression readPositionExpression() throws HsqlException {

        read();
        readThis(Expression.OPEN);

        Function f = new Function(Token.T_POSITION,
                                  "org.hsqldb.Library.position", false);

        f.setArgument(0, readTerm());
        readThis(Expression.IN);
        f.setArgument(1, readOr());
        readThis(Expression.CLOSE);

        return new Expr