Author: tomdz
Date: Mon Dec 26 16:34:36 2005
New Revision: 359147
URL: http://svn.apache.org/viewcvs?rev=359147&view=rev
Log:
Enhanced utility task for dumping a database's JDBC meta data
Modified:
db/ddlutils/trunk/src/java/org/apache/ddlutils/task/DumpMetadataTask.java
Modified:
db/ddlutils/trunk/src/java/org/apache/ddlutils/task/DumpMetadataTask.java
URL:
http://svn.apache.org/viewcvs/db/ddlutils/trunk/src/java/org/apache/ddlutils/task/DumpMetadataTask.java?rev=359147&r1=359146&r2=359147&view=diff
==============================================================================
--- db/ddlutils/trunk/src/java/org/apache/ddlutils/task/DumpMetadataTask.java
(original)
+++ db/ddlutils/trunk/src/java/org/apache/ddlutils/task/DumpMetadataTask.java
Mon Dec 26 16:34:36 2005
@@ -49,7 +49,7 @@
public class DumpMetadataTask extends Task
{
/** Methods that are filtered when enumerating the properties. */
- private static final String[] IGNORED_PROPERTY_METHODS = {
"getConnection", "getCatalogs" };
+ private static final String[] IGNORED_PROPERTY_METHODS = {
"getConnection", "getCatalogs", "getSchemas" };
/** The data source to use for accessing the database. */
private BasicDataSource _dataSource;
@@ -136,7 +136,7 @@
* @param element The XML element
* @param metaData The meta data
*/
- private void dumpMetaData(Element element, DatabaseMetaData metaData)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException
+ private void dumpMetaData(Element element, DatabaseMetaData metaData)
throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, SQLException
{
// We rather iterate over the methods because most metadata properties
// do not follow the bean naming standard
@@ -155,7 +155,8 @@
dumpProperty(element, metaData, methods[idx]);
}
}
- dumpCatalogs(element, metaData);
+ dumpCatalogsAndSchemas(element, metaData);
+ dumpProcedures(element, metaData);
}
/**
@@ -302,232 +303,636 @@
}
/**
- * Dumps the catalogs of the database.
+ * Dumps the catalogs and schemas of the database.
*
* @param parent The parent element
* @param metaData The database meta data
*/
- private void dumpCatalogs(Element parent, DatabaseMetaData metaData)
+ private void dumpCatalogsAndSchemas(Element parent, DatabaseMetaData
metaData) throws SQLException
{
- Element catalogsElem = parent.addElement("catalogs");
ArrayList tableTypeList = new ArrayList();
// First we need the list of supported table types
- try
+ ResultSet result = metaData.getTableTypes();
+
+ while (result.next())
{
- ResultSet result = metaData.getTableTypes();
-
- while (result.next())
+ tableTypeList.add(getString(result, "TABLE_TYPE"));
+ }
+ result.close();
+
+ String[] tableTypes = (String[])tableTypeList.toArray(new
String[tableTypeList.size()]);
+ Element catalogsElem = parent.addElement("catalogs");
+
+ // Next we determine and dump the catalogs
+ result = metaData.getCatalogs();
+
+ while (result.next())
+ {
+ String catalogName = getString(result, "TABLE_CAT");
+
+ if ((catalogName != null) && (catalogName.length() > 0))
{
- tableTypeList.add(result.getString("TABLE_TYPE"));
+ Element catalogElem = catalogsElem.addElement("catalog");
+
+ catalogElem.addAttribute("name", catalogName);
}
}
- catch (Exception ex)
- {}
+ result.close();
- String[] tableTypes = (String[])tableTypeList.toArray(new
String[tableTypeList.size()]);
+ Element schemasElem = parent.addElement("schemas");
- // Next we determine and dump the catalogs
- try
+ // We also dump the schemas (some dbs only support one of the two)
+ result = metaData.getSchemas();
+
+ while (result.next())
{
- ResultSet result = metaData.getCatalogs();
-
- while (result.next())
+ String schemaName = getString(result, "TABLE_SCHEM");
+
+ if ((schemaName != null) && (schemaName.length() > 0))
{
- dumpCatalog(catalogsElem, metaData,
result.getString("TABLE_CAT"), tableTypes);
+ Element schemaElem = schemasElem.addElement("schema");
+
+ schemaElem.addAttribute("name", schemaName);
}
}
- catch (Exception ex)
- {}
+ result.close();
+
+ dumpTables(parent, metaData, tableTypes);
+ }
+
+ /**
+ * Dumps all tables.
+ *
+ * @param parent The parent element
+ * @param metaData The database metadata
+ * @param tableTypes The table types
+ */
+ private void dumpTables(Element parent, DatabaseMetaData metaData,
String[] tableTypes) throws SQLException
+ {
+ ResultSet result = metaData.getTables("%", "%", "%", tableTypes);
+ Element tablesElem = parent.addElement("tables");
+ Set columns = getColumnsInResultSet(result);
+
+ while (result.next())
+ {
+ String tableName = getString(result, "TABLE_NAME");
+
+ if ((tableName == null) || (tableName.length() == 0))
+ {
+ continue;
+ }
+
+ Element tableElem = tablesElem.addElement("table");
+
+ tableElem.addAttribute("name", tableName);
+ addStringAttribute(result, columns, "TABLE_CAT", tableElem,
"catalog");
+ addStringAttribute(result, columns, "TABLE_SCHEM", tableElem,
"schema");
+ addStringAttribute(result, columns, "TABLE_TYPE", tableElem,
"type");
+ addStringAttribute(result, columns, "REMARKS", tableElem,
"remarks");
+ addStringAttribute(result, columns, "TYPE_NAME", tableElem,
"typeName");
+ addStringAttribute(result, columns, "TYPE_CAT", tableElem,
"typeCatalog");
+ addStringAttribute(result, columns, "TYPE_SCHEM", tableElem,
"typeSchema");
+ addStringAttribute(result, columns, "SELF_REFERENCING_COL_NAME",
tableElem, "identifierColumn");
+ addStringAttribute(result, columns, "REF_GENERATION", tableElem,
"identifierGeneration");
+
+ dumpColumns(tableElem, metaData, "%", "%", tableName);
+ dumpPKs(tableElem, metaData, "%", "%", tableName);
+ dumpVersionColumns(tableElem, metaData, "%", "%", tableName);
+ dumpFKs(tableElem, metaData, "%", "%", tableName);
+ dumpIndices(tableElem, metaData, "%", "%", tableName);
+ }
}
/**
- * Dumps the catalog of the given name.
+ * Dumps the columns of the indicated table.
*
- * @param parent The parent element
+ * @param tableElem The XML element for the table
* @param metaData The database metadata
* @param catalogName The catalog name
- * @param tableTypes The table types to return
+ * @param tableName The table name
*/
- private void dumpCatalog(Element parent, DatabaseMetaData metaData, String
catalogName, String[] tableTypes)
+ private void dumpColumns(Element tableElem, DatabaseMetaData metaData,
String catalogName, String schemaName, String tableName) throws SQLException
{
- Element catalogElem = parent.addElement("catalog");
+ ResultSet result = metaData.getColumns(catalogName, schemaName,
tableName, "%");
+ Set columns = getColumnsInResultSet(result);
- catalogElem.addAttribute("name", catalogName);
- try
+ while (result.next())
{
- ResultSet result = metaData.getTables(catalogName, "%", "%",
tableTypes);
- Set columns = getColumnsInResultSet(result);
+ String columnName = getString(result, "COLUMN_NAME");
- while (result.next())
+ if ((columnName == null) || (columnName.length() == 0))
{
- Element tableElem = catalogElem.addElement("table");
- String tableName = result.getString("TABLE_NAME");
+ continue;
+ }
- if (columns.contains("TABLE_NAME"))
- {
- tableElem.addAttribute("name", tableName);
- }
- if (columns.contains("TABLE_CAT"))
- {
- tableElem.addAttribute("catalog",
result.getString("TABLE_CAT"));
- }
- if (columns.contains("TABLE_SCHEM"))
- {
- tableElem.addAttribute("schema",
result.getString("TABLE_SCHEM"));
- }
- if (columns.contains("TABLE_TYPE"))
- {
- tableElem.addAttribute("type",
result.getString("TABLE_TYPE"));
- }
- if (columns.contains("REMARKS"))
- {
- tableElem.addAttribute("remarks",
result.getString("REMARKS"));
- }
- if (columns.contains("TYPE_NAME"))
- {
- tableElem.addAttribute("typeName",
result.getString("TYPE_NAME"));
- }
- if (columns.contains("TYPE_CAT"))
+ Element columnElem = tableElem.addElement("column");
+
+ columnElem.addAttribute("name", columnName);
+ addIntAttribute(result, columns, "DATA_TYPE", columnElem,
"typeCode");
+ addStringAttribute(result, columns, "TYPE_NAME", columnElem,
"type");
+ addIntAttribute(result, columns, "COLUMN_SIZE", columnElem,
"size");
+ addIntAttribute(result, columns, "DECIMAL_DIGITS", columnElem,
"digits");
+ addIntAttribute(result, columns, "NUM_PREC_RADIX", columnElem,
"precision");
+ if (columns.contains("NULLABLE"))
+ {
+ switch (result.getInt("NULLABLE"))
{
- tableElem.addAttribute("typeCatalog",
result.getString("TYPE_CAT"));
+ case DatabaseMetaData.columnNoNulls:
+ columnElem.addAttribute("nullable", "false");
+ break;
+ case DatabaseMetaData.columnNullable:
+ columnElem.addAttribute("nullable", "true");
+ break;
+ default:
+ columnElem.addAttribute("nullable", "unknown");
+ break;
}
- if (columns.contains("TYPE_SCHEM"))
+ }
+ addStringAttribute(result, columns, "REMARKS", columnElem,
"remarks");
+ addStringAttribute(result, columns, "COLUMN_DEF", columnElem,
"defaultValue");
+ addIntAttribute(result, columns, "CHAR_OCTET_LENGTH", columnElem,
"maxByteLength");
+ addIntAttribute(result, columns, "ORDINAL_POSITION", columnElem,
"index");
+ if (columns.contains("IS_NULLABLE"))
+ {
+ String value = getString(result, "IS_NULLABLE");
+
+ if ("no".equalsIgnoreCase(value))
{
- tableElem.addAttribute("typeSchema",
result.getString("TYPE_SCHEM"));
+ columnElem.addAttribute("isNullable", "false");
}
- if (columns.contains("SELF_REFERENCING_COL_NAME"))
+ else if ("yes".equalsIgnoreCase(value))
{
- tableElem.addAttribute("identifierColumn",
result.getString("SELF_REFERENCING_COL_NAME"));
+ columnElem.addAttribute("isNullable", "true");
}
- if (columns.contains("REF_GENERATION"))
+ else
{
- tableElem.addAttribute("identifierGeneration",
result.getString("REF_GENERATION"));
+ columnElem.addAttribute("isNullable", "unknown");
}
- dumpTable(tableElem, metaData, catalogName, tableName);
}
+ 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");
}
- catch (SQLException ex)
+ }
+
+ /**
+ * 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 tableName The table name
+ */
+ private void dumpPKs(Element tableElem, DatabaseMetaData metaData, String
catalogName, String schemaName, String tableName) throws SQLException
+ {
+ ResultSet result = metaData.getPrimaryKeys(catalogName, schemaName,
tableName);
+ Set columns = getColumnsInResultSet(result);
+
+ while (result.next())
{
- ex.printStackTrace();
+ 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");
}
}
/**
- * Dumps the contents of the indicated table.
+ * 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 tableName The table name
*/
- private void dumpTable(Element tableElem, DatabaseMetaData metaData,
String catalogName, String tableName)
+ private void dumpVersionColumns(Element tableElem, DatabaseMetaData
metaData, String catalogName, String schemaName, String tableName) throws
SQLException
{
- try
+ ResultSet result = metaData.getVersionColumns(catalogName,
schemaName, tableName);
+ Set columns = getColumnsInResultSet(result);
+
+ while (result.next())
{
- ResultSet result = metaData.getColumns(catalogName, "%",
tableName, "%");
- Set columns = getColumnsInResultSet(result);
+ String columnName = getString(result, "COLUMN_NAME");
- while (result.next())
+ if ((columnName == null) || (columnName.length() == 0))
{
- Element columnElem = tableElem.addElement("column");
- String columnName = result.getString("COLUMN_NAME");
+ continue;
+ }
- if (columns.contains("COLUMN_NAME"))
- {
- columnElem.addAttribute("name", columnName);
- }
- if (columns.contains("DATA_TYPE"))
- {
- columnElem.addAttribute("typeCode",
String.valueOf(result.getInt("DATA_TYPE")));
- }
- if (columns.contains("TYPE_NAME"))
- {
- columnElem.addAttribute("type",
result.getString("TYPE_NAME"));
- }
- if (columns.contains("COLUMN_SIZE"))
- {
- columnElem.addAttribute("size",
String.valueOf(result.getInt("COLUMN_SIZE")));
- }
- if (columns.contains("DECIMAL_DIGITS"))
- {
- columnElem.addAttribute("digits",
String.valueOf(result.getInt("DECIMAL_DIGITS")));
- }
- if (columns.contains("NUM_PREC_RADIX"))
+ 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"))
{
- columnElem.addAttribute("precision",
String.valueOf(result.getInt("NUM_PREC_RADIX")));
+ case DatabaseMetaData.versionColumnPseudo:
+ columnElem.addAttribute("columnType", "pseudo column");
+ break;
+ case DatabaseMetaData.versionColumnNotPseudo:
+ columnElem.addAttribute("columnType", "real column");
+ break;
+ default:
+ columnElem.addAttribute("columnType", "unknown");
+ break;
}
- if (columns.contains("NULLABLE"))
- {
- switch (result.getInt("NULLABLE"))
- {
- case DatabaseMetaData.columnNoNulls:
- columnElem.addAttribute("nullable", "false");
- break;
- case DatabaseMetaData.columnNullable:
- columnElem.addAttribute("nullable", "true");
- break;
- default:
- columnElem.addAttribute("nullable", "unknown");
- break;
- }
+ }
+ }
+ }
+
+ /**
+ * 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 tableName The table name
+ */
+ private void dumpFKs(Element tableElem, DatabaseMetaData metaData, String
catalogName, String schemaName, String tableName) throws SQLException
+ {
+ ResultSet result = metaData.getImportedKeys(catalogName, schemaName,
tableName);
+ Set columns = getColumnsInResultSet(result);
+
+ 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;
}
- if (columns.contains("REMARKS"))
+ }
+ }
+ }
+
+ /**
+ * 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 tableName The table name
+ */
+ private void dumpIndices(Element tableElem, DatabaseMetaData metaData,
String catalogName, String schemaName, String tableName) throws SQLException
+ {
+ ResultSet result = metaData.getIndexInfo(catalogName, schemaName,
tableName, false, false);
+ Set columns = getColumnsInResultSet(result);
+
+ 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"))
{
- columnElem.addAttribute("remarks",
result.getString("REMARKS"));
+ 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;
}
- if (columns.contains("COLUMN_DEF"))
+ }
+ 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))
{
- columnElem.addAttribute("defaultValue",
result.getString("COLUMN_DEF"));
+ indexElem.addAttribute("sortOrder", "ascending");
}
- if (columns.contains("CHAR_OCTET_LENGTH"))
+ else if ("D".equalsIgnoreCase(value))
{
- columnElem.addAttribute("maxByteLength",
String.valueOf(result.getInt("CHAR_OCTET_LENGTH")));
+ indexElem.addAttribute("sortOrder", "descending");
}
- if (columns.contains("ORDINAL_POSITION"))
+ else
{
- columnElem.addAttribute("index",
String.valueOf(result.getInt("ORDINAL_POSITION")));
+ indexElem.addAttribute("sortOrder", "unknown");
}
- if (columns.contains("IS_NULLABLE"))
- {
- String value = result.getString("IS_NULLABLE");
+ }
+ addIntAttribute(result, columns, "CARDINALITY", indexElem,
"cardinality");
+ addIntAttribute(result, columns, "PAGES", indexElem, "pages");
+ addStringAttribute(result, columns, "FILTER_CONDITION", indexElem,
"filter");
+ }
+ }
- if ("no".equalsIgnoreCase(value))
- {
- columnElem.addAttribute("isNullable", "false");
- }
- else if ("yes".equalsIgnoreCase(value))
- {
- columnElem.addAttribute("isNullable", "true");
- }
- else
- {
- columnElem.addAttribute("isNullable", "unknown");
- }
- }
- if (columns.contains("SCOPE_CATLOG"))
- {
- columnElem.addAttribute("refCatalog",
result.getString("SCOPE_CATLOG"));
- }
- if (columns.contains("SCOPE_SCHEMA"))
+ /**
+ * Dumps all procedures.
+ *
+ * @param parent The parent element
+ * @param metaData The database metadata
+ */
+ private void dumpProcedures(Element parent, DatabaseMetaData metaData)
throws SQLException
+ {
+ ResultSet result = metaData.getProcedures("%", "%", "%");
+ Element proceduresElem = parent.addElement("procedures");
+ Set columns = getColumnsInResultSet(result);
+
+ while (result.next())
+ {
+ String procedureName = getString(result, "PROCEDURE_NAME");
+
+ if ((procedureName == null) || (procedureName.length() == 0))
+ {
+ continue;
+ }
+
+ Element procedureElem = proceduresElem.addElement("procedure");
+
+ procedureElem.addAttribute("name", procedureName);
+ addStringAttribute(result, columns, "PROCEDURE_CAT",
procedureElem, "catalog");
+ addStringAttribute(result, columns, "PROCEDURE_SCHEM",
procedureElem, "schema");
+ addStringAttribute(result, columns, "REMARKS", procedureElem,
"remarks");
+ if (columns.contains("PROCEDURE_TYPE"))
+ {
+ switch (result.getShort("PROCEDURE_TYPE"))
{
- columnElem.addAttribute("refSchema",
result.getString("SCOPE_SCHEMA"));
+ case DatabaseMetaData.procedureReturnsResult:
+ procedureElem.addAttribute("type", "returns result");
+ break;
+ case DatabaseMetaData.procedureNoResult:
+ procedureElem.addAttribute("type", "doesn't return
result");
+ break;
+ case DatabaseMetaData.procedureResultUnknown:
+ procedureElem.addAttribute("type", "may return
result");
+ break;
+ default:
+ procedureElem.addAttribute("type", "unknown");
+ break;
}
- if (columns.contains("SCOPE_TABLE"))
+ }
+
+ dumpProcedure(procedureElem, metaData, "%", "%", procedureName);
+ }
+ }
+
+ /**
+ * Dumps the contents of the indicated procedure.
+ *
+ * @param procedureElem The XML element for the procedure
+ * @param metaData The database metadata
+ * @param catalogName The catalog name
+ * @param procedureName The procedure name
+ */
+ private void dumpProcedure(Element procedureElem, DatabaseMetaData
metaData, String catalogName, String schemaName, String procedureName) throws
SQLException
+ {
+ ResultSet result = metaData.getProcedureColumns(catalogName,
schemaName, procedureName, "%");
+ Set columns = getColumnsInResultSet(result);
+
+ while (result.next())
+ {
+ String columnName = getString(result, "COLUMN_NAME");
+
+ if ((columnName == null) || (columnName.length() == 0))
+ {
+ continue;
+ }
+
+ Element columnElem = procedureElem.addElement("column");
+
+ columnElem.addAttribute("name", columnName);
+ if (columns.contains("COLUMN_TYPE"))
+ {
+ switch (result.getShort("COLUMN_TYPE"))
{
- columnElem.addAttribute("refTable",
result.getString("SCOPE_TABLE"));
+ case DatabaseMetaData.procedureColumnIn:
+ columnElem.addAttribute("type", "in parameter");
+ break;
+ case DatabaseMetaData.procedureColumnInOut:
+ columnElem.addAttribute("type", "in/out parameter");
+ break;
+ case DatabaseMetaData.procedureColumnOut:
+ columnElem.addAttribute("type", "out parameter");
+ break;
+ case DatabaseMetaData.procedureColumnReturn:
+ columnElem.addAttribute("type", "return value");
+ break;
+ case DatabaseMetaData.procedureColumnResult:
+ columnElem.addAttribute("type", "result column in
ResultSet");
+ break;
+ default:
+ columnElem.addAttribute("type", "unknown");
+ break;
}
- if (columns.contains("SOURCE_DATA_TYPE"))
+ }
+
+ addIntAttribute(result, columns, "DATA_TYPE", columnElem,
"typeCode");
+ addStringAttribute(result, columns, "TYPE_NAME", columnElem,
"type");
+ addIntAttribute(result, columns, "LENGTH", columnElem, "length");
+ addIntAttribute(result, columns, "PRECISION", columnElem,
"precision");
+ addShortAttribute(result, columns, "SCALE", columnElem, "short");
+ addShortAttribute(result, columns, "RADIX", columnElem, "radix");
+ if (columns.contains("NULLABLE"))
+ {
+ switch (result.getInt("NULLABLE"))
{
- columnElem.addAttribute("sourceTypeCode",
String.valueOf(result.getShort("SOURCE_DATA_TYPE")));
+ case DatabaseMetaData.procedureNoNulls:
+ columnElem.addAttribute("nullable", "false");
+ break;
+ case DatabaseMetaData.procedureNullable:
+ columnElem.addAttribute("nullable", "true");
+ break;
+ default:
+ columnElem.addAttribute("nullable", "unknown");
+ break;
}
-
}
+ addStringAttribute(result, columns, "REMARKS", columnElem,
"remarks");
}
- catch (SQLException ex)
+ }
+
+ /**
+ * If the result set contains the indicated column, extracts its value and
sets an attribute at the given element.
+ *
+ * @param result The result set
+ * @param columns The columns in the result set
+ * @param columnName The name of the column in the result set
+ * @param element The element to add the attribute
+ * @param attrName The name of the attribute to set
+ * @return The string value or <code>null</code>
+ */
+ private String addStringAttribute(ResultSet result, Set columns, String
columnName, Element element, String attrName) throws SQLException
+ {
+ String value = null;
+
+ if (columns.contains(columnName))
{
- ex.printStackTrace();
+ value = getString(result, columnName);
+ element.addAttribute(attrName, value);
}
+ return value;
+ }
+
+ /**
+ * If the result set contains the indicated column, extracts its int value
and sets an attribute at the given element.
+ *
+ * @param result The result set
+ * @param columns The columns in the result set
+ * @param columnName The name of the column in the result set
+ * @param element The element to add the attribute
+ * @param attrName The name of the attribute to set
+ * @return The string value or <code>null</code>
+ */
+ private String addIntAttribute(ResultSet result, Set columns, String
columnName, Element element, String attrName) throws SQLException
+ {
+ String value = null;
+
+ if (columns.contains(columnName))
+ {
+ value = String.valueOf(result.getInt(columnName));
+ element.addAttribute(attrName, value);
+ }
+ return value;
+ }
+
+ /**
+ * If the result set contains the indicated column, extracts its short
value and sets an attribute at the given element.
+ *
+ * @param result The result set
+ * @param columns The columns in the result set
+ * @param columnName The name of the column in the result set
+ * @param element The element to add the attribute
+ * @param attrName The name of the attribute to set
+ * @return The string value or <code>null</code>
+ */
+ private String addShortAttribute(ResultSet result, Set columns, String
columnName, Element element, String attrName) throws SQLException
+ {
+ String value = null;
+
+ if (columns.contains(columnName))
+ {
+ value = String.valueOf(result.getShort(columnName));
+ element.addAttribute(attrName, value);
+ }
+ return value;
+ }
+
+ /**
+ * If the result set contains the indicated column, extracts its boolean
value and sets an attribute at the given element.
+ *
+ * @param result The result set
+ * @param columns The columns in the result set
+ * @param columnName The name of the column in the result set
+ * @param element The element to add the attribute
+ * @param attrName The name of the attribute to set
+ * @return The string value or <code>null</code>
+ */
+ private String addBooleanAttribute(ResultSet result, Set columns, String
columnName, Element element, String attrName) throws SQLException
+ {
+ String value = null;
+
+ if (columns.contains(columnName))
+ {
+ value = String.valueOf(result.getBoolean(columnName));
+ element.addAttribute(attrName, value);
+ }
+ return value;
+ }
+
+ /**
+ * Extracts a string from the result set.
+ *
+ * @param result The result set
+ * @param columnName The name of the column in the result set
+ * @return The string value
+ */
+ private String getString(ResultSet result, String columnName) throws
SQLException
+ {
+ return result.getString(columnName);
}
/**
