Java HsqlArrayList.get方法代码示例

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private static void dropUser(Session session, HsqlName name,
                             boolean cascade) {

    Grantee grantee = session.database.getUserManager().get(name.name);

    if (session.database.getSessionManager().isUserActive(name.name)) {
        throw Error.error(ErrorCode.X_42539);
    }

    if (!cascade && session.database.schemaManager.hasSchemas(grantee)) {
        HsqlArrayList list =
            session.database.schemaManager.getSchemas(grantee);
        Schema schema = (Schema) list.get(0);

        throw Error.error(ErrorCode.X_42502,
                          schema.getName().statementName);
    }

    session.database.schemaManager.dropSchemas(session, grantee, cascade);
    session.database.getUserManager().dropUser(name.name);
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Check result columns for aggregate or group by violation.
 * If any result column is aggregated, then all result columns need to be
 * aggregated, unless it is included in the group by clause.
 */
private void checkAggregateOrGroupByColumns(int start,
        int end) throws HsqlException {

    if (start < end) {
        HsqlArrayList colExps = new HsqlArrayList();

        for (int i = start; i < end; i++) {
            exprColumns[i].collectInGroupByExpressions(colExps);
        }

        for (int i = 0, size = colExps.size(); i < size; i++) {
            Expression exp = (Expression) colExps.get(i);

            if (inAggregateOrGroupByClause(exp)) {
                continue;
            }

            throw Trace.error(Trace.NOT_IN_AGGREGATE_OR_GROUP_BY, exp);
        }
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 *  Fires all row-level triggers of the given set (trigger type)
 *
 */
void fireAll(Session session, int trigVecIndx, Object[] oldrow,
             Object[] newrow) {

    if (!database.isReferentialIntegrity()) {

        // isReferentialIntegrity is false when reloading db
        return;
    }

    HsqlArrayList trigVec = triggerLists[trigVecIndx];

    if (trigVec == null) {
        return;
    }

    for (int i = 0, size = trigVec.size(); i < size; i++) {
        TriggerDef td = (TriggerDef) trigVec.get(i);

        td.pushPair(session, oldrow, newrow);    // tell the trigger thread to fire with this row
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * called after the completion of defrag
 */
public void setIndexRoots(long[][] roots) {

    readLock.lock();

    try {
        HsqlArrayList allTables =
            database.schemaManager.getAllTables(true);

        for (int i = 0, size = allTables.size(); i < size; i++) {
            Table t = (Table) allTables.get(i);

            if (t.getTableType() == TableBase.CACHED_TABLE) {
                long[] rootsArray = roots[i];

                if (rootsArray != null) {
                    t.setIndexRoots(rootsArray);
                }
            }
        }
    } finally {
        readLock.unlock();
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private static Expression resolveOrderByColumnIndex(Expression e,
        HsqlArrayList vcolumn, int visiblecols) throws HsqlException {

    // order by 1,2,3
    if (e.getDataType() == Types.INTEGER) {
        int i = ((Integer) e.getValue(null)).intValue();

        if (0 < i && i <= visiblecols) {
            Expression colexpr = (Expression) vcolumn.get(i - 1);

            colexpr.joinedTableColumnIndex = i - 1;

            return colexpr;
        }
    }

    throw Trace.error(Trace.INVALID_ORDER_BY);
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Return a lookup of all transactions ids for cached tables.
 */
public DoubleIntIndex getTransactionIDList() {

    Session[]      sessions = database.sessionManager.getAllSessions();
    DoubleIntIndex lookup   = new DoubleIntIndex(10, false);

    lookup.setKeysSearchTarget();

    for (int i = 0; i < sessions.length; i++) {
        HsqlArrayList tlist = sessions[i].rowActionList;

        for (int j = 0, size = tlist.size(); j < size; j++) {
            Transaction tx = (Transaction) tlist.get(j);

            if (tx.tTable.getTableType() == Table.CACHED_TABLE) {
                lookup.addUnique(tx.row.getPos(), 0);
            }
        }
    }

    return lookup;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Convert row ID's for cached table rows in transactions
 */
public void convertTransactionIDs(DoubleIntIndex lookup) {

    Session[] sessions = database.sessionManager.getAllSessions();

    for (int i = 0; i < sessions.length; i++) {
        HsqlArrayList tlist = sessions[i].rowActionList;

        for (int j = 0, size = tlist.size(); j < size; j++) {
            Transaction tx = (Transaction) tlist.get(j);

            if (tx.tTable.getTableType() == Table.CACHED_TABLE) {
                int pos = lookup.lookupFirstEqual(tx.row.getPos());

                tx.row.setPos(pos);
            }
        }
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
void registerConstraintNames(HsqlArrayList constraints) {

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

            switch (c.constType) {

                case Constraint.PRIMARY_KEY :
                case Constraint.UNIQUE :
                case Constraint.CHECK :
                    database.schemaManager.addSchemaObject(c);
            }
        }
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
void registerConstraintNames(HsqlArrayList constraints) {

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

            switch (c.getConstraintType()) {

                case SchemaObject.ConstraintTypes.PRIMARY_KEY :
                case SchemaObject.ConstraintTypes.UNIQUE :
                case SchemaObject.ConstraintTypes.CHECK :
                    database.schemaManager.addSchemaObject(c);
            }
        }
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * called from outside after the complete end of defrag
 */
void updateTableIndexRoots() throws HsqlException {

    HsqlArrayList allTables = database.schemaManager.getAllTables();

    for (int i = 0, size = allTables.size(); i < size; i++) {
        Table t = (Table) allTables.get(i);

        if (t.getTableType() == Table.CACHED_TABLE) {
            int[] rootsArray = rootsList[i];

            t.setIndexRoots(rootsArray);
        }
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Add all columns to a list of expressions
 */
void addTableColumns(HsqlArrayList exprList) {

    if (namedJoinColumns != null) {
        int count    = exprList.size();
        int position = 0;

        for (int i = 0; i < count; i++) {
            Expression e          = (Expression) exprList.get(i);
            String     columnName = e.getColumnName();

            if (namedJoinColumns.contains(columnName)) {
                if (position != i) {
                    exprList.remove(i);
                    exprList.add(position, e);
                }

                e = getColumnExpression(columnName);

                exprList.set(position, e);

                position++;
            }
        }
    }

    addTableColumns(exprList, exprList.size(), namedJoinColumns);
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * After addition or removal of columns and indexes all views that
 * reference the table should be recompiled.
 */
void recompileDependentObjects(Table table) {

    OrderedHashSet set     = getReferencingObjects(table.getName());
    Session        session = database.sessionManager.getSysSession();

    for (int i = 0; i < set.size(); i++) {
        HsqlName name = (HsqlName) set.get(i);

        switch (name.type) {

            case SchemaObject.VIEW :
            case SchemaObject.CONSTRAINT :
            case SchemaObject.ASSERTION :
                SchemaObject object = getSchemaObject(name);

                object.compile(session);
                break;
        }
    }

    HsqlArrayList list = getAllTables();

    for (int i = 0; i < list.size(); i++) {
        Table t = (Table) list.get(i);

        t.updateConstraintPath();
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Creates GET DIAGNOSTICS.
 */
Statement compileGetStatement(RangeGroup[] rangeGroups) {

    read();
    readThis(Tokens.DIAGNOSTICS);

    OrderedHashSet  targetSet    = new OrderedHashSet();
    HsqlArrayList   exprList     = new HsqlArrayList();
    LongDeque       colIndexList = new LongDeque();
    RangeVariable[] rangeVars    = rangeGroups[0].getRangeVariables();

    readGetClauseList(rangeVars, targetSet, colIndexList, exprList);

    if (exprList.size() > 1) {
        throw Error.parseError(ErrorCode.X_42602, null,
                               scanner.getLineNumber());
    }

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

    if (expression.getDegree() != targetSet.size()) {
        throw Error.error(ErrorCode.X_42546, Tokens.T_SET);
    }

    int[] columnMap = new int[colIndexList.size()];

    colIndexList.toArray(columnMap);

    Expression[] targets = new Expression[targetSet.size()];

    targetSet.toArray(targets);

    for (int i = 0; i < targets.length; i++) {
        resolveOuterReferencesAndTypes(rangeGroups, targets[i]);
    }

    resolveOuterReferencesAndTypes(rangeGroups, expression);

    for (int i = 0; i < targets.length; i++) {
        if (targets[i].getColumn().getParameterMode()
                == SchemaObject.ParameterModes.PARAM_IN) {

            // todo - use more specific error message
            throw Error.parseError(ErrorCode.X_0U000, null,
                                   scanner.getLineNumber());
        }

        if (!targets[i].getDataType().canBeAssignedFrom(
                expression.getNodeDataType(i))) {
            throw Error.parseError(ErrorCode.X_42561, null,
                                   scanner.getLineNumber());
        }
    }

    StatementSet cs = new StatementSet(session, targets, expression,
                                       columnMap, compileContext);

    return cs;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
public Result executeDirectStatement(Result cmd) {

        String        sql = cmd.getMainString();
        HsqlArrayList list;
        int           maxRows = cmd.getUpdateCount();

        if (maxRows == -1) {
            sessionContext.currentMaxRows = 0;
        } else if (sessionMaxRows == 0) {
            sessionContext.currentMaxRows = maxRows;
        } else {
            sessionContext.currentMaxRows = sessionMaxRows;
            sessionMaxRows                = 0;
        }

        try {
            list = parser.compileStatements(sql, cmd);
        } catch (Throwable e) {
            return Result.newErrorResult(e);
        }

        Result   result         = null;
        boolean  recompile      = false;
        HsqlName originalSchema = getCurrentSchemaHsqlName();

        for (int i = 0; i < list.size(); i++) {
            Statement cs = (Statement) list.get(i);

            if (i > 0) {
                if (cs.getCompileTimestamp()
                        > database.txManager.getGlobalChangeTimestamp()) {
                    recompile = true;
                }

                if (cs.getSchemaName() != null
                        && cs.getSchemaName() != originalSchema) {
                    recompile = true;
                }
            }

            if (recompile) {
                cs = compileStatement(cs.getSQL(), cmd.getExecuteProperties());
            }

            cs.setGeneratedColumnInfo(cmd.getGeneratedResultType(),
                                      cmd.getGeneratedResultMetaData());

            result = executeCompiledStatement(cs, ValuePool.emptyObjectArray,
                                              cmd.queryTimeout);

            if (result.mode == ResultConstants.ERROR) {
                break;
            }
        }

        return result;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
void expandConditions(HsqlArrayList[] array, boolean isJoin) {

        for (int i = 0; i < rangeVariables.length; i++) {
            HsqlArrayList list = array[i];

            map.clear();
            set.clear();

            boolean hasChain = false;

            for (int j = 0; j < list.size(); j++) {
                Expression e = (Expression) list.get(j);

                if (!e.isColumnEqual
                        || e.getLeftNode().getRangeVariable()
                           == e.getRightNode().getRangeVariable()) {
                    continue;
                }

                if (e.getLeftNode().getRangeVariable() == rangeVariables[i]) {
                    map.put(e.getLeftNode().getColumn(), e.getRightNode());

                    if (!set.add(e.getLeftNode().getColumn())) {
                        hasChain = true;
                    }
                } else {
                    map.put(e.getRightNode().getColumn(), e.getLeftNode());

                    if (!set.add(e.getRightNode().getColumn())) {
                        hasChain = true;
                    }
                }
            }

            if (hasChain && !(hasOuterJoin && isJoin)) {
                Iterator keyIt = map.keySet().iterator();

                while (keyIt.hasNext()) {
                    Object   key = keyIt.next();
                    Iterator it  = map.get(key);

                    set.clear();

                    while (it.hasNext()) {
                        set.add(it.next());
                    }

                    while (set.size() > 1) {
                        Expression e1 = (Expression) set.remove(set.size()
                            - 1);

                        for (int j = 0; j < set.size(); j++) {
                            Expression e2 = (Expression) set.get(j);

                            closeJoinChain(array, e1, e2);
                        }
                    }
                }
            }
        }
    }