Java HsqlArrayList.add方法代码示例

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包/类
HsqlArrayList getSchemas(Grantee grantee) {

        HsqlArrayList list = new HsqlArrayList();
        Iterator      it   = schemaMap.values().iterator();

        while (it.hasNext()) {
            Schema schema = (Schema) it.next();

            if (grantee.equals(schema.owner)) {
                list.add(schema);
            }
        }

        return list;
    }
 

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 void testSpeed() {

        randomGenerator = new Random(System.currentTimeMillis());

        int           TEST_RUNS     = 100000;
        int           LOOP_COUNT    = 1000;
        HsqlArrayList arrayList     = new HsqlArrayList(TEST_RUNS);
        ArrayList     utilArrayList = new ArrayList(TEST_RUNS);
        Vector        vector        = new Vector(TEST_RUNS);
        Integer       value         = new Integer(randomGenerator.nextInt());
        Integer       INT_0         = new Integer(0);
        StopWatch     sw            = new StopWatch();

        System.out.println(sw.currentElapsedTimeToMessage("time"));

        for (int i = 0; i < TEST_RUNS; i++) {
            arrayList.add(INT_0);
        }

        for (int i = 0; i < TEST_RUNS; i++) {
            for (int j = 0; j < LOOP_COUNT; j++) {
                arrayList.set(i, INT_0);
            }
        }

        System.out.println(sw.currentElapsedTimeToMessage("time"));
        sw.zero();

        for (int i = 0; i < TEST_RUNS; i++) {
            utilArrayList.add(INT_0);
        }

        for (int i = 0; i < TEST_RUNS; i++) {
            for (int j = 0; j < LOOP_COUNT; j++) {
                utilArrayList.set(i, INT_0);
            }
        }

        System.out.println(sw.currentElapsedTimeToMessage("time"));
        sw.zero();

        for (int i = 0; i < TEST_RUNS; i++) {
            vector.addElement(INT_0);
        }

        for (int i = 0; i < TEST_RUNS; i++) {
            for (int j = 0; j < LOOP_COUNT; j++) {
                vector.setElementAt(INT_0, i);
            }
        }

        System.out.println(sw.currentElapsedTimeToMessage("time"));
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
HsqlArrayList compileStatements(String sql, int returnType) {

        HsqlArrayList list = new HsqlArrayList();
        Statement     cs   = null;

        reset(sql);

        while (true) {
            if (token.tokenType == Tokens.X_ENDPARSE) {
                break;
            }

            compileContext.reset();

            cs = compilePart();

            if (cs == null) {
                list.add(cs);
            } else {
                list.add(cs);
            }
        }

        if (returnType != StatementTypes.RETURN_ANY) {
            int group = cs.getGroup();

            if (group == StatementTypes.X_SQL_DATA) {
                if (returnType == StatementTypes.RETURN_COUNT) {
                    throw Error.error(ErrorCode.X_07503);
                }
            } else if (returnType == StatementTypes.RETURN_RESULT) {
                throw Error.error(ErrorCode.X_07504);
            }
        }

        return list;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Performs a preformatted statement or group of statements and throws
 *  if the result does not match the expected one.
 * @param line start line in the script file for this test
 * @param stat Statement object used to access the database
 * @param s Contains the type, expected result and SQL for the test
 */
static void test(Statement stat, String s, int line) {

    //maintain the interface for this method
    HsqlArrayList section = new HsqlArrayList();

    section.add(s);
    testSection(stat, section, line);
}
 

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

        readLock.lock();

        try {
            Session       sysSession = database.sessionManager.getSysSession();
            long[][]      rootsArray = getIndexRoots(sysSession);
            HsqlArrayList tableList  = getAllTables(true);
            HsqlArrayList list       = new HsqlArrayList();

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

                if (rootsArray[i] != null && rootsArray[i].length > 0
                        && rootsArray[i][0] != -1) {
                    String ddl = table.getIndexRootsSQL(rootsArray[i]);

                    list.add(ddl);
                }
            }

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

            list.toArray(array);

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

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Used solely by org.hsqldb.dbinfo in existing system tables lacking column
 * level reporting.<p>
 *
 * Returns names of individual rights instead of ALL
 */
String[] getTableRightsArray() {

    if (isFull) {
        return new String[] {
            Tokens.T_SELECT, Tokens.T_INSERT, Tokens.T_UPDATE,
            Tokens.T_DELETE, Tokens.T_REFERENCES
        };
    }

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

    if (isFullSelect) {
        list.add(Tokens.T_SELECT);
    }

    if (isFullInsert) {
        list.add(Tokens.T_INSERT);
    }

    if (isFullUpdate) {
        list.add(Tokens.T_UPDATE);
    }

    if (isFullDelete) {
        list.add(Tokens.T_DELETE);
    }

    if (isFullReferences) {
        list.add(Tokens.T_REFERENCES);
    }

    if (isFullTrigger) {
        list.add(Tokens.T_TRIGGER);
    }

    list.toArray(array);

    return array;
}
 

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

        int           position = getPosition();
        Type          type;
        HsqlArrayList names = new HsqlArrayList();

        try {
            readThis(Tokens.DECLARE);

            if (isReservedKey()) {
                rewind(position);

                return null;
            }

            while (true) {
                HsqlName name = readNewSchemaObjectName(SchemaObject.VARIABLE,
                    false);

                if (token.tokenType == Tokens.CONDITION) {
                    rewind(position);

                    return null;
                }

                names.add(name);

                if (token.tokenType == Tokens.COMMA) {
                    read();
                } else {
                    break;
                }
            }

            type = readTypeDefinition(false, true);
        } catch (HsqlException e) {

            // may be cursor
            rewind(position);

            return null;
        }

        Expression def = null;

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

            def = readDefaultClause(type);
        }

        ColumnSchema[] variable = new ColumnSchema[names.size()];

        for (int i = 0; i < names.size(); i++) {
            variable[i] = new ColumnSchema((HsqlName) names.get(i), type,
                                           true, false, def);

            variable[i].setParameterMode(
                SchemaObject.ParameterModes.PARAM_INOUT);
        }

        readThis(Tokens.SEMICOLON);

        return variable;
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private Expression parseInPredicate(Expression a) throws HsqlException {

        int type = iToken;

        read();
        readThis(Expression.OPEN);

        Expression b        = null;
        int        brackets = 0;

        if (iToken == Expression.OPEN) {
            brackets += parseOpenBrackets() + 1;

            read();
        }

        if (iToken == Expression.SELECT) {
            SubQuery sq = parseSubquery(brackets, null, false, Expression.IN);

            // until we support rows in IN predicates
            Trace.check(sq.select.iResultLen == 1,
                        Trace.SINGLE_COLUMN_EXPECTED);

            b = new Expression(sq);

            read();
        } else {
            tokenizer.back();

            HsqlArrayList v = new HsqlArrayList();

            while (true) {
                Expression value = parseExpression();

                if (value.exprType == Expression.VALUE
                        && value.valueData == null && !value.isParam()) {
                    throw Trace.error(Trace.NULL_IN_VALUE_LIST);
                }

                v.add(value);
                read();

                if (iToken != Expression.COMMA) {
                    break;
                }
            }

            Expression[] valueList;

            valueList = (Expression[]) v.toArray(new Expression[v.size()]);
            b         = new Expression(valueList);
        }

        readThis(Expression.CLOSE);

        return new Expression(type, a, b);
    }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
private Statement readCase(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 StatementSimple(StatementTypes.CONDITION,
                                            condition);

            list.add(statement);

            statements = readSQLProcedureStatementList(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包/类
/**
* if a tiny table is in the middle of the range list, then this will have no
* effect on joins. therefore the larger tables should be put first, avoiding
* multiple lookups
*
* the index selectivity should also account for the size, and account for
* disk seek, which means finding a unique value in large tables takes a lot
* more time than scanning a table with 10 rows.
*
*
*/
   void reorder() {

       if (!reorder) {
           return;
       }

       if (rangeVariables.length == 1
               || firstRightJoinIndex != rangeVariables.length) {
           return;
       }

       if (firstLeftJoinIndex == 1) {
           return;
       }

       if (firstLateralJoinIndex != rangeVariables.length) {
           return;
       }

       if (sortAndSlice.usingIndex
               && sortAndSlice.primaryTableIndex != null) {
           return;
       }

       HsqlArrayList joins  = new HsqlArrayList();
       HsqlArrayList starts = new HsqlArrayList();

       for (int i = 0; i < firstLeftJoinIndex; i++) {
           HsqlArrayList tempJoins = tempJoinExpressions[i];

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

               if (e.isColumnEqual) {
                   joins.add(e);
               } else if (e.isSingleColumnCondition) {
                   starts.add(e);
               }
           }
       }

       reorderRanges(starts, joins);
   }
 

import org.hsqldb.lib.HsqlArrayList; //导入方法依赖的package包/类
/**
 * Divides AND conditions and assigns
 */
static Expression decomposeCondition(Expression e,
                                     HsqlArrayList conditions) {

    if (e == null) {
        return Expression.EXPR_TRUE;
    }

    Expression arg1 = e.getLeftNode();
    Expression arg2 = e.getRightNode();
    int        type = e.getType();

    if (type == OpTypes.AND) {
        arg1 = decomposeCondition(arg1, conditions);
        arg2 = decomposeCondition(arg2, conditions);

        if (arg1 == Expression.EXPR_TRUE) {
            return arg2;
        }

        if (arg2 == Expression.EXPR_TRUE) {
            return arg1;
        }

        e.setLeftNode(arg1);
        e.setRightNode(arg2);

        return e;
    } else if (type == OpTypes.EQUAL) {
        if (arg1.getType() == OpTypes.ROW
                && arg2.getType() == OpTypes.ROW) {
            for (int i = 0; i < arg1.nodes.length; i++) {
                Expression part = new ExpressionLogical(arg1.nodes[i],
                    arg2.nodes[i]);

                part.resolveTypes(null, null);
                conditions.add(part);
            }

            return Expression.EXPR_TRUE;
        }
    }

    if (e != Expression.EXPR_TRUE) {
        conditions.add(e);
    }

    return Expression.EXPR_TRUE;
}
 

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(OrderedHashSet insertColumnNames,
                           OrderedHashSet updateColumnNames,
                           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, updateColumnNames,
                          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) {
            readSimpleColumnNames(insertColumnNames, targetRangeVars[0]);
            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(insertColumnNames, updateColumnNames,
                      insertExpressions, updateExpressions,
                      targetRangeVars, sourceRangeVar);
    }
}
 

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

        HsqlArrayList list = new HsqlArrayList();

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

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

        list.toArray(array);

        return array;
    }