import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
private static void addConditionsToList(HsqlArrayList list,
        Expression[] array) {

    if (array == null) {
        return;
    }

    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            if (array[i].isSingleColumnCondition
                    || array[i].isSingleColumnNull
                    || array[i].isSingleColumnNotNull) {
                list.add(array[i]);
            }
        }
    }
}
 

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包/类
/**
     * Collects all expressions that must be in the GROUP BY clause, for a
     * grouped select statement.
     *
     * @param colExps expression list
     */
    void collectInGroupByExpressions(HsqlArrayList colExps) {

        if (!(isConstant() || isSelfAggregate())) {
            if (isColumn()) {
                colExps.add(this);
            } else if (exprType == FUNCTION) {

//                function.collectInGroupByExpressions(colExps);
            } else if (exprType == CASEWHEN) {
                eArg2.collectInGroupByExpressions(colExps);
            } else {
                if (eArg != null) {
                    eArg.collectInGroupByExpressions(colExps);
                }

                if (eArg2 != null) {
                    eArg2.collectInGroupByExpressions(colExps);
                }
            }
        }
    }
 

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

    Grantee role = session.database.getGranteeManager().getRole(name.name);

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

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

    session.database.schemaManager.dropSchemas(session, role, cascade);
    session.database.getGranteeManager().dropRole(name.name);
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Compare contents of lists to the vector.  Print out stuff if they are
 * inconsistent and exit.
 */
public void compareLists(HsqlArrayList arrayList,
                         HsqlLinkedList linkedList, Vector vector) {

    boolean arrayListError  = false;
    boolean linkedListError = false;

    if (!equalsVector(arrayList, vector)) {
        System.out.println("Error in array list implementation");

        arrayListError = true;
    }

    if (!equalsVector(linkedList, vector)) {
        System.out.println("Error in linked list implementation");

        linkedListError = true;
    }

    if (arrayListError || linkedListError) {
        this.printListCommandsCalled(listCommandsCalled);
        System.out.flush();
        fail("test failed");
        System.exit(0);
    }
}
 

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包/类
/**
 * 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包/类
private void checkAggregateOrGroupByOrderColumns(int start,
        int end) throws HsqlException {

    checkAggregateOrGroupByColumns(start, end);

    if (start < end && isDistinctSelect) {
        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 (isSimilarIn(exp, 0, iResultLen)) {
                continue;
            }

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

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
private static String[] getRightsArraySub(int right) {

//        checkValidFlags(right);
        if (right == 0) {
            return emptyRightsList;
        }

        HsqlArrayList a  = new HsqlArrayList();
        Iterator      it = rightsStringLookup.keySet().iterator();

        for (; it.hasNext(); ) {
            String rightString = (String) it.next();

            if (rightString.equals(S_R_ALL)) {
                continue;
            }

            int i = rightsStringLookup.get(rightString, 0);

            if ((right & i) != 0) {
                a.add(rightString);
            }
        }

        return (String[]) a.toArray(new String[a.size()]);
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Constructs a new Session object.
 *
 * @param  db the database to which this represents a connection
 * @param  user the initial user
 * @param  autocommit the initial autocommit value
 * @param  readonly the initial readonly value
 * @param  id the session identifier, as known to the database
 */
Session(Database db, User user, boolean autocommit, boolean readonly,
        int id) {

    sessionId                 = id;
    database                  = db;
    this.user                 = user;
    rowActionList             = new HsqlArrayList(true);
    savepoints                = new HashMappedList(4);
    isAutoCommit              = autocommit;
    isReadOnly                = readonly;
    dbCommandInterpreter      = new DatabaseCommandInterpreter(this);
    compiledStatementExecutor = new CompiledStatementExecutor(this);
    compiledStatementManager  = db.compiledStatementManager;
    tokenizer                 = new Tokenizer();
    parser                    = new Parser(this, database, tokenizer);

    resetSchema();
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Add all columns to a list of expressions
 */
int addTableColumns(HsqlArrayList expList, int position, HashSet exclude) {

    Table table = getTable();
    int   count = table.getColumnCount();

    for (int i = 0; i < count; i++) {
        ColumnSchema column = table.getColumn(i);
        String columnName = columnAliases == null ? column.getName().name
                                                  : (String) columnAliases
                                                      .get(i);

        if (exclude != null && exclude.contains(columnName)) {
            continue;
        }

        Expression e = new ExpressionColumn(this, column, i);

        expList.add(position++, e);
    }

    return position;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
public HsqlArrayList getSQLArray(OrderedHashSet resolved,
                                 OrderedHashSet unresolved) {

    HsqlArrayList list      = new HsqlArrayList();
    String        setSchema = getSetSchemaSQL(name);

    list.add(setSchema);
    sequenceLookup.getSQL(list, resolved, unresolved);
    tableLookup.getSQL(list, resolved, unresolved);
    functionLookup.getSQL(list, resolved, unresolved);
    procedureLookup.getSQL(list, resolved, unresolved);
    referenceLookup.getSQL(list, resolved, unresolved);

    if (list.size() == 1) {
        list.clear();
    }

    return list;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Creates SET Statement for a trigger row from this parse context.
 */
StatementDMQL compileTriggerSetStatement(Table table, RangeVariable[] rangeVars) {

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

    columnMap = table.getColumnIndexes(colNames);
    updateExpressions = new Expression[exprList.size()];

    exprList.toArray(updateExpressions);
    resolveUpdateExpressions(table, rangeVars, columnMap, updateExpressions, RangeVariable.emptyArray);

    StatementDMQL cs = new StatementDML(session, table, rangeVars, columnMap, updateExpressions, compileContext);

    return cs;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Constructs a new Session object.
 *
 * @param  db the database to which this represents a connection
 * @param  user the initial user
 * @param  autocommit the initial autocommit value
 * @param  readonly the initial readonly value
 * @param  id the session identifier, as known to the database
 */
Session(Database db, User user, boolean autocommit, boolean readonly,
        long id, String zoneString, int timeZoneSeconds) {

    sessionId                   = id;
    database                    = db;
    this.user                   = user;
    this.sessionUser            = user;
    this.zoneString             = zoneString;
    this.sessionTimeZoneSeconds = timeZoneSeconds;
    this.timeZoneSeconds        = timeZoneSeconds;
    rowActionList               = new HsqlArrayList(32, true);
    waitedSessions              = new OrderedHashSet();
    waitingSessions             = new OrderedHashSet();
    tempSet                     = new OrderedHashSet();
    isolationLevelDefault       = database.defaultIsolationLevel;
    ignoreCase                  = database.sqlIgnoreCase;
    isolationLevel              = isolationLevelDefault;
    txConflictRollback          = database.txConflictRollback;
    isReadOnlyDefault           = readonly;
    isReadOnlyIsolation = isolationLevel
                          == SessionInterface.TX_READ_UNCOMMITTED;
    sessionContext              = new SessionContext(this);
    sessionContext.isAutoCommit = autocommit ? Boolean.TRUE
                                             : Boolean.FALSE;
    sessionContext.isReadOnly   = isReadOnlyDefault ? Boolean.TRUE
                                                    : Boolean.FALSE;
    parser = new ParserCommand(this, new Scanner(database));

    setResultMemoryRowCount(database.getResultMaxMemoryRows());
    resetSchema();

    sessionData           = new SessionData(database, this);
    statementManager      = new StatementManager(database);
    timeoutManager        = new TimeoutManager();
    sessionStartTimestamp = System.currentTimeMillis();
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
ExpressionArrayAggregate(int type, boolean distinct, Expression e,
                         SortAndSlice sort, String separator) {

    super(type);

    this.isDistinctAggregate = distinct;
    this.sort                = sort;

    if (separator != null) {
        this.separator = separator;
    }

    if (type == OpTypes.MEDIAN) {
        nodes = new Expression[]{ e };

        return;
    }

    if (sort == null) {
        nodes = new Expression[]{ e };
    } else {
        HsqlArrayList list = sort.getExpressionList();

        nodes = new Expression[list.size() + 1];

        list.toArray(nodes);

        nodes[list.size()] = e;

        sort.prepare(1);
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
public String[] getRightsSQL() {

        HsqlArrayList list     = new HsqlArrayList();
        Iterator      grantees = getGrantees().iterator();

        while (grantees.hasNext()) {
            Grantee grantee = (Grantee) grantees.next();
            String  name    = grantee.getName().getNameString();

            // _SYSTEM user, DBA Role grants not persisted
            if (GranteeManager.isImmutable(name)) {
                continue;
            }

            if (grantee instanceof User && ((User) grantee).isExternalOnly) {
                continue;
            }

            HsqlArrayList subList = grantee.getRightsSQL();

            list.addAll(subList);
        }

        String[] array = new String[list.size()];

        list.toArray(array);

        return array;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
/**
 * Add all columns to a list of expressions
 */
public 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包/类
/**
 * called from outside after the complete end of defrag
 */
void updateTableIndexRoots() {

    HsqlArrayList allTables = database.schemaManager.getAllTables();

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

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

            t.setIndexRoots(rootsArray);
        }
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
RangeVariableResolver(RangeVariable[] rangeVars, Expression conditions,
                      CompileContext compileContext) {

    this.rangeVariables = rangeVars;
    this.conditions     = conditions;
    this.compileContext = compileContext;

    for (int i = 0; i < rangeVars.length; i++) {
        RangeVariable range = rangeVars[i];

        rangeVarSet.add(range);

        if (range.isLeftJoin || range.isRightJoin) {
            hasOuterJoin = true;
        }
    }

    inExpressions       = new Expression[rangeVars.length];
    flags               = new boolean[rangeVars.length];
    tempJoinExpressions = new HsqlArrayList[rangeVars.length];

    for (int i = 0; i < rangeVars.length; i++) {
        tempJoinExpressions[i] = new HsqlArrayList();
    }

    joinExpressions = new HsqlArrayList[rangeVars.length];

    for (int i = 0; i < rangeVars.length; i++) {
        joinExpressions[i] = new HsqlArrayList();
    }

    whereExpressions = new HsqlArrayList[rangeVars.length];

    for (int i = 0; i < rangeVars.length; i++) {
        whereExpressions[i] = new HsqlArrayList();
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入依赖的package包/类
QuerySpecification(CompileContext compileContext) {

        super(compileContext);

        this.compileContext = compileContext;
        resultRangePosition = compileContext.getNextRangeVarIndex();
        rangeVariableList   = new HsqlArrayList();
        exprColumnList      = new HsqlArrayList();
        sortAndSlice        = SortAndSlice.noSort;
    }