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

        return check;
    }


    public OrderedHashSet getCheckColumnExpressions() {


        OrderedHashSet set = new OrderedHashSet();


        Expression.collectAllExpressions(set, check,
                                         Expression.columnExpressionSet,
                                         Expression.emptyExpressionSet);

View Full Code Here

    public Grantee getOwner() {
        return name.schema.owner;
    }


    public OrderedHashSet getReferences() {
        return new OrderedHashSet();
    }

View Full Code Here


    OrderedHashSet makeNewTables(OrderedHashSet tableSet,
                                 OrderedHashSet dropConstraintSet,
                                 OrderedHashSet dropIndexSet) {


        OrderedHashSet newSet = new OrderedHashSet();


        for (int i = 0; i < tableSet.size(); i++) {
            Table      t  = (Table) tableSet.get(i);
            TableWorks tw = new TableWorks(session, t);


            tw.makeNewTable(dropConstraintSet, dropIndexSet);
            newSet.add(tw.getTable());
        }


        return newSet;
    }

View Full Code Here

        index = table.getIndex(indexName);


        if (table.isIndexingMutable()) {
            table.dropIndex(session, indexName);
        } else {
            OrderedHashSet indexSet = new OrderedHashSet();


            indexSet.add(table.getIndex(indexName).getName());


            Table tn = table.moveDefinition(session, table.tableType, null,
                                            null, null, -1, 0, emptySet,
                                            indexSet);

View Full Code Here

        database.schemaManager.recompileDependentObjects(table);
    }


    void dropColumn(int colIndex, boolean cascade) {


        OrderedHashSet constraintNameSet = new OrderedHashSet();
        OrderedHashSet dependentConstraints =
            table.getDependentConstraints(colIndex);
        OrderedHashSet cascadingConstraints =
            table.getContainingConstraints(colIndex);
        OrderedHashSet indexNameSet = table.getContainingIndexNames(colIndex);
        HsqlName       columnName   = table.getColumn(colIndex).getName();
        OrderedHashSet referencingObjects =
            database.schemaManager.getReferencingObjects(table.getName(),
                columnName);


        if (table.isText() && !table.isEmpty(session)) {
            throw Error.error(ErrorCode.X_S0521);
        }


        if (!cascade) {
            if (!cascadingConstraints.isEmpty()) {
                Constraint c    = (Constraint) cascadingConstraints.get(0);
                HsqlName   name = c.getName();


                throw Error.error(ErrorCode.X_42536,
                                  name.getSchemaQualifiedStatementName());
            }


            if (!referencingObjects.isEmpty()) {
                for (int i = 0; i < referencingObjects.size(); i++) {
                    HsqlName name = (HsqlName) referencingObjects.get(i);


                    throw Error.error(ErrorCode.X_42536,
                                      name.getSchemaQualifiedStatementName());
                }
            }
        }


        dependentConstraints.addAll(cascadingConstraints);
        cascadingConstraints.clear();


        OrderedHashSet tableSet = new OrderedHashSet();


        for (int i = 0; i < dependentConstraints.size(); i++) {
            Constraint c = (Constraint) dependentConstraints.get(i);


            if (c.constType == Constraint.FOREIGN_KEY) {
                tableSet.add(c.getMain());
                constraintNameSet.add(c.getMainName());
                constraintNameSet.add(c.getRefName());
                indexNameSet.add(c.getRefIndex().getName());
            }


            if (c.constType == Constraint.MAIN) {
                tableSet.add(c.getRef());
                constraintNameSet.add(c.getMainName());
                constraintNameSet.add(c.getRefName());
                indexNameSet.add(c.getRefIndex().getName());
            }

View Full Code Here


            case Constraint.MAIN :
                throw Error.error(ErrorCode.X_28502);
            case Constraint.PRIMARY_KEY :
            case Constraint.UNIQUE : {
                OrderedHashSet dependentConstraints =
                    table.getDependentConstraints(constraint);


                // throw if unique constraint is referenced by foreign key
                if (!cascade && !dependentConstraints.isEmpty()) {
                    Constraint c = (Constraint) dependentConstraints.get(0);


                    throw Error.error(
                        ErrorCode.X_42533,
                        c.getName().getSchemaQualifiedStatementName());
                }


                OrderedHashSet tableSet          = new OrderedHashSet();
                OrderedHashSet constraintNameSet = new OrderedHashSet();
                OrderedHashSet indexNameSet      = new OrderedHashSet();


                for (int i = 0; i < dependentConstraints.size(); i++) {
                    Constraint c = (Constraint) dependentConstraints.get(i);
                    Table      t = c.getMain();


                    if (t != table) {
                        tableSet.add(t);
                    }


                    t = c.getRef();


                    if (t != table) {
                        tableSet.add(t);
                    }


                    constraintNameSet.add(c.getMainName());
                    constraintNameSet.add(c.getRefName());
                    indexNameSet.add(c.getRefIndex().getName());
                }


                constraintNameSet.add(constraint.getName());


                if (constraint.getConstraintType() == Constraint.UNIQUE) {
                    indexNameSet.add(constraint.getMainIndex().getName());
                }


                Table tn = table.moveDefinition(session, table.tableType,
                                                null, null, null, -1, 0,
                                                constraintNameSet,
                                                indexNameSet);


                tn.moveData(session, table, -1, 0);


                tableSet = makeNewTables(tableSet, constraintNameSet,
                                         indexNameSet);


                if (constraint.getConstraintType() == Constraint.PRIMARY_KEY) {
                    int[] cols = constraint.getMainColumns();


                    for (int i = 0; i < cols.length; i++) {
                        tn.getColumn(cols[i]).setPrimaryKey(false);
                        tn.setColumnTypeVars(cols[i]);
                    }
                }


                //
                database.schemaManager.removeSchemaObjects(constraintNameSet);
                setNewTableInSchema(tn);
                setNewTablesInSchema(tableSet);
                updateConstraints(tn, emptySet);
                updateConstraints(tableSet, constraintNameSet);
                database.persistentStoreCollection.releaseStore(table);
                database.schemaManager.recompileDependentObjects(tableSet);
                database.schemaManager.recompileDependentObjects(tn);


                table = tn;


                // handle cascadingConstraints and cascadingTables
                break;
            }
            case Constraint.FOREIGN_KEY : {
                OrderedHashSet constraints = new OrderedHashSet();
                Table          mainTable   = constraint.getMain();
                HsqlName       mainName    = constraint.getMainName();
                boolean        isSelf      = mainTable == table;


                constraints.add(mainName);
                constraints.add(constraint.getRefName());


                OrderedHashSet indexes = new OrderedHashSet();


                indexes.add(constraint.getRefIndex().getName());


                Table tn = table.moveDefinition(session, table.tableType,
                                                null, null, null, -1, 0,
                                                constraints, indexes);

View Full Code Here

    void addLimitConstraint(Constraint c)
    {
        // Find any pre-existing LIMIT constraint on the table and remove it
        for (Constraint cst : table.constraintList) {
            if (cst.getConstraintType() == Constraint.LIMIT) {
                OrderedHashSet constraintNameSet = new OrderedHashSet();
                HsqlName name = cst.getName();
                constraintNameSet.add(name);
                updateConstraints(table, constraintNameSet);
                database.schemaManager.removeSchemaObject(name);
                break; // Highlander rules for Constraint.LIMIT
            }
        }

View Full Code Here

     */
    StatementSimple compileSetStatement(RangeVariable rangeVars[]) {


        read();


        OrderedHashSet colNames = new OrderedHashSet();
        HsqlArrayList  exprList = new HsqlArrayList();


        readSetClauseList(rangeVars, colNames, exprList);


        if (exprList.size() > 1) {
            throw Error.error(ErrorCode.X_42602);
        }


        Expression expression = (Expression) exprList.get(0);


        if (expression.getDegree() != colNames.size()) {


//            throw Error.error(ErrorCode.X_42546);
        }


        int[]          indexes   = new int[colNames.size()];
        ColumnSchema[] variables = new ColumnSchema[colNames.size()];


        setVariables(rangeVars, colNames, indexes, variables);


        HsqlList unresolved = expression.resolveColumnReferences(rangeVars,
            rangeVars.length, null, false);

View Full Code Here

        return new StatementSimple(StatementTypes.RETURN, e);
    }


    private Statement readSelectSingleRowStatement(RangeVariable[] rangeVars) {


        OrderedHashSet     variableNames = new OrderedHashSet();
        QuerySpecification select        = XreadSelect();


        readThis(Tokens.INTO);
        readColumnNamesForSelectInto(variableNames, rangeVars);
        XreadTableExpression(select);
        select.setAsTopLevel();
        select.resolve(session);


        int[]          indexes   = new int[variableNames.size()];
        ColumnSchema[] variables = new ColumnSchema[variableNames.size()];
        Statement statement = new StatementSimple(StatementTypes.ASSIGNMENT,
            variables, null, indexes);


        return statement;
    }

View Full Code Here

    public Expression getEquiJoinExpressions(OrderedHashSet nameSet,
            RangeVariable rightRange, boolean fullList) {


        HashSet        set             = new HashSet();
        Expression     result          = null;
        OrderedHashSet joinColumnNames = new OrderedHashSet();


        for (int i = 0; i < rangeVariableList.size(); i++) {
            RangeVariable  range = (RangeVariable) rangeVariableList.get(i);
            HashMappedList columnList = range.rangeTable.columnList;


            for (int j = 0; j < columnList.size(); j++) {
                ColumnSchema column       = (ColumnSchema) columnList.get(j);
                String       name         = range.getColumnAlias(j);
                boolean      columnInList = nameSet.contains(name);
                boolean namedJoin = range.namedJoinColumns != null
                                    && range.namedJoinColumns.contains(name);
                boolean repeated = !namedJoin && !set.add(name);


                if (repeated && (!fullList || columnInList)) {
                    throw Error.error(ErrorCode.X_42578, name);
                }


                if (!columnInList) {
                    continue;
                }


                joinColumnNames.add(name);


                int position = rightRange.rangeTable.getColumnIndex(name);
                ColumnSchema rightColumn =
                    rightRange.rangeTable.getColumn(position);
                Expression e = new ExpressionLogical(range, column,
                                                     rightRange, rightColumn);


                result = ExpressionLogical.andExpressions(result, e);


                ExpressionColumn col = range.getColumnExpression(name);


                if (col == null) {
                    col = new ExpressionColumn(new Expression[] {
                        e.getLeftNode(), e.getRightNode()
                    }, name);


                    range.addNamedJoinColumnExpression(name, col);
                } else {
                    col.nodes = (Expression[]) ArrayUtil.resizeArray(col.nodes,
                            col.nodes.length + 1);
                    col.nodes[col.nodes.length - 1] = e.getRightNode();
                }


                rightRange.addNamedJoinColumnExpression(name, col);
            }
        }


        if (fullList && !joinColumnNames.containsAll(nameSet)) {
            throw Error.error(ErrorCode.X_42501);
        }


        rightRange.addNamedJoinColumns(joinColumnNames);

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.