Examples of org.hsqldb_voltpatches.lib.OrderedIntHashSet

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

        String[] rightNames = rightQueryExpression.getColumnNames();


        if (unionCorrespondingColumns == null) {
            unionCorrespondingColumns = new OrderedHashSet();


            OrderedIntHashSet leftColumns  = new OrderedIntHashSet();
            OrderedIntHashSet rightColumns = new OrderedIntHashSet();


            for (int i = 0; i < leftNames.length; i++) {
                String name  = leftNames[i];
                int    index = ArrayUtil.find(rightNames, name);


                if (name.length() > 0 && index != -1) {
                    leftColumns.add(i);
                    rightColumns.add(index);
                    unionCorrespondingColumns.add(name);
                }
            }


            if (unionCorrespondingColumns.isEmpty()) {
                throw Error.error(ErrorCode.X_42579);
            }


            leftQueryExpression.unionColumnMap  = leftColumns.toArray();
            rightQueryExpression.unionColumnMap = rightColumns.toArray();
        } else {
            leftQueryExpression.unionColumnMap =
                new int[unionCorrespondingColumns.size()];
            rightQueryExpression.unionColumnMap =
                new int[unionCorrespondingColumns.size()];

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 = Constraint.NO_ACTION;
        int               updateAction = Constraint.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) {


        OrderedIntHashSet set = new OrderedIntHashSet();


        while (true) {
            boolean end = false;


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


            switch (token.tokenType) {


                case Tokens.AS : {
                    if (withType) {
                        read();


                        Type type = readTypeDefinition(true);


                        sequence.setDefaults(sequence.name, type);


                        break;
                    }


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


                    long value = readBigint();


                    sequence.setStartValueNoCheck(value);


                    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 (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;


                default :

View Full Code Here

                                   null, null);
    }


    void processAlterColumnSequenceOptions(ColumnSchema column) {


        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();
                    readThis(Tokens.WITH);


                    long value = readBigint();


                    sequence.setStartValue(value);


                    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

        return cs;
    }


    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 =
                        readNewSchemaObjectNameNoCheck(routine.getType());


                    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();
                    }


                    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);
                    readBigint();


                    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 (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

TOP

Related Classes of org.hsqldb_voltpatches.lib.OrderedIntHashSet

org.hsqldb_voltpatches.ParserDDL

org.hsqldb_voltpatches.ParserRoutine

org.hsqldb_voltpatches.QueryExpression

org.hsqldb_voltpatches.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.