Examples of org.hsqldb.lib.OrderedIntHashSet

org.hsqldb.lib.OrderedIntHashSet
@author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0

        table.createPrimaryKey();
    }


    private void readRoutineCharacteristics(Routine routine) {


        OrderedIntHashSet set = new OrderedIntHashSet();
        boolean           end = false;


        while (!end) {
            switch (token.tokenType) {


                case Tokens.LANGUAGE : {
                    if (!set.add(Tokens.LANGUAGE)) {
                        throw unexpectedToken();
                    }


                    read();


                    if (token.tokenType == Tokens.JAVA) {
                        read();
                        routine.setLanguage(Routine.LANGUAGE_JAVA);
                    } else if (token.tokenType == Tokens.SQL) {
                        read();
                        routine.setLanguage(Routine.LANGUAGE_SQL);
                    } else {
                        throw unexpectedToken();
                    }


                    break;
                }
                case Tokens.PARAMETER : {
                    if (!set.add(Tokens.PARAMETER)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.STYLE);


                    if (token.tokenType == Tokens.JAVA) {
                        read();
                        routine.setParameterStyle(Routine.PARAM_STYLE_JAVA);
                    } else {
                        readThis(Tokens.SQL);
                        routine.setParameterStyle(Routine.PARAM_STYLE_SQL);
                    }


                    break;
                }
                case Tokens.SPECIFIC : {
                    if (!set.add(Tokens.SPECIFIC)) {
                        throw unexpectedToken();
                    }


                    read();


                    HsqlName name =
                        readNewSchemaObjectName(SchemaObject.SPECIFIC_ROUTINE,
                                                false);


                    routine.setSpecificName(name);


                    break;
                }
                case Tokens.DETERMINISTIC : {
                    if (!set.add(Tokens.DETERMINISTIC)) {
                        throw unexpectedToken();
                    }


                    read();
                    routine.setDeterministic(true);


                    break;
                }
                case Tokens.NOT : {
                    if (!set.add(Tokens.DETERMINISTIC)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.DETERMINISTIC);
                    routine.setDeterministic(false);


                    break;
                }
                case Tokens.MODIFIES : {
                    if (!set.add(Tokens.SQL)) {
                        throw unexpectedToken();
                    }


                    if (routine.getType() == SchemaObject.FUNCTION) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SQL);
                    readThis(Tokens.DATA);
                    routine.setDataImpact(Routine.MODIFIES_SQL);


                    break;
                }
                case Tokens.NO : {
                    if (!set.add(Tokens.SQL)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SQL);
                    routine.setDataImpact(Routine.NO_SQL);


                    break;
                }
                case Tokens.READS : {
                    if (!set.add(Tokens.SQL)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SQL);
                    readThis(Tokens.DATA);
                    routine.setDataImpact(Routine.READS_SQL);


                    break;
                }
                case Tokens.CONTAINS : {
                    if (!set.add(Tokens.SQL)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SQL);
                    routine.setDataImpact(Routine.CONTAINS_SQL);


                    break;
                }
                case Tokens.RETURNS : {
                    if (!set.add(Tokens.NULL) || routine.isProcedure()) {
                        throw unexpectedToken();
                    }


                    if (routine.isAggregate()) {
                        throw Error.error(ErrorCode.X_42604,
                                          token.tokenString);
                    }


                    read();
                    readThis(Tokens.NULL);
                    readThis(Tokens.ON);
                    readThis(Tokens.NULL);
                    readThis(Tokens.INPUT);
                    routine.setNullInputOutput(true);


                    break;
                }
                case Tokens.CALLED : {
                    if (!set.add(Tokens.NULL) || routine.isProcedure()) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.ON);
                    readThis(Tokens.NULL);
                    readThis(Tokens.INPUT);
                    routine.setNullInputOutput(false);


                    break;
                }
                case Tokens.DYNAMIC : {
                    if (!set.add(Tokens.RESULT) || routine.isFunction()) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.RESULT);
                    readThis(Tokens.SETS);


                    int results = readInteger();


                    if (results < 0 || results > 16) {
                        throw Error.error(ErrorCode.X_42604,
                                          String.valueOf(results));
                    }


                    routine.setMaxDynamicResults(results);


                    break;
                }
                case Tokens.NEW : {
                    if (routine.getType() == SchemaObject.FUNCTION
                            || !set.add(Tokens.SAVEPOINT)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SAVEPOINT);
                    readThis(Tokens.LEVEL);
                    routine.setNewSavepointLevel(true);


                    break;
                }
                case Tokens.OLD : {
                    if (routine.getType() == SchemaObject.FUNCTION
                            || !set.add(Tokens.SAVEPOINT)) {
                        throw unexpectedToken();
                    }


                    read();
                    readThis(Tokens.SAVEPOINT);

View Full Code Here


                    if (e.getRightNode().isCorrelated()) {
                        continue;
                    }


                    OrderedIntHashSet set = new OrderedIntHashSet();


                    ((ExpressionLogical) e).addLeftColumnsForAllAny(
                        conditions.rangeVar, set);


                    IndexUse[] indexes =

View Full Code Here

        for (int i = rangeVariables.length - 1; i >= 0; i--) {
            RangeVariable     rangeVar = rangeVariables[i];
            ExpressionLogical in       = (ExpressionLogical) inExpressions[i];


            if (in != null) {
                OrderedIntHashSet set = new OrderedIntHashSet();


                in.addLeftColumnsForAllAny(rangeVar, set);


                IndexUse[] indexes =
                    rangeVar.rangeTable.getIndexForColumns(session, set,
                        OpTypes.EQUAL, false);
                Index index           = indexes[0].index;
                int   indexedColCount = 0;


                for (int j = 0; j < index.getColumnCount(); j++) {
                    if (set.contains(index.getColumns()[j])) {
                        indexedColCount++;
                    } else {
                        break;
                    }
                }


                RangeVariable newRangeVar =
                    new RangeVariable(in.getRightNode().getTable(), null,
                                      null, null, compileContext);


                newRangeVar.isGenerated = true;


                RangeVariable[] newList =
                    new RangeVariable[rangeVariables.length + 1];


                ArrayUtil.copyAdjustArray(rangeVariables, newList,
                                          newRangeVar, i, 1);


                rangeVariables = newList;


                // make two columns as arg
                Expression[] exprList = new Expression[index.getColumnCount()];


                for (int j = 0; j < indexedColCount; j++) {
                    int leftIndex  = index.getColumns()[j];
                    int rightIndex = set.getIndex(leftIndex);
                    Expression e = new ExpressionLogical(rangeVar, leftIndex,
                                                         newRangeVar,
                                                         rightIndex);


                    exprList[j] = e;
                }


                boolean isOuter = rangeVariables[i].isLeftJoin
                                  || rangeVariables[i].isRightJoin;
                RangeVariableConditions conditions =
                    !inInJoin[i] && isOuter ? rangeVar.whereConditions[0]
                                            : rangeVar.joinConditions[0];


                conditions.addIndexCondition(exprList, index, indexedColCount);


                for (int j = 0; j < set.size(); j++) {
                    int leftIndex  = set.get(j);
                    int rightIndex = j;
                    Expression e = new ExpressionLogical(rangeVar, leftIndex,
                                                         newRangeVar,
                                                         rightIndex);

View Full Code Here


        boolean           generated = false;
        boolean           identity  = false;
        boolean           defaults  = false;
        Table             likeTable = readTableName();
        OrderedIntHashSet set       = new OrderedIntHashSet();


        while (true) {
            boolean including = token.tokenType == Tokens.INCLUDING;


            if (!including && token.tokenType != Tokens.EXCLUDING) {
                break;
            }


            read();


            switch (token.tokenType) {


                case Tokens.GENERATED :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    generated = including;
                    break;


                case Tokens.IDENTITY :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    identity = including;
                    break;


                case Tokens.DEFAULTS :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    defaults = including;
                    break;

View Full Code Here

        // -- "ON" statements following the foreign key
        // -- definition this can be
        // -- ON [UPDATE|DELETE] [NO ACTION|RESTRICT|CASCADE|SET [NULL|DEFAULT]]
        int deleteAction      = SchemaObject.ReferentialAction.NO_ACTION;
        int updateAction      = SchemaObject.ReferentialAction.NO_ACTION;
        OrderedIntHashSet set = new OrderedIntHashSet();


        while (token.tokenType == Tokens.ON) {
            read();


            if (!set.add(token.tokenType)) {
                throw unexpectedToken();
            }


            if (token.tokenType == Tokens.DELETE) {
                read();

View Full Code Here

     */
    private void readSequenceOptions(NumberSequence sequence,
                                     boolean withType, boolean isAlter,
                                     boolean allowComma) {


        OrderedIntHashSet set = new OrderedIntHashSet();


        while (true) {
            boolean end = false;


            if (set.contains(token.tokenType)) {
                throw unexpectedToken();
            }


            switch (token.tokenType) {


                case Tokens.AS : {
                    if (withType) {
                        set.add(token.tokenType);
                        read();


                        Type type = readTypeDefinition(false, true);


                        sequence.setDefaults(sequence.getName(), type);


                        break;
                    }


                    throw unexpectedToken();
                }
                case Tokens.START : {
                    set.add(token.tokenType);
                    read();
                    readThis(Tokens.WITH);


                    long value = readBigint();


                    sequence.setStartValueNoCheck(value);


                    if (allowComma) {
                        readIfThis(Tokens.COMMA);
                    }


                    break;
                }
                case Tokens.RESTART : {
                    if (!isAlter) {
                        end = true;


                        break;
                    }


                    set.add(token.tokenType);
                    read();


                    if (readIfThis(Tokens.WITH)) {
                        long value = readBigint();


                        sequence.setCurrentValueNoCheck(value);
                    } else {
                        sequence.setStartValueDefault();
                    }


                    break;
                }
                case Tokens.INCREMENT : {
                    set.add(token.tokenType);
                    read();
                    readThis(Tokens.BY);


                    long value = readBigint();


                    sequence.setIncrement(value);


                    break;
                }
                case Tokens.NO : {
                    read();


                    if (set.contains(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    if (token.tokenType == Tokens.MAXVALUE) {
                        sequence.setDefaultMaxValue();
                    } else if (token.tokenType == Tokens.MINVALUE) {
                        sequence.setDefaultMinValue();
                    } else if (token.tokenType == Tokens.CYCLE) {
                        sequence.setCycle(false);
                    } else {
                        throw unexpectedToken();
                    }


                    set.add(token.tokenType);
                    read();


                    break;
                }
                case Tokens.MAXVALUE : {
                    set.add(token.tokenType);
                    read();


                    long value = readBigint();


                    sequence.setMaxValueNoCheck(value);


                    break;
                }
                case Tokens.MINVALUE : {
                    set.add(token.tokenType);
                    read();


                    long value = readBigint();


                    sequence.setMinValueNoCheck(value);


                    break;
                }
                case Tokens.CYCLE : {
                    set.add(token.tokenType);
                    read();
                    sequence.setCycle(true);


                    break;
                }

View Full Code Here

    }


    StatementSchema compileAlterColumnSequenceOptions(Table table,
            ColumnSchema column, int columnIndex) {


        OrderedIntHashSet set      = new OrderedIntHashSet();
        NumberSequence    sequence = column.getIdentitySequence().duplicate();


        while (true) {
            boolean end = false;


            switch (token.tokenType) {


                case Tokens.RESTART : {
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    read();


                    if (readIfThis(Tokens.WITH)) {
                        long value = readBigint();


                        sequence.setCurrentValueNoCheck(value);
                    } else {
                        sequence.reset();
                    }


                    break;
                }
                case Tokens.SET :
                    read();


                    switch (token.tokenType) {


                        case Tokens.INCREMENT : {
                            if (!set.add(token.tokenType)) {
                                throw unexpectedToken();
                            }


                            read();
                            readThis(Tokens.BY);


                            long value = readBigint();


                            sequence.setIncrement(value);


                            break;
                        }
                        case Tokens.NO :
                            read();


                            if (token.tokenType == Tokens.MAXVALUE) {
                                sequence.setDefaultMaxValue();
                            } else if (token.tokenType == Tokens.MINVALUE) {
                                sequence.setDefaultMinValue();
                            } else if (token.tokenType == Tokens.CYCLE) {
                                sequence.setCycle(false);
                            } else {
                                throw unexpectedToken();
                            }


                            if (!set.add(token.tokenType)) {
                                throw unexpectedToken();
                            }


                            read();
                            break;


                        case Tokens.MAXVALUE : {
                            if (!set.add(token.tokenType)) {
                                throw unexpectedToken();
                            }


                            read();


                            long value = readBigint();


                            sequence.setMaxValueNoCheck(value);


                            break;
                        }
                        case Tokens.MINVALUE : {
                            if (!set.add(token.tokenType)) {
                                throw unexpectedToken();
                            }


                            read();


                            long value = readBigint();


                            sequence.setMinValueNoCheck(value);


                            break;
                        }
                        case Tokens.CYCLE :
                            if (!set.add(token.tokenType)) {
                                throw unexpectedToken();
                            }


                            read();
                            sequence.setCycle(true);

View Full Code Here

        if (handlers.length == 0) {
            return;
        }


        HashSet           statesSet = new HashSet();
        OrderedIntHashSet typesSet  = new OrderedIntHashSet();


        for (int i = 0; i < handlers.length; i++) {
            int[] types = handlers[i].getConditionTypes();


            for (int j = 0; j < types.length; j++) {
                if (!typesSet.add(types[j])) {
                    throw Error.error(ErrorCode.X_42601);
                }
            }


            String[] states = handlers[i].getConditionStates();

View Full Code Here


        boolean           generated = false;
        boolean           identity  = false;
        boolean           defaults  = false;
        Table             likeTable = readTableName();
        OrderedIntHashSet set       = new OrderedIntHashSet();


        while (true) {
            boolean including = token.tokenType == Tokens.INCLUDING;


            if (!including && token.tokenType != Tokens.EXCLUDING) {
                break;
            }


            read();


            switch (token.tokenType) {


                case Tokens.GENERATED :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    generated = including;
                    break;


                case Tokens.IDENTITY :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    identity = including;
                    break;


                case Tokens.DEFAULTS :
                    if (!set.add(token.tokenType)) {
                        throw unexpectedToken();
                    }


                    defaults = including;
                    break;

View Full Code Here

        // -- "ON" statements following the foreign key
        // -- definition this can be
        // -- ON [UPDATE|DELETE] [NO ACTION|RESTRICT|CASCADE|SET [NULL|DEFAULT]]
        int deleteAction      = SchemaObject.ReferentialAction.NO_ACTION;
        int updateAction      = SchemaObject.ReferentialAction.NO_ACTION;
        OrderedIntHashSet set = new OrderedIntHashSet();


        while (token.tokenType == Tokens.ON) {
            read();


            if (!set.add(token.tokenType)) {
                throw unexpectedToken();
            }


            if (token.tokenType == Tokens.DELETE) {
                read();

View Full Code Here

0 1 2 3

TOP

Related Classes of org.hsqldb.lib.OrderedIntHashSet

org.hsqldb.ParserDDL

org.hsqldb.ParserRoutine

org.hsqldb.QueryExpression

org.hsqldb.RangeVariable$RangeIteratorMain

org.hsqldb.RangeVariableResolver

org.hsqldb.StatementCompound

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.