import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * Constructor declaration
 *
 *
 * @param name HsqlName of the index
 * @param table table of the index
 * @param column array of column indexes
 * @param type array of column types
 * @param unique is this a unique index
 * @param constraint does this index belonging to a constraint
 * @param forward is this an auto-index for an FK that refers to a table defined after this table
 * @param visColumns count of visible columns
 */
Index(HsqlName name, Table table, int column[], int type[],
        boolean unique, boolean constraint, boolean forward,
        int visColumns) {

    indexName      = name;
    colIndex       = column;
    colType        = type;
    isUnique       = unique;
    isConstraint   = constraint;
    isForward      = forward;
    colIndex_0     = colIndex[0];
    colType_0      = colType[0];
    visibleColumns = visColumns;
    isExact        = colIndex.length == visibleColumns;
    colCheck       = table.getNewColumnCheckList();

    ArrayUtil.intIndexesToBooleanArray(colIndex, colCheck);
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
public void release() {

        if (!isCached) {
            destroy();
        }

        if (isCached) {
            cache.adjustStoreCount(-1);

            cache    = null;
            isCached = false;
        }

        elementCount.set(0);
        ArrayUtil.fillArray(accessorList, null);
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
public TableDerived(Database database, HsqlName name, int type,
                    Type[] columnTypes, HashMappedList columnList,
                    QueryExpression queryExpression) {

    this(database, name, type, queryExpression);

    this.colTypes          = columnTypes;
    this.columnList        = columnList;
    columnCount            = columnList.size();
    primaryKeyCols         = ValuePool.emptyIntArray;
    primaryKeyTypes        = Type.emptyArray;
    primaryKeyColsSequence = ValuePool.emptyIntArray;
    colDefaults            = new Expression[columnCount];
    colNotNull             = new boolean[columnCount];
    defaultColumnMap       = new int[columnCount];

    ArrayUtil.fillSequence(defaultColumnMap);

    bestIndexForColumn = new int[colTypes.length];

    ArrayUtil.fillArray(bestIndexForColumn, -1);
    createPrimaryIndex(primaryKeyCols, primaryKeyTypes, null);
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
Object[] getRow(Object[] row) {

        if (isGrouped) {
            ResultGroup newGroup = new ResultGroup(row);
            ResultGroup group    = (ResultGroup) groups.get(newGroup);

            if (group != null) {
                ArrayUtil.copyArray(group.row, row, row.length);
            }
        } else if (isAggregated) {
            if (currGroup != null) {
                ArrayUtil.copyArray(currGroup.row, row, row.length);
            }
        }

        return row;
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
final void addIndex(Session session, Index index) {

        int i = 0;

        for (; i < indexList.length; i++) {
            Index current = indexList[i];
            int order = index.getIndexOrderValue()
                        - current.getIndexOrderValue();

            if (order < 0) {
                break;
            }
        }

        Index[] oldIndexList = indexList;

        indexList = (Index[]) ArrayUtil.toAdjustedArray(indexList, index, i,
                1);

        for (i = 0; i < indexList.length; i++) {
            indexList[i].setPosition(i);
        }

        resetAccessorKeys(session, indexList, oldIndexList);
        setBestRowIdentifiers();
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * For the candidate table row, finds any referring node in the main table.
 * This is used to check referential integrity when updating a node. We
 * have to make sure that the main table still holds a valid main record.
 * returns true If a valid row is found, false if there are null in the data
 * Otherwise a 'INTEGRITY VIOLATION' Exception gets thrown.
 */
boolean checkHasMainRef(Session session, Object[] row) {

    if (ArrayUtil.hasNull(row, core.refCols)) {
        return false;
    }

    PersistentStore store =
        session.sessionData.getRowStore(core.mainTable);
    boolean exists = core.mainIndex.exists(session, store, row,
                                           core.refCols);

    if (!exists) {
        String[] info = new String[] {
            core.refName.name, core.mainTable.getName().name
        };

        throw Error.error(ErrorCode.X_23502, ErrorCode.CONSTRAINT, info);
    }

    return exists;
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
void resolveTypesPartOne(Session session) {

        ArrayUtil.projectRowReverse(leftQueryExpression.unionColumnTypes,
                                    leftQueryExpression.unionColumnMap,
                                    unionColumnTypes);
        leftQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(leftQueryExpression.unionColumnTypes,
                             leftQueryExpression.unionColumnMap,
                             unionColumnTypes);
        ArrayUtil.projectRowReverse(rightQueryExpression.unionColumnTypes,
                                    rightQueryExpression.unionColumnMap,
                                    unionColumnTypes);
        rightQueryExpression.resolveTypesPartOne(session);
        ArrayUtil.projectRow(rightQueryExpression.unionColumnTypes,
                             rightQueryExpression.unionColumnMap,
                             unionColumnTypes);
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
private Result getBytesCompressed(long lobID, long offset, int length,
                                  boolean isClob) {

    byte[]   dataBytes = new byte[length];
    long[][] parts     = getParts(lobID, offset, offset + length);

    for (int i = 0; i < parts.length; i++) {
        long[] part       = parts[i];
        long   partOffset = part[ALLOC_PART.PART_OFFSET];
        int    partLength = (int) part[ALLOC_PART.PART_LENGTH];
        Result result = getPartBytesCompressedInBuffer(lobID, part,
            isClob);

        if (result.isError()) {
            return result;
        }

        ArrayUtil.copyBytes(partOffset, dataBuffer, 0, partLength, offset,
                            dataBytes, length);
    }

    return ResultLob.newLobGetBytesResponse(lobID, offset, dataBytes);
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * Used for subquery inserts. No checks. No identity
 * columns.
 */
int insertResult(Session session, Result ins) throws HsqlException {

    Record ni    = ins.rRoot;
    int    count = 0;

    while (ni != null) {
        Object[] newData =
            (Object[]) ArrayUtil.resizeArrayIfDifferent(ni.data,
                columnCount);

        insertData(session, newData);

        ni = ni.next;

        count++;
    }

    return count;
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * Choice limited to values list, defaultValue must be in the values list.
 */
public int getIntegerProperty(String key, int defaultValue, int[] values) {

    String prop  = getProperty(key);
    int    value = defaultValue;

    try {
        if (prop != null) {
            value = Integer.parseInt(prop);
        }
    } catch (NumberFormatException e) {}

    if (ArrayUtil.find(values, value) == -1) {
        return defaultValue;
    }

    return value;
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 *  Removes any foreign key Constraint objects (exported keys) held by any
 *  tables referenced by the specified table. <p>
 *
 *  This method is called as the last step of a successful call to
 *  dropTable() in order to ensure that the dropped Table ceases to be
 *  referenced when enforcing referential integrity.
 *
 * @param  toDrop The table to which other tables may be holding keys.
 *      This is a table that is in the process of being dropped.
 */
void removeExportedKeys(Table toDrop) {

    Schema schema = (Schema) schemaMap.get(toDrop.getSchemaName());

    for (int i = 0; i < schema.tableList.size(); i++) {
        Table table = (Table) schema.tableList.get(i);

        for (int j = table.constraintList.length - 1; j >= 0; j--) {
            Table refTable = table.constraintList[j].getRef();

            if (toDrop == refTable) {
                table.constraintList =
                    (Constraint[]) ArrayUtil.toAdjustedArray(
                        table.constraintList, null, j, -1);
            }
        }
    }
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
public void union(Session session, RowSetNavigatorData other) {

        Object[] currentData;
        int      colCount = table.getColumnTypes().length;

        removeDuplicates(session);
        other.reset();

        while (other.hasNext()) {
            currentData = other.getNext();

            RowIterator it = findFirstRow(currentData);

            if (!it.hasNext()) {
                currentData =
                    (Object[]) ArrayUtil.resizeArrayIfDifferent(currentData,
                        colCount);

                add(currentData);
            }
        }

        other.release();
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
public void prepare(int degree) {

        columnCount = exprList.size();

        if (columnCount == 0) {
            return;
        }

        sortOrder      = new int[columnCount + degree];
        sortDescending = new boolean[columnCount + degree];
        sortNullsLast  = new boolean[columnCount + degree];

        ArrayUtil.fillSequence(sortOrder);

        for (int i = 0; i < columnCount; i++) {
            ExpressionOrderBy sort = (ExpressionOrderBy) exprList.get(i);

            sortDescending[i] = sort.isDescending();
            sortNullsLast[i]  = sort.isNullsLast();
            hasNullsLast      |= sortNullsLast[i];
        }
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * Compares this with another constraint column set. This implementation
 * only checks FOREIGN KEY constraints.
 */
boolean isEquivalent(Table tablemain, int[] colmain, Table tableref,
                     int[] colref) {

    if (constType != Constraint.MAIN
            && constType != Constraint.FOREIGN_KEY) {
        return false;
    }

    if (tablemain != core.mainTable || tableref != core.refTable) {
        return false;
    }

    return ArrayUtil.areEqualSets(core.mainColArray, colmain)
           && ArrayUtil.areEqualSets(core.refColArray, colref);
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
private void resolveAggregates() {

        tempSet.clear();

        if (isAggregated) {
            aggregateCheck = new boolean[indexStartAggregates];

            tempSet.addAll(aggregateSet);

            indexLimitData = indexLimitExpressions = exprColumns.length
                    + tempSet.size();
            exprColumns = (Expression[]) ArrayUtil.resizeArray(exprColumns,
                    indexLimitExpressions);

            for (int i = indexStartAggregates, j = 0;
                    i < indexLimitExpressions; i++, j++) {
                Expression e = (Expression) tempSet.get(j);

                exprColumns[i]          = e.duplicate();
                exprColumns[i].nodes    = e.nodes;    // keep original nodes
                exprColumns[i].dataType = e.dataType;
            }

            tempSet.clear();
        }
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
boolean hasColumn(int colIndex) {

        switch (constType) {

            case CHECK :
                return rangeVariable.usedColumns[colIndex];

            case PRIMARY_KEY :
            case UNIQUE :
            case MAIN :
                return ArrayUtil.find(core.mainCols, colIndex) != -1;

            case FOREIGN_KEY :
                return ArrayUtil.find(core.refCols, colIndex) != -1;

            default :
                throw Error.runtimeError(ErrorCode.U_S0500, "Constraint");
        }
    }
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 *  Used for TableFilter to get an index for the columns
 */
Index getIndexForColumns(boolean[] columnCheck) {

    Index indexChoice = null;
    int   colCount    = 0;

    for (int i = 0; i < indexList.length; i++) {
        Index index = indexList[i];
        boolean result = ArrayUtil.containsAllTrueElements(columnCheck,
            index.colCheck);

        if (result && index.getVisibleColumns() > colCount) {
            colCount    = index.getVisibleColumns();
            indexChoice = index;
        }
    }

    return indexChoice;
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 *  Finds an existing index for a foreign key column group
 */
Index getIndexForColumns(int[] col, boolean unique) throws HsqlException {

    for (int i = 0, count = getIndexCount(); i < count; i++) {
        Index currentindex = getIndex(i);
        int[] indexcol     = currentindex.getColumns();

        if (ArrayUtil.haveEqualArrays(indexcol, col, col.length)) {
            if (!unique || currentindex.isUnique()) {
                return currentindex;
            }
        }
    }

    return null;
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
/**
 * Compares this with another constraint column set. This implementation
 * only checks FOREIGN KEY constraints.
 */
boolean isEquivalent(Table mainTable, int[] mainCols, Table refTable,
                     int[] refCols) {

    if (constType != Constraint.MAIN
            && constType != Constraint.FOREIGN_KEY) {
        return false;
    }

    if (mainTable != core.mainTable || refTable != core.refTable) {
        return false;
    }

    return ArrayUtil.areEqualSets(core.mainCols, mainCols)
           && ArrayUtil.areEqualSets(core.refCols, refCols);
}
 

import org.hsqldb.lib.ArrayUtil; //导入依赖的package包/类
String parseSQLFeatureValue() {

        if (!isUndelimitedSimpleName()) {
            throw Error.parseError(ErrorCode.X_42555, token.tokenString,
                                   scanner.getLineNumber());
        }

        String sqlFeature = token.tokenString;
        int    index      = ArrayUtil.find(featureStrings, sqlFeature);

        if (index < 0) {
            throw Error.parseError(ErrorCode.X_42555, token.tokenString,
                                   scanner.getLineNumber());
        }

        read();

        return sqlFeature;
    }