import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
void checkSchemaUpdateAuthorisation(HsqlName schema) {

        if (session.isProcessingLog) {
            return;
        }

        SqlInvariants.checkSchemaNameNotSystem(schema.name);

        if (isSchemaDefinition) {
            if (schema != session.getCurrentSchemaHsqlName()) {
                throw Error.error(ErrorCode.X_42505);
            }
        } else {
            session.getGrantee().checkSchemaUpdateOrGrantRights(schema.name);
        }

        session.checkDDLWrite();
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
StatementSchema compileCreateSequence() {

        read();

        /*
         * CREATE SEQUENCE <name> [AS {INTEGER | BIGINT}] [START WITH <value>]
         * [INCREMENT BY <value>]
         */
        HsqlName name = readNewSchemaObjectNameNoCheck(SchemaObject.SEQUENCE);
        NumberSequence sequence = new NumberSequence(name, Type.SQL_INTEGER);

        readSequenceOptions(sequence, true, false);

        String sql = getLastPart();
        Object[] args = new Object[] { sequence };

        return new StatementSchema(sql, StatementTypes.CREATE_SEQUENCE, args, null, null);
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的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(grantee, cascade);
    session.database.getUserManager().dropUser(name.name);
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
public MultiValueHashMap getReferencesToSchema(String schemaName) {

        MultiValueHashMap map          = new MultiValueHashMap();
        Iterator          mainIterator = referenceMap.keySet().iterator();

        while (mainIterator.hasNext()) {
            HsqlName name = (HsqlName) mainIterator.next();

            if (!name.schema.name.equals(schemaName)) {
                continue;
            }

            Iterator it = referenceMap.get(name);

            while (it.hasNext()) {
                map.put(name, it.next());
            }
        }

        return map;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
public OrderedHashSet getReferencesTo(HsqlName object) {

        readLock.lock();

        try {
            OrderedHashSet set = new OrderedHashSet();
            Iterator       it  = referenceMap.get(object);

            while (it.hasNext()) {
                HsqlName name = (HsqlName) it.next();

                set.add(name);
            }

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

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
ColumnSchema readRoutineParameter(Routine routine, boolean isParam) {

        HsqlName hsqlName = null;
        int parameterMode = readRoutineParameterMode(routine.routineType,
            routine.isAggregate);

        if (!isReservedKey()) {
            hsqlName = readNewDependentSchemaObjectName(routine.getName(),
                    SchemaObject.PARAMETER);
        }

        Type typeObject = readTypeDefinition(false, true);
        ColumnSchema column = new ColumnSchema(hsqlName, typeObject, true,
                                               false, null);

        if (isParam) {
            column.setParameterMode((byte) parameterMode);
        }

        return column;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
void removeParent(HsqlName parent) {

        Iterator it = map.values().iterator();

        while (it.hasNext()) {
            if (type == SchemaObject.TRIGGER
                    || type == SchemaObject.SPECIFIC_ROUTINE) {
                SchemaObject object = (SchemaObject) it.next();

                if (object.getName().parent == parent) {
                    it.remove();
                }
            } else {
                HsqlName name = (HsqlName) it.next();

                if (name.parent == parent) {
                    it.remove();
                }
            }
        }
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
/**
 * Instantiate this as a SELECT statement.
 *
 * @param select
 * @param params
 */
CompiledStatement(Session session, Database database, HsqlName schema,
                  Select select, SubQuery[] subqueries,
                  Expression[] params) throws HsqlException {

    schemaHsqlName = schema;
    this.select    = select;

    // resolve any parameters in SELECT as VARCHAR
    for (int i = 0; i < select.iResultLen; i++) {
        Expression colexpr = select.exprColumns[i];

        if (colexpr.getDataType() == Types.NULL) {
            colexpr.setDataType(Types.VARCHAR);
        }
    }

    // set select result metadata etc.
    select.prepareResult(session);
    setParameters(params);
    setSubqueries(subqueries);

    type = SELECT;
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
/**
 * Responsible for handling tail of ALTER COLUMN ... RENAME ...
 */
private Statement compileAlterColumnRename(Table table,
        ColumnSchema column) {

    checkIsSimpleName();

    HsqlName name = readNewSchemaObjectName(SchemaObject.COLUMN, true);

    if (table.findColumn(name.name) > -1) {
        throw Error.error(ErrorCode.X_42504, name.name);
    }

    database.schemaManager.checkColumnIsReferenced(table.getName(),
            column.getName());

    String     sql            = getLastPart();
    Object[]   args           = new Object[] {
        column.getName(), name
    };
    HsqlName[] writeLockNames = new HsqlName[] {
        database.getCatalogName(), table.getName()
    };

    return new StatementSchema(sql, StatementTypes.RENAME_OBJECT, args,
                               null, writeLockNames);
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
/**
 * Initializes this as a DELETE statement
 *
 * @param targetFilter
 * @param deleteCondition
 * @param parameters
 */
CompiledStatement(Session session, Database database, HsqlName schema,
                  TableFilter targetFilter, Expression deleteCondition,
                  SubQuery[] subqueries,
                  Expression[] params) throws HsqlException {

    schemaHsqlName    = schema;
    this.targetFilter = targetFilter;
    targetTable       = targetFilter.filterTable;

    if (deleteCondition != null) {
        condition = new Expression(deleteCondition);

        condition.resolveTables(targetFilter);
        condition.resolveTypes(session);
        targetFilter.setConditions(session, condition);
    }

    setParameters(params);
    setSubqueries(subqueries);

    type = DELETE;
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的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.HsqlNameManager.HsqlName; //导入依赖的package包/类
/**
 * Returns the table that has an index with the given name and schema.
 */
Table findUserTableForIndex(Session session, String name,
                            String schemaName) {

    readLock.lock();

    try {
        Schema   schema    = (Schema) schemaMap.get(schemaName);
        HsqlName indexName = schema.indexLookup.getName(name);

        if (indexName == null) {
            return null;
        }

        return findUserTable(session, indexName.parent.name, schemaName);
    } finally {
        readLock.unlock();
    }
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
public OrderedHashSet getReferences() {

        OrderedHashSet set = new OrderedHashSet();

        if (colTypes == null)
            return set;

        for (int i = 0; i < colTypes.length; i++) {
            if (colTypes[i].isDomainType() || colTypes[i].isDistinctType()) {
                HsqlName name = ((SchemaObject) colTypes[i]).getName();

                set.add(name);
            }
        }

        return set;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
/**
 * Returns true if any of the rights represented by the
 * rights argument has been granted on the database object identified
 * by the dbobject argument. <p>
 *
 * This is done by checking that a mapping exists in the rights map
 * from the dbobject argument for at least one of the rights
 * contained in the rights argument.
 *
 * Only does one level of recursion to check the PUBLIC role.
 */
boolean isAccessible(HsqlName dbObject, int rights) throws HsqlException {

    if (isAdmin) {
        return true;
    }

    if (pubGrantee != null && pubGrantee.isAccessible(dbObject, rights)) {
        return true;
    }

    int n = fullRightsMap.get(dbObject, 0);

    if (n != 0) {
        return (n & rights) != 0;
    }

    return false;
}
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
Table UDT_PRIVILEGES() {

        Table t = sysTables[UDT_PRIVILEGES];

        if (t == null) {
            t = createBlankTable(sysTableHsqlNames[UDT_PRIVILEGES]);

            addColumn(t, "UDT_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "UDT_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "UDT_NAME", SQL_IDENTIFIER);
            addColumn(t, "PRIVILEGE_TYPE", CHARACTER_DATA);
            addColumn(t, "IS_GRANTABLE", YES_OR_NO);

            HsqlName name = HsqlNameManager.newInfoSchemaObjectName(
                sysTableHsqlNames[UDT_PRIVILEGES].name, false,
                SchemaObject.INDEX);

            t.createPrimaryKey(name, new int[] {
                0, 1, 2, 3, 4
            }, false);

            return t;
        }

        return t;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
public HsqlName getUserSchemaHsqlName(String name) {

        readLock.lock();

        try {
            Schema schema = (Schema) schemaMap.get(name);

            if (schema == null) {
                throw Error.error(ErrorCode.X_3F000, name);
            }

            if (schema.getName()
                    == SqlInvariants.INFORMATION_SCHEMA_HSQLNAME) {
                throw Error.error(ErrorCode.X_3F000, name);
            }

            return schema.getName();
        } finally {
            readLock.unlock();
        }
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
private void addReferencesFrom(SchemaObject object) {

        OrderedHashSet set  = object.getReferences();
        HsqlName       name = object.getName();

        if (set == null) {
            return;
        }

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

            if (object instanceof Routine) {
                name = ((Routine) object).getSpecificName();
            }

            referenceMap.put(referenced, name);
        }
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
public HsqlName findSchemaHsqlName(String name) {

        readLock.lock();

        try {
            Schema schema = ((Schema) schemaMap.get(name));

            if (schema == null) {
                return null;
            }

            return schema.getName();
        } finally {
            readLock.unlock();
        }
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
private Statement compileCheckpoint() {

        boolean defrag = false;

        read();

        if (token.tokenType == Tokens.DEFRAG) {
            defrag = true;

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

            // only semicolon is accepted here
        }

        if (token.tokenType != Tokens.X_ENDPARSE) {
            throw unexpectedToken();
        }

        HsqlName[] names =
            database.schemaManager.getCatalogAndBaseTableNames();
        Object[] args = new Object[]{ Boolean.valueOf(defrag) };
        Statement cs = new StatementCommand(StatementTypes.DATABASE_CHECKPOINT,
                                            args, null, names);

        return cs;
    }
 

import org.hsqldb.HsqlNameManager.HsqlName; //导入依赖的package包/类
private Statement readFor(Routine routine, StatementCompound context,
                          HsqlName label) {

    readThis(Tokens.FOR);

    Statement cursorStatement = compileCursorSpecification();

    readThis(Tokens.DO);

    Statement[] statements = readSQLProcedureStatementList(routine,
        context);

    readThis(Tokens.END);
    readThis(Tokens.FOR);

    if (isSimpleName() && !isReservedKey()) {
        if (label == null) {
            throw unexpectedToken();
        }

        if (!label.name.equals(token.tokenString)) {
            throw Error.error(ErrorCode.X_42508, token.tokenString);
        }

        read();
    }

    StatementCompound result = new StatementCompound(StatementTypes.FOR,
        label);

    result.setLoopStatement(cursorStatement);
    result.setStatements(statements);

    return result;
}