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-unsubscr...@tomcat.apache.org For additional commands, e-mail: dev-h...@tomcat.apache.org
