Java Table.createPrimaryKeyConstraint方法代码示例

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

    Table t = sysTables[SQL_SIZING_PROFILES];

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

        addColumn(t, "SIZING_ID", CARDINAL_NUMBER);
        addColumn(t, "SIZING_NAME", CHARACTER_DATA);
        addColumn(t, "PROFILE_ID", CARDINAL_NUMBER);
        addColumn(t, "PROFILE_NAME", CHARACTER_DATA);
        addColumn(t, "REQUIRED_VALUE", CARDINAL_NUMBER);
        addColumn(t, "COMMENTS", CHARACTER_DATA);

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

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

        return t;
    }

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的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.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The SQL_PACHAGES view lists the packages of the SQL Standard supported by
 * HyperSQL.<p>
 *
 */
Table SQL_PACKAGES(Session session, PersistentStore store) {

    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.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_packages*/");
    Result rs  = sys.executeDirectStatement(sql);

    t.insertSys(session, store, rs);

    return t;
}
 

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

    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.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_parts*/");
    Result rs  = sys.executeDirectStatement(sql);

    t.insertSys(session, store, rs);

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的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.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The DATA_TYPE_PRIVILEGES view has one row for each use of a data type.
 * Currently this view does not report the DTD_IDENTIFIER column.
 * <b>Definition:</b> <p>
 *
 * <pre class="SqlCodeExample">
 *      OBJECT_CATALOG      VARCHAR
 *      OBJECT_SCHEMA       VARCHAR
 *      OBJECT_NAME         VARCHAR
 *      OBJECT_TYPE         VARCHAR
 *      DTD_IDENTIFIER      VARCHAR
 * </pre>
 *
 * <b>Description:</b> <p>
 *
 * <ol>
 * <li> The values of OBJECT_CATALOG, OBJECT_SCHEMA, and
 *      OBJECT_NAME are the catalog name, schema name,
 *       and identifier, respectively, of the object. <p>
 *
 * <li> The value of OBJECT_TYPE is the type of the object, for example
 *      'TABLE'.
 *
 * <1i> Tables are reported only if the user or one of its roles is
 *      the authorization (owner) of the table.
 * </ol>
 *
 * @return Table
 */
Table DATA_TYPE_PRIVILEGES(Session session, PersistentStore store) {

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

        return 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(session, store, rs);
    sys.close();

    return t;
}
 

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

    Table t = sysTables[JAR_JAR_USAGE];

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

        addColumn(t, "PATH_JAR_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "PATH_JAR_SCHAMA", SQL_IDENTIFIER);
        addColumn(t, "PATH_JAR_NAME", SQL_IDENTIFIER);
        addColumn(t, "JAR_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "JAR_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "JAR_NAME", SQL_IDENTIFIER);

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

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

        return t;
    }

    // column number mappings
    final int path_jar_catalog = 0;
    final int path_jar_schema  = 1;
    final int path_jar_name    = 2;
    final int jar_catalog      = 3;
    final int jar_schema       = 4;
    final int jar_name         = 5;

    //
    Iterator it;
    Object[] row;

    return t;
}
 

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

    Table t = sysTables[JARS];

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

        addColumn(t, "JAR_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "JAR_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "JAR_NAME", SQL_IDENTIFIER);
        addColumn(t, "JAR_PATH", CHARACTER_DATA);

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

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

        return t;
    }

    // column number mappings
    final int jar_catalog = 0;
    final int jar_schema  = 1;
    final int jar_name    = 2;
    final int jar_path    = 3;

    //
    Iterator it;
    Object[] row;

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The ROLE_UDT_GRANT view has one row for each privilege granted to each
 * user defined type. <p>
 *
 * <b>Definition:</b><p>
 *
 * <pre class="SqlCodeExample">
 *      GRANTOR                        VARCHAR ,
 *      GRANTEE                        VARCHAR ,
 *      UDT_CATALOG                    VARCHAR ,
 *      UDT_SCHEMA                     VARCHAR ,
 *      UDT_NAME                       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 UDT_CATALOG, UDT_SCHEMA and
 *      UDT_NAME are the catalog name, schema name and
 *      table name, respectively, of the table level grant being
 *      described. <p>
 *
 * <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_UDT_GRANTS(Session session, PersistentStore store) {

    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_UDT_GRANTS].name, false,
            SchemaObject.INDEX);

        t.createPrimaryKeyConstraint(name, null, false);

        return t;
    }

    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    Result rs = sys.executeDirectStatement(
        "SELECT U.GRANTOR, U.GRANTEE, U.UDT_CATALOG, U.UDT_SCHEMA, U.UDT_NAME, "
        + "U.PRIVILEGE_TYPE, U.IS_GRANTABLE "
        + "FROM INFORMATION_SCHEMA.UDT_PRIVILEGES U "
        + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES ON U.GRANTEE = ROLE_NAME;");

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

    return t;
}
 

import org.hsqldb.Table; //导入方法依赖的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.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The ROLE_ROUTINE_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 ,
 *      TABLE_CATALOG                  VARCHAR ,
 *      TABLE_SCHEMA                   VARCHAR ,
 *      TABLE_NAME                     VARCHAR ,
 *      PRIVILEGE_TYPE                 VARCHAR ,
 *      IS_GRANTABLE                   VARCHAR ,
 *      WITH_HIERARCHY                 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 TABLE_CATALOG, TABLE_SCHEMA and
 *      TABLE_NAME are the catalog name, schema name and
 *      table name, respectively, of the table level grant being
 *      described. <p>
 *
 * <li> The value of PRIVILEGE_TYPE is the type of the privilege, including,
 *      'DELETE', 'SELECT', 'UPDATE', 'INSERT', 'REFERENCES' and 'TRIGGER'.
 *      The value IS_GRANTABLE is 'YES' if the privilege is grantable. <p>
 * </ol>
 *
 * @return Table
 */
Table ROLE_TABLE_GRANTS(Session session, PersistentStore store) {

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

        return t;
    }

    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    Result rs = sys.executeDirectStatement(
        "SELECT T.GRANTOR, T.GRANTEE, T.TABLE_CATALOG, T.TABLE_SCHEMA, T.TABLE_NAME, "
        + "T.PRIVILEGE_TYPE, T.IS_GRANTABLE, 'NO' "
        + "FROM INFORMATION_SCHEMA.TABLE_PRIVILEGES T "
        + "JOIN INFORMATION_SCHEMA.APPLICABLE_ROLES ON T.GRANTEE = ROLE_NAME;");

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

    return t;
}
 

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

        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.createPrimaryKeyConstraint(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;

        //
        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(session, store, data);
        }

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

import org.hsqldb.Table; //导入方法依赖的package包/类
/**
 * SQL:2008 VIEW<p>
 *
 * The CONSTRAINT_TABLE_USAGE view has one row for each table identified by a
 * &lt;table name&gt; simply contained in a &lt;table reference&gt;
 * contained in the &lt;search condition&gt; of a check constraint,
 * domain constraint, or assertion. It has one row for each table
 * containing / referenced by each PRIMARY KEY, UNIQUE and FOREIGN KEY
 * constraint<p>
 *
 * <b>Definition:</b> <p>
 *
 * <pre class="SqlCodeExample">
 *      TABLE_CATALOG           VARCHAR
 *      TABLE_SCHEMA            VARCHAR
 *      TABLE_NAME              VARCHAR
 *      CONSTRAINT_CATALOG      VARCHAR
 *      CONSTRAINT_SCHEMA       VARCHAR
 *      CONSTRAINT_NAME         VARCHAR
 * </pre>
 *
 * <b>Description:</b> <p>
 *
 * <ol>
 * <li> The values of CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, and
 *      CONSTRAINT_NAME are the catalog name, schema name,
 *       and identifier, respectively, of the constraint being
 *      described. <p>
 *
 * <li> The values of TABLE_CATALOG, TABLE_SCHEMA, and TABLE_NAME are the
 *      catalog name, schema name, and identifier,
 *      respectively, of a table identified by a &lt;table name&gt;
 *      simply contained in a &lt;table reference&gt; contained in the
 *      *lt;search condition&gt; of the constraint being described, or
 *      its columns.
 *
 * <1i> Tables are reported only if the user or one of its roles is
 *      the authorization (owner) of the table.
 * </ol>
 *
 * @return Table
 */
Table CONSTRAINT_TABLE_USAGE(Session session, PersistentStore store) {

    Table t = sysTables[CONSTRAINT_TABLE_USAGE];

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

        addColumn(t, "TABLE_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "TABLE_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "TABLE_NAME", SQL_IDENTIFIER);         // not null
        addColumn(t, "CONSTRAINT_CATALOG", SQL_IDENTIFIER);
        addColumn(t, "CONSTRAINT_SCHEMA", SQL_IDENTIFIER);
        addColumn(t, "CONSTRAINT_NAME", SQL_IDENTIFIER);    // not null

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

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

        return t;
    }

    //
    Session sys = database.sessionManager.newSysSession(
        SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, session.getUser());
    Result rs = sys.executeDirectStatement(
        "select DISTINCT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, "
        + "CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME "
        + "from INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE");

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

    return t;
}