You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2018/06/19 11:21:13 UTC
svn commit: r1833816 [6/16] - in
/tomcat/tc8.0.x/trunk/java/org/apache/tomcat/dbcp/dbcp2: ./ cpdsadapter/
datasources/
Modified: tomcat/tc8.0.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingDatabaseMetaData.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.0.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingDatabaseMetaData.java?rev=1833816&r1=1833815&r2=1833816&view=diff
==============================================================================
--- tomcat/tc8.0.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingDatabaseMetaData.java (original)
+++ tomcat/tc8.0.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingDatabaseMetaData.java Tue Jun 19 11:21:13 2018
@@ -23,53 +23,67 @@ import java.sql.RowIdLifetime;
import java.sql.SQLException;
/**
- * <p>A base delegating implementation of {@link DatabaseMetaData}.</p>
+ * <p>
+ * A base delegating implementation of {@link DatabaseMetaData}.
+ * </p>
+ * <p>
+ * Methods that create {@link ResultSet} objects are wrapped to create {@link DelegatingResultSet} objects and the
+ * remaining methods simply call the corresponding method on the "delegate" provided in the constructor.
+ * </p>
*
- * <p>Methods that create {@link ResultSet} objects are wrapped to
- * create {@link DelegatingResultSet} objects and the remaining methods
- * simply call the corresponding method on the "delegate"
- * provided in the constructor.</p>
* @since 2.0
*/
public class DelegatingDatabaseMetaData implements DatabaseMetaData {
/** My delegate {@link DatabaseMetaData} */
- private final DatabaseMetaData _meta;
+ private final DatabaseMetaData databaseMetaData;
/** The connection that created me. **/
- private final DelegatingConnection<?> _conn;
+ private final DelegatingConnection<?> connection;
- public DelegatingDatabaseMetaData(final DelegatingConnection<?> c,
- final DatabaseMetaData m) {
+ /**
+ * Constructs a new instance for the given delegating connection and database meta data.
+ *
+ * @param connection
+ * the delegating connection
+ * @param databaseMetaData
+ * the database meta data
+ */
+ public DelegatingDatabaseMetaData(final DelegatingConnection<?> connection,
+ final DatabaseMetaData databaseMetaData) {
super();
- _conn = c;
- _meta = m;
+ this.connection = connection;
+ this.databaseMetaData = databaseMetaData;
}
+ /**
+ * Gets the underlying database meta data.
+ *
+ * @return The underlying database meta data.
+ */
public DatabaseMetaData getDelegate() {
- return _meta;
+ return databaseMetaData;
}
/**
- * If my underlying {@link ResultSet} is not a
- * {@code DelegatingResultSet}, returns it,
- * otherwise recursively invokes this method on
- * my delegate.
+ * If my underlying {@link ResultSet} is not a {@code DelegatingResultSet}, returns it, otherwise recursively
+ * invokes this method on my delegate.
* <p>
- * Hence this method will return the first
- * delegate that is not a {@code DelegatingResultSet},
- * or {@code null} when no non-{@code DelegatingResultSet}
- * delegate can be found by traversing this chain.
+ * Hence this method will return the first delegate that is not a {@code DelegatingResultSet}, or {@code null} when
+ * no non-{@code DelegatingResultSet} delegate can be found by traversing this chain.
+ * </p>
* <p>
- * This method is useful when you may have nested
- * {@code DelegatingResultSet}s, and you want to make
- * sure to obtain a "genuine" {@link ResultSet}.
+ * This method is useful when you may have nested {@code DelegatingResultSet}s, and you want to make sure to obtain
+ * a "genuine" {@link ResultSet}.
+ * </p>
+ *
+ * @return the innermost database meta data.
*/
public DatabaseMetaData getInnermostDelegate() {
- DatabaseMetaData m = _meta;
- while(m != null && m instanceof DelegatingDatabaseMetaData) {
- m = ((DelegatingDatabaseMetaData)m).getDelegate();
- if(this == m) {
+ DatabaseMetaData m = databaseMetaData;
+ while (m != null && m instanceof DelegatingDatabaseMetaData) {
+ m = ((DelegatingDatabaseMetaData) m).getDelegate();
+ if (this == m) {
return null;
}
}
@@ -77,76 +91,94 @@ public class DelegatingDatabaseMetaData
}
protected void handleException(final SQLException e) throws SQLException {
- if (_conn != null) {
- _conn.handleException(e);
- }
- else {
+ if (connection != null) {
+ connection.handleException(e);
+ } else {
throw e;
}
}
@Override
public boolean allProceduresAreCallable() throws SQLException {
- try { return _meta.allProceduresAreCallable(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.allProceduresAreCallable();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean allTablesAreSelectable() throws SQLException {
- try { return _meta.allTablesAreSelectable(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.allTablesAreSelectable();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
- try { return _meta.dataDefinitionCausesTransactionCommit(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.dataDefinitionCausesTransactionCommit();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
- try { return _meta.dataDefinitionIgnoredInTransactions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.dataDefinitionIgnoredInTransactions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean deletesAreDetected(final int type) throws SQLException {
- try { return _meta.deletesAreDetected(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.deletesAreDetected(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
- try { return _meta.doesMaxRowSizeIncludeBlobs(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.doesMaxRowSizeIncludeBlobs();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public ResultSet getAttributes(final String catalog, final String schemaPattern,
- final String typeNamePattern, final String attributeNamePattern)
- throws SQLException {
- _conn.checkOpen();
+ public ResultSet getAttributes(final String catalog, final String schemaPattern, final String typeNamePattern,
+ final String attributeNamePattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,_meta.getAttributes(
- catalog, schemaPattern, typeNamePattern,
- attributeNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getBestRowIdentifier(final String catalog, final String schema,
- final String table, final int scope, final boolean nullable) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getBestRowIdentifier(final String catalog, final String schema, final String table,
+ final int scope, final boolean nullable) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getBestRowIdentifier(catalog, schema, table, scope,
- nullable));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getBestRowIdentifier(catalog, schema, table, scope, nullable));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -154,55 +186,56 @@ public class DelegatingDatabaseMetaData
@Override
public String getCatalogSeparator() throws SQLException {
- try { return _meta.getCatalogSeparator(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getCatalogSeparator();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getCatalogTerm() throws SQLException {
- try { return _meta.getCatalogTerm(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getCatalogTerm();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public ResultSet getCatalogs() throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getCatalogs());
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCatalogs());
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getColumnPrivileges(final String catalog, final String schema,
- final String table, final String columnNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getColumnPrivileges(final String catalog, final String schema, final String table,
+ final String columnNamePattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getColumnPrivileges(catalog, schema, table,
- columnNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getColumnPrivileges(catalog, schema, table, columnNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getColumns(final String catalog, final String schemaPattern,
- final String tableNamePattern, final String columnNamePattern)
- throws SQLException {
- _conn.checkOpen();
+ public ResultSet getColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
+ final String columnNamePattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getColumns(catalog, schemaPattern, tableNamePattern,
- columnNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -210,21 +243,17 @@ public class DelegatingDatabaseMetaData
@Override
public Connection getConnection() throws SQLException {
- return _conn;
+ return connection;
}
@Override
- public ResultSet getCrossReference(final String parentCatalog,
- final String parentSchema, final String parentTable, final String foreignCatalog,
- final String foreignSchema, final String foreignTable) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getCrossReference(final String parentCatalog, final String parentSchema, final String parentTable,
+ final String foreignCatalog, final String foreignSchema, final String foreignTable) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getCrossReference(parentCatalog, parentSchema,
- parentTable, foreignCatalog, foreignSchema,
- foreignTable));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCrossReference(parentCatalog,
+ parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -232,61 +261,92 @@ public class DelegatingDatabaseMetaData
@Override
public int getDatabaseMajorVersion() throws SQLException {
- try { return _meta.getDatabaseMajorVersion(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getDatabaseMajorVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getDatabaseMinorVersion() throws SQLException {
- try { return _meta.getDatabaseMinorVersion(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getDatabaseMinorVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public String getDatabaseProductName() throws SQLException {
- try { return _meta.getDatabaseProductName(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getDatabaseProductName();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getDatabaseProductVersion() throws SQLException {
- try { return _meta.getDatabaseProductVersion(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getDatabaseProductVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public int getDefaultTransactionIsolation() throws SQLException {
- try { return _meta.getDefaultTransactionIsolation(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getDefaultTransactionIsolation();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
- public int getDriverMajorVersion() {return _meta.getDriverMajorVersion();}
+ public int getDriverMajorVersion() {
+ return databaseMetaData.getDriverMajorVersion();
+ }
@Override
- public int getDriverMinorVersion() {return _meta.getDriverMinorVersion();}
+ public int getDriverMinorVersion() {
+ return databaseMetaData.getDriverMinorVersion();
+ }
@Override
public String getDriverName() throws SQLException {
- try { return _meta.getDriverName(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getDriverName();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getDriverVersion() throws SQLException {
- try { return _meta.getDriverVersion(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getDriverVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public ResultSet getExportedKeys(final String catalog, final String schema, final String table)
throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getExportedKeys(catalog, schema, table));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getExportedKeys(catalog, schema, table));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -294,40 +354,45 @@ public class DelegatingDatabaseMetaData
@Override
public String getExtraNameCharacters() throws SQLException {
- try { return _meta.getExtraNameCharacters(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getExtraNameCharacters();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getIdentifierQuoteString() throws SQLException {
- try { return _meta.getIdentifierQuoteString(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getIdentifierQuoteString();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public ResultSet getImportedKeys(final String catalog, final String schema, final String table)
throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getImportedKeys(catalog, schema, table));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getImportedKeys(catalog, schema, table));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getIndexInfo(final String catalog, final String schema, final String table,
- final boolean unique, final boolean approximate) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getIndexInfo(final String catalog, final String schema, final String table, final boolean unique,
+ final boolean approximate) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getIndexInfo(catalog, schema, table, unique,
- approximate));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getIndexInfo(catalog, schema, table, unique, approximate));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -335,151 +400,241 @@ public class DelegatingDatabaseMetaData
@Override
public int getJDBCMajorVersion() throws SQLException {
- try { return _meta.getJDBCMajorVersion(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getJDBCMajorVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getJDBCMinorVersion() throws SQLException {
- try { return _meta.getJDBCMinorVersion(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getJDBCMinorVersion();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxBinaryLiteralLength() throws SQLException {
- try { return _meta.getMaxBinaryLiteralLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxBinaryLiteralLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxCatalogNameLength() throws SQLException {
- try { return _meta.getMaxCatalogNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxCatalogNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxCharLiteralLength() throws SQLException {
- try { return _meta.getMaxCharLiteralLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxCharLiteralLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnNameLength() throws SQLException {
- try { return _meta.getMaxColumnNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnsInGroupBy() throws SQLException {
- try { return _meta.getMaxColumnsInGroupBy(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnsInGroupBy();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnsInIndex() throws SQLException {
- try { return _meta.getMaxColumnsInIndex(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnsInIndex();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnsInOrderBy() throws SQLException {
- try { return _meta.getMaxColumnsInOrderBy(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnsInOrderBy();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnsInSelect() throws SQLException {
- try { return _meta.getMaxColumnsInSelect(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnsInSelect();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxColumnsInTable() throws SQLException {
- try { return _meta.getMaxColumnsInTable(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxColumnsInTable();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxConnections() throws SQLException {
- try { return _meta.getMaxConnections(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxConnections();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxCursorNameLength() throws SQLException {
- try { return _meta.getMaxCursorNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxCursorNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxIndexLength() throws SQLException {
- try { return _meta.getMaxIndexLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxIndexLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxProcedureNameLength() throws SQLException {
- try { return _meta.getMaxProcedureNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxProcedureNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxRowSize() throws SQLException {
- try { return _meta.getMaxRowSize(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxRowSize();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxSchemaNameLength() throws SQLException {
- try { return _meta.getMaxSchemaNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxSchemaNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxStatementLength() throws SQLException {
- try { return _meta.getMaxStatementLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxStatementLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxStatements() throws SQLException {
- try { return _meta.getMaxStatements(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxStatements();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxTableNameLength() throws SQLException {
- try { return _meta.getMaxTableNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxTableNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxTablesInSelect() throws SQLException {
- try { return _meta.getMaxTablesInSelect(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxTablesInSelect();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public int getMaxUserNameLength() throws SQLException {
- try { return _meta.getMaxUserNameLength(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getMaxUserNameLength();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public String getNumericFunctions() throws SQLException {
- try { return _meta.getNumericFunctions(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getNumericFunctions();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getPrimaryKeys(final String catalog, final String schema, final String table)
- throws SQLException {
- _conn.checkOpen();
+ public ResultSet getPrimaryKeys(final String catalog, final String schema, final String table) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getPrimaryKeys(catalog, schema, table));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getPrimaryKeys(catalog, schema, table));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -487,15 +642,12 @@ public class DelegatingDatabaseMetaData
@Override
public ResultSet getProcedureColumns(final String catalog, final String schemaPattern,
- final String procedureNamePattern, final String columnNamePattern)
- throws SQLException {
- _conn.checkOpen();
+ final String procedureNamePattern, final String columnNamePattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getProcedureColumns(catalog, schemaPattern,
- procedureNamePattern, columnNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getProcedureColumns(catalog,
+ schemaPattern, procedureNamePattern, columnNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -503,20 +655,22 @@ public class DelegatingDatabaseMetaData
@Override
public String getProcedureTerm() throws SQLException {
- try { return _meta.getProcedureTerm(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getProcedureTerm();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getProcedures(final String catalog, final String schemaPattern,
- final String procedureNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getProcedures(final String catalog, final String schemaPattern, final String procedureNamePattern)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getProcedures(catalog, schemaPattern,
- procedureNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getProcedures(catalog, schemaPattern, procedureNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -524,36 +678,50 @@ public class DelegatingDatabaseMetaData
@Override
public int getResultSetHoldability() throws SQLException {
- try { return _meta.getResultSetHoldability(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getResultSetHoldability();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public String getSQLKeywords() throws SQLException {
- try { return _meta.getSQLKeywords(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getSQLKeywords();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public int getSQLStateType() throws SQLException {
- try { return _meta.getSQLStateType(); }
- catch (final SQLException e) { handleException(e); return 0; }
+ try {
+ return databaseMetaData.getSQLStateType();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
}
@Override
public String getSchemaTerm() throws SQLException {
- try { return _meta.getSchemaTerm(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getSchemaTerm();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public ResultSet getSchemas() throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getSchemas());
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas());
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -561,41 +729,45 @@ public class DelegatingDatabaseMetaData
@Override
public String getSearchStringEscape() throws SQLException {
- try { return _meta.getSearchStringEscape(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getSearchStringEscape();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getStringFunctions() throws SQLException {
- try { return _meta.getStringFunctions(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getStringFunctions();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getSuperTables(final String catalog, final String schemaPattern,
- final String tableNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getSuperTables(final String catalog, final String schemaPattern, final String tableNamePattern)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getSuperTables(catalog, schemaPattern,
- tableNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getSuperTables(catalog, schemaPattern, tableNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getSuperTypes(final String catalog, final String schemaPattern,
- final String typeNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getSuperTypes(final String catalog, final String schemaPattern, final String typeNamePattern)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getSuperTypes(catalog, schemaPattern,
- typeNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getSuperTypes(catalog, schemaPattern, typeNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -603,20 +775,22 @@ public class DelegatingDatabaseMetaData
@Override
public String getSystemFunctions() throws SQLException {
- try { return _meta.getSystemFunctions(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getSystemFunctions();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getTablePrivileges(final String catalog, final String schemaPattern,
- final String tableNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getTablePrivileges(final String catalog, final String schemaPattern, final String tableNamePattern)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getTablePrivileges(catalog, schemaPattern,
- tableNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getTablePrivileges(catalog, schemaPattern, tableNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -624,27 +798,23 @@ public class DelegatingDatabaseMetaData
@Override
public ResultSet getTableTypes() throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getTableTypes());
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTableTypes());
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getTables(final String catalog, final String schemaPattern,
- final String tableNamePattern, final String[] types) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getTables(final String catalog, final String schemaPattern, final String tableNamePattern,
+ final String[] types) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getTables(catalog, schemaPattern, tableNamePattern,
- types));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -652,33 +822,33 @@ public class DelegatingDatabaseMetaData
@Override
public String getTimeDateFunctions() throws SQLException {
- try { return _meta.getTimeDateFunctions(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getTimeDateFunctions();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public ResultSet getTypeInfo() throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getTypeInfo());
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTypeInfo());
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getUDTs(final String catalog, final String schemaPattern,
- final String typeNamePattern, final int[] types) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getUDTs(final String catalog, final String schemaPattern, final String typeNamePattern,
+ final int[] types) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getUDTs(catalog, schemaPattern, typeNamePattern,
- types));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getUDTs(catalog, schemaPattern, typeNamePattern, types));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -686,25 +856,32 @@ public class DelegatingDatabaseMetaData
@Override
public String getURL() throws SQLException {
- try { return _meta.getURL(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getURL();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
public String getUserName() throws SQLException {
- try { return _meta.getUserName(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getUserName();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getVersionColumns(final String catalog, final String schema,
- final String table) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getVersionColumns(final String catalog, final String schema, final String table)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getVersionColumns(catalog, schema, table));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getVersionColumns(catalog, schema, table));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -712,548 +889,902 @@ public class DelegatingDatabaseMetaData
@Override
public boolean insertsAreDetected(final int type) throws SQLException {
- try { return _meta.insertsAreDetected(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.insertsAreDetected(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean isCatalogAtStart() throws SQLException {
- try { return _meta.isCatalogAtStart(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.isCatalogAtStart();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean isReadOnly() throws SQLException {
- try { return _meta.isReadOnly(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.isReadOnly();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean locatorsUpdateCopy() throws SQLException {
- try { return _meta.locatorsUpdateCopy(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.locatorsUpdateCopy();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean nullPlusNonNullIsNull() throws SQLException {
- try { return _meta.nullPlusNonNullIsNull(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.nullPlusNonNullIsNull();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean nullsAreSortedAtEnd() throws SQLException {
- try { return _meta.nullsAreSortedAtEnd(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.nullsAreSortedAtEnd();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean nullsAreSortedAtStart() throws SQLException {
- try { return _meta.nullsAreSortedAtStart(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.nullsAreSortedAtStart();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean nullsAreSortedHigh() throws SQLException {
- try { return _meta.nullsAreSortedHigh(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.nullsAreSortedHigh();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean nullsAreSortedLow() throws SQLException {
- try { return _meta.nullsAreSortedLow(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.nullsAreSortedLow();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean othersDeletesAreVisible(final int type) throws SQLException {
- try { return _meta.othersDeletesAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.othersDeletesAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean othersInsertsAreVisible(final int type) throws SQLException {
- try { return _meta.othersInsertsAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
- }
+ try {
+ return databaseMetaData.othersInsertsAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
public boolean othersUpdatesAreVisible(final int type) throws SQLException {
- try { return _meta.othersUpdatesAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.othersUpdatesAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean ownDeletesAreVisible(final int type) throws SQLException {
- try { return _meta.ownDeletesAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.ownDeletesAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean ownInsertsAreVisible(final int type) throws SQLException {
- try { return _meta.ownInsertsAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.ownInsertsAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean ownUpdatesAreVisible(final int type) throws SQLException {
- try { return _meta.ownUpdatesAreVisible(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.ownUpdatesAreVisible(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesLowerCaseIdentifiers() throws SQLException {
- try { return _meta.storesLowerCaseIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesLowerCaseIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
- try { return _meta.storesLowerCaseQuotedIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesLowerCaseQuotedIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesMixedCaseIdentifiers() throws SQLException {
- try { return _meta.storesMixedCaseIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesMixedCaseIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
- try { return _meta.storesMixedCaseQuotedIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesMixedCaseQuotedIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesUpperCaseIdentifiers() throws SQLException {
- try { return _meta.storesUpperCaseIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesUpperCaseIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
- try { return _meta.storesUpperCaseQuotedIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.storesUpperCaseQuotedIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsANSI92EntryLevelSQL() throws SQLException {
- try { return _meta.supportsANSI92EntryLevelSQL(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsANSI92EntryLevelSQL();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsANSI92FullSQL() throws SQLException {
- try { return _meta.supportsANSI92FullSQL(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsANSI92FullSQL();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsANSI92IntermediateSQL() throws SQLException {
- try { return _meta.supportsANSI92IntermediateSQL(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsANSI92IntermediateSQL();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsAlterTableWithAddColumn() throws SQLException {
- try { return _meta.supportsAlterTableWithAddColumn(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsAlterTableWithAddColumn();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsAlterTableWithDropColumn() throws SQLException {
- try { return _meta.supportsAlterTableWithDropColumn(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsAlterTableWithDropColumn();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsBatchUpdates() throws SQLException {
- try { return _meta.supportsBatchUpdates(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsBatchUpdates();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCatalogsInDataManipulation() throws SQLException {
- try { return _meta.supportsCatalogsInDataManipulation(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCatalogsInDataManipulation();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
- try { return _meta.supportsCatalogsInIndexDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCatalogsInIndexDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
- try { return _meta.supportsCatalogsInPrivilegeDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCatalogsInProcedureCalls() throws SQLException {
- try { return _meta.supportsCatalogsInProcedureCalls(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCatalogsInProcedureCalls();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCatalogsInTableDefinitions() throws SQLException {
- try { return _meta.supportsCatalogsInTableDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCatalogsInTableDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsColumnAliasing() throws SQLException {
- try { return _meta.supportsColumnAliasing(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsColumnAliasing();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsConvert() throws SQLException {
- try { return _meta.supportsConvert(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsConvert();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsConvert(final int fromType, final int toType)
- throws SQLException {
- try { return _meta.supportsConvert(fromType, toType); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsConvert(final int fromType, final int toType) throws SQLException {
+ try {
+ return databaseMetaData.supportsConvert(fromType, toType);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCoreSQLGrammar() throws SQLException {
- try { return _meta.supportsCoreSQLGrammar(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCoreSQLGrammar();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsCorrelatedSubqueries() throws SQLException {
- try { return _meta.supportsCorrelatedSubqueries(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsCorrelatedSubqueries();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsDataDefinitionAndDataManipulationTransactions()
- throws SQLException {
- try { return _meta.supportsDataDefinitionAndDataManipulationTransactions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
+ try {
+ return databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsDataManipulationTransactionsOnly()
- throws SQLException {
- try { return _meta.supportsDataManipulationTransactionsOnly(); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
+ try {
+ return databaseMetaData.supportsDataManipulationTransactionsOnly();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsDifferentTableCorrelationNames() throws SQLException {
- try { return _meta.supportsDifferentTableCorrelationNames(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsDifferentTableCorrelationNames();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsExpressionsInOrderBy() throws SQLException {
- try { return _meta.supportsExpressionsInOrderBy(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsExpressionsInOrderBy();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsExtendedSQLGrammar() throws SQLException {
- try { return _meta.supportsExtendedSQLGrammar(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsExtendedSQLGrammar();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsFullOuterJoins() throws SQLException {
- try { return _meta.supportsFullOuterJoins(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsFullOuterJoins();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsGetGeneratedKeys() throws SQLException {
- try { return _meta.supportsGetGeneratedKeys(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsGetGeneratedKeys();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsGroupBy() throws SQLException {
- try { return _meta.supportsGroupBy(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsGroupBy();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsGroupByBeyondSelect() throws SQLException {
- try { return _meta.supportsGroupByBeyondSelect(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsGroupByBeyondSelect();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsGroupByUnrelated() throws SQLException {
- try { return _meta.supportsGroupByUnrelated(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsGroupByUnrelated();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsIntegrityEnhancementFacility() throws SQLException {
- try { return _meta.supportsIntegrityEnhancementFacility(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsIntegrityEnhancementFacility();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsLikeEscapeClause() throws SQLException {
- try { return _meta.supportsLikeEscapeClause(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsLikeEscapeClause();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsLimitedOuterJoins() throws SQLException {
- try { return _meta.supportsLimitedOuterJoins(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsLimitedOuterJoins();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMinimumSQLGrammar() throws SQLException {
- try { return _meta.supportsMinimumSQLGrammar(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMinimumSQLGrammar();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMixedCaseIdentifiers() throws SQLException {
- try { return _meta.supportsMixedCaseIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMixedCaseIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
- try { return _meta.supportsMixedCaseQuotedIdentifiers(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMixedCaseQuotedIdentifiers();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMultipleOpenResults() throws SQLException {
- try { return _meta.supportsMultipleOpenResults(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMultipleOpenResults();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMultipleResultSets() throws SQLException {
- try { return _meta.supportsMultipleResultSets(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMultipleResultSets();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsMultipleTransactions() throws SQLException {
- try { return _meta.supportsMultipleTransactions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsMultipleTransactions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsNamedParameters() throws SQLException {
- try { return _meta.supportsNamedParameters(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsNamedParameters();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsNonNullableColumns() throws SQLException {
- try { return _meta.supportsNonNullableColumns(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsNonNullableColumns();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
- try { return _meta.supportsOpenCursorsAcrossCommit(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOpenCursorsAcrossCommit();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
- try { return _meta.supportsOpenCursorsAcrossRollback(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOpenCursorsAcrossRollback();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
- try { return _meta.supportsOpenStatementsAcrossCommit(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOpenStatementsAcrossCommit();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
- try { return _meta.supportsOpenStatementsAcrossRollback(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOpenStatementsAcrossRollback();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOrderByUnrelated() throws SQLException {
- try { return _meta.supportsOrderByUnrelated(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOrderByUnrelated();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsOuterJoins() throws SQLException {
- try { return _meta.supportsOuterJoins(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsOuterJoins();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsPositionedDelete() throws SQLException {
- try { return _meta.supportsPositionedDelete(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsPositionedDelete();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsPositionedUpdate() throws SQLException {
- try { return _meta.supportsPositionedUpdate(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsPositionedUpdate();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsResultSetConcurrency(final int type, final int concurrency)
- throws SQLException {
- try { return _meta.supportsResultSetConcurrency(type, concurrency); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsResultSetConcurrency(final int type, final int concurrency) throws SQLException {
+ try {
+ return databaseMetaData.supportsResultSetConcurrency(type, concurrency);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsResultSetHoldability(final int holdability)
- throws SQLException {
- try { return _meta.supportsResultSetHoldability(holdability); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsResultSetHoldability(final int holdability) throws SQLException {
+ try {
+ return databaseMetaData.supportsResultSetHoldability(holdability);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsResultSetType(final int type) throws SQLException {
- try { return _meta.supportsResultSetType(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsResultSetType(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSavepoints() throws SQLException {
- try { return _meta.supportsSavepoints(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSavepoints();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSchemasInDataManipulation() throws SQLException {
- try { return _meta.supportsSchemasInDataManipulation(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSchemasInDataManipulation();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSchemasInIndexDefinitions() throws SQLException {
- try { return _meta.supportsSchemasInIndexDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSchemasInIndexDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
- try { return _meta.supportsSchemasInPrivilegeDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSchemasInPrivilegeDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSchemasInProcedureCalls() throws SQLException {
- try { return _meta.supportsSchemasInProcedureCalls(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSchemasInProcedureCalls();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSchemasInTableDefinitions() throws SQLException {
- try { return _meta.supportsSchemasInTableDefinitions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSchemasInTableDefinitions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSelectForUpdate() throws SQLException {
- try { return _meta.supportsSelectForUpdate(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSelectForUpdate();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsStatementPooling() throws SQLException {
- try { return _meta.supportsStatementPooling(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsStatementPooling();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsStoredProcedures() throws SQLException {
- try { return _meta.supportsStoredProcedures(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsStoredProcedures();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSubqueriesInComparisons() throws SQLException {
- try { return _meta.supportsSubqueriesInComparisons(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSubqueriesInComparisons();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSubqueriesInExists() throws SQLException {
- try { return _meta.supportsSubqueriesInExists(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSubqueriesInExists();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSubqueriesInIns() throws SQLException {
- try { return _meta.supportsSubqueriesInIns(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSubqueriesInIns();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsSubqueriesInQuantifieds() throws SQLException {
- try { return _meta.supportsSubqueriesInQuantifieds(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsSubqueriesInQuantifieds();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsTableCorrelationNames() throws SQLException {
- try { return _meta.supportsTableCorrelationNames(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsTableCorrelationNames();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
- public boolean supportsTransactionIsolationLevel(final int level)
- throws SQLException {
- try { return _meta.supportsTransactionIsolationLevel(level); }
- catch (final SQLException e) { handleException(e); return false; }
+ public boolean supportsTransactionIsolationLevel(final int level) throws SQLException {
+ try {
+ return databaseMetaData.supportsTransactionIsolationLevel(level);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsTransactions() throws SQLException {
- try { return _meta.supportsTransactions(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsTransactions();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsUnion() throws SQLException {
- try { return _meta.supportsUnion(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsUnion();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsUnionAll() throws SQLException {
- try { return _meta.supportsUnionAll(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsUnionAll();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean updatesAreDetected(final int type) throws SQLException {
- try { return _meta.updatesAreDetected(type); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.updatesAreDetected(type);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean usesLocalFilePerTable() throws SQLException {
- try { return _meta.usesLocalFilePerTable(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.usesLocalFilePerTable();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean usesLocalFiles() throws SQLException {
- try { return _meta.usesLocalFiles(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.usesLocalFiles();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
/* JDBC_4_ANT_KEY_BEGIN */
@@ -1262,10 +1793,10 @@ public class DelegatingDatabaseMetaData
public boolean isWrapperFor(final Class<?> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
- } else if (iface.isAssignableFrom(_meta.getClass())) {
+ } else if (iface.isAssignableFrom(databaseMetaData.getClass())) {
return true;
} else {
- return _meta.isWrapperFor(iface);
+ return databaseMetaData.isWrapperFor(iface);
}
}
@@ -1273,28 +1804,29 @@ public class DelegatingDatabaseMetaData
public <T> T unwrap(final Class<T> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
- } else if (iface.isAssignableFrom(_meta.getClass())) {
- return iface.cast(_meta);
+ } else if (iface.isAssignableFrom(databaseMetaData.getClass())) {
+ return iface.cast(databaseMetaData);
} else {
- return _meta.unwrap(iface);
+ return databaseMetaData.unwrap(iface);
}
}
@Override
public RowIdLifetime getRowIdLifetime() throws SQLException {
- try { return _meta.getRowIdLifetime(); }
- catch (final SQLException e) { handleException(e); throw new AssertionError(); }
+ try {
+ return databaseMetaData.getRowIdLifetime();
+ } catch (final SQLException e) {
+ handleException(e);
+ throw new AssertionError();
+ }
}
@Override
- public ResultSet getSchemas(final String catalog, final String schemaPattern)
- throws SQLException {
- _conn.checkOpen();
+ public ResultSet getSchemas(final String catalog, final String schemaPattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getSchemas(catalog, schemaPattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas(catalog, schemaPattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -1302,39 +1834,43 @@ public class DelegatingDatabaseMetaData
@Override
public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
- try { return _meta.autoCommitFailureClosesAllResultSets(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.autoCommitFailureClosesAllResultSets();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
- try { return _meta.supportsStoredFunctionsUsingCallSyntax(); }
- catch (final SQLException e) { handleException(e); return false; }
+ try {
+ return databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
}
@Override
public ResultSet getClientInfoProperties() throws SQLException {
- _conn.checkOpen();
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getClientInfoProperties());
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getClientInfoProperties());
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public ResultSet getFunctions(final String catalog, final String schemaPattern,
- final String functionNamePattern) throws SQLException {
- _conn.checkOpen();
+ public ResultSet getFunctions(final String catalog, final String schemaPattern, final String functionNamePattern)
+ throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getFunctions(catalog, schemaPattern,
- functionNamePattern));
- }
- catch (final SQLException e) {
+ return DelegatingResultSet.wrapResultSet(connection,
+ databaseMetaData.getFunctions(catalog, schemaPattern, functionNamePattern));
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -1342,15 +1878,12 @@ public class DelegatingDatabaseMetaData
@Override
public ResultSet getFunctionColumns(final String catalog, final String schemaPattern,
- final String functionNamePattern, final String columnNamePattern)
- throws SQLException {
- _conn.checkOpen();
+ final String functionNamePattern, final String columnNamePattern) throws SQLException {
+ connection.checkOpen();
try {
- return DelegatingResultSet.wrapResultSet(_conn,
- _meta.getFunctionColumns(catalog, schemaPattern,
- functionNamePattern, columnNamePattern));
- }
- catch (final SQLException e) {
[... 46 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org