Examples of org.hsqldb_voltpatches.lib.OrderedHashSet

org.hsqldb_voltpatches.lib.OrderedHashSet
Implementation of an ordered Set which maintains the inserted order of elements and allows access by index. Iterators return the elements in the index order. This class does not store null elements. @author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0

    private Constraint readFKReferences(Table refTable,
                                        HsqlName constraintName,
                                        OrderedHashSet refColSet) {


        HsqlName       mainTableName;
        OrderedHashSet mainColSet = null;


        readThis(Tokens.REFERENCES);


        HsqlName schema;

View Full Code Here

        int            operationType;
        String         className;
        TriggerDef     td;
        HsqlName       name;
        HsqlName       otherName = null;
        OrderedHashSet columns   = null;
        int[]          updateColumnIndexes = null;


        read();


        name = readNewSchemaObjectName(SchemaObject.TRIGGER);


        switch (token.tokenType) {


            case Tokens.INSTEAD :
                beforeOrAfter     = token.tokenString;
                beforeOrAfterType = token.tokenType;


                read();
                readThis(Tokens.OF);
                break;


            case Tokens.BEFORE :
            case Tokens.AFTER :
                beforeOrAfter     = token.tokenString;
                beforeOrAfterType = token.tokenType;


                read();
                break;


            default :
                throw unexpectedToken();
        }


        switch (token.tokenType) {


            case Tokens.INSERT :
            case Tokens.DELETE :
                operation     = token.tokenString;
                operationType = token.tokenType;


                read();
                break;


            case Tokens.UPDATE :
                operation     = token.tokenString;
                operationType = token.tokenType;


                read();


                if (token.tokenType == Tokens.OF
                        && beforeOrAfterType != Tokens.INSTEAD) {
                    read();


                    columns = readColumnNames(false);
                }
                break;


            default :
                throw unexpectedToken();
        }


        readThis(Tokens.ON);


        table = readTableName();


        if (token.tokenType == Tokens.BEFORE) {
            read();
            checkIsSimpleName();


            otherName = readNewSchemaObjectName(SchemaObject.TRIGGER);
        }


        name.setSchemaIfNull(table.getSchemaName());
        checkSchemaUpdateAuthorisation(name.schema);


        if (beforeOrAfterType == Tokens.INSTEAD) {
            if (!table.isView()
                    || ((View) table).getCheckOption()
                       == SchemaObject.ViewCheckModes.CHECK_CASCADE) {
                throw Error.error(ErrorCode.X_42538, name.schema.name);
            }
        } else {
            if (table.isView()) {
                throw Error.error(ErrorCode.X_42538, name.schema.name);
            }
        }


        if (name.schema != table.getSchemaName()) {
            throw Error.error(ErrorCode.X_42505, name.schema.name);
        }


        name.parent = table.getName();


        database.schemaManager.checkSchemaObjectNotExists(name);


        if (columns != null) {
            updateColumnIndexes = table.getColumnIndexes(columns);


            for (int i = 0; i < updateColumnIndexes.length; i++) {
                if (updateColumnIndexes[i] == -1) {
                    throw Error.error(ErrorCode.X_42544,
                                      (String) columns.get(i));
                }
            }
        }


        Expression      condition          = null;
        String          oldTableName       = null;
        String          newTableName       = null;
        String          oldRowName         = null;
        String          newRowName         = null;
        Table[]         transitions        = new Table[4];
        RangeVariable[] rangeVars          = new RangeVariable[4];
        HsqlArrayList   compiledStatements = new HsqlArrayList();
        String          conditionSQL       = null;
        String          procedureSQL       = null;


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


            if (token.tokenType != Tokens.OLD
                    && token.tokenType != Tokens.NEW) {
                throw unexpectedToken();
            }


            while (true) {
                if (token.tokenType == Tokens.OLD) {
                    if (operationType == Tokens.INSERT) {
                        throw unexpectedToken();
                    }


                    read();


                    if (token.tokenType == Tokens.TABLE) {
                        if (oldTableName != null
                                || beforeOrAfterType == Tokens.BEFORE) {
                            throw unexpectedToken();
                        }


                        read();
                        readIfThis(Tokens.AS);
                        checkIsSimpleName();


                        oldTableName = token.tokenString;


                        String n = oldTableName;


                        if (n.equals(newTableName) || n.equals(oldRowName)
                                || n.equals(newRowName)) {
                            throw unexpectedToken();
                        }


                        HsqlName hsqlName = database.nameManager.newHsqlName(
                            table.getSchemaName(), n, isDelimitedIdentifier(),
                            SchemaObject.TRANSITION);
                        Table transition = new Table(table, hsqlName);
                        RangeVariable range = new RangeVariable(transition,
                            null, null, null, compileContext);


                        transitions[TriggerDef.OLD_TABLE] = transition;
                        rangeVars[TriggerDef.OLD_TABLE]   = range;
                    } else if (token.tokenType == Tokens.ROW) {
                        if (oldRowName != null) {
                            throw unexpectedToken();
                        }


                        read();
                        readIfThis(Tokens.AS);
                        checkIsSimpleName();


                        oldRowName = token.tokenString;


                        String n = oldRowName;


                        if (n.equals(newTableName) || n.equals(oldTableName)
                                || n.equals(newRowName)) {
                            throw unexpectedToken();
                        }


                        isForEachRow = true;


                        HsqlName hsqlName = database.nameManager.newHsqlName(
                            table.getSchemaName(), n, isDelimitedIdentifier(),
                            SchemaObject.TRANSITION);
                        Table transition = new Table(table, hsqlName);
                        RangeVariable range = new RangeVariable(transition,
                            null, null, null, compileContext);


                        transitions[TriggerDef.OLD_ROW] = transition;
                        rangeVars[TriggerDef.OLD_ROW]   = range;
                    } else {
                        throw unexpectedToken();
                    }
                } else if (token.tokenType == Tokens.NEW) {
                    if (operationType == Tokens.DELETE) {
                        throw unexpectedToken();
                    }


                    read();


                    if (token.tokenType == Tokens.TABLE) {
                        if (newTableName != null
                                || beforeOrAfterType == Tokens.BEFORE) {
                            throw unexpectedToken();
                        }


                        read();
                        readIfThis(Tokens.AS);
                        checkIsSimpleName();


                        newTableName = token.tokenString;


                        String n = newTableName;


                        if (n.equals(oldTableName) || n.equals(oldRowName)
                                || n.equals(newRowName)) {
                            throw unexpectedToken();
                        }


                        HsqlName hsqlName = database.nameManager.newHsqlName(
                            table.getSchemaName(), n, isDelimitedIdentifier(),
                            SchemaObject.TRANSITION);
                        Table transition = new Table(table, hsqlName);
                        RangeVariable range = new RangeVariable(transition,
                            null, null, null, compileContext);


                        transitions[TriggerDef.NEW_TABLE] = transition;
                        rangeVars[TriggerDef.NEW_TABLE]   = range;
                    } else if (token.tokenType == Tokens.ROW) {
                        if (newRowName != null) {
                            throw unexpectedToken();
                        }


                        read();
                        readIfThis(Tokens.AS);
                        checkIsSimpleName();


                        newRowName   = token.tokenString;
                        isForEachRow = true;


                        String n = newRowName;


                        if (n.equals(oldTableName) || n.equals(newTableName)
                                || n.equals(oldRowName)) {
                            throw unexpectedToken();
                        }


                        HsqlName hsqlName = database.nameManager.newHsqlName(
                            table.getSchemaName(), n, isDelimitedIdentifier(),
                            SchemaObject.TRANSITION);
                        Table transition = new Table(table, hsqlName);
                        RangeVariable range = new RangeVariable(transition,
                            null, null, null, compileContext);


                        transitions[TriggerDef.NEW_ROW] = transition;
                        rangeVars[TriggerDef.NEW_ROW]   = range;
                    } else {
                        throw unexpectedToken();
                    }
                } else {
                    break;
                }


                read();
            }
        }


        if (isForEachRow && token.tokenType != Tokens.FOR) {
            throw unexpectedToken();
        }


        // "FOR EACH ROW" or "CALL"
        if (token.tokenType == Tokens.FOR) {
            read();
            readThis(Tokens.EACH);


            if (token.tokenType == Tokens.ROW) {
                isForEachRow = true;
            } else if (token.tokenType == Tokens.STATEMENT) {
                if (isForEachRow) {
                    throw unexpectedToken();
                }
            } else {
                throw unexpectedToken();
            }


            read();
        }


        //
        if (rangeVars[TriggerDef.OLD_TABLE] != null) {}


        if (rangeVars[TriggerDef.NEW_TABLE] != null) {}


        //
        if (Tokens.T_NOWAIT.equals(token.tokenString)) {
            read();


            isNowait = true;
        } else if (Tokens.T_QUEUE.equals(token.tokenString)) {
            read();


            queueSize    = readInteger();
            hasQueueSize = true;
        }


        if (token.tokenType == Tokens.WHEN
                && beforeOrAfterType != Tokens.INSTEAD) {
            read();
            readThis(Tokens.OPENBRACKET);


            int position = getPosition();


            isCheckOrTriggerCondition = true;
            condition                 = XreadBooleanValueExpression();
            conditionSQL              = getLastPart(position);
            isCheckOrTriggerCondition = false;


            readThis(Tokens.CLOSEBRACKET);


            HsqlList unresolved = condition.resolveColumnReferences(rangeVars,
                null);


            ExpressionColumn.checkColumnsResolved(unresolved);
            condition.resolveTypes(session, null);


            if (condition.getDataType() != Type.SQL_BOOLEAN) {
                throw Error.error(ErrorCode.X_42568);
            }
        }


        if (token.tokenType == Tokens.CALL) {
            read();
            checkIsSimpleName();
            checkIsDelimitedIdentifier();


            className = token.tokenString;


            read();


            td = new TriggerDef(name, beforeOrAfter, operation, isForEachRow,
                                table, transitions, rangeVars, condition,
                                conditionSQL, updateColumnIndexes, className, isNowait,
                                queueSize);


            String   sql  = getLastPart();
            Object[] args = new Object[] {
                td, otherName
            };


            return new StatementSchema(sql, StatementTypes.CREATE_TRIGGER,
                                       args, null, table.getName());
        }


        //
        if (isNowait) {
            throw unexpectedToken(Tokens.T_NOWAIT);
        }


        if (hasQueueSize) {
            throw unexpectedToken(Tokens.T_QUEUE);
        }


        // procedure
        boolean isBlock = false;


        if (readIfThis(Tokens.BEGIN)) {
            readThis(Tokens.ATOMIC);


            isBlock = true;
        }


        int position = getPosition();


        while (true) {
            StatementDMQL cs = null;


            switch (token.tokenType) {


                case Tokens.INSERT :
                    if (beforeOrAfterType == Tokens.BEFORE) {
                        throw unexpectedToken();
                    }


                    cs = compileInsertStatement(rangeVars);


                    compiledStatements.add(cs);


                    if (isBlock) {
                        readThis(Tokens.SEMICOLON);
                    }
                    break;


                case Tokens.UPDATE :
                    if (beforeOrAfterType == Tokens.BEFORE) {
                        throw unexpectedToken();
                    }


                    cs = compileUpdateStatement(rangeVars);


                    compiledStatements.add(cs);


                    if (isBlock) {
                        readThis(Tokens.SEMICOLON);
                    }
                    break;


                case Tokens.DELETE :
                    if (beforeOrAfterType == Tokens.BEFORE) {
                        throw unexpectedToken();
                    }


                    cs = compileDeleteStatement(rangeVars);


                    compiledStatements.add(cs);


                    if (isBlock) {
                        readThis(Tokens.SEMICOLON);
                    }
                    break;


                case Tokens.MERGE :
                    if (beforeOrAfterType == Tokens.BEFORE) {
                        throw unexpectedToken();
                    }


                    cs = compileMergeStatement(rangeVars);


                    compiledStatements.add(cs);


                    if (isBlock) {
                        readThis(Tokens.SEMICOLON);
                    }
                    break;


                case Tokens.SET :
                    if (beforeOrAfterType != Tokens.BEFORE
                            || operationType == Tokens.DELETE) {
                        throw unexpectedToken();
                    }


                    cs = compileTriggerSetStatement(table, rangeVars);


                    compiledStatements.add(cs);


                    if (isBlock) {
                        readThis(Tokens.SEMICOLON);
                    }
                    break;


                case Tokens.END :
                    break;


                default :
                    throw unexpectedToken();
            }


            if (!isBlock || token.tokenType == Tokens.END) {
                break;
            }
        }


        procedureSQL = getLastPart(position);


        if (isBlock) {
            readThis(Tokens.END);
        }


        StatementDMQL[] csArray = new StatementDMQL[compiledStatements.size()];


        compiledStatements.toArray(csArray);


        OrderedHashSet references = compileContext.getSchemaObjectNames();


        for (int i = 0; i < csArray.length; i++) {
            Table     targetTable = csArray[i].targetTable;
            boolean[] check = csArray[i].getInsertOrUpdateColumnCheckList();


            if (check != null) {
                targetTable.getColumnNames(check, references);
            }
        }


        references.remove(table.getName());


        td = new TriggerDefSQL(name, beforeOrAfter, operation, isForEachRow,
                               table, transitions, rangeVars, condition,
                               conditionSQL, updateColumnIndexes, csArray, procedureSQL,
                               references);

View Full Code Here


        read();


        Expression[]   updateExpressions;
        int[]          columnMap;
        OrderedHashSet colNames = new OrderedHashSet();
        HsqlArrayList  exprList = new HsqlArrayList();
        RangeVariable[] targetRangeVars = new RangeVariable[]{
            rangeVars[TriggerDef.NEW_ROW] };


        readSetClauseList(targetRangeVars, colNames, exprList);

View Full Code Here

        if (isIdentity) {
            column.setIdentity(sequence);
        }


        if (isPKIdentity && !column.isPrimaryKey()) {
            OrderedHashSet set = new OrderedHashSet();


            set.add(column.getName().name);


            HsqlName constName = database.nameManager.newAutoName("PK",
                table.getSchemaName(), table.getName(),
                SchemaObject.CONSTRAINT);
            Constraint c = new Constraint(constName, set,

View Full Code Here

                    constName = database.nameManager.newAutoName("PK",
                            schemaObject.getSchemaName(),
                            schemaObject.getName(), SchemaObject.CONSTRAINT);
                }


                OrderedHashSet set = readColumnNames(false);
                Constraint c = new Constraint(constName, set,
                                              Constraint.PRIMARY_KEY);


                constraintList.set(0, c);


                break;
            }
            // A VoltDB extension to support indexed expressions and the assume unique attribute
            case Tokens.ASSUMEUNIQUE :
                assumeUnique = true;
                // $FALL-THROUGH$
            // End of VoltDB extension
            case Tokens.UNIQUE : {
                if (schemaObject.getName().type != SchemaObject.TABLE) {
                    throw this.unexpectedTokenRequire(Tokens.T_CHECK);
                }


                read();


                // A VoltDB extension to "readColumnNames(false)" to support indexed expressions.
                java.util.List<Expression> indexExprs = XreadExpressions(null);
                OrderedHashSet set = getSimpleColumnNames(indexExprs);
                /* disable 1 line ...
                OrderedHashSet set = readColumnNames(false);
                ... disabled 1 line */
                // End of VoltDB extension


                if (constName == null) {
                    constName = database.nameManager.newAutoName("CT",
                            schemaObject.getSchemaName(),
                            schemaObject.getName(), SchemaObject.CONSTRAINT);
                }


                // A VoltDB extension to support indexed expressions.
                boolean hasNonColumnExprs = false;
                if (set == null) {
                    hasNonColumnExprs = true;
                    set = getBaseColumnNames(indexExprs);
                }
                // End of VoltDB extension
                Constraint c = new Constraint(constName, set,
                                              Constraint.UNIQUE);
                // A VoltDB extension to support indexed expressions and assume unique attribute.
                c.setAssumeUnique(assumeUnique);
                if (hasNonColumnExprs) {
                    c = c.withExpressions(indexExprs.toArray(new Expression[indexExprs.size()]));
                }
                // End of VoltDB extension


                constraintList.add(c);


                break;
            }
            case Tokens.FOREIGN : {
                if (schemaObject.getName().type != SchemaObject.TABLE) {
                    throw this.unexpectedTokenRequire(Tokens.T_CHECK);
                }


                read();
                readThis(Tokens.KEY);


                OrderedHashSet set = readColumnNames(false);
                Constraint c = readFKReferences((Table) schemaObject,
                                                constName, set);


                constraintList.add(c);

View Full Code Here


                    if (existingConst.constType == Constraint.PRIMARY_KEY) {
                        throw Error.error(ErrorCode.X_42532);
                    }


                    OrderedHashSet set = new OrderedHashSet();


                    set.add(column.getName().name);


                    if (constName == null) {
                        constName = database.nameManager.newAutoName("PK",
                                table.getSchemaName(), table.getName(),
                                SchemaObject.CONSTRAINT);
                    }


                    Constraint c = new Constraint(constName, set,
                                                  Constraint.PRIMARY_KEY);


                    constraintList.set(0, c);
                    column.setPrimaryKey(true);


                    break;
                }
                // A VoltDB extension to support indexed expressions and the assume unique attribute
                case Tokens.ASSUMEUNIQUE :
                    assumeUnique = true;
                    // $FALL-THROUGH$
                // End of VoltDB extension
                case Tokens.UNIQUE : {
                    read();


                    OrderedHashSet set = new OrderedHashSet();


                    set.add(column.getName().name);


                    if (constName == null) {
                        constName = database.nameManager.newAutoName("CT",
                                table.getSchemaName(), table.getName(),
                                SchemaObject.CONSTRAINT);
                    }


                    Constraint c = new Constraint(constName, set,
                                                  Constraint.UNIQUE);
                    // A VoltDB extension to support indexed expressions and the assume unique attribute
                    c.setAssumeUnique(assumeUnique);
                    // End of VoltDB extension


                    constraintList.add(c);


                    break;
                }
                case Tokens.FOREIGN : {
                    read();
                    readThis(Tokens.KEY);
                }


                // $FALL-THROUGH$
                case Tokens.REFERENCES : {
                    OrderedHashSet set = new OrderedHashSet();


                    set.add(column.getName().name);


                    Constraint c = readFKReferences(table, constName, set);


                    constraintList.add(c);


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


                    if (constName == null) {
                        constName = database.nameManager.newAutoName("CT",
                                table.getSchemaName(), table.getName(),
                                SchemaObject.CONSTRAINT);
                    }


                    Constraint c = new Constraint(constName, null,
                                                  Constraint.CHECK);


                    readCheckConstraintCondition(c);


                    OrderedHashSet set = c.getCheckColumnExpressions();


                    for (int i = 0; i < set.size(); i++) {
                        ExpressionColumn e = (ExpressionColumn) set.get(i);


                        if (column.getName().name.equals(e.getColumnName())) {
                            if (e.getSchemaName() != null
                                    && e.getSchemaName()
                                       != table.getSchemaName().name) {

View Full Code Here

     * @param ascOrDesc boolean
     * @return array of column indexes
     */
    private int[] readColumnList(Table table, boolean ascOrDesc) {


        OrderedHashSet set = readColumnNames(ascOrDesc);


        return table.getColumnIndexes(set);
    }

View Full Code Here


        // A VoltDB extension to support indexed expressions and the assume unique attribute
        java.util.List<Boolean> ascDesc = new java.util.ArrayList<Boolean>();
        // A VoltDB extension to "readColumnList(table, true)" to support indexed expressions.
        java.util.List<Expression> indexExprs = XreadExpressions(ascDesc);
        OrderedHashSet set = getSimpleColumnNames(indexExprs);
        int[] indexColumns = null;
        if (set == null) {
            // A VoltDB extension to support indexed expressions.
            // Not just indexing columns.
            // The meaning of set and indexColumns shifts here to be

View Full Code Here

                    SchemaObject.CONSTRAINT);
        }


        // A VoltDB extension to "readColumnList(table, false)" to support indexed expressions.
        java.util.List<Expression> indexExprs = XreadExpressions(null);
        OrderedHashSet set = getSimpleColumnNames(indexExprs);
        int[] cols = getColumnList(set, table);
        /* disable 1 line ...
        int[] cols = this.readColumnList(table, false);
        ... disabled 1 line */
        // End of VoltDB extension

View Full Code Here

            name = database.nameManager.newAutoName("FK",
                    table.getSchemaName(), table.getName(),
                    SchemaObject.CONSTRAINT);
        }


        OrderedHashSet set           = readColumnNames(false);
        Constraint     c             = readFKReferences(table, name, set);
        HsqlName       mainTableName = c.getMainTableName();


        c.core.mainTable = database.schemaManager.getTable(session,
                mainTableName.name, mainTableName.schema.name);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hsqldb_voltpatches.lib.OrderedHashSet

org.hsqldb_voltpatches.Collation

org.hsqldb_voltpatches.ColumnSchema

org.hsqldb_voltpatches.Constraint

org.hsqldb_voltpatches.dbinfo.DatabaseInformationFull

org.hsqldb_voltpatches.dbinfo.DatabaseInformationMain

org.hsqldb_voltpatches.Expression

org.hsqldb_voltpatches.ExpressionColumn

org.hsqldb_voltpatches.index.IndexAVL

org.hsqldb_voltpatches.NumberSequence

org.hsqldb_voltpatches.ParserCommand

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.