dumpmetadatatask.java

OBPM是一个开源

                    else if ("yes".equalsIgnoreCase(value))
                    {
                        columnElem.addAttribute("isNullable", "true");
                    }
                    else
                    {
                        columnElem.addAttribute("isNullable", "unknown");
                    }
                }
                addStringAttribute(result, columns, "SCOPE_CATLOG", columnElem, "refCatalog");
                addStringAttribute(result, columns, "SCOPE_SCHEMA", columnElem, "refSchema");
                addStringAttribute(result, columns, "SCOPE_TABLE", columnElem, "refTable");
                addShortAttribute(result, columns, "SOURCE_DATA_TYPE", columnElem, "sourceTypeCode");
            }
        }
        finally
        {
            if (result != null)
            {
                result.close();
            }
        }
    }

    /**
     * Dumps the primary key columns of the indicated table.
     * 
     * @param tableElem   The XML element for the table
     * @param metaData    The database metadata
     * @param catalogName The catalog name
     * @param schemaName  The schema name
     * @param tableName   The table name
     */
    private void dumpPKs(Element tableElem, DatabaseMetaData metaData, String catalogName, String schemaName, String tableName) throws SQLException
    {
        ResultSet result = null;

        try
        {
            result = metaData.getPrimaryKeys(catalogName, schemaName, tableName);
        }
        catch (SQLException ex)
        {
            log("Could not determine the primary key columns for table '"+tableName+"': "+ex.getMessage(), Project.MSG_ERR);
            return;
        }

        Set columns = getColumnsInResultSet(result);

        try
        {
            while (result.next())
            {
                String columnName = getString(result, "COLUMN_NAME");
    
                if ((columnName == null) || (columnName.length() == 0))
                {
                    continue;
                }
    
                Element pkElem = tableElem.addElement("primaryKey");
    
                pkElem.addAttribute("column", columnName);
                addStringAttribute(result, columns, "PK_NAME", pkElem, "name");
                addShortAttribute(result, columns, "KEY_SEQ", pkElem, "sequenceNumberInPK");
            }
        }
        finally
        {
            if (result != null)
            {
                result.close();
            }
        }
    }

    /**
     * Dumps the versioned (auto-updating) columns of the indicated table.
     * 
     * @param tableElem   The XML element for the table
     * @param metaData    The database metadata
     * @param catalogName The catalog name
     * @param schemaName  The schema name
     * @param tableName   The table name
     */
    private void dumpVersionColumns(Element tableElem, DatabaseMetaData metaData, String catalogName, String schemaName, String tableName) throws SQLException
    {
        ResultSet result = null;

        try
        {
            result = metaData.getVersionColumns(catalogName, schemaName, tableName);
        }
        catch (SQLException ex)
        {
            log("Could not determine the versioned columns for table '"+tableName+"': "+ex.getMessage(), Project.MSG_ERR);
            return;
        }

        Set columns = getColumnsInResultSet(result);

        try
        {
            while (result.next())
            {
                String columnName = getString(result, "COLUMN_NAME");
    
                if ((columnName == null) || (columnName.length() == 0))
                {
                    continue;
                }
    
                Element columnElem = tableElem.addElement("versionedColumn");
    
                columnElem.addAttribute("column", columnName);
                addIntAttribute(result, columns, "DATA_TYPE", columnElem, "typeCode");
                addStringAttribute(result, columns, "TYPE_NAME", columnElem, "type");
                addIntAttribute(result, columns, "BUFFER_LENGTH", columnElem, "size");
                addIntAttribute(result, columns, "COLUMN_SIZE", columnElem, "precision");
                addShortAttribute(result, columns, "DECIMAL_DIGITS", columnElem, "scale");
                if (columns.contains("PSEUDO_COLUMN"))
                {
                    switch (result.getShort("PSEUDO_COLUMN"))
                    {
                        case DatabaseMetaData.versionColumnPseudo:
                            columnElem.addAttribute("columnType", "pseudo column");
                            break;
                        case DatabaseMetaData.versionColumnNotPseudo:
                            columnElem.addAttribute("columnType", "real column");
                            break;
                        default:
                            columnElem.addAttribute("columnType", "unknown");
                            break;
                    }
                }
            }
        }
        finally
        {
            if (result != null)
            {
                result.close();
            }
        }
    }

    /**
     * Dumps the foreign key columns of the indicated table to other tables.
     * 
     * @param tableElem   The XML element for the table
     * @param metaData    The database metadata
     * @param catalogName The catalog name
     * @param schemaName  The schema name
     * @param tableName   The table name
     */
    private void dumpFKs(Element tableElem, DatabaseMetaData metaData, String catalogName, String schemaName, String tableName) throws SQLException
    {
        ResultSet result = null;

        try
        {
            result = metaData.getImportedKeys(catalogName, schemaName, tableName);
        }
        catch (SQLException ex)
        {
            log("Could not determine the foreign keys for table '"+tableName+"': "+ex.getMessage(), Project.MSG_ERR);
            return;
        }

        Set columns = getColumnsInResultSet(result);

        try
        {
            while (result.next())
            {
                Element fkElem = tableElem.addElement("foreignKey");
    
                addStringAttribute(result, columns, "FK_NAME", fkElem, "name");
                addStringAttribute(result, columns, "PK_NAME", fkElem, "primaryKeyName");
                addStringAttribute(result, columns, "PKCOLUMN_NAME", fkElem, "column");
                addStringAttribute(result, columns, "FKTABLE_CAT", fkElem, "foreignCatalog");
                addStringAttribute(result, columns, "FKTABLE_SCHEM", fkElem, "foreignSchema");
                addStringAttribute(result, columns, "FKTABLE_NAME", fkElem, "foreignTable");
                addStringAttribute(result, columns, "FKCOLUMN_NAME", fkElem, "foreignColumn");
                addShortAttribute(result, columns, "KEY_SEQ", fkElem, "sequenceNumberInFK");
                if (columns.contains("UPDATE_RULE"))
                {
                    switch (result.getShort("UPDATE_RULE"))
                    {
                        case DatabaseMetaData.importedKeyNoAction:
                            fkElem.addAttribute("updateRule", "no action");
                            break;
                        case DatabaseMetaData.importedKeyCascade:
                            fkElem.addAttribute("updateRule", "cascade PK change");
                            break;
                        case DatabaseMetaData.importedKeySetNull:
                            fkElem.addAttribute("updateRule", "set FK to NULL");
                            break;
                        case DatabaseMetaData.importedKeySetDefault:
                            fkElem.addAttribute("updateRule", "set FK to default");
                            break;
                        default:
                            fkElem.addAttribute("updateRule", "unknown");
                            break;
                    }
                }
                if (columns.contains("DELETE_RULE"))
                {
                    switch (result.getShort("DELETE_RULE"))
                    {
                        case DatabaseMetaData.importedKeyNoAction:
                        case DatabaseMetaData.importedKeyRestrict:
                            fkElem.addAttribute("deleteRule", "no action");
                            break;
                        case DatabaseMetaData.importedKeyCascade:
                            fkElem.addAttribute("deleteRule", "cascade PK change");
                            break;
                        case DatabaseMetaData.importedKeySetNull:
                            fkElem.addAttribute("deleteRule", "set FK to NULL");
                            break;
                        case DatabaseMetaData.importedKeySetDefault:
                            fkElem.addAttribute("deleteRule", "set FK to default");
                            break;
                        default:
                            fkElem.addAttribute("deleteRule", "unknown");
                            break;
                    }
                }
                if (columns.contains("DEFERRABILITY"))
                {
                    switch (result.getShort("DEFERRABILITY"))
                    {
                        case DatabaseMetaData.importedKeyInitiallyDeferred:
                            fkElem.addAttribute("deferrability", "initially deferred");
                            break;
                        case DatabaseMetaData.importedKeyInitiallyImmediate:
                            fkElem.addAttribute("deferrability", "immediately deferred");
                            break;
                        case DatabaseMetaData.importedKeyNotDeferrable:
                            fkElem.addAttribute("deferrability", "not deferred");
                            break;
                        default:
                            fkElem.addAttribute("deferrability", "unknown");
                            break;
                    }
                }
            }
        }
        finally
        {
            if (result != null)
            {
                result.close();
            }
        }
    }

    /**
     * Dumps the indices of the indicated table.
     * 
     * @param tableElem   The XML element for the table
     * @param metaData    The database metadata
     * @param catalogName The catalog name
     * @param schemaName  The schema name
     * @param tableName   The table name
     */
    private void dumpIndices(Element tableElem, DatabaseMetaData metaData, String catalogName, String schemaName, String tableName) throws SQLException
    {
        ResultSet result = null;

        try
        {
            result = metaData.getIndexInfo(catalogName, schemaName, tableName, false, false);
        }
        catch (SQLException ex)
        {
            log("Could not determine the indices for table '"+tableName+"': "+ex.getMessage(), Project.MSG_ERR);
            return;
        }

        Set columns = getColumnsInResultSet(result);

        try
        {
            while (result.next())
            {
                Element indexElem = tableElem.addElement("index");
    
                addStringAttribute(result, columns, "INDEX_NAME", indexElem, "name");
                addBooleanAttribute(result, columns, "NON_UNIQUE", indexElem, "nonUnique");
                addStringAttribute(result, columns, "INDEX_QUALIFIER", indexElem, "indexCatalog");
                if (columns.contains("TYPE"))
                {
                    switch (result.getShort("TYPE"))
                    {
                        case DatabaseMetaData.tableIndexStatistic:
                            indexElem.addAttribute("type", "table statistics");
                            break;
                        case DatabaseMetaData.tableIndexClustered:
                            indexElem.addAttribute("type", "clustered");
                            break;
                        case DatabaseMetaData.tableIndexHashed:
                            indexElem.addAttribute("type", "hashed");
                            break;
                        case DatabaseMetaData.tableIndexOther:
                            indexElem.addAttribute("type", "other");
                            break;
                        default:
                            indexElem.addAttribute("type", "unknown");
                            break;
                    }
                }
                addStringAttribute(result, columns, "COLUMN_NAME", indexElem, "column");
                addShortAttribute(result, columns, "ORDINAL_POSITION", indexElem, "sequenceNumberInIndex");
                if (columns.contains("ASC_OR_DESC"))
                {
                    String value = getString(result, "ASC_OR_DESC");
    
                    if ("A".equalsIgnoreCase(value))
                    {
                        indexElem.addAttribute("sortOrder", "ascending");
                    }
                    else if ("D".equalsIgnoreCase(value))
                    {
                        indexElem.addAttribute("sortOrder", "descending");
                    }
                    else
                    {
                        indexElem.addAttribute("sortOrder", "unknown");
                    }
                }
                addIntAttribute(result, columns, "CARDINALITY", indexElem, "cardinality");
                addIntAttribute(result, columns, "PAGES", indexElem, "pages");
                addStringAttribute(result, columns, "FILTER_CONDITION", indexElem, "filter");
            }
        }
        finally
        {
            if (result != null)
            {
                result.close();
            }
        }
    }