Ticket #21037: commons-dbcp-JDK-1.6.diff

File commons-dbcp-JDK-1.6.diff, 61.9 KB (added by nox@…, 15 years ago)

A patch for JDK-1.6 support

  • files/patch-JDK-1.6.diff

     
     1Taken from https://issues.apache.org/jira/browse/DBCP-191
     2
     3Index: src/test/org/apache/commons/dbcp/TesterPreparedStatement.java
     4===================================================================
     5--- src/test/org/apache/commons/dbcp/TesterPreparedStatement.java       (revision 558600)
     6+++ src/test/org/apache/commons/dbcp/TesterPreparedStatement.java       (working copy)
     7@@ -28,6 +28,13 @@
     8 import java.sql.ResultSetMetaData;
     9 import java.sql.SQLException;
     10 import java.util.Calendar;
     11+/* JDBC_4_ANT_KEY_BEGIN */
     12+import java.io.InputStream;
     13+import java.io.Reader;
     14+import java.sql.NClob;
     15+import java.sql.RowId;
     16+import java.sql.SQLXML;
     17+/* JDBC_4_ANT_KEY_END */
     18 
     19 /**
     20  * A dummy {@link PreparedStatement}, for testing purposes.
     21@@ -288,7 +295,79 @@
     22     public java.sql.ParameterMetaData getParameterMetaData() throws SQLException {
     23         throw new SQLException("Not implemented.");
     24     }
     25-
     26 /* JDBC_3_ANT_KEY_END */
     27+/* JDBC_4_ANT_KEY_BEGIN */
     28 
     29+    public void setRowId(int parameterIndex, RowId value) throws SQLException {
     30+        throw new SQLException("Not implemented.");
     31+    }
     32+
     33+    public void setNString(int parameterIndex, String value) throws SQLException {
     34+        throw new SQLException("Not implemented.");
     35+    }
     36+
     37+    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     38+        throw new SQLException("Not implemented.");
     39+    }
     40+
     41+    public void setNClob(int parameterIndex, NClob value) throws SQLException {
     42+        throw new SQLException("Not implemented.");
     43+    }
     44+
     45+    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     46+        throw new SQLException("Not implemented.");
     47+    }
     48+
     49+    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     50+        throw new SQLException("Not implemented.");
     51+    }
     52+
     53+    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     54+        throw new SQLException("Not implemented.");
     55+    }
     56+
     57+    public void setSQLXML(int parameterIndex, SQLXML value) throws SQLException {
     58+        throw new SQLException("Not implemented.");
     59+    }
     60+
     61+    public void setAsciiStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     62+        throw new SQLException("Not implemented.");
     63+    }
     64+
     65+    public void setBinaryStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     66+        throw new SQLException("Not implemented.");
     67+    }
     68+
     69+    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     70+        throw new SQLException("Not implemented.");
     71+    }
     72+
     73+    public void setAsciiStream(int parameterIndex, InputStream inputStream) throws SQLException {
     74+        throw new SQLException("Not implemented.");
     75+    }
     76+
     77+    public void setBinaryStream(int parameterIndex, InputStream inputStream) throws SQLException {
     78+        throw new SQLException("Not implemented.");
     79+    }
     80+
     81+    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     82+        throw new SQLException("Not implemented.");
     83+    }
     84+
     85+    public void setNCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     86+        throw new SQLException("Not implemented.");
     87+    }
     88+
     89+    public void setClob(int parameterIndex, Reader reader) throws SQLException {
     90+        throw new SQLException("Not implemented.");
     91+    }
     92+
     93+    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     94+        throw new SQLException("Not implemented.");
     95+    }
     96+
     97+    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     98+        throw new SQLException("Not implemented.");
     99+    }
     100+/* JDBC_4_ANT_KEY_END */
     101 }
     102Index: src/test/org/apache/commons/dbcp/TesterResultSet.java
     103===================================================================
     104--- src/test/org/apache/commons/dbcp/TesterResultSet.java       (revision 558600)
     105+++ src/test/org/apache/commons/dbcp/TesterResultSet.java       (working copy)
     106@@ -28,6 +28,13 @@
     107 import java.sql.SQLWarning;
     108 import java.sql.Statement;
     109 import java.util.Calendar;
     110+/* JDBC_4_ANT_KEY_BEGIN */
     111+import java.io.InputStream;
     112+import java.io.Reader;
     113+import java.sql.NClob;
     114+import java.sql.RowId;
     115+import java.sql.SQLXML;
     116+/* JDBC_4_ANT_KEY_END */
     117 
     118 /**
     119  * A dummy {@link ResultSet}, for testing purposes.
     120@@ -759,7 +766,207 @@
     121         throws SQLException {
     122         throw new SQLException("Not implemented.");
     123     }
     124-
     125 /* JDBC_3_ANT_KEY_END */
     126+/* JDBC_4_ANT_KEY_BEGIN */
     127 
     128+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     129+        throw new SQLException("Not implemented.");
     130+    }
     131+
     132+    public <T> T unwrap(Class<T> iface) throws SQLException {
     133+        throw new SQLException("Not implemented.");
     134+    }
     135+
     136+    public RowId getRowId(int columnIndex) throws SQLException {
     137+        throw new SQLException("Not implemented.");
     138+    }
     139+
     140+    public RowId getRowId(String columnLabel) throws SQLException {
     141+        throw new SQLException("Not implemented.");
     142+    }
     143+
     144+    public void updateRowId(int columnIndex, RowId value) throws SQLException {
     145+        throw new SQLException("Not implemented.");
     146+    }
     147+
     148+    public void updateRowId(String columnLabel, RowId value) throws SQLException {
     149+        throw new SQLException("Not implemented.");
     150+    }
     151+
     152+    public int getHoldability() throws SQLException {
     153+        throw new SQLException("Not implemented.");
     154+    }
     155+
     156+    public boolean isClosed() throws SQLException {
     157+        throw new SQLException("Not implemented.");
     158+    }
     159+
     160+    public void updateNString(int columnIndex, String value) throws SQLException {
     161+        throw new SQLException("Not implemented.");
     162+    }
     163+
     164+    public void updateNString(String columnLabel, String value) throws SQLException {
     165+        throw new SQLException("Not implemented.");
     166+    }
     167+
     168+    public void updateNClob(int columnIndex, NClob value) throws SQLException {
     169+        throw new SQLException("Not implemented.");
     170+    }
     171+
     172+    public void updateNClob(String columnLabel, NClob value) throws SQLException {
     173+        throw new SQLException("Not implemented.");
     174+    }
     175+
     176+    public NClob getNClob(int columnIndex) throws SQLException {
     177+        throw new SQLException("Not implemented.");
     178+    }
     179+
     180+    public NClob getNClob(String columnLabel) throws SQLException {
     181+        throw new SQLException("Not implemented.");
     182+    }
     183+
     184+    public SQLXML getSQLXML(int columnIndex) throws SQLException {
     185+        throw new SQLException("Not implemented.");
     186+    }
     187+
     188+    public SQLXML getSQLXML(String columnLabel) throws SQLException {
     189+        throw new SQLException("Not implemented.");
     190+    }
     191+
     192+    public void updateSQLXML(int columnIndex, SQLXML value) throws SQLException {
     193+        throw new SQLException("Not implemented.");
     194+    }
     195+
     196+    public void updateSQLXML(String columnLabel, SQLXML value) throws SQLException {
     197+        throw new SQLException("Not implemented.");
     198+    }
     199+
     200+    public String getNString(int columnIndex) throws SQLException {
     201+        throw new SQLException("Not implemented.");
     202+    }
     203+
     204+    public String getNString(String columnLabel) throws SQLException {
     205+        throw new SQLException("Not implemented.");
     206+    }
     207+
     208+    public Reader getNCharacterStream(int columnIndex) throws SQLException {
     209+        throw new SQLException("Not implemented.");
     210+    }
     211+
     212+    public Reader getNCharacterStream(String columnLabel) throws SQLException {
     213+        throw new SQLException("Not implemented.");
     214+    }
     215+
     216+    public void updateNCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     217+        throw new SQLException("Not implemented.");
     218+    }
     219+
     220+    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     221+        throw new SQLException("Not implemented.");
     222+    }
     223+
     224+    public void updateAsciiStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     225+        throw new SQLException("Not implemented.");
     226+    }
     227+
     228+    public void updateBinaryStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     229+        throw new SQLException("Not implemented.");
     230+    }
     231+
     232+    public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     233+        throw new SQLException("Not implemented.");
     234+    }
     235+
     236+    public void updateAsciiStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     237+        throw new SQLException("Not implemented.");
     238+    }
     239+
     240+    public void updateBinaryStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     241+        throw new SQLException("Not implemented.");
     242+    }
     243+
     244+    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     245+        throw new SQLException("Not implemented.");
     246+    }
     247+
     248+    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
     249+        throw new SQLException("Not implemented.");
     250+    }
     251+
     252+    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
     253+        throw new SQLException("Not implemented.");
     254+    }
     255+
     256+    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
     257+        throw new SQLException("Not implemented.");
     258+    }
     259+
     260+    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
     261+        throw new SQLException("Not implemented.");
     262+    }
     263+
     264+    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
     265+        throw new SQLException("Not implemented.");
     266+    }
     267+
     268+    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
     269+        throw new SQLException("Not implemented.");
     270+    }
     271+
     272+    public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException {
     273+        throw new SQLException("Not implemented.");
     274+    }
     275+
     276+    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
     277+        throw new SQLException("Not implemented.");
     278+    }
     279+
     280+    public void updateAsciiStream(int columnIndex, InputStream inputStream) throws SQLException {
     281+        throw new SQLException("Not implemented.");
     282+    }
     283+
     284+    public void updateBinaryStream(int columnIndex, InputStream inputStream) throws SQLException {
     285+        throw new SQLException("Not implemented.");
     286+    }
     287+
     288+    public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException {
     289+        throw new SQLException("Not implemented.");
     290+    }
     291+
     292+    public void updateAsciiStream(String columnLabel, InputStream inputStream) throws SQLException {
     293+        throw new SQLException("Not implemented.");
     294+    }
     295+
     296+    public void updateBinaryStream(String columnLabel, InputStream inputStream) throws SQLException {
     297+        throw new SQLException("Not implemented.");
     298+    }
     299+
     300+    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
     301+        throw new SQLException("Not implemented.");
     302+    }
     303+
     304+    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
     305+        throw new SQLException("Not implemented.");
     306+    }
     307+
     308+    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
     309+        throw new SQLException("Not implemented.");
     310+    }
     311+
     312+    public void updateClob(int columnIndex, Reader reader) throws SQLException {
     313+        throw new SQLException("Not implemented.");
     314+    }
     315+
     316+    public void updateClob(String columnLabel, Reader reader) throws SQLException {
     317+        throw new SQLException("Not implemented.");
     318+    }
     319+
     320+    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
     321+        throw new SQLException("Not implemented.");
     322+    }
     323+
     324+    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
     325+        throw new SQLException("Not implemented.");
     326+    }
     327+/* JDBC_4_ANT_KEY_END */
     328 }
     329Index: src/test/org/apache/commons/dbcp/TesterConnection.java
     330===================================================================
     331--- src/test/org/apache/commons/dbcp/TesterConnection.java      (revision 558600)
     332+++ src/test/org/apache/commons/dbcp/TesterConnection.java      (working copy)
     333@@ -25,6 +25,16 @@
     334 import java.sql.SQLWarning;
     335 import java.sql.Statement;
     336 import java.util.Map;
     337+/* JDBC_4_ANT_KEY_BEGIN */
     338+import java.sql.Array;
     339+import java.sql.Blob;
     340+import java.sql.Clob;
     341+import java.sql.NClob;
     342+import java.sql.SQLClientInfoException;
     343+import java.sql.SQLXML;
     344+import java.sql.Struct;
     345+import java.util.Properties;
     346+/* JDBC_4_ANT_KEY_END */
     347 
     348 /**
     349  * A dummy {@link Connection}, for testing purposes.
     350@@ -274,6 +284,59 @@
     351         throws SQLException {
     352         return prepareStatement(sql);
     353     }
     354+/* JDBC_3_ANT_KEY_END */
     355+/* JDBC_4_ANT_KEY_BEGIN */
     356 
     357-/* JDBC_3_ANT_KEY_END */
     358+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     359+        throw new SQLException("Not implemented.");
     360+    }
     361+
     362+    public <T> T unwrap(Class<T> iface) throws SQLException {
     363+        throw new SQLException("Not implemented.");
     364+    }
     365+
     366+    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     367+        throw new SQLException("Not implemented.");
     368+    }
     369+
     370+    public Blob createBlob() throws SQLException {
     371+        throw new SQLException("Not implemented.");
     372+    }
     373+
     374+    public Clob createClob() throws SQLException {
     375+        throw new SQLException("Not implemented.");
     376+    }
     377+
     378+    public NClob createNClob() throws SQLException {
     379+        throw new SQLException("Not implemented.");
     380+    }
     381+
     382+    public SQLXML createSQLXML() throws SQLException {
     383+        throw new SQLException("Not implemented.");
     384+    }
     385+
     386+    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     387+        throw new SQLException("Not implemented.");
     388+    }
     389+
     390+    public boolean isValid(int timeout) throws SQLException {
     391+        throw new SQLException("Not implemented.");
     392+    }
     393+
     394+    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     395+        throw new SQLClientInfoException();
     396+    }
     397+
     398+    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     399+        throw new SQLClientInfoException();
     400+    }
     401+
     402+    public Properties getClientInfo() throws SQLException {
     403+        throw new SQLException("Not implemented.");
     404+    }
     405+
     406+    public String getClientInfo(String name) throws SQLException {
     407+        throw new SQLException("Not implemented.");
     408+    }
     409+/* JDBC_4_ANT_KEY_END */
     410 }
     411Index: src/test/org/apache/commons/dbcp/TesterStatement.java
     412===================================================================
     413--- src/test/org/apache/commons/dbcp/TesterStatement.java       (revision 558600)
     414+++ src/test/org/apache/commons/dbcp/TesterStatement.java       (working copy)
     415@@ -268,5 +268,26 @@
     416         throw new SQLException("Not implemented.");
     417     }
     418 /* JDBC_3_ANT_KEY_END */
     419+/* JDBC_4_ANT_KEY_BEGIN */
     420 
     421+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     422+        throw new SQLException("Not implemented.");
     423+    }
     424+
     425+    public <T> T unwrap(Class<T> iface) throws SQLException {
     426+        throw new SQLException("Not implemented.");
     427+    }
     428+
     429+    public boolean isClosed() throws SQLException {
     430+        throw new SQLException("Not implemented.");
     431+    }
     432+
     433+    public void setPoolable(boolean poolable) throws SQLException {
     434+        throw new SQLException("Not implemented.");
     435+    }
     436+
     437+    public boolean isPoolable() throws SQLException {
     438+        throw new SQLException("Not implemented.");
     439+    }
     440+/* JDBC_4_ANT_KEY_END */
     441 }
     442Index: src/java/org/apache/commons/dbcp/DelegatingCallableStatement.java
     443===================================================================
     444--- src/java/org/apache/commons/dbcp/DelegatingCallableStatement.java   (revision 558600)
     445+++ src/java/org/apache/commons/dbcp/DelegatingCallableStatement.java   (working copy)
     446@@ -32,6 +32,11 @@
     447 import java.io.InputStream;
     448 import java.io.Reader;
     449 import java.sql.SQLException;
     450+/* JDBC_4_ANT_KEY_BEGIN */
     451+import java.sql.NClob;
     452+import java.sql.RowId;
     453+import java.sql.SQLXML;
     454+/* JDBC_4_ANT_KEY_END */
     455 
     456 /**
     457  * A base delegating implementation of {@link CallableStatement}.
     458@@ -332,6 +337,337 @@
     459 
     460     public URL getURL(String parameterName) throws SQLException
     461     { checkOpen(); try { return _stmt.getURL(parameterName); } catch (SQLException e) { handleException(e); return null; } }
     462+/* JDBC_3_ANT_KEY_END */
     463+/* JDBC_4_ANT_KEY_BEGIN */
     464 
     465-/* JDBC_3_ANT_KEY_END */
     466+    public RowId getRowId(int parameterIndex) throws SQLException {
     467+        checkOpen();
     468+        try {
     469+            return _stmt.getRowId(parameterIndex);
     470+        }
     471+        catch (SQLException e) {
     472+            handleException(e);
     473+            return null;
     474+        }
     475+    }
     476+
     477+    public RowId getRowId(String parameterName) throws SQLException {
     478+        checkOpen();
     479+        try {
     480+            return _stmt.getRowId(parameterName);
     481+        }
     482+        catch (SQLException e) {
     483+            handleException(e);
     484+            return null;
     485+        }
     486+    }
     487+
     488+    public void setRowId(String parameterName, RowId value) throws SQLException {
     489+        checkOpen();
     490+        try {
     491+            _stmt.setRowId(parameterName, value);
     492+        }
     493+        catch (SQLException e) {
     494+            handleException(e);
     495+        }
     496+    }
     497+
     498+    public void setNString(String parameterName, String value) throws SQLException {
     499+        checkOpen();
     500+        try {
     501+            _stmt.setNString(parameterName, value);
     502+        }
     503+        catch (SQLException e) {
     504+            handleException(e);
     505+        }
     506+    }
     507+
     508+    public void setNCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     509+        checkOpen();
     510+        try {
     511+            _stmt.setNCharacterStream(parameterName, reader, length);
     512+        }
     513+        catch (SQLException e) {
     514+            handleException(e);
     515+        }
     516+    }
     517+
     518+    public void setNClob(String parameterName, NClob value) throws SQLException {
     519+        checkOpen();
     520+        try {
     521+            _stmt.setNClob(parameterName, value);
     522+        }
     523+        catch (SQLException e) {
     524+            handleException(e);
     525+        }
     526+    }
     527+
     528+    public void setClob(String parameterName, Reader reader, long length) throws SQLException {
     529+        checkOpen();
     530+        try {
     531+            _stmt.setClob(parameterName, reader, length);
     532+        }
     533+        catch (SQLException e) {
     534+            handleException(e);
     535+        }
     536+    }
     537+
     538+    public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
     539+        checkOpen();
     540+        try {
     541+            _stmt.setBlob(parameterName, inputStream, length);
     542+        }
     543+        catch (SQLException e) {
     544+            handleException(e);
     545+        }
     546+    }
     547+
     548+    public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
     549+        checkOpen();
     550+        try {
     551+            _stmt.setNClob(parameterName, reader, length);
     552+        }
     553+        catch (SQLException e) {
     554+            handleException(e);
     555+        }
     556+    }
     557+
     558+    public NClob getNClob(int parameterIndex) throws SQLException {
     559+        checkOpen();
     560+        try {
     561+            return _stmt.getNClob(parameterIndex);
     562+        }
     563+        catch (SQLException e) {
     564+            handleException(e);
     565+            return null;
     566+        }
     567+    }
     568+
     569+    public NClob getNClob(String parameterName) throws SQLException {
     570+        checkOpen();
     571+        try {
     572+            return _stmt.getNClob(parameterName);
     573+        }
     574+        catch (SQLException e) {
     575+            handleException(e);
     576+            return null;
     577+        }
     578+    }
     579+
     580+    public void setSQLXML(String parameterName, SQLXML value) throws SQLException {
     581+        checkOpen();
     582+        try {
     583+            _stmt.setSQLXML(parameterName, value);
     584+        }
     585+        catch (SQLException e) {
     586+            handleException(e);
     587+        }
     588+    }
     589+
     590+    public SQLXML getSQLXML(int parameterIndex) throws SQLException {
     591+        checkOpen();
     592+        try {
     593+            return _stmt.getSQLXML(parameterIndex);
     594+        }
     595+        catch (SQLException e) {
     596+            handleException(e);
     597+            return null;
     598+        }
     599+    }
     600+
     601+    public SQLXML getSQLXML(String parameterName) throws SQLException {
     602+        checkOpen();
     603+        try {
     604+            return _stmt.getSQLXML(parameterName);
     605+        }
     606+        catch (SQLException e) {
     607+            handleException(e);
     608+            return null;
     609+        }
     610+    }
     611+
     612+    public String getNString(int parameterIndex) throws SQLException {
     613+        checkOpen();
     614+        try {
     615+            return _stmt.getNString(parameterIndex);
     616+        }
     617+        catch (SQLException e) {
     618+            handleException(e);
     619+            return null;
     620+        }
     621+    }
     622+
     623+    public String getNString(String parameterName) throws SQLException {
     624+        checkOpen();
     625+        try {
     626+            return _stmt.getNString(parameterName);
     627+        }
     628+        catch (SQLException e) {
     629+            handleException(e);
     630+            return null;
     631+        }
     632+    }
     633+
     634+    public Reader getNCharacterStream(int parameterIndex) throws SQLException {
     635+        checkOpen();
     636+        try {
     637+            return _stmt.getNCharacterStream(parameterIndex);
     638+        }
     639+        catch (SQLException e) {
     640+            handleException(e);
     641+            return null;
     642+        }
     643+    }
     644+
     645+    public Reader getNCharacterStream(String parameterName) throws SQLException {
     646+        checkOpen();
     647+        try {
     648+            return _stmt.getNCharacterStream(parameterName);
     649+        }
     650+        catch (SQLException e) {
     651+            handleException(e);
     652+            return null;
     653+        }
     654+    }
     655+
     656+    public Reader getCharacterStream(int parameterIndex) throws SQLException {
     657+        checkOpen();
     658+        try {
     659+            return _stmt.getCharacterStream(parameterIndex);
     660+        }
     661+        catch (SQLException e) {
     662+            handleException(e);
     663+            return null;
     664+        }
     665+    }
     666+
     667+    public Reader getCharacterStream(String parameterName) throws SQLException {
     668+        checkOpen();
     669+        try {
     670+            return _stmt.getCharacterStream(parameterName);
     671+        }
     672+        catch (SQLException e) {
     673+            handleException(e);
     674+            return null;
     675+        }
     676+    }
     677+
     678+    public void setBlob(String parameterName, Blob blob) throws SQLException {
     679+        checkOpen();
     680+        try {
     681+            _stmt.setBlob(parameterName, blob);
     682+        }
     683+        catch (SQLException e) {
     684+            handleException(e);
     685+        }
     686+    }
     687+
     688+    public void setClob(String parameterName, Clob clob) throws SQLException {
     689+        checkOpen();
     690+        try {
     691+            _stmt.setClob(parameterName, clob);
     692+        }
     693+        catch (SQLException e) {
     694+            handleException(e);
     695+        }
     696+    }
     697+
     698+    public void setAsciiStream(String parameterName, InputStream inputStream, long length) throws SQLException {
     699+        checkOpen();
     700+        try {
     701+            _stmt.setAsciiStream(parameterName, inputStream, length);
     702+        }
     703+        catch (SQLException e) {
     704+            handleException(e);
     705+        }
     706+    }
     707+
     708+    public void setBinaryStream(String parameterName, InputStream inputStream, long length) throws SQLException {
     709+        checkOpen();
     710+        try {
     711+            _stmt.setBinaryStream(parameterName, inputStream, length);
     712+        }
     713+        catch (SQLException e) {
     714+            handleException(e);
     715+        }
     716+    }
     717+
     718+    public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     719+        checkOpen();
     720+        try {
     721+            _stmt.setCharacterStream(parameterName, reader, length);
     722+        }
     723+        catch (SQLException e) {
     724+            handleException(e);
     725+        }
     726+    }
     727+
     728+    public void setAsciiStream(String parameterName, InputStream inputStream) throws SQLException {
     729+        checkOpen();
     730+        try {
     731+            _stmt.setAsciiStream(parameterName, inputStream);
     732+        }
     733+        catch (SQLException e) {
     734+            handleException(e);
     735+        }
     736+    }
     737+
     738+    public void setBinaryStream(String parameterName, InputStream inputStream) throws SQLException {
     739+        checkOpen();
     740+        try {
     741+            _stmt.setBinaryStream(parameterName, inputStream);
     742+        }
     743+        catch (SQLException e) {
     744+            handleException(e);
     745+        }
     746+    }
     747+
     748+    public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
     749+        checkOpen();
     750+        try {
     751+            _stmt.setCharacterStream(parameterName, reader);
     752+        }
     753+        catch (SQLException e) {
     754+            handleException(e);
     755+        }
     756+    }
     757+
     758+    public void setNCharacterStream(String parameterName, Reader reader) throws SQLException {
     759+        checkOpen();
     760+        try {
     761+            _stmt.setNCharacterStream(parameterName, reader);
     762+        }
     763+        catch (SQLException e) {
     764+            handleException(e);
     765+        }
     766+    }
     767+
     768+    public void setClob(String parameterName, Reader reader) throws SQLException {
     769+        checkOpen();
     770+        try {
     771+            _stmt.setClob(parameterName, reader);
     772+        }
     773+        catch (SQLException e) {
     774+            handleException(e);
     775+        }    }
     776+
     777+    public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
     778+        checkOpen();
     779+        try {
     780+            _stmt.setBlob(parameterName, inputStream);
     781+        }
     782+        catch (SQLException e) {
     783+            handleException(e);
     784+        }    }
     785+
     786+    public void setNClob(String parameterName, Reader reader) throws SQLException {
     787+        checkOpen();
     788+        try {
     789+            _stmt.setNClob(parameterName, reader);
     790+        }
     791+        catch (SQLException e) {
     792+            handleException(e);
     793+        }
     794+    }
     795+/* JDBC_4_ANT_KEY_END */
     796 }
     797Index: src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java
     798===================================================================
     799--- src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java    (revision 558600)
     800+++ src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java    (working copy)
     801@@ -25,6 +25,19 @@
     802 import java.sql.Statement;
     803 import java.sql.SQLWarning;
     804 import java.sql.SQLException;
     805+/* JDBC_4_ANT_KEY_BEGIN */
     806+import java.sql.Array;
     807+import java.sql.Blob;
     808+import java.sql.ClientInfoStatus;
     809+import java.sql.Clob;
     810+import java.sql.NClob;
     811+import java.sql.SQLClientInfoException;
     812+import java.sql.SQLXML;
     813+import java.sql.Struct;
     814+import java.util.Collections;
     815+import java.util.Map;
     816+import java.util.Properties;
     817+/* JDBC_4_ANT_KEY_END */
     818 
     819 /**
     820  * This class is the <code>Connection</code> that will be returned
     821@@ -42,6 +55,11 @@
     822     private static final String CLOSED
     823             = "Attempted to use Connection after closed() was called.";
     824 
     825+/* JDBC_4_ANT_KEY_BEGIN */
     826+    private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =
     827+        Collections.<String, ClientInfoStatus>emptyMap();
     828+/* JDBC_4_ANT_KEY_END */
     829+
     830     /** The JDBC database connection. */
     831     private Connection connection;
     832 
     833@@ -453,6 +471,86 @@
     834         assertOpen();
     835         return connection.prepareStatement(sql, columnNames);
     836     }
     837+/* JDBC_3_ANT_KEY_END */
     838+/* JDBC_4_ANT_KEY_BEGIN */
     839 
     840-/* JDBC_3_ANT_KEY_END */
     841+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     842+        return connection.isWrapperFor(iface);
     843+    }
     844+
     845+    public <T> T unwrap(Class<T> iface) throws SQLException {
     846+        return connection.unwrap(iface);
     847+    }
     848+
     849+    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     850+        assertOpen();
     851+        return connection.createArrayOf(typeName, elements);
     852+    }
     853+
     854+    public Blob createBlob() throws SQLException {
     855+        assertOpen();
     856+        return connection.createBlob();
     857+    }
     858+
     859+    public Clob createClob() throws SQLException {
     860+        assertOpen();
     861+        return connection.createClob();
     862+    }
     863+
     864+    public NClob createNClob() throws SQLException {
     865+        assertOpen();
     866+        return connection.createNClob();
     867+    }
     868+
     869+    public SQLXML createSQLXML() throws SQLException {
     870+        assertOpen();
     871+        return connection.createSQLXML();
     872+    }
     873+
     874+    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     875+        assertOpen();
     876+        return connection.createStruct(typeName, attributes);
     877+    }
     878+
     879+    public boolean isValid(int timeout) throws SQLException {
     880+        assertOpen();
     881+        return connection.isValid(timeout);
     882+    }
     883+
     884+    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     885+        try {
     886+            assertOpen();
     887+            connection.setClientInfo(name, value);
     888+        }
     889+        catch (SQLClientInfoException e) {
     890+            throw e;
     891+        }
     892+        catch (SQLException e) {
     893+            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     894+        }
     895+    }
     896+
     897+    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     898+        try {
     899+            assertOpen();
     900+            connection.setClientInfo(properties);
     901+        }
     902+        catch (SQLClientInfoException e) {
     903+            throw e;
     904+        }
     905+        catch (SQLException e) {
     906+            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     907+        }
     908+    }
     909+
     910+    public Properties getClientInfo() throws SQLException {
     911+        assertOpen();
     912+        return connection.getClientInfo();
     913+    }
     914+
     915+    public String getClientInfo(String name) throws SQLException {
     916+        assertOpen();
     917+        return connection.getClientInfo(name);
     918+    }
     919+/* JDBC_4_ANT_KEY_END */
     920 }
     921Index: src/java/org/apache/commons/dbcp/cpdsadapter/PooledConnectionImpl.java
     922===================================================================
     923--- src/java/org/apache/commons/dbcp/cpdsadapter/PooledConnectionImpl.java      (revision 558600)
     924+++ src/java/org/apache/commons/dbcp/cpdsadapter/PooledConnectionImpl.java      (working copy)
     925@@ -26,6 +26,7 @@
     926 import javax.sql.ConnectionEvent;
     927 import javax.sql.ConnectionEventListener;
     928 import javax.sql.PooledConnection;
     929+import javax.sql.StatementEventListener;
     930 
     931 import org.apache.commons.dbcp.DelegatingConnection;
     932 import org.apache.commons.dbcp.DelegatingPreparedStatement;
     933@@ -66,6 +67,11 @@
     934     private Vector eventListeners;
     935 
     936     /**
     937+     * StatementEventListeners
     938+     */
     939+    private Vector statementEventListeners;
     940+
     941+    /**
     942      * flag set to true, once close() is called.
     943      */
     944     boolean isClosed;
     945@@ -101,6 +107,12 @@
     946         }
     947     }
     948 
     949+    public void addStatementEventListener(StatementEventListener listener) {
     950+        if (!statementEventListeners.contains(listener)) {
     951+            statementEventListeners.add(listener);
     952+        }
     953+    }
     954+
     955     /**
     956      * Closes the physical connection and marks this
     957      * <code>PooledConnection</code> so that it may not be used
     958@@ -169,6 +181,10 @@
     959         eventListeners.remove(listener);
     960     }
     961 
     962+    public void removeStatementEventListener(StatementEventListener listener) {
     963+        statementEventListeners.remove(listener);
     964+    }
     965+
     966     /**
     967      * Closes the physical connection and checks that the logical connection
     968      * was closed as well.
     969Index: src/java/org/apache/commons/dbcp/DelegatingPreparedStatement.java
     970===================================================================
     971--- src/java/org/apache/commons/dbcp/DelegatingPreparedStatement.java   (revision 558600)
     972+++ src/java/org/apache/commons/dbcp/DelegatingPreparedStatement.java   (working copy)
     973@@ -27,6 +27,13 @@
     974 import java.sql.ResultSetMetaData;
     975 import java.sql.SQLException;
     976 import java.util.Calendar;
     977+/* JDBC_4_ANT_KEY_BEGIN */
     978+import java.io.InputStream;
     979+import java.io.Reader;
     980+import java.sql.NClob;
     981+import java.sql.RowId;
     982+import java.sql.SQLXML;
     983+/* JDBC_4_ANT_KEY_END */
     984 
     985 /**
     986  * A base delegating implementation of {@link PreparedStatement}.
     987@@ -221,6 +228,187 @@
     988 
     989     public java.sql.ParameterMetaData getParameterMetaData() throws SQLException
     990     { checkOpen(); try { return _stmt.getParameterMetaData(); } catch (SQLException e) { handleException(e); return null; } }
     991+/* JDBC_3_ANT_KEY_END */
     992+/* JDBC_4_ANT_KEY_BEGIN */
     993 
     994-/* JDBC_3_ANT_KEY_END */
     995+    public void setRowId(int parameterIndex, RowId value) throws SQLException {
     996+        checkOpen();
     997+        try {
     998+            _stmt.setRowId(parameterIndex, value);
     999+        }
     1000+        catch (SQLException e) {
     1001+            handleException(e);
     1002+        }
     1003+    }
     1004+
     1005+    public void setNString(int parameterIndex, String value) throws SQLException {
     1006+        checkOpen();
     1007+        try {
     1008+            _stmt.setNString(parameterIndex, value);
     1009+        }
     1010+        catch (SQLException e) {
     1011+            handleException(e);
     1012+        }
     1013+    }
     1014+
     1015+    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     1016+        checkOpen();
     1017+        try {
     1018+            _stmt.setNCharacterStream(parameterIndex, value, length);
     1019+        }
     1020+        catch (SQLException e) {
     1021+            handleException(e);
     1022+        }
     1023+    }
     1024+
     1025+    public void setNClob(int parameterIndex, NClob value) throws SQLException {
     1026+        checkOpen();
     1027+        try {
     1028+            _stmt.setNClob(parameterIndex, value);
     1029+        }
     1030+        catch (SQLException e) {
     1031+            handleException(e);
     1032+        }
     1033+    }
     1034+
     1035+    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     1036+        checkOpen();
     1037+        try {
     1038+            _stmt.setClob(parameterIndex, reader, length);
     1039+        }
     1040+        catch (SQLException e) {
     1041+            handleException(e);
     1042+        }
     1043+    }
     1044+
     1045+    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     1046+        checkOpen();
     1047+        try {
     1048+            _stmt.setBlob(parameterIndex, inputStream, length);
     1049+        }
     1050+        catch (SQLException e) {
     1051+            handleException(e);
     1052+        }
     1053+    }
     1054+
     1055+    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     1056+        checkOpen();
     1057+        try {
     1058+            _stmt.setNClob(parameterIndex, reader, length);
     1059+        }
     1060+        catch (SQLException e) {
     1061+            handleException(e);
     1062+        }
     1063+    }
     1064+
     1065+    public void setSQLXML(int parameterIndex, SQLXML value) throws SQLException {
     1066+        checkOpen();
     1067+        try {
     1068+            _stmt.setSQLXML(parameterIndex, value);
     1069+        }
     1070+        catch (SQLException e) {
     1071+            handleException(e);
     1072+        }
     1073+    }
     1074+
     1075+    public void setAsciiStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     1076+        checkOpen();
     1077+        try {
     1078+            _stmt.setAsciiStream(parameterIndex, inputStream, length);
     1079+        }
     1080+        catch (SQLException e) {
     1081+            handleException(e);
     1082+        }
     1083+    }
     1084+
     1085+    public void setBinaryStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     1086+        checkOpen();
     1087+        try {
     1088+            _stmt.setBinaryStream(parameterIndex, inputStream, length);
     1089+        }
     1090+        catch (SQLException e) {
     1091+            handleException(e);
     1092+        }
     1093+    }
     1094+
     1095+    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     1096+        checkOpen();
     1097+        try {
     1098+            _stmt.setCharacterStream(parameterIndex, reader, length);
     1099+        }
     1100+        catch (SQLException e) {
     1101+            handleException(e);
     1102+        }
     1103+    }
     1104+
     1105+    public void setAsciiStream(int parameterIndex, InputStream inputStream) throws SQLException {
     1106+        checkOpen();
     1107+        try {
     1108+            _stmt.setAsciiStream(parameterIndex, inputStream);
     1109+        }
     1110+        catch (SQLException e) {
     1111+            handleException(e);
     1112+        }
     1113+    }
     1114+
     1115+    public void setBinaryStream(int parameterIndex, InputStream inputStream) throws SQLException {
     1116+        checkOpen();
     1117+        try {
     1118+            _stmt.setBinaryStream(parameterIndex, inputStream);
     1119+        }
     1120+        catch (SQLException e) {
     1121+            handleException(e);
     1122+        }
     1123+    }
     1124+
     1125+    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     1126+        checkOpen();
     1127+        try {
     1128+            _stmt.setCharacterStream(parameterIndex, reader);
     1129+        }
     1130+        catch (SQLException e) {
     1131+            handleException(e);
     1132+        }
     1133+    }
     1134+
     1135+    public void setNCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     1136+        checkOpen();
     1137+        try {
     1138+            _stmt.setNCharacterStream(parameterIndex, reader);
     1139+        }
     1140+        catch (SQLException e) {
     1141+            handleException(e);
     1142+        }
     1143+    }
     1144+
     1145+    public void setClob(int parameterIndex, Reader reader) throws SQLException {
     1146+        checkOpen();
     1147+        try {
     1148+            _stmt.setClob(parameterIndex, reader);
     1149+        }
     1150+        catch (SQLException e) {
     1151+            handleException(e);
     1152+        }
     1153+    }
     1154+
     1155+    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     1156+        checkOpen();
     1157+        try {
     1158+            _stmt.setBlob(parameterIndex, inputStream);
     1159+        }
     1160+        catch (SQLException e) {
     1161+            handleException(e);
     1162+        }
     1163+    }
     1164+
     1165+    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     1166+        checkOpen();
     1167+        try {
     1168+            _stmt.setNClob(parameterIndex, reader);
     1169+        }
     1170+        catch (SQLException e) {
     1171+            handleException(e);
     1172+        }
     1173+    }
     1174+/* JDBC_4_ANT_KEY_END */
     1175 }
     1176Index: src/java/org/apache/commons/dbcp/DelegatingResultSet.java
     1177===================================================================
     1178--- src/java/org/apache/commons/dbcp/DelegatingResultSet.java   (revision 558600)
     1179+++ src/java/org/apache/commons/dbcp/DelegatingResultSet.java   (working copy)
     1180@@ -34,6 +34,11 @@
     1181 import java.sql.Clob;
     1182 import java.sql.Array;
     1183 import java.util.Calendar;
     1184+/* JDBC_4_ANT_KEY_BEGIN */
     1185+import java.sql.NClob;
     1186+import java.sql.RowId;
     1187+import java.sql.SQLXML;
     1188+/* JDBC_4_ANT_KEY_END */
     1189 
     1190 /**
     1191  * A base delegating implementation of {@link ResultSet}.
     1192@@ -585,6 +590,459 @@
     1193 
     1194     public void updateArray(String columnName, java.sql.Array x) throws SQLException
     1195     { try { _res.updateArray(columnName, x); } catch (SQLException e) { handleException(e); } }
     1196+/* JDBC_3_ANT_KEY_END */
     1197+/* JDBC_4_ANT_KEY_BEGIN */
     1198 
     1199-/* JDBC_3_ANT_KEY_END */
     1200+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1201+        return _res.isWrapperFor(iface);
     1202+    }
     1203+
     1204+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1205+        return _res.unwrap(iface);
     1206+    }
     1207+
     1208+    public RowId getRowId(int columnIndex) throws SQLException {
     1209+        try {
     1210+            return _res.getRowId(columnIndex);
     1211+        }
     1212+        catch (SQLException e) {
     1213+            handleException(e);
     1214+            return null;
     1215+        }
     1216+    }
     1217+
     1218+    public RowId getRowId(String columnLabel) throws SQLException {
     1219+        try {
     1220+            return _res.getRowId(columnLabel);
     1221+        }
     1222+        catch (SQLException e) {
     1223+            handleException(e);
     1224+            return null;
     1225+        }
     1226+    }
     1227+
     1228+    public void updateRowId(int columnIndex, RowId value) throws SQLException {
     1229+        try {
     1230+            _res.updateRowId(columnIndex, value);
     1231+        }
     1232+        catch (SQLException e) {
     1233+            handleException(e);
     1234+        }
     1235+    }
     1236+
     1237+    public void updateRowId(String columnLabel, RowId value) throws SQLException {
     1238+        try {
     1239+            _res.updateRowId(columnLabel, value);
     1240+        }
     1241+        catch (SQLException e) {
     1242+            handleException(e);
     1243+        }
     1244+    }
     1245+
     1246+    public int getHoldability() throws SQLException {
     1247+        try {
     1248+            return _res.getHoldability();
     1249+        }
     1250+        catch (SQLException e) {
     1251+            handleException(e);
     1252+            return 0;
     1253+        }
     1254+    }
     1255+
     1256+    public boolean isClosed() throws SQLException {
     1257+        try {
     1258+            return _res.isClosed();
     1259+        }
     1260+        catch (SQLException e) {
     1261+            handleException(e);
     1262+            return false;
     1263+        }
     1264+    }
     1265+
     1266+    public void updateNString(int columnIndex, String value) throws SQLException {
     1267+        try {
     1268+            _res.updateNString(columnIndex, value);
     1269+        }
     1270+        catch (SQLException e) {
     1271+            handleException(e);
     1272+        }
     1273+    }
     1274+
     1275+    public void updateNString(String columnLabel, String value) throws SQLException {
     1276+        try {
     1277+            _res.updateNString(columnLabel, value);
     1278+        }
     1279+        catch (SQLException e) {
     1280+            handleException(e);
     1281+        }
     1282+    }
     1283+
     1284+    public void updateNClob(int columnIndex, NClob value) throws SQLException {
     1285+        try {
     1286+            _res.updateNClob(columnIndex, value);
     1287+        }
     1288+        catch (SQLException e) {
     1289+            handleException(e);
     1290+        }
     1291+    }
     1292+
     1293+    public void updateNClob(String columnLabel, NClob value) throws SQLException {
     1294+        try {
     1295+            _res.updateNClob(columnLabel, value);
     1296+        }
     1297+        catch (SQLException e) {
     1298+            handleException(e);
     1299+        }
     1300+    }
     1301+
     1302+    public NClob getNClob(int columnIndex) throws SQLException {
     1303+        try {
     1304+            return _res.getNClob(columnIndex);
     1305+        }
     1306+        catch (SQLException e) {
     1307+            handleException(e);
     1308+            return null;
     1309+        }
     1310+    }
     1311+
     1312+    public NClob getNClob(String columnLabel) throws SQLException {
     1313+        try {
     1314+            return _res.getNClob(columnLabel);
     1315+        }
     1316+        catch (SQLException e) {
     1317+            handleException(e);
     1318+            return null;
     1319+        }
     1320+    }
     1321+
     1322+    public SQLXML getSQLXML(int columnIndex) throws SQLException {
     1323+        try {
     1324+            return _res.getSQLXML(columnIndex);
     1325+        }
     1326+        catch (SQLException e) {
     1327+            handleException(e);
     1328+            return null;
     1329+        }
     1330+    }
     1331+
     1332+    public SQLXML getSQLXML(String columnLabel) throws SQLException {
     1333+        try {
     1334+            return _res.getSQLXML(columnLabel);
     1335+        }
     1336+        catch (SQLException e) {
     1337+            handleException(e);
     1338+            return null;
     1339+        }
     1340+    }
     1341+
     1342+    public void updateSQLXML(int columnIndex, SQLXML value) throws SQLException {
     1343+        try {
     1344+            _res.updateSQLXML(columnIndex, value);
     1345+        }
     1346+        catch (SQLException e) {
     1347+            handleException(e);
     1348+        }
     1349+    }
     1350+
     1351+    public void updateSQLXML(String columnLabel, SQLXML value) throws SQLException {
     1352+        try {
     1353+            _res.updateSQLXML(columnLabel, value);
     1354+        }
     1355+        catch (SQLException e) {
     1356+            handleException(e);
     1357+        }
     1358+    }
     1359+
     1360+    public String getNString(int columnIndex) throws SQLException {
     1361+        try {
     1362+            return _res.getNString(columnIndex);
     1363+        }
     1364+        catch (SQLException e) {
     1365+            handleException(e);
     1366+            return null;
     1367+        }
     1368+    }
     1369+
     1370+    public String getNString(String columnLabel) throws SQLException {
     1371+        try {
     1372+            return _res.getNString(columnLabel);
     1373+        }
     1374+        catch (SQLException e) {
     1375+            handleException(e);
     1376+            return null;
     1377+        }
     1378+    }
     1379+
     1380+    public Reader getNCharacterStream(int columnIndex) throws SQLException {
     1381+        try {
     1382+            return _res.getNCharacterStream(columnIndex);
     1383+        }
     1384+        catch (SQLException e) {
     1385+            handleException(e);
     1386+            return null;
     1387+        }
     1388+    }
     1389+
     1390+    public Reader getNCharacterStream(String columnLabel) throws SQLException {
     1391+        try {
     1392+            return _res.getNCharacterStream(columnLabel);
     1393+        }
     1394+        catch (SQLException e) {
     1395+            handleException(e);
     1396+            return null;
     1397+        }
     1398+    }
     1399+
     1400+    public void updateNCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     1401+        try {
     1402+            _res.updateNCharacterStream(columnIndex, reader, length);
     1403+        }
     1404+        catch (SQLException e) {
     1405+            handleException(e);
     1406+        }
     1407+    }
     1408+
     1409+    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     1410+        try {
     1411+            _res.updateNCharacterStream(columnLabel, reader, length);
     1412+        }
     1413+        catch (SQLException e) {
     1414+            handleException(e);
     1415+        }
     1416+    }
     1417+
     1418+    public void updateAsciiStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     1419+        try {
     1420+            _res.updateAsciiStream(columnIndex, inputStream, length);
     1421+        }
     1422+        catch (SQLException e) {
     1423+            handleException(e);
     1424+        }
     1425+    }
     1426+
     1427+    public void updateBinaryStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     1428+        try {
     1429+            _res.updateBinaryStream(columnIndex, inputStream, length);
     1430+        }
     1431+        catch (SQLException e) {
     1432+            handleException(e);
     1433+        }
     1434+    }
     1435+
     1436+    public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     1437+        try {
     1438+            _res.updateCharacterStream(columnIndex, reader, length);
     1439+        }
     1440+        catch (SQLException e) {
     1441+            handleException(e);
     1442+        }
     1443+    }
     1444+
     1445+    public void updateAsciiStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     1446+        try {
     1447+            _res.updateAsciiStream(columnLabel, inputStream, length);
     1448+        }
     1449+        catch (SQLException e) {
     1450+            handleException(e);
     1451+        }
     1452+    }
     1453+
     1454+    public void updateBinaryStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     1455+        try {
     1456+            _res.updateBinaryStream(columnLabel, inputStream, length);
     1457+        }
     1458+        catch (SQLException e) {
     1459+            handleException(e);
     1460+        }
     1461+    }
     1462+
     1463+    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     1464+        try {
     1465+            _res.updateCharacterStream(columnLabel, reader, length);
     1466+        }
     1467+        catch (SQLException e) {
     1468+            handleException(e);
     1469+        }
     1470+    }
     1471+
     1472+    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
     1473+        try {
     1474+            _res.updateBlob(columnIndex, inputStream, length);
     1475+        }
     1476+        catch (SQLException e) {
     1477+            handleException(e);
     1478+        }
     1479+    }
     1480+
     1481+    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
     1482+        try {
     1483+            _res.updateBlob(columnLabel, inputStream, length);
     1484+        }
     1485+        catch (SQLException e) {
     1486+            handleException(e);
     1487+        }
     1488+    }
     1489+
     1490+    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
     1491+        try {
     1492+            _res.updateClob(columnIndex, reader, length);
     1493+        }
     1494+        catch (SQLException e) {
     1495+            handleException(e);
     1496+        }
     1497+    }
     1498+
     1499+    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
     1500+        try {
     1501+            _res.updateClob(columnLabel, reader, length);
     1502+        }
     1503+        catch (SQLException e) {
     1504+            handleException(e);
     1505+        }
     1506+    }
     1507+
     1508+    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
     1509+        try {
     1510+            _res.updateNClob(columnIndex, reader, length);
     1511+        }
     1512+        catch (SQLException e) {
     1513+            handleException(e);
     1514+        }
     1515+    }
     1516+
     1517+    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
     1518+        try {
     1519+            _res.updateNClob(columnLabel, reader, length);
     1520+        }
     1521+        catch (SQLException e) {
     1522+            handleException(e);
     1523+        }
     1524+    }
     1525+
     1526+    public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException {
     1527+        try {
     1528+            _res.updateNCharacterStream(columnIndex, reader);
     1529+        }
     1530+        catch (SQLException e) {
     1531+            handleException(e);
     1532+        }
     1533+    }
     1534+
     1535+    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
     1536+        try {
     1537+            _res.updateNCharacterStream(columnLabel, reader);
     1538+        }
     1539+        catch (SQLException e) {
     1540+            handleException(e);
     1541+        }
     1542+    }
     1543+
     1544+    public void updateAsciiStream(int columnIndex, InputStream inputStream) throws SQLException {
     1545+        try {
     1546+            _res.updateAsciiStream(columnIndex, inputStream);
     1547+        }
     1548+        catch (SQLException e) {
     1549+            handleException(e);
     1550+        }
     1551+    }
     1552+
     1553+    public void updateBinaryStream(int columnIndex, InputStream inputStream) throws SQLException {
     1554+        try {
     1555+            _res.updateBinaryStream(columnIndex, inputStream);
     1556+        }
     1557+        catch (SQLException e) {
     1558+            handleException(e);
     1559+        }
     1560+    }
     1561+
     1562+    public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException {
     1563+        try {
     1564+            _res.updateCharacterStream(columnIndex, reader);
     1565+        }
     1566+        catch (SQLException e) {
     1567+            handleException(e);
     1568+        }
     1569+    }
     1570+
     1571+    public void updateAsciiStream(String columnLabel, InputStream inputStream) throws SQLException {
     1572+        try {
     1573+            _res.updateAsciiStream(columnLabel, inputStream);
     1574+        }
     1575+        catch (SQLException e) {
     1576+            handleException(e);
     1577+        }
     1578+    }
     1579+
     1580+    public void updateBinaryStream(String columnLabel, InputStream inputStream) throws SQLException {
     1581+        try {
     1582+            _res.updateBinaryStream(columnLabel, inputStream);
     1583+        }
     1584+        catch (SQLException e) {
     1585+            handleException(e);
     1586+        }
     1587+    }
     1588+
     1589+    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
     1590+        try {
     1591+            _res.updateCharacterStream(columnLabel, reader);
     1592+        }
     1593+        catch (SQLException e) {
     1594+            handleException(e);
     1595+        }
     1596+    }
     1597+
     1598+    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
     1599+        try {
     1600+            _res.updateBlob(columnIndex, inputStream);
     1601+        }
     1602+        catch (SQLException e) {
     1603+            handleException(e);
     1604+        }
     1605+    }
     1606+
     1607+    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
     1608+        try {
     1609+            _res.updateBlob(columnLabel, inputStream);
     1610+        }
     1611+        catch (SQLException e) {
     1612+            handleException(e);
     1613+        }
     1614+    }
     1615+
     1616+    public void updateClob(int columnIndex, Reader reader) throws SQLException {
     1617+        try {
     1618+            _res.updateClob(columnIndex, reader);
     1619+        }
     1620+        catch (SQLException e) {
     1621+            handleException(e);
     1622+        }
     1623+    }
     1624+
     1625+    public void updateClob(String columnLabel, Reader reader) throws SQLException {
     1626+        try {
     1627+            _res.updateClob(columnLabel, reader);
     1628+        }
     1629+        catch (SQLException e) {
     1630+            handleException(e);
     1631+        }
     1632+    }
     1633+
     1634+    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
     1635+        try {
     1636+            _res.updateNClob(columnIndex, reader);
     1637+        }
     1638+        catch (SQLException e) {
     1639+            handleException(e);
     1640+        }
     1641+    }
     1642+
     1643+    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
     1644+        try {
     1645+            _res.updateNClob(columnLabel, reader);
     1646+        }
     1647+        catch (SQLException e) {
     1648+            handleException(e);
     1649+        }
     1650+    }
     1651+/* JDBC_4_ANT_KEY_END */
     1652 }
     1653Index: src/java/org/apache/commons/dbcp/PoolingDataSource.java
     1654===================================================================
     1655--- src/java/org/apache/commons/dbcp/PoolingDataSource.java     (revision 558600)
     1656+++ src/java/org/apache/commons/dbcp/PoolingDataSource.java     (working copy)
     1657@@ -84,6 +84,14 @@
     1658     public void setAccessToUnderlyingConnectionAllowed(boolean allow) {
     1659         this.accessToUnderlyingConnectionAllowed = allow;
     1660     }
     1661+
     1662+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1663+        return false;
     1664+    }
     1665+
     1666+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1667+        throw new SQLException("PoolingDataSource is not a wrapper.");
     1668+    }
     1669     
     1670     //--- DataSource methods -----------------------------------------
     1671 
     1672Index: src/java/org/apache/commons/dbcp/DelegatingConnection.java
     1673===================================================================
     1674--- src/java/org/apache/commons/dbcp/DelegatingConnection.java  (revision 558600)
     1675+++ src/java/org/apache/commons/dbcp/DelegatingConnection.java  (working copy)
     1676@@ -26,6 +26,19 @@
     1677 import java.sql.Statement;
     1678 import java.util.List;
     1679 import java.util.Map;
     1680+/* JDBC_4_ANT_KEY_BEGIN */
     1681+import java.sql.Array;
     1682+import java.sql.Blob;
     1683+import java.sql.ClientInfoStatus;
     1684+import java.sql.Clob;
     1685+import java.sql.NClob;
     1686+import java.sql.SQLClientInfoException;
     1687+import java.sql.SQLXML;
     1688+import java.sql.Struct;
     1689+import java.util.Collections;
     1690+import java.util.Map;
     1691+import java.util.Properties;
     1692+/* JDBC_4_ANT_KEY_END */
     1693 
     1694 /**
     1695  * A base delegating implementation of {@link Connection}.
     1696@@ -50,6 +63,10 @@
     1697  */
     1698 public class DelegatingConnection extends AbandonedTrace
     1699         implements Connection {
     1700+/* JDBC_4_ANT_KEY_BEGIN */
     1701+    private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =
     1702+        Collections.<String, ClientInfoStatus>emptyMap();
     1703+/* JDBC_4_ANT_KEY_END */
     1704     /** My delegate {@link Connection}. */
     1705     protected Connection _conn = null;
     1706 
     1707@@ -495,4 +512,139 @@
     1708         }
     1709     }
     1710 /* JDBC_3_ANT_KEY_END */
     1711+/* JDBC_4_ANT_KEY_BEGIN */
     1712+
     1713+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1714+        return _conn.isWrapperFor(iface);
     1715+    }
     1716+
     1717+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1718+        return _conn.unwrap(iface);
     1719+    }
     1720+
     1721+    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     1722+        checkOpen();
     1723+        try {
     1724+            return _conn.createArrayOf(typeName, elements);
     1725+        }
     1726+        catch (SQLException e) {
     1727+            handleException(e);
     1728+            return null;
     1729+        }
     1730+    }
     1731+
     1732+    public Blob createBlob() throws SQLException {
     1733+        checkOpen();
     1734+        try {
     1735+            return _conn.createBlob();
     1736+        }
     1737+        catch (SQLException e) {
     1738+            handleException(e);
     1739+            return null;
     1740+        }
     1741+    }
     1742+
     1743+    public Clob createClob() throws SQLException {
     1744+        checkOpen();
     1745+        try {
     1746+            return _conn.createClob();
     1747+        }
     1748+        catch (SQLException e) {
     1749+            handleException(e);
     1750+            return null;
     1751+        }
     1752+    }
     1753+
     1754+    public NClob createNClob() throws SQLException {
     1755+        checkOpen();
     1756+        try {
     1757+            return _conn.createNClob();
     1758+        }
     1759+        catch (SQLException e) {
     1760+            handleException(e);
     1761+            return null;
     1762+        }
     1763+    }
     1764+
     1765+    public SQLXML createSQLXML() throws SQLException {
     1766+        checkOpen();
     1767+        try {
     1768+            return _conn.createSQLXML();
     1769+        }
     1770+        catch (SQLException e) {
     1771+            handleException(e);
     1772+            return null;
     1773+        }
     1774+    }
     1775+
     1776+    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     1777+        checkOpen();
     1778+        try {
     1779+            return _conn.createStruct(typeName, attributes);
     1780+        }
     1781+        catch (SQLException e) {
     1782+            handleException(e);
     1783+            return null;
     1784+        }
     1785+    }
     1786+
     1787+    public boolean isValid(int timeout) throws SQLException {
     1788+        checkOpen();
     1789+        try {
     1790+            return _conn.isValid(timeout);
     1791+        }
     1792+        catch (SQLException e) {
     1793+            handleException(e);
     1794+            return false;
     1795+        }
     1796+    }
     1797+
     1798+    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     1799+        try {
     1800+            checkOpen();
     1801+            _conn.setClientInfo(name, value);
     1802+        }
     1803+        catch (SQLClientInfoException e) {
     1804+            throw e;
     1805+        }
     1806+        catch (SQLException e) {
     1807+            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     1808+        }
     1809+    }
     1810+
     1811+    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     1812+        try {
     1813+            checkOpen();
     1814+            _conn.setClientInfo(properties);
     1815+        }
     1816+        catch (SQLClientInfoException e) {
     1817+            throw e;
     1818+        }
     1819+        catch (SQLException e) {
     1820+            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     1821+        }
     1822+    }
     1823+
     1824+    public Properties getClientInfo() throws SQLException {
     1825+        checkOpen();
     1826+        try {
     1827+            return _conn.getClientInfo();
     1828+        }
     1829+        catch (SQLException e) {
     1830+            handleException(e);
     1831+            return null;
     1832+        }
     1833+    }
     1834+
     1835+    public String getClientInfo(String name) throws SQLException {
     1836+        checkOpen();
     1837+        try {
     1838+            return _conn.getClientInfo(name);
     1839+        }
     1840+        catch (SQLException e) {
     1841+            handleException(e);
     1842+            return null;
     1843+        }
     1844+    }
     1845+/* JDBC_4_ANT_KEY_END */
     1846 }
     1847Index: src/java/org/apache/commons/dbcp/DelegatingStatement.java
     1848===================================================================
     1849--- src/java/org/apache/commons/dbcp/DelegatingStatement.java   (revision 558600)
     1850+++ src/java/org/apache/commons/dbcp/DelegatingStatement.java   (working copy)
     1851@@ -128,10 +128,6 @@
     1852 
     1853     protected boolean _closed = false;
     1854 
     1855-    protected boolean isClosed() {
     1856-        return _closed;
     1857-    }
     1858-
     1859     protected void checkOpen() throws SQLException {
     1860         if(isClosed()) {
     1861             throw new SQLException
     1862@@ -346,4 +342,39 @@
     1863     { checkOpen(); try { return _stmt.getResultSetHoldability(); } catch (SQLException e) { handleException(e); return 0; } }
     1864 
     1865 /* JDBC_3_ANT_KEY_END */
     1866+/* JDBC_4_ANT_KEY_BEGIN */
     1867+
     1868+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1869+        return _conn.isWrapperFor(iface);
     1870+    }
     1871+
     1872+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1873+        return _conn.unwrap(iface);
     1874+    }
     1875+
     1876+    public boolean isClosed() throws SQLException {
     1877+        return _closed;
     1878+    }
     1879+
     1880+    public void setPoolable(boolean poolable) throws SQLException {
     1881+        checkOpen();
     1882+        try {
     1883+            _stmt.setPoolable(poolable);
     1884+        }
     1885+        catch (SQLException e) {
     1886+            handleException(e);
     1887+        }
     1888+    }
     1889+
     1890+    public boolean isPoolable() throws SQLException {
     1891+        checkOpen();
     1892+        try {
     1893+            return _stmt.isPoolable();
     1894+        }
     1895+        catch (SQLException e) {
     1896+            handleException(e);
     1897+            return false;
     1898+        }
     1899+    }
     1900+/* JDBC_4_ANT_KEY_END */
     1901 }
     1902Index: src/java/org/apache/commons/dbcp/BasicDataSource.java
     1903===================================================================
     1904--- src/java/org/apache/commons/dbcp/BasicDataSource.java       (revision 558600)
     1905+++ src/java/org/apache/commons/dbcp/BasicDataSource.java       (working copy)
     1906@@ -1115,7 +1115,14 @@
     1907         }
     1908     }
     1909 
     1910+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1911+        return false;
     1912+    }
     1913 
     1914+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1915+        throw new SQLException("BasicDataSource is not a wrapper.");
     1916+    }
     1917+
     1918     // ------------------------------------------------------ Protected Methods
     1919 
     1920 
     1921Index: src/java/org/apache/commons/dbcp/datasources/InstanceKeyDataSource.java
     1922===================================================================
     1923--- src/java/org/apache/commons/dbcp/datasources/InstanceKeyDataSource.java     (revision 558600)
     1924+++ src/java/org/apache/commons/dbcp/datasources/InstanceKeyDataSource.java     (working copy)
     1925@@ -154,6 +154,14 @@
     1926      */
     1927     public abstract void close() throws Exception;
     1928 
     1929+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1930+        return false;
     1931+    }
     1932+
     1933+    public <T> T unwrap(Class<T> iface) throws SQLException {
     1934+        throw new SQLException("InstanceKeyDataSource is not a wrapper.");
     1935+    }
     1936+
     1937     // -------------------------------------------------------------------
     1938     // Properties
     1939 
     1940Index: project.properties
     1941===================================================================
     1942--- project.properties  (revision 558600)
     1943+++ project.properties  (working copy)
     1944@@ -30,8 +30,8 @@
     1945 maven.xdoc.developmentProcessUrl=http://jakarta.apache.org/commons/charter.html
     1946 
     1947 # JDK level
     1948-maven.compile.source=1.3
     1949-maven.compile.target=1.3
     1950+maven.compile.source=1.6
     1951+maven.compile.target=1.6
     1952 
     1953 # Merge in a file containing just Built-By attribute
     1954 maven.jar.manifest=${basedir}/manifestMods.txt

  • Portfile

     
    4343        file attributes ${destroot}${prefix}/share/doc/${name} -permissions goa+r
    4444}
    4545
     46platform darwin 10 {
     47        build.args-append -Djavac.source=5
     48        patchfiles-append patch-JDK-1.6.diff
     49}
     50
    4651livecheck.check regex
    4752livecheck.url   http://commons.apache.org/downloads/download_dbcp.cgi
    4853livecheck.regex "${name}-(\\d+\\.\\d+(\\.\\d+)?)-src.tar.gz"