Java Table.createPrimaryKey方法代码示例

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

        Table t = sysTables[ROLE_UDT_GRANTS];

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

            addColumn(t, "GRANTOR", SQL_IDENTIFIER);     // not null
            addColumn(t, "GRANTEE", SQL_IDENTIFIER);     // not null
            addColumn(t, "UDT_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "UDT_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "UDT_NAME", SQL_IDENTIFIER);    // not null
            addColumn(t, "PRIVILEGE_TYPE", CHARACTER_DATA);
            addColumn(t, "IS_GRANTABLE", YES_OR_NO);     // not null

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

            t.createPrimaryKey(name, null, false);

            return t;
        }

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

        // column number mappings
        final int grantor        = 0;
        final int grantee        = 1;
        final int udt_catalog    = 2;
        final int udt_schema     = 3;
        final int udt_name       = 4;
        final int privilege_type = 5;
        final int is_grantable   = 6;

        return t;
    }
 

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

    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.createPrimaryKey(name, new int[] {
            0, 1, 2
        }, false);

        return t;
    }

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

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Domains are shown if the authorization is the user or a role given to the
 * user.
 *
 * <p>
 *
 * @return Table
 */
Table COLUMN_DOMAIN_USAGE() {

    Table t = sysTables[COLUMN_DOMAIN_USAGE];

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

        addColumn(t, "DOMAIN_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "DOMAIN_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "DOMAIN_NAME", SQL_IDENTIFIER);
        addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "TABLE_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);     // not null
        addColumn(t, "COLUMN_NAME", SQL_IDENTIFIER);    // not null

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

        t.createPrimaryKey(name, new int[] {
            0, 1, 2, 3, 4, 5, 6
        }, 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 DOMAIN_CATALOG, DOMAIN_SCHEMA, DOMAIN_NAME, TABLE_CATALOG, "
        + "TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS "
        + "WHERE DOMAIN_NAME IS NOT NULL;");

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

    return t;
}
 

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

        Table t = sysTables[DATA_TYPE_PRIVILEGES];

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

            addColumn(t, "OBJECT_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "OBJECT_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "OBJECT_NAME", SQL_IDENTIFIER);    // not null
            addColumn(t, "OBJECT_TYPE", SQL_IDENTIFIER);
            addColumn(t, "DTD_IDENTIFIER", SQL_IDENTIFIER);

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

            t.createPrimaryKey(name, new int[] {
                0, 1, 2, 3, 4
            }, 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("/*data_type_privileges*/");
        Result rs  = sys.executeDirectStatement(sql);

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

        return t;
    }
 

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

        Table t = sysTables[TRANSLATIONS];

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

            addColumn(t, "TRANSLATION_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TRANSLATION_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TRANSLATION_NAME", SQL_IDENTIFIER);
            addColumn(t, "SOURCE_CHARACTER_SET_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "SOURCE_CHARACTER_SET_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "SOURCE_CHARACTER_SET_NAME", SQL_IDENTIFIER);
            addColumn(t, "TARGET_CHARACTER_SET_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TARGET_CHARACTER_SET_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TARGET_CHARACTER_SET_NAME", SQL_IDENTIFIER);
            addColumn(t, "TRANSLATION_SOURCE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TRANSLATION_SOURCE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TRANSLATION_SOURCE_NAME", SQL_IDENTIFIER);

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

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

            return t;
        }

        return t;
    }
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * For generated columns
 * <p>
 *
 * @return Table
 */
Table COLUMN_COLUMN_USAGE() {

    Table t = sysTables[COLUMN_COLUMN_USAGE];

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

        addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "TABLE_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);
        addColumn(t, "COLUMN_NAME", SQL_IDENTIFIER);
        addColumn(t, "DEPENDENT_COLUMN", SQL_IDENTIFIER);

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

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

        return t;
    }

    final int table_catalog    = 0;
    final int table_schema     = 1;
    final int table_name       = 2;
    final int column_name      = 3;
    final int dependent_column = 4;

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Retrieves a <code>Table</code> object describing the accessible schemas
 * defined within this database. <p>
 *
 * Each row is a schema description with the following
 * columns: <p>
 *
 * <pre class="SqlCodeExample">
 * TABLE_SCHEM      VARCHAR   simple schema name
 * TABLE_CATALOG    VARCHAR   catalog in which schema is defined
 * IS_DEFAULT       BOOLEAN   is the schema the default for new sessions
 * </pre> <p>
 *
 * @return table containing information about schemas defined
 *      within this database
 */
final Table SYSTEM_SCHEMAS() {

    Table t = sysTables[SYSTEM_SCHEMAS];

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

        addColumn(t, "TABLE_SCHEM", SQL_IDENTIFIER);    // not null
        addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "IS_DEFAULT", Type.SQL_BOOLEAN);

        // order: TABLE_SCHEM
        // true PK, as rows never have null TABLE_SCHEM
        HsqlName name = HsqlNameManager.newInfoSchemaObjectName(
            sysTableHsqlNames[SYSTEM_SCHEMAS].name, false,
            SchemaObject.INDEX);

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

        return t;
    }

    PersistentStore store = database.persistentStoreCollection.getStore(t);
    Iterator        schemas;
    Object[]        row;

    // Initialization
    schemas = database.schemaManager.fullSchemaNamesIterator();

    String defschema =
        database.schemaManager.getDefaultSchemaHsqlName().name;

    // Do it.
    while (schemas.hasNext()) {
        row = t.getEmptyRowData();

        String schema = (String) schemas.next();

        row[0] = schema;
        row[1] = database.getCatalogName().name;
        row[2] = schema.equals(defschema) ? Boolean.TRUE
                                          : Boolean.FALSE;

        t.insertSys(store, row);
    }

    return t;
}
 

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

        Table t = sysTables[TRIGGERED_UPDATE_COLUMNS];

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

            addColumn(t, "TRIGGER_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TRIGGER_NAME", SQL_IDENTIFIER);            // not null
            addColumn(t, "EVENT_OBJECT_CATALOG", SQL_IDENTIFIER);    // not null
            addColumn(t, "EVENT_OBJECT_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "EVENT_OBJECT_TABLE", SQL_IDENTIFIER);
            addColumn(t, "EVENT_OBJECT_COLUMN", SQL_IDENTIFIER);     // not null

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

            t.createPrimaryKey(name, new int[] {
                0, 1, 2, 3, 4, 5, 6
            }, 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 event_object_catalog = 3;
        final int event_object_schema  = 4;
        final int event_object_table   = 5;
        final int event_object_column  = 6;
        Iterator  it;
        Object[]  row;

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

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

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

            int[] colIndexes = trigger.getUpdateColumnIndexes();

            if (colIndexes == null) {
                continue;
            }

            for (int i = 0; i < colIndexes.length; i++) {
                ColumnSchema column =
                    trigger.getTable().getColumn(colIndexes[i]);

                row                       = t.getEmptyRowData();
                row[trigger_catalog]      = database.getCatalogName().name;
                row[trigger_schema]       = trigger.getSchemaName().name;
                row[trigger_name]         = trigger.getName().name;
                row[event_object_catalog] = database.getCatalogName().name;
                row[event_object_schema] =
                    trigger.getTable().getSchemaName().name;
                row[event_object_table]  = trigger.getTable().getName().name;
                row[event_object_column] = column.getNameString();

                t.insertSys(store, row);
            }
        }

        // Initialization
        return t;
    }
 

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

        Table t = sysTables[CHARACTER_SETS];

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

            addColumn(t, "CHARACTER_SET_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "CHARACTER_SET_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "CHARACTER_SET_NAME", SQL_IDENTIFIER);
            addColumn(t, "CHARACTER_REPERTOIRE", SQL_IDENTIFIER);
            addColumn(t, "FORM_OF_USE", SQL_IDENTIFIER);
            addColumn(t, "DEFAULT_COLLATE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "DEFAULT_COLLATE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "DEFAULT_COLLATE_NAME", SQL_IDENTIFIER);

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

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

            return t;
        }

        final int character_set_catalog   = 0;
        final int character_set_schema    = 1;
        final int character_set_name      = 2;
        final int character_repertoire    = 3;
        final int form_of_use             = 4;
        final int default_collate_catalog = 5;
        final int default_collate_schema  = 6;
        final int default_collate_name    = 7;

        //
        PersistentStore store = database.persistentStoreCollection.getStore(t);
        Iterator it = database.schemaManager.databaseObjectIterator(
            SchemaObject.CHARSET);

        while (it.hasNext()) {
            Charset charset = (Charset) it.next();

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

            Object[] data = t.getEmptyRowData();

            data[character_set_catalog]   = database.getCatalogName().name;
            data[character_set_schema]    = charset.getSchemaName().name;
            data[character_set_name]      = charset.getName().name;
            data[character_repertoire]    = "UCS";
            data[form_of_use]             = "UTF16";
            data[default_collate_catalog] = data[character_set_catalog];

            if (charset.base == null) {
                data[default_collate_schema] = data[character_set_schema];
                data[default_collate_name]   = data[character_set_name];
            } else {
                data[default_collate_schema] = charset.base.schema.name;
                data[default_collate_name]   = charset.base.name;
            }

            t.insertSys(store, data);
        }

        return t;
    }
 

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

        Table t = sysTables[ROLE_USAGE_GRANTS];

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

            addColumn(t, "GRANTOR", SQL_IDENTIFIER);        // not null
            addColumn(t, "GRANTEE", SQL_IDENTIFIER);        // not null
            addColumn(t, "OBJECT_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "OBJECT_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "OBJECT_NAME", SQL_IDENTIFIER);    // not null
            addColumn(t, "OBJECT_TYPE", CHARACTER_DATA);    // not null
            addColumn(t, "PRIVILEGE_TYPE", CHARACTER_DATA);
            addColumn(t, "IS_GRANTABLE", YES_OR_NO);        // not null

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

            t.createPrimaryKey(name, new int[] {
                0, 1, 2, 3, 4, 5, 6, 7
            }, 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, OBJECT_CATALOG, OBJECT_SCHEMA, OBJECT_NAME, "
            + "OBJECT_TYPE, PRIVILEGE_TYPE, IS_GRANTABLE "
            + "FROM INFORMATION_SCHEMA.USAGE_PRIVILEGES "
            + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES ON GRANTEE = ROLE_NAME;");

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

        return t;
    }
 

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

        Table t = sysTables[ROLE_TABLE_GRANTS];

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

            addColumn(t, "GRANTOR", SQL_IDENTIFIER);           // not null
            addColumn(t, "GRANTEE", SQL_IDENTIFIER);           // not null
            addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "TABLE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);        // not null
            addColumn(t, "PRIVILEGE_TYPE", CHARACTER_DATA);    // not null
            addColumn(t, "IS_GRANTABLE", YES_OR_NO);           // not null
            addColumn(t, "WITH_HIERARCHY", YES_OR_NO);

            // order:  TABLE_SCHEM, TABLE_NAME, and PRIVILEGE,
            // added for unique:  GRANTEE, GRANTOR,
            // false PK, as TABLE_SCHEM and/or TABLE_CAT may be null
            HsqlName name = HsqlNameManager.newInfoSchemaObjectName(
                sysTableHsqlNames[ROLE_TABLE_GRANTS].name, false,
                SchemaObject.INDEX);

            t.createPrimaryKey(name, new int[] {
                3, 4, 5, 0, 1
            }, 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, TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, PRIVILEGE_TYPE, IS_GRANTABLE, 'NO' "
            + "FROM INFORMATION_SCHEMA.TABLE_PRIVILEGES "
            + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES ON GRANTEE = ROLE_NAME;");

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

        return t;
    }