Java HsqlArrayList.size方法代码示例

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

        Session       sysSession = database.sessionManager.getSysSession();
        HsqlArrayList tableList  = getAllTables();
        HsqlArrayList list       = new HsqlArrayList();

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

            if (t.isIndexCached() && !t.isEmpty(sysSession)) {
                String ddl = ((Table) tableList.get(i)).getIndexRootsSQL();

                if (ddl != null) {
                    list.add(ddl);
                }
            }
        }

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

        list.toArray(array);

        return array;
    }
 

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包/类
/**
 * 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包/类
/**
 * 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包/类
/**
 * Drops all triggers.
 */
void dropTriggers() {

    // look in each trigger list of each type of trigger
    int numTrigs = TriggerDef.NUM_TRIGS;

    for (int tv = 0; tv < numTrigs; tv++) {
        HsqlArrayList v = triggerLists[tv];

        if (v == null) {
            continue;
        }

        for (int tr = v.size() - 1; tr >= 0; tr--) {
            TriggerDef td = (TriggerDef) v.get(tr);

            td.terminate();
        }

        triggerLists[tv] = null;
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
void checkDelete(Session session,
                 HsqlArrayList rowSet) throws HsqlException {

    if (!reWriteProtect) {
        return;
    }

    int sessionid = session.getId();

    for (int i = 0, size = rowSet.size(); i < size; i++) {
        Row  row   = (Row) rowSet.get(i);
        long rowid = row.getId();

        if (rowSessionMap.get(rowid, sessionid) != sessionid) {
            throw Trace.error(Trace.INVALID_TRANSACTION_STATE_NO_SUBCLASS,
                              Trace.ITSNS_OVERWRITE);
        }
    }
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
public String[] getSQLForTextSource(boolean withHeader) {

        // readonly for TEXT tables only
        if (isText()) {
            HsqlArrayList list = new HsqlArrayList();

            if (isReadOnly) {
                list.add(getSQLForReadOnly());
            }

            // data source
            String dataSource = ((TextTable) this).getDataSourceDDL();

            if (dataSource != null) {
                list.add(dataSource);
            }

            // header
            String header = ((TextTable) this).getDataSourceHeader();

            if (withHeader && header != null && !isReadOnly) {
                list.add(header);
            }

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

            list.toArray(array);

            return array;
        } else {
            return null;
        }
    }
 

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

        readLock.lock();

        try {
            HsqlArrayList tableList = getAllTables(false);
            HsqlArrayList list      = new HsqlArrayList();

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

                if (t.isCached()) {
                    String ddl = t.getSQLForTableSpace();

                    if (ddl != null) {
                        list.add(ddl);
                    }
                }
            }

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

            list.toArray(array);

            return array;
        } finally {
            readLock.unlock();
        }
    }
 

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

        HsqlArrayList list = new HsqlArrayList();

        if (schemaManager.getDefaultTableType() == TableBase.CACHED_TABLE) {
            list.add("SET DATABASE DEFAULT TABLE TYPE CACHED");
        }

        if (logger.hasLog()) {
            int     delay  = logger.getWriteDelay();
            boolean millis = delay < 1000;

            if (millis) {
                if (delay != 0 && delay < 20) {
                    delay = 20;
                }
            } else {
                delay /= 1000;
            }

            list.add("SET WRITE_DELAY " + delay + (millis ? " MILLIS"
                                                          : ""));
        }

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

        list.toArray(array);

        return array;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private Statement[] compileSQLProcedureStatementList(Routine routine,
        StatementCompound context) {

    Statement     e;
    HsqlArrayList list = new HsqlArrayList();

    while (true) {
        e = compileSQLProcedureStatementOrNull(routine, context);

        if (e == null) {
            break;
        }

        readThis(Tokens.SEMICOLON);
        list.add(e);
    }

    if (list.size() == 0) {
        throw unexpectedToken();
    }

    Statement[] statements = new Statement[list.size()];

    list.toArray(statements);

    return statements;
}
 

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

    read();

    Expression[]   updateExpressions;
    int[]          columnMap;
    OrderedHashSet targetSet = new OrderedHashSet();
    HsqlArrayList  exprList  = new HsqlArrayList();
    RangeVariable[] targetRangeVars = new RangeVariable[]{
        rangeGroups[0].getRangeVariables()[TriggerDef.NEW_ROW] };
    LongDeque colIndexList = new LongDeque();

    readSetClauseList(targetRangeVars, targetSet, colIndexList, exprList);

    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(RangeGroup.emptyArray, targets[i]);
    }

    updateExpressions = new Expression[exprList.size()];

    exprList.toArray(updateExpressions);
    resolveUpdateExpressions(table, RangeGroup.emptyGroup, columnMap,
                             updateExpressions, rangeGroups);

    StatementDMQL cs = new StatementSet(session, targets, table,
                                        rangeGroups[0].getRangeVariables(),
                                        columnMap, updateExpressions,
                                        compileContext);

    return cs;
}
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Allows changes to type of column or addition of an IDENTITY generator.
 * IDENTITY is not removed if it does not appear in new column definition
 * Constraint definitions are not allowed
 */
private void processAlterColumnType(Table table, ColumnSchema oldCol, boolean fullDefinition) {

    ColumnSchema newCol;

    if (oldCol.isGenerated()) {
        throw Error.error(ErrorCode.X_42561);
    }

    if (fullDefinition) {
        HsqlArrayList list = new HsqlArrayList();
        Constraint c = table.getPrimaryConstraint();

        if (c == null) {
            c = new Constraint(null, null, Constraint.TEMP);
        }

        list.add(c);

        newCol = readColumnDefinitionOrNull(table, oldCol.getName(), list);

        if (newCol == null) {
            throw Error.error(ErrorCode.X_42000);
        }

        if (oldCol.isIdentity() && newCol.isIdentity()) {
            throw Error.error(ErrorCode.X_42525);
        }

        if (list.size() > 1) {
            throw Error.error(ErrorCode.X_42524);
        }
    } else {
        Type type = readTypeDefinition(true);

        if (oldCol.isIdentity()) {
            if (!type.isIntegralType()) {
                throw Error.error(ErrorCode.X_42561);
            }
        }

        newCol = oldCol.duplicate();

        newCol.setType(type);
    }

    TableWorks tw = new TableWorks(session, table);

    tw.retypeColumn(oldCol, newCol);
}
 

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

        int position = getPosition();

        try {
            readThis(Tokens.DECLARE);
            readThis(Tokens.LOCAL);
            readThis(Tokens.TEMPORARY);
            readThis(Tokens.TABLE);
        } catch (HsqlException e) {
            lastError = e;

            // may be cursor
            rewind(position);

            return null;
        }

        if (token.namePrePrefix == null
                && (token.namePrefix == null
                    || Tokens.T_MODULE.equals(token.namePrefix)
                    || Tokens.T_SESSION.equals(token.namePrefix))) {

            // valid name
        } else {
            throw unexpectedToken();
        }

        boolean  ifNot = readIfNotExists();
        HsqlName name  = readNewSchemaObjectName(SchemaObject.TABLE, false);

        name.schema = SqlInvariants.MODULE_HSQLNAME;

        Table table = new Table(database, name, TableBase.TEMP_TABLE);
        StatementSchema cs;

        if (token.tokenType == Tokens.AS) {
            cs = compileCreateTableAsSubqueryDefinition(table);
        } else {
            cs = compileCreateTableBody(table, ifNot);

            HsqlArrayList constraints = (HsqlArrayList) cs.arguments[1];

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

                if (c.getConstraintType()
                        == SchemaObject.ConstraintTypes.FOREIGN_KEY) {
                    throw unexpectedToken(Tokens.T_FOREIGN);
                }
            }
        }

        StatementSession ss =
            new StatementSession(StatementTypes.DECLARE_SESSION_TABLE,
                                 cs.arguments);

        return ss;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private Statement compileCase(Routine routine, StatementCompound context) {

        HsqlArrayList list      = new HsqlArrayList();
        Expression    condition = null;
        Statement     statement;
        Statement[]   statements;

        readThis(Tokens.CASE);

        if (token.tokenType == Tokens.WHEN) {
            list = readCaseWhen(routine, context);
        } else {
            list = readSimpleCaseWhen(routine, context);
        }

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

            condition = Expression.EXPR_TRUE;
            statement = new StatementExpression(session, compileContext,
                                                StatementTypes.CONDITION,
                                                condition);

            list.add(statement);

            statements = compileSQLProcedureStatementList(routine, context);

            for (int i = 0; i < statements.length; i++) {
                list.add(statements[i]);
            }
        }

        readThis(Tokens.END);
        readThis(Tokens.CASE);

        statements = new Statement[list.size()];

        list.toArray(statements);

        StatementCompound result = new StatementCompound(StatementTypes.IF,
            null);

        result.setStatements(statements);

        return result;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Parses a WHEN clause from a MERGE statement. This can be either a
 * WHEN MATCHED or WHEN NOT MATCHED clause, or both, and the appropriate
 * values will be updated.
 *
 * If the var that is to hold the data is not null, then we already
 * encountered this type of clause, which is only allowed once, and at least
 * one is required.
 */
private void readMergeWhen(LongDeque updateColIndexList,
                           OrderedHashSet insertColumnNames,
                           OrderedHashSet updateTargetSet,
                           HsqlArrayList insertExpressions,
                           HsqlArrayList updateExpressions,
                           RangeVariable[] targetRangeVars,
                           RangeVariable sourceRangeVar) {

    Table table       = targetRangeVars[0].rangeTable;
    int   columnCount = table.getColumnCount();

    readThis(Tokens.WHEN);

    if (token.tokenType == Tokens.MATCHED) {
        if (updateExpressions.size() != 0) {
            throw Error.error(ErrorCode.X_42547);
        }

        read();
        readThis(Tokens.THEN);
        readThis(Tokens.UPDATE);
        readThis(Tokens.SET);
        readSetClauseList(targetRangeVars, updateTargetSet,
                          updateColIndexList, updateExpressions);
    } else if (token.tokenType == Tokens.NOT) {
        if (insertExpressions.size() != 0) {
            throw Error.error(ErrorCode.X_42548);
        }

        read();
        readThis(Tokens.MATCHED);
        readThis(Tokens.THEN);
        readThis(Tokens.INSERT);

        // parse INSERT statement
        // optional column list
        int brackets = readOpenBrackets();

        if (brackets == 1) {
            boolean withPrefix = database.sqlSyntaxOra;

            readSimpleColumnNames(insertColumnNames, targetRangeVars[0],
                                  withPrefix);

            columnCount = insertColumnNames.size();

            readThis(Tokens.CLOSEBRACKET);

            brackets = 0;
        }

        readThis(Tokens.VALUES);

        Expression e = XreadContextuallyTypedTable(columnCount);

        if (e.nodes.length != 1) {
            throw Error.error(ErrorCode.X_21000);
        }

        insertExpressions.add(e);
    } else {
        throw unexpectedToken();
    }

    if (token.tokenType == Tokens.WHEN) {
        readMergeWhen(updateColIndexList, insertColumnNames,
                      updateTargetSet, insertExpressions,
                      updateExpressions, targetRangeVars, sourceRangeVar);
    }
}