Java Table.insertSys方法代码示例

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包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The SQL_IMPLEMENTATION_INFO shows some properties and capabilities
 * of the database engine .<p>
 *
 */
Table SQL_IMPLEMENTATION_INFO(Session session, PersistentStore store) {

    Table t = sysTables[SQL_IMPLEMENTATION_INFO];

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

        addColumn(t, "IMPLEMENTATION_INFO_ID", CARDINAL_NUMBER);
        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.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_implementation_info*/");
    Result rs  = sys.executeDirectStatement(sql);

    t.insertSys(session, store, rs);

    return t;
}
 

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

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

        t.insertSys(store, rs);

        return t;
    }
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Inserts a set of procedure description rows into the <code>Table</code>
 * object specified by the <code>t</code> argument. <p>
 *
 * @param t the table into which the specified rows will eventually
 *      be inserted
 * @param l the list of procedure name aliases to which the specified column
 *      values apply
 * @param cat the procedure catalog name
 * @param schem the procedure schema name
 * @param pName the base (non-alias) procedure name
 * @param ip the procedure input parameter count
 * @param op the procedure output parameter count
 * @param rs the procedure result column count
 * @param remark a human-readable remark regarding the procedure
 * @param pType the procedure type code, indicating whether it is a
 *      function, procedure, or uncatagorized (i.e. returns
 *      a value, does not return a value, or it is unknown
 *      if it returns a value)
 * @param specificName the specific name of the procedure
 *      (typically but not limited to a
 *      fully qualified Java Method name and signature)
 * @param origin origin of the procedure, e.g.
 *      (["BUILTIN" | "USER DEFINED"] "ROUTINE" | "TRIGGER") | "ALIAS", etc.
 *
 */
protected void addProcRows(Session session, Table t, HsqlArrayList l,
                           String cat, String schem, String pName,
                           Integer ip, Integer op, Integer rs,
                           String remark, Integer pType,
                           String specificName, String origin) {

    PersistentStore store = t.getRowStore(session);

    // column number mappings
    final int icat          = 0;
    final int ischem        = 1;
    final int ipname        = 2;
    final int iinput_parms  = 3;
    final int ioutput_parms = 4;
    final int iresult_sets  = 5;
    final int iremark       = 6;
    final int iptype        = 7;
    final int isn           = 8;
    final int iporigin      = 9;
    Object[]  row           = t.getEmptyRowData();

    row[icat]          = cat;
    row[ischem]        = schem;
    row[ipname]        = pName;
    row[iinput_parms]  = ip;
    row[ioutput_parms] = op;
    row[iresult_sets]  = rs;
    row[iremark]       = remark;
    row[iptype]        = pType;
    row[iporigin]      = origin;
    row[isn]           = specificName;

    t.insertSys(session, store, row);

    if (l != null) {
        int size = l.size();

        for (int i = 0; i < size; i++) {
            row                = t.getEmptyRowData();
            pName              = (String) l.get(i);
            row[icat]          = cat;
            row[ischem]        = schem;
            row[ipname]        = pName;
            row[iinput_parms]  = ip;
            row[ioutput_parms] = op;
            row[iresult_sets]  = rs;
            row[iremark]       = remark;
            row[iptype]        = pType;
            row[iporigin]      = "ALIAS";
            row[isn]           = specificName;

            t.insertSys(session, store, row);
        }
    }
}
 

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(Session session, PersistentStore store) {

    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.createPrimaryKeyConstraint(name, new int[]{ 0 }, true);

        return t;
    }

    Object[] row;

    // Initialization
    String[] schemas = database.schemaManager.getSchemaNamesArray();
    String defschema =
        database.schemaManager.getDefaultSchemaHsqlName().name;

    // Do it.
    for (int i = 0; i < schemas.length; i++) {
        row = t.getEmptyRowData();

        String schema = schemas[i];

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

        t.insertSys(session, store, row);
    }

    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 ROUTINE_SEQUENCE_USAGE() {

        Table t = sysTables[ROUTINE_SEQUENCE_USAGE];

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

            addColumn(t, "SPECIFIC_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "SPECIFIC_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "SPECIFIC_NAME", SQL_IDENTIFIER);
            addColumn(t, "SEQUENCE_CATALOG", SQL_IDENTIFIER);
            addColumn(t, "SEQUENCE_SCHEMA", SQL_IDENTIFIER);
            addColumn(t, "SEQUENCE_NAME", SQL_IDENTIFIER);

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

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

            return t;
        }

        // column number mappings
        final int specific_catalog = 0;
        final int specific_schema  = 1;
        final int specific_name    = 2;
        final int sequence_catalog = 3;
        final int sequence_schema  = 4;
        final int sequence_name    = 5;

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

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

        while (it.hasNext()) {
            RoutineSchema routine = (RoutineSchema) it.next();

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

            Routine[] specifics = routine.getSpecificRoutines();

            for (int m = 0; m < specifics.length; m++) {
                OrderedHashSet set = specifics[m].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[specific_catalog] = database.getCatalogName().name;
                    row[specific_schema]  = specifics[m].getSchemaName().name;
                    row[specific_name]    = specifics[m].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) {}
                }
            }
        }

        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_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;
    }
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The ROLE_USAGE_GRANTS view has one row for each privilege granted to each
 * ROLE on each table. <p>
 *
 * <b>Definition:</b><p>
 *
 * <pre class="SqlCodeExample">
 *      GRANTOR                        VARCHAR ,
 *      GRANTEE                        VARCHAR ,
 *      OBJECT_CATALOG                 VARCHAR ,
 *      OBJECT_SCHEMA                  VARCHAR ,
 *      OBJECT_NAME                    VARCHAR ,
 *      OBJECT_TYPE                    VARCHAR ,
 *      PRIVILEGE_TYPE                 VARCHAR ,
 *      IS_GRANTABLE                   VARCHAR ,
 * </pre>
 *
 * <b>Description:</b><p>
 *
 * <ol>
 * <li> The values of GRANTOR is the grantor of the privilege. The value of
 *      GRANTEE is the name of the ROLE.
 *
 * <li> The values of OBJECT_CATALOG, OBJECT_SCHEMA and
 *      OBJECT_NAME are the catalog name, schema name and
 *      table name, respectively, of the object being
 *      described. <p>
 * <li> The value of OBJECT_TYPE is they type of object, including 'DOMAIN', 'CHARACTER SET',
 *      'COLLATION', 'TRANSLATION' and 'SEQUENCE'.
 * <li> The value of PRIVILEGE_TYPE is the type of the privilege, including,
 *      'USAGE'.
 *      The value IS_GRANTABLE is 'YES' if the privilege is grantable. <p>
 * </ol>
 *
 * @return Table
 */
Table ROLE_USAGE_GRANTS(Session session, PersistentStore store) {

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

        return t;
    }

    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    Result rs = sys.executeDirectStatement(
        "SELECT U.GRANTOR, U.GRANTEE, U.OBJECT_CATALOG, U.OBJECT_SCHEMA, U.OBJECT_NAME, "
        + "U.OBJECT_TYPE, U.PRIVILEGE_TYPE, U.IS_GRANTABLE "
        + "FROM INFORMATION_SCHEMA.USAGE_PRIVILEGES U "
        + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES A ON U.GRANTEE = A.ROLE_NAME;");

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

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Inserts a set of procedure description rows into the <code>Table</code>
 * object specified by the <code>t</code> argument. <p>
 *
 * @param t the table into which the specified rows will eventually
 *      be inserted
 * @param l the list of procedure name aliases to which the specified column
 *      values apply
 * @param cat the procedure catalog name
 * @param schem the procedure schema name
 * @param pName the base (non-alias) procedure name
 * @param ip the procedure input parameter count
 * @param op the procedure output parameter count
 * @param rs the procedure result column count
 * @param remark a human-readable remark regarding the procedure
 * @param pType the procedure type code, indicating whether it is a
 *      function, procedure, or uncatagorized (i.e. returns
 *      a value, does not return a value, or it is unknown
 *      if it returns a value)
 * @param specificName the specific name of the procedure
 *      (typically but not limited to a
 *      fully qualified Java Method name and signature)
 * @param origin origin of the procedure, e.g.
 *      (["BUILTIN" | "USER DEFINED"] "ROUTINE" | "TRIGGER") | "ALIAS", etc.
 *
 */
protected void addProcRows(Table t, HsqlArrayList l, String cat,
                           String schem, String pName, Integer ip,
                           Integer op, Integer rs, String remark,
                           Integer pType, String specificName,
                           String origin) {

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

    // column number mappings
    final int icat          = 0;
    final int ischem        = 1;
    final int ipname        = 2;
    final int iinput_parms  = 3;
    final int ioutput_parms = 4;
    final int iresult_sets  = 5;
    final int iremark       = 6;
    final int iptype        = 7;
    final int isn           = 8;
    final int iporigin      = 9;
    Object[]  row           = t.getEmptyRowData();

    row[icat]          = cat;
    row[ischem]        = schem;
    row[ipname]        = pName;
    row[iinput_parms]  = ip;
    row[ioutput_parms] = op;
    row[iresult_sets]  = rs;
    row[iremark]       = remark;
    row[iptype]        = pType;
    row[iporigin]      = origin;
    row[isn]           = specificName;

    t.insertSys(store, row);

    if (l != null) {
        int size = l.size();

        for (int i = 0; i < size; i++) {
            row                = t.getEmptyRowData();
            pName              = (String) l.get(i);
            row[icat]          = cat;
            row[ischem]        = schem;
            row[ipname]        = pName;
            row[iinput_parms]  = ip;
            row[ioutput_parms] = op;
            row[iresult_sets]  = rs;
            row[iremark]       = remark;
            row[iptype]        = pType;
            row[iporigin]      = "ALIAS";
            row[isn]           = specificName;

            t.insertSys(store, row);
        }
    }
}
 

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

    Table t = sysTables[DOMAIN_CONSTRAINTS];

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

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

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

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

        return t;
    }

    final int constraint_catalog = 0;
    final int constraint_schema  = 1;
    final int constraint_name    = 2;
    final int domain_catalog     = 3;
    final int domain_schema      = 4;
    final int domain_name        = 5;
    final int is_deferrable      = 6;
    final int initially_deferred = 7;

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

    //
    Iterator it =
        database.schemaManager.databaseObjectIterator(SchemaObject.DOMAIN);

    while (it.hasNext()) {
        Type domain = (Type) it.next();

        if (!domain.isDomainType()) {
            continue;
        }

        if (!session.getGrantee().isFullyAccessibleByRole(domain)) {
            continue;
        }

        Constraint[] constraints =
            domain.userTypeModifier.getConstraints();

        for (int i = 0; i < constraints.length; i++) {
            Object[] data = t.getEmptyRowData();

            data[constraint_catalog] = data[domain_catalog] =
                database.getCatalogName().name;
            data[constraint_schema] = data[domain_schema] =
                domain.getSchemaName().name;
            data[constraint_name]    = constraints[i].getName().name;
            data[domain_name]        = domain.getName().name;
            data[is_deferrable]      = Tokens.T_NO;
            data[initially_deferred] = Tokens.T_NO;

            t.insertSys(store, data);
        }
    }

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Retrieves a <code>Table</code> object describing the table types
 * available in this database. <p>
 *
 * In general, the range of values that may be commonly encountered across
 * most DBMS implementations is: <p>
 *
 * <UL>
 *   <LI><FONT color='#FF00FF'>"TABLE"</FONT>
 *   <LI><FONT color='#FF00FF'>"VIEW"</FONT>
 *   <LI><FONT color='#FF00FF'>"SYSTEM TABLE"</FONT>
 *   <LI><FONT color='#FF00FF'>"GLOBAL TEMPORARY"</FONT>
 *   <LI><FONT color='#FF00FF'>"LOCAL TEMPORARY"</FONT>
 *   <LI><FONT color='#FF00FF'>"ALIAS"</FONT>
 *   <LI><FONT color='#FF00FF'>"SYNONYM"</FONT>
 * </UL> <p>
 *
 * As of HSQLDB 1.7.2, the engine supports and thus this method reports
 * only a subset of the range above: <p>
 *
 * <UL>
 *   <LI><FONT color='#FF00FF'>"TABLE"</FONT>
 *    (HSQLDB MEMORY, CACHED and TEXT tables)
 *   <LI><FONT color='#FF00FF'>"VIEW"</FONT>  (Views)
 *   <LI><FONT color='#FF00FF'>"SYSTEM TABLE"</FONT>
 *    (The tables generated by this object)
 *   <LI><FONT color='#FF00FF'>"GLOBAL TEMPORARY"</FONT>
 *    (HSQLDB TEMP and TEMP TEXT tables)
 * </UL> <p>
 *
 * @return a <code>Table</code> object describing the table types
 *        available in this database
 */
Table SYSTEM_TABLETYPES(Session session, PersistentStore store) {

    Table t = sysTables[SYSTEM_TABLETYPES];

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

        addColumn(t, "TABLE_TYPE", SQL_IDENTIFIER);    // not null

        // order: TABLE_TYPE
        // true PK
        HsqlName name = HsqlNameManager.newInfoSchemaObjectName(
            sysTableHsqlNames[SYSTEM_TABLETYPES].name, false,
            SchemaObject.INDEX);

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

        return t;
    }

    Object[] row;

    for (int i = 0; i < tableTypes.length; i++) {
        row    = t.getEmptyRowData();
        row[0] = tableTypes[i];

        t.insertSys(session, store, row);
    }

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * Retrieves a <code>Table</code> object naming the accessible catalogs
 * defined within this database. <p>
 *
 * Each row is a catalog name description with the following column: <p>
 *
 * <pre class="SqlCodeExample">
 * TABLE_CAT   VARCHAR   catalog name
 * </pre> <p>
 *
 * @return a <code>Table</code> object naming the accessible
 *        catalogs defined within this database
 */
final Table INFORMATION_SCHEMA_CATALOG_NAME(Session session,
        PersistentStore store) {

    Table t = sysTables[INFORMATION_SCHEMA_CATALOG_NAME];

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

        addColumn(t, "CATALOG_NAME", SQL_IDENTIFIER);    // not null

        // order:  TABLE_CAT
        // true PK
        HsqlName name = HsqlNameManager.newInfoSchemaObjectName(
            sysTableHsqlNames[INFORMATION_SCHEMA_CATALOG_NAME].name,
            false, SchemaObject.INDEX);

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

        return t;
    }

    Object[] row = t.getEmptyRowData();

    row[0] = database.getCatalogName().name;

    t.insertSys(session, store, row);

    return t;
}