Java HsqlNameManager.newInfoSchemaObjectName方法代码示例

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
private Collation(String name, String language, String country,
                  int strength, int decomposition, boolean ucc) {

    locale   = new Locale(language, country);
    collator = Collator.getInstance(locale);

    if (strength >= 0) {
        collator.setStrength(strength);
    }

    if (decomposition >= 0) {
        collator.setDecomposition(decomposition);
    }

    strength        = collator.getStrength();
    isUnicodeSimple = false;
    this.name = HsqlNameManager.newInfoSchemaObjectName(name, true,
            SchemaObject.COLLATION);
    charset            = Charset.SQL_TEXT;
    isUpperCaseCompare = ucc;
    isFinal            = true;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的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; //导入方法依赖的package包/类
Table SQL_IMPLEMENTATION_INFO() {

        Table t = sysTables[SQL_IMPLEMENTATION_INFO];

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

            addColumn(t, "IMPLEMENTATION_INFO_ID", CHARACTER_DATA);
            addColumn(t, "IMPLEMENTATION_INFO_NAME", CHARACTER_DATA);
            addColumn(t, "INTEGER_VALUE", CARDINAL_NUMBER);
            addColumn(t, "CHARACTER_VALUE", CHARACTER_DATA);
            addColumn(t, "COMMENTS", CHARACTER_DATA);

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);
        Session sys = database.sessionManager.newSysSession(
            SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());

/*
        Result rs = sys.executeDirectStatement(
            "VALUES "
            + ";");

        t.insertSys(store, rs);
*/
        return t;
    }
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The SQL_SIZING view has one row for the maximum size of each built in
 * type supported by HyperSQL.<p>
 *
 */
Table SQL_SIZING(Session session, PersistentStore store) {

    Table t = sysTables[SQL_SIZING];

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

        addColumn(t, "SIZING_ID", CARDINAL_NUMBER);
        addColumn(t, "SIZING_NAME", CHARACTER_DATA);
        addColumn(t, "SUPPORTED_VALUE", CARDINAL_NUMBER);
        addColumn(t, "COMMENTS", CHARACTER_DATA);

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

        t.createPrimaryKeyConstraint(name, new int[]{ 0 }, false);

        return t;
    }

    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    String sql = (String) statementMap.get("/*sql_sizing*/");
    Result rs  = sys.executeDirectStatement(sql);

    t.insertSys(session, store, rs);

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * Retrieves a <code>Table</code> object describing the accessible
 * columns that are automatically updated when any value in a row
 * is updated. <p>
 *
 * Each row is a version column description with the following columns: <p>
 *
 * <OL>
 * <LI><B>SCOPE</B> <code>SMALLINT</code> => is not used
 * <LI><B>COLUMN_NAME</B> <code>VARCHAR</code> => column name
 * <LI><B>DATA_TYPE</B> <code>SMALLINT</code> =>
 *        SQL data type from java.sql.Types
 * <LI><B>TYPE_NAME</B> <code>SMALLINT</code> =>
 *       Data source dependent type name
 * <LI><B>COLUMN_SIZE</B> <code>INTEGER</code> => precision
 * <LI><B>BUFFER_LENGTH</B> <code>INTEGER</code> =>
 *        length of column value in bytes
 * <LI><B>DECIMAL_DIGITS</B> <code>SMALLINT</code> => scale
 * <LI><B>PSEUDO_COLUMN</B> <code>SMALLINT</code> =>
 *        is this a pseudo column like an Oracle <code>ROWID</code>:<BR>
 *        (as defined in <code>java.sql.DatabaseMetadata</code>)
 * <UL>
 *    <LI><code>versionColumnUnknown</code> - may or may not be
 *        pseudo column
 *    <LI><code>versionColumnNotPseudo</code> - is NOT a pseudo column
 *    <LI><code>versionColumnPseudo</code> - is a pseudo column
 * </UL>
 * </OL> <p>
 *
 * <B>Note:</B> Currently, the HSQLDB engine does not support version
 * columns, so an empty table is returned. <p>
 *
 * @return a <code>Table</code> object describing the columns
 *        that are automatically updated when any value
 *        in a row is updated
 */
Table SYSTEM_VERSIONCOLUMNS(Session session, PersistentStore store) {

    Table t = sysTables[SYSTEM_VERSIONCOLUMNS];

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

        // ----------------------------------------------------------------
        // required by DatabaseMetaData.getVersionColumns result set
        // ----------------------------------------------------------------
        addColumn(t, "SCOPE", Type.SQL_INTEGER);
        addColumn(t, "COLUMN_NAME", SQL_IDENTIFIER);         // not null
        addColumn(t, "DATA_TYPE", Type.SQL_SMALLINT);        // not null
        addColumn(t, "TYPE_NAME", SQL_IDENTIFIER);           // not null
        addColumn(t, "COLUMN_SIZE", Type.SQL_SMALLINT);
        addColumn(t, "BUFFER_LENGTH", Type.SQL_INTEGER);
        addColumn(t, "DECIMAL_DIGITS", Type.SQL_SMALLINT);
        addColumn(t, "PSEUDO_COLUMN", Type.SQL_SMALLINT);    // not null

        // -----------------------------------------------------------------
        // required by DatabaseMetaData.getVersionColumns filter parameters
        // -----------------------------------------------------------------
        addColumn(t, "TABLE_CAT", SQL_IDENTIFIER);
        addColumn(t, "TABLE_SCHEM", SQL_IDENTIFIER);
        addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);          // not null

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

        t.createPrimaryKeyConstraint(name, null, false);

        return t;
    }

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * Retrieves a <code>Table</code> object describing the accessible
 * columns that are automatically updated when any value in a row
 * is updated. <p>
 *
 * Each row is a version column description with the following columns: <p>
 *
 * <OL>
 * <LI><B>SCOPE</B> <code>SMALLINT</code> => is not used
 * <LI><B>COLUMN_NAME</B> <code>VARCHAR</code> => column name
 * <LI><B>DATA_TYPE</B> <code>SMALLINT</code> =>
 *        SQL data type from java.sql.Types
 * <LI><B>TYPE_NAME</B> <code>SMALLINT</code> =>
 *       Data source dependent type name
 * <LI><B>COLUMN_SIZE</B> <code>INTEGER</code> => precision
 * <LI><B>BUFFER_LENGTH</B> <code>INTEGER</code> =>
 *        length of column value in bytes
 * <LI><B>DECIMAL_DIGITS</B> <code>SMALLINT</code> => scale
 * <LI><B>PSEUDO_COLUMN</B> <code>SMALLINT</code> =>
 *        is this a pseudo column like an Oracle <code>ROWID</code>:<BR>
 *        (as defined in <code>java.sql.DatabaseMetadata</code>)
 * <UL>
 *    <LI><code>versionColumnUnknown</code> - may or may not be
 *        pseudo column
 *    <LI><code>versionColumnNotPseudo</code> - is NOT a pseudo column
 *    <LI><code>versionColumnPseudo</code> - is a pseudo column
 * </UL>
 * </OL> <p>
 *
 * <B>Note:</B> Currently, the HSQLDB engine does not support version
 * columns, so an empty table is returned. <p>
 *
 * @return a <code>Table</code> object describing the columns
 *        that are automatically updated when any value
 *        in a row is updated
 */
Table SYSTEM_VERSIONCOLUMNS() {

    Table t = sysTables[SYSTEM_VERSIONCOLUMNS];

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

        // ----------------------------------------------------------------
        // required by DatabaseMetaData.getVersionColumns result set
        // ----------------------------------------------------------------
        addColumn(t, "SCOPE", Type.SQL_INTEGER);
        addColumn(t, "COLUMN_NAME", SQL_IDENTIFIER);         // not null
        addColumn(t, "DATA_TYPE", Type.SQL_SMALLINT);        // not null
        addColumn(t, "TYPE_NAME", SQL_IDENTIFIER);           // not null
        addColumn(t, "COLUMN_SIZE", Type.SQL_SMALLINT);
        addColumn(t, "BUFFER_LENGTH", Type.SQL_INTEGER);
        addColumn(t, "DECIMAL_DIGITS", Type.SQL_SMALLINT);
        addColumn(t, "PSEUDO_COLUMN", Type.SQL_SMALLINT);    // not null

        // -----------------------------------------------------------------
        // required by DatabaseMetaData.getVersionColumns filter parameters
        // -----------------------------------------------------------------
        addColumn(t, "TABLE_CAT", SQL_IDENTIFIER);
        addColumn(t, "TABLE_SCHEM", SQL_IDENTIFIER);
        addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);          // not null

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

        t.createPrimaryKey(name, null, false);

        return t;
    }

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * ADMINISTRABLE_ROLE_AUTHORIZATIONS<p>
 *
 * Returns roles that are grantable by an admin user, which means all the
 * roles.
 *
 * @return Table
 */
Table ADMINISTRABLE_ROLE_AUTHORIZATIONS(Session session,
        PersistentStore store) {

    Table t = sysTables[ADMINISTRABLE_ROLE_AUTHORIZATIONS];

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

        addColumn(t, "GRANTEE", SQL_IDENTIFIER);
        addColumn(t, "ROLE_NAME", SQL_IDENTIFIER);
        addColumn(t, "IS_GRANTABLE", SQL_IDENTIFIER);

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

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

        return t;
    }

    if (session.isAdmin()) {
        insertRoles(session, t, session.getGrantee(), true);
    }

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * APPLICABLE_ROLES<p>
 *
 * Identifies the applicable roles for the current user.<p>
 *
 * <b>Definition</b><p>
 *
 * <pre class="SqlCodeExample">
 * CREATE RECURSIVE VIEW APPLICABLE_ROLES ( GRANTEE, ROLE_NAME, IS_GRANTABLE ) AS
 *      ( ( SELECT GRANTEE, ROLE_NAME, IS_GRANTABLE
 *            FROM DEFINITION_SCHEMA.ROLE_AUTHORIZATION_DESCRIPTORS
 *           WHERE ( GRANTEE IN ( CURRENT_USER, 'PUBLIC' )
 *                OR GRANTEE IN ( SELECT ROLE_NAME
 *                                  FROM ENABLED_ROLES ) ) )
 *      UNION
 *      ( SELECT RAD.GRANTEE, RAD.ROLE_NAME, RAD.IS_GRANTABLE
 *          FROM DEFINITION_SCHEMA.ROLE_AUTHORIZATION_DESCRIPTORS RAD
 *          JOIN APPLICABLE_ROLES R
 *            ON RAD.GRANTEE = R.ROLE_NAME ) );
 *
 * GRANT SELECT ON TABLE APPLICABLE_ROLES
 *    TO PUBLIC WITH GRANT OPTION;
 * </pre>
 */
Table APPLICABLE_ROLES(Session session, PersistentStore store) {

    Table t = sysTables[APPLICABLE_ROLES];

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

        addColumn(t, "GRANTEE", SQL_IDENTIFIER);
        addColumn(t, "ROLE_NAME", SQL_IDENTIFIER);
        addColumn(t, "IS_GRANTABLE", SQL_IDENTIFIER);

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

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

        return t;
    }

    insertRoles(session, t, session.getGrantee(), session.isAdmin());

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The ASSERTIONS view is empty.<p>
 *
 */
Table ASSERTIONS(Session session, PersistentStore store) {

    Table t = sysTables[ASSERTIONS];

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

        addColumn(t, "CONSTRAINT_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "CONSTRAINT_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "CONSTRAINT_NAME", SQL_IDENTIFIER);    // not null
        addColumn(t, "IS_DEFERRABLE", YES_OR_NO);
        addColumn(t, "INITIALLY_DEFERRED", YES_OR_NO);

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

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

        return t;
    }

    final int constraint_catalog = 0;
    final int constraint_schema  = 1;
    final int constraint_name    = 2;
    final int is_deferrable      = 3;
    final int initially_deferred = 4;

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The SQL_FEATURES view lists the individual features of the SQL Standard
 * supported by HyperSQL.<p>
 *
 */
Table SQL_FEATURES(Session session, PersistentStore store) {

    Table t = sysTables[SQL_FEATURES];

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

        addColumn(t, "FEATURE_ID", CHARACTER_DATA);
        addColumn(t, "FEATURE_NAME", CHARACTER_DATA);
        addColumn(t, "SUB_FEATURE_ID", CHARACTER_DATA);
        addColumn(t, "SUB_FEATURE_NAME", CHARACTER_DATA);
        addColumn(t, "IS_SUPPORTED", YES_OR_NO);
        addColumn(t, "IS_VERIFIED_BY", CHARACTER_DATA);
        addColumn(t, "COMMENTS", CHARACTER_DATA);

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

        t.createPrimaryKeyConstraint(name, new int[] {
            0, 2
        }, false);

        return t;
    }

    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    String sql = (String) statementMap.get("/*sql_features*/");
    Result rs  = sys.executeDirectStatement(sql);

    t.insertSys(session, store, rs);

    return t;
}
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
Table SQL_PARTS() {

        Table t = sysTables[SQL_PARTS];

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

            addColumn(t, "PART", CHARACTER_DATA);
            addColumn(t, "NAME", CHARACTER_DATA);
            addColumn(t, "IS_SUPPORTED", YES_OR_NO);
            addColumn(t, "IS_VERIFIED_BY", CHARACTER_DATA);
            addColumn(t, "COMMENTS", CHARACTER_DATA);

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);
        Session sys = database.sessionManager.newSysSession(
            SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
        String sql = (String) statementMap.get("/*sql_parts*/");
        Result rs = sys.executeDirectStatement(sql);


        t.insertSys(store, rs);

        return t;
    }
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
Table SQL_PACKAGES() {

        Table t = sysTables[SQL_PACKAGES];

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

            addColumn(t, "ID", CHARACTER_DATA);
            addColumn(t, "NAME", CHARACTER_DATA);
            addColumn(t, "IS_SUPPORTED", YES_OR_NO);
            addColumn(t, "IS_VERIFIED_BY", CHARACTER_DATA);
            addColumn(t, "COMMENTS", CHARACTER_DATA);

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);
        Session sys = database.sessionManager.newSysSession(
            SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
        String sql = (String) statementMap.get("/*sql_packages*/");
        Result rs = sys.executeDirectStatement(sql);

        t.insertSys(store, rs);

        return t;
    }
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
Table TRIGGER_TABLE_USAGE() {

        Table t = sysTables[TRIGGER_TABLE_USAGE];

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

            addColumn(t, "TRIGGER_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_NAME", SQL_IDENTIFIER);    // not null
            addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TABLE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);      // not null

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);

        // column number mappings
        final int trigger_catalog = 0;
        final int trigger_schema  = 1;
        final int trigger_name    = 2;
        final int table_catalog   = 3;
        final int table_schema    = 4;
        final int table_name      = 5;
        Iterator  it;
        Object[]  row;

        it = database.schemaManager.databaseObjectIterator(
            SchemaObject.TRIGGER);

        while (it.hasNext()) {
            TriggerDef trigger = (TriggerDef) it.next();

            if (!session.getGrantee().isAccessible(trigger)) {
                continue;
            }

            OrderedHashSet set = trigger.getReferences();

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

                if (refName.type != SchemaObject.TABLE
                        && refName.type != SchemaObject.VIEW) {
                    continue;
                }

                if (!session.getGrantee().isAccessible(refName)) {
                    continue;
                }

                row                  = t.getEmptyRowData();
                row[trigger_catalog] = database.getCatalogName().name;
                row[trigger_schema]  = trigger.getSchemaName().name;
                row[trigger_name]    = trigger.getName().name;
                row[table_catalog]   = database.getCatalogName().name;
                row[table_schema]    = refName.schema.name;
                row[table_name]      = refName.name;

                try {
                    t.insertSys(store, row);
                } catch (HsqlException e) {}
            }
        }

        // Initialization
        return t;
    }
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
Table TRIGGER_SEQUENCE_USAGE() {

        Table t = sysTables[TRIGGER_SEQUENCE_USAGE];

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

            addColumn(t, "TRIGGER_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_NAME", SQL_IDENTIFIER);     // not null
            addColumn(t, "SEQUENCE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "SEQUENCE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "SEQUENCE_NAME", SQL_IDENTIFIER);    // not null

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);

        // column number mappings
        final int trigger_catalog  = 0;
        final int trigger_schema   = 1;
        final int trigger_name     = 2;
        final int sequence_catalog = 3;
        final int sequence_schema  = 4;
        final int sequence_name    = 5;
        Iterator  it;
        Object[]  row;

        it = database.schemaManager.databaseObjectIterator(
            SchemaObject.TRIGGER);

        while (it.hasNext()) {
            TriggerDef trigger = (TriggerDef) it.next();

            if (!session.getGrantee().isAccessible(trigger)) {
                continue;
            }

            OrderedHashSet set = trigger.getReferences();

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

                if (refName.type != SchemaObject.SEQUENCE) {
                    continue;
                }

                if (!session.getGrantee().isAccessible(refName)) {
                    continue;
                }

                row                   = t.getEmptyRowData();
                row[trigger_catalog]  = database.getCatalogName().name;
                row[trigger_schema]   = trigger.getSchemaName().name;
                row[trigger_name]     = trigger.getName().name;
                row[sequence_catalog] = database.getCatalogName().name;
                row[sequence_schema]  = refName.schema.name;
                row[sequence_name]    = refName.name;

                try {
                    t.insertSys(store, row);
                } catch (HsqlException e) {}
            }
        }

        // Initialization
        return t;
    }
 

import org.hsqldb.HsqlNameManager; //导入方法依赖的package包/类
Table ROLE_ROUTINE_GRANTS() {

        Table t = sysTables[ROLE_ROUTINE_GRANTS];

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

            addColumn(t, "GRANTOR", SQL_IDENTIFIER);          // not null
            addColumn(t, "GRANTEE", SQL_IDENTIFIER);          // not null
            addColumn(t, "SPECIFIC_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "SPECIFIC_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "SPECIFIC_NAME", SQL_IDENTIFIER);    // not null
            addColumn(t, "ROUTINE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "ROUTINE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "ROUTINE_NAME", SQL_IDENTIFIER);
            addColumn(t, "PRIVILEGE_TYPE", CHARACTER_DATA);
            addColumn(t, "IS_GRANTABLE", YES_OR_NO);

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

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

            return t;
        }

        PersistentStore store = database.persistentStoreCollection.getStore(t);
        Session sys = database.sessionManager.newSysSession(
            SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
        Result rs = sys.executeDirectStatement(
            "SELECT GRANTOR, GRANTEE, SPECIFIC_CATALOG, SPECIFIC_SCHEMA, "
            + "SPECIFIC_NAME, ROUTINE_CATALOG, ROUTINE_SCHEMA, ROUTINE_NAME, "
            + "PRIVILEGE_TYPE, IS_GRANTABLE, 'NO' "
            + "FROM INFORMATION_SCHEMA.ROUTINE_PRIVILEGES "
            + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES ON GRANTEE = ROLE_NAME;");

        t.insertSys(store, rs);
        sys.close();

        // Column number mappings
        final int grantor          = 0;
        final int grantee          = 1;
        final int table_name       = 2;
        final int specific_catalog = 3;
        final int specific_schema  = 4;
        final int specific_name    = 5;
        final int routine_catalog  = 6;
        final int routine_schema   = 7;
        final int routine_name     = 8;
        final int privilege_type   = 9;
        final int is_grantable     = 10;

        //
        return t;
    }