commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject svn commit: r1099879 [1/4] - in /commons/proper/dbcp/trunk/src: java/org/apache/commons/dbcp2/ java/org/apache/commons/dbcp2/cpdsadapter/ java/org/apache/commons/dbcp2/datasources/ java/org/apache/commons/dbcp2/managed/ java/org/apache/commons/jocl2/ t...
Date Thu, 05 May 2011 17:19:04 GMT
Author: markt
Date: Thu May  5 17:19:01 2011
New Revision: 1099879

URL: http://svn.apache.org/viewvc?rev=1099879&view=rev
Log:
Add missing @Override (thanks Eclipse)

Modified:
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedObjectPool.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedTrace.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSourceFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DataSourceConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DbcpException.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingCallableStatement.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingConnection.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingDatabaseMetaData.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingResultSet.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingStatement.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DriverConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DriverManagerConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolableCallableStatement.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolableConnection.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolableConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolablePreparedStatement.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolingConnection.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolingDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/PoolingDriver.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/cpdsadapter/ConnectionImpl.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/cpdsadapter/DriverAdapterCPDS.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/cpdsadapter/PoolablePreparedStatementStub.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/cpdsadapter/PooledConnectionImpl.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/CPDSConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/InstanceKeyDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/InstanceKeyObjectFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/KeyedCPDSConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/PerUserPoolDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/PerUserPoolDataSourceFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/PoolKey.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/SharedPoolDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/SharedPoolDataSourceFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/datasources/UserPassKey.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/BasicManagedDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/DataSourceXAConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/LocalXAConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/ManagedConnection.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/ManagedDataSource.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/PoolableManagedConnection.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/PoolableManagedConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/TransactionContext.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/managed/XAConnectionFactory.java
    commons/proper/dbcp/trunk/src/java/org/apache/commons/jocl2/JOCLContentHandler.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestAbandonedBasicDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestAbandonedObjectPool.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestBasicDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestConnectionPool.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDelegatingCallableStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDelegatingConnection.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDelegatingDatabaseMetaData.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDelegatingPreparedStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDelegatingStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestJOCLed.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestJndi.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestManual.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestPStmtPoolingBasicDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestPoolableConnection.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TestPoolingDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterCallableStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterConnection.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterDatabaseMetaData.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterDriver.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterPreparedStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterResultSet.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/TesterStatement.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/ConnectionPoolDataSourceProxy.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/PooledConnectionProxy.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/TestCPDSConnectionFactory.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/TestKeyedCPDSConnectionFactory.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/datasources/TestSharedPoolDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/managed/TestManagedDataSource.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/dbcp2/managed/TestManagedDataSourceInTx.java
    commons/proper/dbcp/trunk/src/test/org/apache/commons/jocl2/TestJOCLContentHandler.java

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedObjectPool.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedObjectPool.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedObjectPool.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedObjectPool.java Thu May  5 17:19:01 2011
@@ -69,6 +69,7 @@ public class AbandonedObjectPool extends
      * @throws Exception if an exception occurs retrieving a 
      * connection from the pool
      */
+    @Override
     public Object borrowObject() throws Exception {
         if (config != null
                 && config.getRemoveAbandoned()
@@ -95,6 +96,7 @@ public class AbandonedObjectPool extends
      * @throws Exception if an exception occurs returning the connection
      * to the pool
      */
+    @Override
     public void returnObject(Object obj) throws Exception {
         if (config != null && config.getRemoveAbandoned()) {
             synchronized (trace) {
@@ -113,6 +115,7 @@ public class AbandonedObjectPool extends
      * @param obj object to be returned
      * @throws Exception if an exception occurs invalidating the object
      */
+    @Override
     public void invalidateObject(Object obj) throws Exception {
         if (config != null && config.getRemoveAbandoned()) {
             synchronized (trace) {

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedTrace.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedTrace.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedTrace.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/AbandonedTrace.java Thu May  5 17:19:01 2011
@@ -220,6 +220,7 @@ public class AbandonedTrace {
 
         // Override getMessage to avoid creating objects and formatting
         // dates unless the log message will actually be used.
+        @Override
         public String getMessage() {
             String msg;
             synchronized(format) {

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSource.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSource.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSource.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSource.java Thu May  5 17:19:01 2011
@@ -1133,6 +1133,7 @@ public class BasicDataSource implements 
      * @throws SQLException if a database access error occurs
      * @return a database connection
      */
+    @Override
     public Connection getConnection() throws SQLException {
         return createDataSource().getConnection();
     }
@@ -1149,6 +1150,7 @@ public class BasicDataSource implements 
      * @throws SQLException if a database access error occurs
      * @return nothing - always throws UnsupportedOperationException
      */
+    @Override
     public Connection getConnection(String user, String pass) throws SQLException {
         // This method isn't supported by the PoolingDataSource returned by
         // the createDataSource
@@ -1170,6 +1172,7 @@ public class BasicDataSource implements 
      *   does not support the login timeout feature.
      * @return login timeout in seconds
      */
+    @Override
     public int getLoginTimeout() throws SQLException {
         // This method isn't supported by the PoolingDataSource returned by
         // the createDataSource
@@ -1187,6 +1190,7 @@ public class BasicDataSource implements 
      * @throws SQLException if a database access error occurs
      * @return log writer in use
      */
+    @Override
     public PrintWriter getLogWriter() throws SQLException {
         return createDataSource().getLogWriter();
     }
@@ -1206,6 +1210,7 @@ public class BasicDataSource implements 
      *   does not support the login timeout feature.
      * @throws SQLException if a database access error occurs
      */
+    @Override
     public void setLoginTimeout(int loginTimeout) throws SQLException {
         // This method isn't supported by the PoolingDataSource returned by
         // the createDataSource
@@ -1223,6 +1228,7 @@ public class BasicDataSource implements 
      * @param logWriter The new log writer
      * @throws SQLException if a database access error occurs
      */
+    @Override
     public void setLogWriter(PrintWriter logWriter) throws SQLException {
         createDataSource().setLogWriter(logWriter);
         this.logWriter = logWriter;
@@ -1455,10 +1461,12 @@ public class BasicDataSource implements 
     }
 
     /* JDBC_4_ANT_KEY_BEGIN */
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return false;
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         throw new SQLException("BasicDataSource is not a wrapper.");
     }

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSourceFactory.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSourceFactory.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSourceFactory.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/BasicDataSourceFactory.java Thu May  5 17:19:01 2011
@@ -133,6 +133,7 @@ public class BasicDataSourceFactory impl
      *
      * @exception Exception if an exception occurs creating the instance
      */
+    @Override
     public Object getObjectInstance(Object obj, Name name, Context nameCtx,
                                     Hashtable environment)
         throws Exception {

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DataSourceConnectionFactory.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DataSourceConnectionFactory.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DataSourceConnectionFactory.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DataSourceConnectionFactory.java Thu May  5 17:19:01 2011
@@ -38,6 +38,7 @@ public class DataSourceConnectionFactory
         _passwd = passwd;
     }
 
+    @Override
     public Connection createConnection() throws SQLException {
         if(null == _uname && null == _passwd) {
             return _source.getConnection();

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DbcpException.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DbcpException.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DbcpException.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DbcpException.java Thu May  5 17:19:01 2011
@@ -104,6 +104,7 @@ public class DbcpException extends Runti
     /**
      * Return the root cause of this exception (if any).
      */
+    @Override
     public Throwable getCause() {
 
         return (this.cause);

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingCallableStatement.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingCallableStatement.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingCallableStatement.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingCallableStatement.java Thu May  5 17:19:01 2011
@@ -71,6 +71,7 @@ public class DelegatingCallableStatement
         super(c, s);
     }
 
+    @Override
     public boolean equals(Object obj) {
     	if (this == obj) return true;
         CallableStatement delegate = (CallableStatement) getInnermostDelegate();
@@ -92,246 +93,326 @@ public class DelegatingCallableStatement
         _stmt = s;
     }
 
+    @Override
     public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter( parameterIndex,  sqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter( parameterIndex,  sqlType,  scale); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public boolean wasNull() throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).wasNull(); } catch (SQLException e) { handleException(e); return false; } }
 
+    @Override
     public String getString(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getString( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public boolean getBoolean(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBoolean( parameterIndex); } catch (SQLException e) { handleException(e); return false; } }
 
+    @Override
     public byte getByte(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getByte( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public short getShort(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getShort( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public int getInt(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getInt( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public long getLong(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getLong( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public float getFloat(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getFloat( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public double getDouble(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDouble( parameterIndex); } catch (SQLException e) { handleException(e); return 0; } }
 
     /** @deprecated */
+    @Override
     public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBigDecimal( parameterIndex,  scale); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public byte[] getBytes(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBytes( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Date getDate(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDate( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Time getTime(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTime( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Timestamp getTimestamp(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTimestamp( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Object getObject(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getObject( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public BigDecimal getBigDecimal(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBigDecimal( parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Object getObject(int i, Map map) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getObject( i, map); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Ref getRef(int i) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getRef( i); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Blob getBlob(int i) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBlob( i); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Clob getClob(int i) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getClob( i); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Array getArray(int i) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getArray( i); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Date getDate(int parameterIndex, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDate( parameterIndex,  cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Time getTime(int parameterIndex, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTime( parameterIndex,  cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTimestamp( parameterIndex,  cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public void registerOutParameter(int paramIndex, int sqlType, String typeName) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter( paramIndex,  sqlType,  typeName); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter(parameterName, sqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter(parameterName, sqlType, scale); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).registerOutParameter(parameterName, sqlType, typeName); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public URL getURL(int parameterIndex) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getURL(parameterIndex); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public void setURL(String parameterName, URL val) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setURL(parameterName, val); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setNull(String parameterName, int sqlType) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setNull(parameterName, sqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBoolean(String parameterName, boolean x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setBoolean(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setByte(String parameterName, byte x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setByte(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setShort(String parameterName, short x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setShort(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setInt(String parameterName, int x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setInt(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setLong(String parameterName, long x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setLong(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setFloat(String parameterName, float x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setFloat(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setDouble(String parameterName, double x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setDouble(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setBigDecimal(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setString(String parameterName, String x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setString(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBytes(String parameterName, byte [] x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setBytes(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setDate(String parameterName, Date x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setDate(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTime(String parameterName, Time x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setTime(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTimestamp(String parameterName, Timestamp x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setTimestamp(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setAsciiStream(parameterName, x, length); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setBinaryStream(parameterName, x, length); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setObject(parameterName, x, targetSqlType, scale); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setObject(parameterName, x, targetSqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(String parameterName, Object x) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setObject(parameterName, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException
     { checkOpen(); ((CallableStatement)_stmt).setCharacterStream(parameterName, reader, length); }
 
+    @Override
     public void setDate(String parameterName, Date x, Calendar cal) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setDate(parameterName, x, cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTime(String parameterName, Time x, Calendar cal) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setTime(parameterName, x, cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setTimestamp(parameterName, x, cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setNull(String parameterName, int sqlType, String typeName) throws SQLException
     { checkOpen(); try { ((CallableStatement)_stmt).setNull(parameterName, sqlType, typeName); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public String getString(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getString(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public boolean getBoolean(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBoolean(parameterName); } catch (SQLException e) { handleException(e); return false; } }
 
+    @Override
     public byte getByte(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getByte(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public short getShort(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getShort(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public int getInt(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getInt(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public long getLong(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getLong(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public float getFloat(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getFloat(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public double getDouble(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDouble(parameterName); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public byte[] getBytes(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBytes(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Date getDate(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDate(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Time getTime(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTime(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Timestamp getTimestamp(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTimestamp(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Object getObject(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getObject(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public BigDecimal getBigDecimal(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBigDecimal(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Object getObject(String parameterName, Map map) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getObject(parameterName, map); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Ref getRef(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getRef(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Blob getBlob(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getBlob(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Clob getClob(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getClob(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Array getArray(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getArray(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Date getDate(String parameterName, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getDate(parameterName, cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Time getTime(String parameterName, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTime(parameterName, cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getTimestamp(parameterName, cal); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public URL getURL(String parameterName) throws SQLException
     { checkOpen(); try { return ((CallableStatement)_stmt).getURL(parameterName); } catch (SQLException e) { handleException(e); return null; } }
 
 /* JDBC_4_ANT_KEY_BEGIN */
 
+    @Override
     public RowId getRowId(int parameterIndex) throws SQLException {
         checkOpen();
         try {
@@ -343,6 +424,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public RowId getRowId(String parameterName) throws SQLException {
         checkOpen();
         try {
@@ -354,6 +436,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setRowId(String parameterName, RowId value) throws SQLException {
         checkOpen();
         try {
@@ -364,6 +447,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setNString(String parameterName, String value) throws SQLException {
         checkOpen();
         try {
@@ -374,6 +458,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setNCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -384,6 +469,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setNClob(String parameterName, NClob value) throws SQLException {
         checkOpen();
         try {
@@ -394,6 +480,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setClob(String parameterName, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -404,6 +491,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
         checkOpen();
         try {
@@ -414,6 +502,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -424,6 +513,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public NClob getNClob(int parameterIndex) throws SQLException {
         checkOpen();
         try {
@@ -435,6 +525,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public NClob getNClob(String parameterName) throws SQLException {
         checkOpen();
         try {
@@ -446,6 +537,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public void setSQLXML(String parameterName, SQLXML value) throws SQLException {
         checkOpen();
         try {
@@ -456,6 +548,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public SQLXML getSQLXML(int parameterIndex) throws SQLException {
         checkOpen();
         try {
@@ -467,6 +560,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public SQLXML getSQLXML(String parameterName) throws SQLException {
         checkOpen();
         try {
@@ -478,6 +572,7 @@ public class DelegatingCallableStatement
         }
     }
 
+    @Override
     public String getNString(int parameterIndex) throws SQLException {
         checkOpen();
         try {

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingConnection.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingConnection.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingConnection.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingConnection.java Thu May  5 17:19:01 2011
@@ -105,6 +105,7 @@ public class DelegatingConnection extend
      * 
      * @since 1.2.2
      */
+    @Override
     public String toString() {
         String s = null;
         
@@ -174,6 +175,7 @@ public class DelegatingConnection extend
      * This method considers two objects to be equal 
      * if the underlying jdbc objects are equal.
      */
+    @Override
     public boolean equals(Object obj) {
         if (obj == null) {
             return false;
@@ -192,6 +194,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public int hashCode() {
         Object obj = getInnermostDelegateInternal();
         if (obj == null) {
@@ -240,6 +243,7 @@ public class DelegatingConnection extend
      * Closes the underlying connection, and close
      * any Statements that were not explicitly closed.
      */
+    @Override
     public void close() throws SQLException {
         passivate();
         _conn.close();
@@ -249,6 +253,7 @@ public class DelegatingConnection extend
         throw e;
     }
 
+    @Override
     public Statement createStatement() throws SQLException {
         checkOpen();
         try {
@@ -260,6 +265,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Statement createStatement(int resultSetType,
                                      int resultSetConcurrency) throws SQLException {
         checkOpen();
@@ -273,6 +279,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql) throws SQLException {
         checkOpen();
         try {
@@ -285,6 +292,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql,
                                               int resultSetType,
                                               int resultSetConcurrency) throws SQLException {
@@ -300,6 +308,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public CallableStatement prepareCall(String sql) throws SQLException {
         checkOpen();
         try {
@@ -311,6 +320,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public CallableStatement prepareCall(String sql,
                                          int resultSetType,
                                          int resultSetConcurrency) throws SQLException {
@@ -325,18 +335,23 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public void clearWarnings() throws SQLException
     { checkOpen(); try { _conn.clearWarnings(); } catch (SQLException e) { handleException(e); } }
     
+    @Override
     public void commit() throws SQLException
     { checkOpen(); try { _conn.commit(); } catch (SQLException e) { handleException(e); } }
     
+    @Override
     public boolean getAutoCommit() throws SQLException
     { checkOpen(); try { return _conn.getAutoCommit(); } catch (SQLException e) { handleException(e); return false; } 
     }
+    @Override
     public String getCatalog() throws SQLException
     { checkOpen(); try { return _conn.getCatalog(); } catch (SQLException e) { handleException(e); return null; } }
     
+    @Override
     public DatabaseMetaData getMetaData() throws SQLException {
         checkOpen();
         try {
@@ -347,39 +362,51 @@ public class DelegatingConnection extend
         }
     }
     
+    @Override
     public int getTransactionIsolation() throws SQLException
     { checkOpen(); try { return _conn.getTransactionIsolation(); } catch (SQLException e) { handleException(e); return -1; } }
     
+    @Override
     public Map getTypeMap() throws SQLException
     { checkOpen(); try { return _conn.getTypeMap(); } catch (SQLException e) { handleException(e); return null; } }
     
+    @Override
     public SQLWarning getWarnings() throws SQLException
     { checkOpen(); try { return _conn.getWarnings(); } catch (SQLException e) { handleException(e); return null; } }
     
+    @Override
     public boolean isReadOnly() throws SQLException
     { checkOpen(); try { return _conn.isReadOnly(); } catch (SQLException e) { handleException(e); return false; } }
     
+    @Override
     public String nativeSQL(String sql) throws SQLException
     { checkOpen(); try { return _conn.nativeSQL(sql); } catch (SQLException e) { handleException(e); return null; } }
     
+    @Override
     public void rollback() throws SQLException
     { checkOpen(); try {  _conn.rollback(); } catch (SQLException e) { handleException(e); } }
     
+    @Override
     public void setAutoCommit(boolean autoCommit) throws SQLException
     { checkOpen(); try { _conn.setAutoCommit(autoCommit); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setCatalog(String catalog) throws SQLException
     { checkOpen(); try { _conn.setCatalog(catalog); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setReadOnly(boolean readOnly) throws SQLException
     { checkOpen(); try { _conn.setReadOnly(readOnly); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTransactionIsolation(int level) throws SQLException
     { checkOpen(); try { _conn.setTransactionIsolation(level); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTypeMap(Map map) throws SQLException
     { checkOpen(); try { _conn.setTypeMap(map); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public boolean isClosed() throws SQLException {
         return _closed || _conn.isClosed();
     }
@@ -440,24 +467,31 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public int getHoldability() throws SQLException
     { checkOpen(); try { return _conn.getHoldability(); } catch (SQLException e) { handleException(e); return 0; } }
 
+    @Override
     public void setHoldability(int holdability) throws SQLException
     { checkOpen(); try { _conn.setHoldability(holdability); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public java.sql.Savepoint setSavepoint() throws SQLException
     { checkOpen(); try { return _conn.setSavepoint(); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public java.sql.Savepoint setSavepoint(String name) throws SQLException
     { checkOpen(); try { return _conn.setSavepoint(name); } catch (SQLException e) { handleException(e); return null; } }
 
+    @Override
     public void rollback(java.sql.Savepoint savepoint) throws SQLException
     { checkOpen(); try { _conn.rollback(savepoint); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void releaseSavepoint(java.sql.Savepoint savepoint) throws SQLException
     { checkOpen(); try { _conn.releaseSavepoint(savepoint); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public Statement createStatement(int resultSetType,
                                      int resultSetConcurrency,
                                      int resultSetHoldability) throws SQLException {
@@ -472,6 +506,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql, int resultSetType,
                                               int resultSetConcurrency,
                                               int resultSetHoldability) throws SQLException {
@@ -486,6 +521,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public CallableStatement prepareCall(String sql, int resultSetType,
                                          int resultSetConcurrency,
                                          int resultSetHoldability) throws SQLException {
@@ -500,6 +536,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
         checkOpen();
         try {
@@ -512,6 +549,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql, int columnIndexes[]) throws SQLException {
         checkOpen();
         try {
@@ -524,6 +562,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {
         checkOpen();
         try {
@@ -538,10 +577,12 @@ public class DelegatingConnection extend
 
 /* JDBC_4_ANT_KEY_BEGIN */
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return iface.isAssignableFrom(getClass()) || _conn.isWrapperFor(iface);
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         if (iface.isAssignableFrom(getClass())) {
             return iface.cast(this);
@@ -552,6 +593,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
         checkOpen();
         try {
@@ -563,6 +605,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Blob createBlob() throws SQLException {
         checkOpen();
         try {
@@ -574,6 +617,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Clob createClob() throws SQLException {
         checkOpen();
         try {
@@ -585,6 +629,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public NClob createNClob() throws SQLException {
         checkOpen();
         try {
@@ -596,6 +641,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public SQLXML createSQLXML() throws SQLException {
         checkOpen();
         try {
@@ -607,6 +653,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
         checkOpen();
         try {
@@ -618,6 +665,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public boolean isValid(int timeout) throws SQLException {
         checkOpen();
         try {
@@ -629,6 +677,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public void setClientInfo(String name, String value) throws SQLClientInfoException {
         try {
             checkOpen();
@@ -642,6 +691,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public void setClientInfo(Properties properties) throws SQLClientInfoException {
         try {
             checkOpen();
@@ -655,6 +705,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public Properties getClientInfo() throws SQLException {
         checkOpen();
         try {
@@ -666,6 +717,7 @@ public class DelegatingConnection extend
         }
     }
 
+    @Override
     public String getClientInfo(String name) throws SQLException {
         checkOpen();
         try {

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingDatabaseMetaData.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingDatabaseMetaData.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingDatabaseMetaData.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingDatabaseMetaData.java Thu May  5 17:19:01 2011
@@ -52,6 +52,7 @@ public class DelegatingDatabaseMetaData 
         return _meta;
     }
 
+    @Override
     public boolean equals(Object obj) {
     	if (this == obj) return true;
         DatabaseMetaData delegate = getInnermostDelegate();
@@ -67,6 +68,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public int hashCode() {
         Object obj = getInnermostDelegate();
         if (obj == null) {
@@ -110,36 +112,43 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public boolean allProceduresAreCallable() throws SQLException {
         { try { return _meta.allProceduresAreCallable(); }
           catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean allTablesAreSelectable() throws SQLException {
         { try { return _meta.allTablesAreSelectable(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
         { try { return _meta.dataDefinitionCausesTransactionCommit(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
         { try { return _meta.dataDefinitionIgnoredInTransactions(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean deletesAreDetected(int type) throws SQLException {
         { try { return _meta.deletesAreDetected(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
         { try { return _meta.doesMaxRowSizeIncludeBlobs(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public ResultSet getAttributes(String catalog, String schemaPattern,
             String typeNamePattern, String attributeNamePattern)
             throws SQLException {
@@ -155,6 +164,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getBestRowIdentifier(String catalog, String schema,
             String table, int scope, boolean nullable) throws SQLException {
         _conn.checkOpen();
@@ -169,16 +179,19 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getCatalogSeparator() throws SQLException {
         { try { return _meta.getCatalogSeparator(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getCatalogTerm() throws SQLException {
         { try { return _meta.getCatalogTerm(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getCatalogs() throws SQLException {
         _conn.checkOpen();
         try {
@@ -191,6 +204,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getColumnPrivileges(String catalog, String schema,
             String table, String columnNamePattern) throws SQLException {
         _conn.checkOpen();
@@ -205,6 +219,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getColumns(String catalog, String schemaPattern,
             String tableNamePattern, String columnNamePattern)
             throws SQLException {
@@ -220,10 +235,12 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public Connection getConnection() throws SQLException {
         return _conn;
     }
 
+    @Override
     public ResultSet getCrossReference(String parentCatalog,
             String parentSchema, String parentTable, String foreignCatalog,
             String foreignSchema, String foreignTable) throws SQLException {
@@ -240,45 +257,55 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public int getDatabaseMajorVersion() throws SQLException {
         { try { return _meta.getDatabaseMajorVersion(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getDatabaseMinorVersion() throws SQLException {
         { try { return _meta.getDatabaseMinorVersion(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public String getDatabaseProductName() throws SQLException {
         { try { return _meta.getDatabaseProductName(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getDatabaseProductVersion() throws SQLException {
         { try { return _meta.getDatabaseProductVersion(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public int getDefaultTransactionIsolation() throws SQLException {
         { try { return _meta.getDefaultTransactionIsolation(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getDriverMajorVersion() {return _meta.getDriverMajorVersion();}
 
+    @Override
     public int getDriverMinorVersion() {return _meta.getDriverMinorVersion();}
 
+    @Override
     public String getDriverName() throws SQLException {
         { try { return _meta.getDriverName(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getDriverVersion() throws SQLException {
         { try { return _meta.getDriverVersion(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getExportedKeys(String catalog, String schema, String table)
             throws SQLException {
         _conn.checkOpen();
@@ -292,16 +319,19 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getExtraNameCharacters() throws SQLException {
         { try { return _meta.getExtraNameCharacters(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getIdentifierQuoteString() throws SQLException {
         { try { return _meta.getIdentifierQuoteString(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getImportedKeys(String catalog, String schema, String table)
             throws SQLException {
         _conn.checkOpen();
@@ -315,6 +345,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getIndexInfo(String catalog, String schema, String table,
             boolean unique, boolean approximate) throws SQLException {
         _conn.checkOpen();
@@ -329,121 +360,145 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public int getJDBCMajorVersion() throws SQLException {
         { try { return _meta.getJDBCMajorVersion(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getJDBCMinorVersion() throws SQLException {
         { try { return _meta.getJDBCMinorVersion(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxBinaryLiteralLength() throws SQLException {
         { try { return _meta.getMaxBinaryLiteralLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxCatalogNameLength() throws SQLException {
         { try { return _meta.getMaxCatalogNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxCharLiteralLength() throws SQLException {
         { try { return _meta.getMaxCharLiteralLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnNameLength() throws SQLException {
         { try { return _meta.getMaxColumnNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnsInGroupBy() throws SQLException {
         { try { return _meta.getMaxColumnsInGroupBy(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnsInIndex() throws SQLException {
         { try { return _meta.getMaxColumnsInIndex(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnsInOrderBy() throws SQLException {
         { try { return _meta.getMaxColumnsInOrderBy(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnsInSelect() throws SQLException {
         { try { return _meta.getMaxColumnsInSelect(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxColumnsInTable() throws SQLException {
         { try { return _meta.getMaxColumnsInTable(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxConnections() throws SQLException {
         { try { return _meta.getMaxConnections(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxCursorNameLength() throws SQLException {
         { try { return _meta.getMaxCursorNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxIndexLength() throws SQLException {
         { try { return _meta.getMaxIndexLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxProcedureNameLength() throws SQLException {
         { try { return _meta.getMaxProcedureNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxRowSize() throws SQLException {
         { try { return _meta.getMaxRowSize(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxSchemaNameLength() throws SQLException {
         { try { return _meta.getMaxSchemaNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxStatementLength() throws SQLException {
         { try { return _meta.getMaxStatementLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxStatements() throws SQLException {
         { try { return _meta.getMaxStatements(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxTableNameLength() throws SQLException {
         { try { return _meta.getMaxTableNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxTablesInSelect() throws SQLException {
         { try { return _meta.getMaxTablesInSelect(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public int getMaxUserNameLength() throws SQLException {
         { try { return _meta.getMaxUserNameLength(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public String getNumericFunctions() throws SQLException {
         { try { return _meta.getNumericFunctions(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getPrimaryKeys(String catalog, String schema, String table)
             throws SQLException {
         _conn.checkOpen();
@@ -457,6 +512,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getProcedureColumns(String catalog, String schemaPattern,
             String procedureNamePattern, String columnNamePattern)
             throws SQLException {
@@ -472,11 +528,13 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getProcedureTerm() throws SQLException {
         { try { return _meta.getProcedureTerm(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getProcedures(String catalog, String schemaPattern,
             String procedureNamePattern) throws SQLException {
         _conn.checkOpen();
@@ -491,26 +549,31 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public int getResultSetHoldability() throws SQLException {
         { try { return _meta.getResultSetHoldability(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public String getSQLKeywords() throws SQLException {
         { try { return _meta.getSQLKeywords(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public int getSQLStateType() throws SQLException {
         { try { return _meta.getSQLStateType(); }
         catch (SQLException e) { handleException(e); return 0; } }
     }
 
+    @Override
     public String getSchemaTerm() throws SQLException {
         { try { return _meta.getSchemaTerm(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getSchemas() throws SQLException {
         _conn.checkOpen();
         try {
@@ -523,16 +586,19 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getSearchStringEscape() throws SQLException {
         { try { return _meta.getSearchStringEscape(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getStringFunctions() throws SQLException {
         { try { return _meta.getStringFunctions(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getSuperTables(String catalog, String schemaPattern,
             String tableNamePattern) throws SQLException {
         _conn.checkOpen();
@@ -547,6 +613,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getSuperTypes(String catalog, String schemaPattern,
             String typeNamePattern) throws SQLException {
         _conn.checkOpen();
@@ -561,11 +628,13 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getSystemFunctions() throws SQLException {
         { try { return _meta.getSystemFunctions(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getTablePrivileges(String catalog, String schemaPattern,
             String tableNamePattern) throws SQLException {
         _conn.checkOpen();
@@ -580,6 +649,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getTableTypes() throws SQLException {
         _conn.checkOpen();
         try {
@@ -592,6 +662,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getTables(String catalog, String schemaPattern,
             String tableNamePattern, String[] types) throws SQLException {
         _conn.checkOpen();
@@ -606,11 +677,13 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getTimeDateFunctions() throws SQLException {
         { try { return _meta.getTimeDateFunctions(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getTypeInfo() throws SQLException {
         _conn.checkOpen();
         try {
@@ -623,6 +696,7 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public ResultSet getUDTs(String catalog, String schemaPattern,
             String typeNamePattern, int[] types) throws SQLException {
         _conn.checkOpen();
@@ -637,16 +711,19 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public String getURL() throws SQLException {
         { try { return _meta.getURL(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public String getUserName() throws SQLException {
         { try { return _meta.getUserName(); }
         catch (SQLException e) { handleException(e); throw new AssertionError(); } }
     }
 
+    @Override
     public ResultSet getVersionColumns(String catalog, String schema,
             String table) throws SQLException {
         _conn.checkOpen();
@@ -660,116 +737,139 @@ public class DelegatingDatabaseMetaData 
         }
     }
 
+    @Override
     public boolean insertsAreDetected(int type) throws SQLException {
         { try { return _meta.insertsAreDetected(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean isCatalogAtStart() throws SQLException {
         { try { return _meta.isCatalogAtStart(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean isReadOnly() throws SQLException {
         { try { return _meta.isReadOnly(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean locatorsUpdateCopy() throws SQLException {
         { try { return _meta.locatorsUpdateCopy(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean nullPlusNonNullIsNull() throws SQLException {
         { try { return _meta.nullPlusNonNullIsNull(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean nullsAreSortedAtEnd() throws SQLException {
         { try { return _meta.nullsAreSortedAtEnd(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean nullsAreSortedAtStart() throws SQLException {
         { try { return _meta.nullsAreSortedAtStart(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean nullsAreSortedHigh() throws SQLException {
         { try { return _meta.nullsAreSortedHigh(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean nullsAreSortedLow() throws SQLException {
         { try { return _meta.nullsAreSortedLow(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean othersDeletesAreVisible(int type) throws SQLException {
         { try { return _meta.othersDeletesAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean othersInsertsAreVisible(int type) throws SQLException {
         { try { return _meta.othersInsertsAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean othersUpdatesAreVisible(int type) throws SQLException {
         { try { return _meta.othersUpdatesAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean ownDeletesAreVisible(int type) throws SQLException {
         { try { return _meta.ownDeletesAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean ownInsertsAreVisible(int type) throws SQLException {
         { try { return _meta.ownInsertsAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean ownUpdatesAreVisible(int type) throws SQLException {
         { try { return _meta.ownUpdatesAreVisible(type); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesLowerCaseIdentifiers() throws SQLException {
         { try { return _meta.storesLowerCaseIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
         { try { return _meta.storesLowerCaseQuotedIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesMixedCaseIdentifiers() throws SQLException {
         { try { return _meta.storesMixedCaseIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
         { try { return _meta.storesMixedCaseQuotedIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesUpperCaseIdentifiers() throws SQLException {
         { try { return _meta.storesUpperCaseIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
         { try { return _meta.storesUpperCaseQuotedIdentifiers(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean supportsANSI92EntryLevelSQL() throws SQLException {
         { try { return _meta.supportsANSI92EntryLevelSQL(); }
         catch (SQLException e) { handleException(e); return false; } }
     }
 
+    @Override
     public boolean supportsANSI92FullSQL() throws SQLException {
         { try { return _meta.supportsANSI92FullSQL(); }
         catch (SQLException e) { handleException(e); return false; } }

Modified: commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java?rev=1099879&r1=1099878&r2=1099879&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java (original)
+++ commons/proper/dbcp/trunk/src/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java Thu May  5 17:19:01 2011
@@ -70,6 +70,7 @@ public class DelegatingPreparedStatement
         super(c, s);
     }
 
+    @Override
     public boolean equals(Object obj) {
     	if (this == obj) return true;
         PreparedStatement delegate = (PreparedStatement) getInnermostDelegate();
@@ -91,6 +92,7 @@ public class DelegatingPreparedStatement
         _stmt = s;
     }
 
+    @Override
     public ResultSet executeQuery() throws SQLException {
         checkOpen();
         if (_conn != null) {
@@ -105,6 +107,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public int executeUpdate() throws SQLException {
         checkOpen();
         if (_conn != null) {
@@ -118,70 +121,92 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNull(int parameterIndex, int sqlType) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setNull(parameterIndex,sqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBoolean(int parameterIndex, boolean x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setBoolean(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setByte(int parameterIndex, byte x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setByte(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setShort(int parameterIndex, short x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setShort(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setInt(int parameterIndex, int x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setInt(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setLong(int parameterIndex, long x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setLong(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setFloat(int parameterIndex, float x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setFloat(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setDouble(int parameterIndex, double x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setDouble(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setBigDecimal(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setString(int parameterIndex, String x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setString(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBytes(int parameterIndex, byte[] x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setBytes(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setDate(int parameterIndex, java.sql.Date x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setDate(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTime(int parameterIndex, java.sql.Time x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setTime(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setTimestamp(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setAsciiStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setAsciiStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
 
     /** @deprecated */
+    @Override
     public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setUnicodeStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
     
+    @Override
     public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setBinaryStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void clearParameters() throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).clearParameters(); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setObject(parameterIndex, x, targetSqlType, scale); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setObject(parameterIndex, x, targetSqlType); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setObject(int parameterIndex, Object x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setObject(parameterIndex, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public boolean execute() throws SQLException {
         checkOpen();
         if (_conn != null) {
@@ -195,36 +220,47 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void addBatch() throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).addBatch(); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setCharacterStream(int parameterIndex, java.io.Reader reader, int length) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setCharacterStream(parameterIndex,reader,length); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setRef(int i, Ref x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setRef(i,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setBlob(int i, Blob x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setBlob(i,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setClob(int i, Clob x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setClob(i,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setArray(int i, Array x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setArray(i,x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public ResultSetMetaData getMetaData() throws SQLException
     { checkOpen(); try { return ((PreparedStatement)_stmt).getMetaData(); } catch (SQLException e) { handleException(e); throw new AssertionError(); } }
 
+    @Override
     public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setDate(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setTime(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setTimestamp(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setNull(paramIndex,sqlType,typeName); } catch (SQLException e) { handleException(e); } }
 
@@ -234,18 +270,22 @@ public class DelegatingPreparedStatement
      * @return String 
      * @since 1.2.2
      */
+    @Override
     public String toString() {
     return _stmt.toString();
     }
 
+    @Override
     public void setURL(int parameterIndex, java.net.URL x) throws SQLException
     { checkOpen(); try { ((PreparedStatement)_stmt).setURL(parameterIndex, x); } catch (SQLException e) { handleException(e); } }
 
+    @Override
     public java.sql.ParameterMetaData getParameterMetaData() throws SQLException
     { checkOpen(); try { return ((PreparedStatement)_stmt).getParameterMetaData(); } catch (SQLException e) { handleException(e); throw new AssertionError(); } }
 
 /* JDBC_4_ANT_KEY_BEGIN */
 
+    @Override
     public void setRowId(int parameterIndex, RowId value) throws SQLException {
         checkOpen();
         try {
@@ -256,6 +296,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNString(int parameterIndex, String value) throws SQLException {
         checkOpen();
         try {
@@ -266,6 +307,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
         checkOpen();
         try {
@@ -276,6 +318,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNClob(int parameterIndex, NClob value) throws SQLException {
         checkOpen();
         try {
@@ -286,6 +329,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -296,6 +340,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
         checkOpen();
         try {
@@ -306,6 +351,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -316,6 +362,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setSQLXML(int parameterIndex, SQLXML value) throws SQLException {
         checkOpen();
         try {
@@ -326,6 +373,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
         checkOpen();
         try {
@@ -336,6 +384,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
         checkOpen();
         try {
@@ -346,6 +395,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
         checkOpen();
         try {
@@ -356,6 +406,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setAsciiStream(int parameterIndex, InputStream inputStream) throws SQLException {
         checkOpen();
         try {
@@ -366,6 +417,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setBinaryStream(int parameterIndex, InputStream inputStream) throws SQLException {
         checkOpen();
         try {
@@ -376,6 +428,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
         checkOpen();
         try {
@@ -386,6 +439,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNCharacterStream(int parameterIndex, Reader reader) throws SQLException {
         checkOpen();
         try {
@@ -396,6 +450,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setClob(int parameterIndex, Reader reader) throws SQLException {
         checkOpen();
         try {
@@ -406,6 +461,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
         checkOpen();
         try {
@@ -416,6 +472,7 @@ public class DelegatingPreparedStatement
         }
     }
 
+    @Override
     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
         checkOpen();
         try {



Mime
View raw message