source: trunk/dports/java/commons-dbcp/files/patch-JDK-1.6.diff @ 61152

Last change on this file since 61152 was 61152, checked in by nox@…, 10 years ago

Add Snow Leopard support to commons-dbcp (#21037)

commons-dbcp requires JDK 1.5 and cannot compile with
JDK 1.6, complaining that some abstract methods are not defined
in concrete classes. patch-JDK-1.6.diff fixes that.

File size: 59.3 KB
  • src/test/org/apache/commons/dbcp/TesterPreparedStatement.java

    Taken from https://issues.apache.org/jira/browse/DBCP-191
    
     
    2828import java.sql.ResultSetMetaData;
    2929import java.sql.SQLException;
    3030import java.util.Calendar;
     31/* JDBC_4_ANT_KEY_BEGIN */
     32import java.io.InputStream;
     33import java.io.Reader;
     34import java.sql.NClob;
     35import java.sql.RowId;
     36import java.sql.SQLXML;
     37/* JDBC_4_ANT_KEY_END */
    3138
    3239/**
    3340 * A dummy {@link PreparedStatement}, for testing purposes.
     
    288295    public java.sql.ParameterMetaData getParameterMetaData() throws SQLException {
    289296        throw new SQLException("Not implemented.");
    290297    }
    291 
    292298/* JDBC_3_ANT_KEY_END */
     299/* JDBC_4_ANT_KEY_BEGIN */
    293300
     301    public void setRowId(int parameterIndex, RowId value) throws SQLException {
     302        throw new SQLException("Not implemented.");
     303    }
     304
     305    public void setNString(int parameterIndex, String value) throws SQLException {
     306        throw new SQLException("Not implemented.");
     307    }
     308
     309    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     310        throw new SQLException("Not implemented.");
     311    }
     312
     313    public void setNClob(int parameterIndex, NClob value) throws SQLException {
     314        throw new SQLException("Not implemented.");
     315    }
     316
     317    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     318        throw new SQLException("Not implemented.");
     319    }
     320
     321    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     322        throw new SQLException("Not implemented.");
     323    }
     324
     325    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     326        throw new SQLException("Not implemented.");
     327    }
     328
     329    public void setSQLXML(int parameterIndex, SQLXML value) throws SQLException {
     330        throw new SQLException("Not implemented.");
     331    }
     332
     333    public void setAsciiStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     334        throw new SQLException("Not implemented.");
     335    }
     336
     337    public void setBinaryStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     338        throw new SQLException("Not implemented.");
     339    }
     340
     341    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     342        throw new SQLException("Not implemented.");
     343    }
     344
     345    public void setAsciiStream(int parameterIndex, InputStream inputStream) throws SQLException {
     346        throw new SQLException("Not implemented.");
     347    }
     348
     349    public void setBinaryStream(int parameterIndex, InputStream inputStream) throws SQLException {
     350        throw new SQLException("Not implemented.");
     351    }
     352
     353    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     354        throw new SQLException("Not implemented.");
     355    }
     356
     357    public void setNCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     358        throw new SQLException("Not implemented.");
     359    }
     360
     361    public void setClob(int parameterIndex, Reader reader) throws SQLException {
     362        throw new SQLException("Not implemented.");
     363    }
     364
     365    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     366        throw new SQLException("Not implemented.");
     367    }
     368
     369    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     370        throw new SQLException("Not implemented.");
     371    }
     372/* JDBC_4_ANT_KEY_END */
    294373}
  • src/test/org/apache/commons/dbcp/TesterResultSet.java

     
    2828import java.sql.SQLWarning;
    2929import java.sql.Statement;
    3030import java.util.Calendar;
     31/* JDBC_4_ANT_KEY_BEGIN */
     32import java.io.InputStream;
     33import java.io.Reader;
     34import java.sql.NClob;
     35import java.sql.RowId;
     36import java.sql.SQLXML;
     37/* JDBC_4_ANT_KEY_END */
    3138
    3239/**
    3340 * A dummy {@link ResultSet}, for testing purposes.
     
    759766        throws SQLException {
    760767        throw new SQLException("Not implemented.");
    761768    }
    762 
    763769/* JDBC_3_ANT_KEY_END */
     770/* JDBC_4_ANT_KEY_BEGIN */
    764771
     772    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     773        throw new SQLException("Not implemented.");
     774    }
     775
     776    public <T> T unwrap(Class<T> iface) throws SQLException {
     777        throw new SQLException("Not implemented.");
     778    }
     779
     780    public RowId getRowId(int columnIndex) throws SQLException {
     781        throw new SQLException("Not implemented.");
     782    }
     783
     784    public RowId getRowId(String columnLabel) throws SQLException {
     785        throw new SQLException("Not implemented.");
     786    }
     787
     788    public void updateRowId(int columnIndex, RowId value) throws SQLException {
     789        throw new SQLException("Not implemented.");
     790    }
     791
     792    public void updateRowId(String columnLabel, RowId value) throws SQLException {
     793        throw new SQLException("Not implemented.");
     794    }
     795
     796    public int getHoldability() throws SQLException {
     797        throw new SQLException("Not implemented.");
     798    }
     799
     800    public boolean isClosed() throws SQLException {
     801        throw new SQLException("Not implemented.");
     802    }
     803
     804    public void updateNString(int columnIndex, String value) throws SQLException {
     805        throw new SQLException("Not implemented.");
     806    }
     807
     808    public void updateNString(String columnLabel, String value) throws SQLException {
     809        throw new SQLException("Not implemented.");
     810    }
     811
     812    public void updateNClob(int columnIndex, NClob value) throws SQLException {
     813        throw new SQLException("Not implemented.");
     814    }
     815
     816    public void updateNClob(String columnLabel, NClob value) throws SQLException {
     817        throw new SQLException("Not implemented.");
     818    }
     819
     820    public NClob getNClob(int columnIndex) throws SQLException {
     821        throw new SQLException("Not implemented.");
     822    }
     823
     824    public NClob getNClob(String columnLabel) throws SQLException {
     825        throw new SQLException("Not implemented.");
     826    }
     827
     828    public SQLXML getSQLXML(int columnIndex) throws SQLException {
     829        throw new SQLException("Not implemented.");
     830    }
     831
     832    public SQLXML getSQLXML(String columnLabel) throws SQLException {
     833        throw new SQLException("Not implemented.");
     834    }
     835
     836    public void updateSQLXML(int columnIndex, SQLXML value) throws SQLException {
     837        throw new SQLException("Not implemented.");
     838    }
     839
     840    public void updateSQLXML(String columnLabel, SQLXML value) throws SQLException {
     841        throw new SQLException("Not implemented.");
     842    }
     843
     844    public String getNString(int columnIndex) throws SQLException {
     845        throw new SQLException("Not implemented.");
     846    }
     847
     848    public String getNString(String columnLabel) throws SQLException {
     849        throw new SQLException("Not implemented.");
     850    }
     851
     852    public Reader getNCharacterStream(int columnIndex) throws SQLException {
     853        throw new SQLException("Not implemented.");
     854    }
     855
     856    public Reader getNCharacterStream(String columnLabel) throws SQLException {
     857        throw new SQLException("Not implemented.");
     858    }
     859
     860    public void updateNCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     861        throw new SQLException("Not implemented.");
     862    }
     863
     864    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     865        throw new SQLException("Not implemented.");
     866    }
     867
     868    public void updateAsciiStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     869        throw new SQLException("Not implemented.");
     870    }
     871
     872    public void updateBinaryStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     873        throw new SQLException("Not implemented.");
     874    }
     875
     876    public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     877        throw new SQLException("Not implemented.");
     878    }
     879
     880    public void updateAsciiStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     881        throw new SQLException("Not implemented.");
     882    }
     883
     884    public void updateBinaryStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     885        throw new SQLException("Not implemented.");
     886    }
     887
     888    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     889        throw new SQLException("Not implemented.");
     890    }
     891
     892    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
     893        throw new SQLException("Not implemented.");
     894    }
     895
     896    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
     897        throw new SQLException("Not implemented.");
     898    }
     899
     900    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
     901        throw new SQLException("Not implemented.");
     902    }
     903
     904    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
     905        throw new SQLException("Not implemented.");
     906    }
     907
     908    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
     909        throw new SQLException("Not implemented.");
     910    }
     911
     912    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
     913        throw new SQLException("Not implemented.");
     914    }
     915
     916    public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException {
     917        throw new SQLException("Not implemented.");
     918    }
     919
     920    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
     921        throw new SQLException("Not implemented.");
     922    }
     923
     924    public void updateAsciiStream(int columnIndex, InputStream inputStream) throws SQLException {
     925        throw new SQLException("Not implemented.");
     926    }
     927
     928    public void updateBinaryStream(int columnIndex, InputStream inputStream) throws SQLException {
     929        throw new SQLException("Not implemented.");
     930    }
     931
     932    public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException {
     933        throw new SQLException("Not implemented.");
     934    }
     935
     936    public void updateAsciiStream(String columnLabel, InputStream inputStream) throws SQLException {
     937        throw new SQLException("Not implemented.");
     938    }
     939
     940    public void updateBinaryStream(String columnLabel, InputStream inputStream) throws SQLException {
     941        throw new SQLException("Not implemented.");
     942    }
     943
     944    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
     945        throw new SQLException("Not implemented.");
     946    }
     947
     948    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
     949        throw new SQLException("Not implemented.");
     950    }
     951
     952    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
     953        throw new SQLException("Not implemented.");
     954    }
     955
     956    public void updateClob(int columnIndex, Reader reader) throws SQLException {
     957        throw new SQLException("Not implemented.");
     958    }
     959
     960    public void updateClob(String columnLabel, Reader reader) throws SQLException {
     961        throw new SQLException("Not implemented.");
     962    }
     963
     964    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
     965        throw new SQLException("Not implemented.");
     966    }
     967
     968    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
     969        throw new SQLException("Not implemented.");
     970    }
     971/* JDBC_4_ANT_KEY_END */
    765972}
  • src/test/org/apache/commons/dbcp/TesterConnection.java

     
    2525import java.sql.SQLWarning;
    2626import java.sql.Statement;
    2727import java.util.Map;
     28/* JDBC_4_ANT_KEY_BEGIN */
     29import java.sql.Array;
     30import java.sql.Blob;
     31import java.sql.Clob;
     32import java.sql.NClob;
     33import java.sql.SQLClientInfoException;
     34import java.sql.SQLXML;
     35import java.sql.Struct;
     36import java.util.Properties;
     37/* JDBC_4_ANT_KEY_END */
    2838
    2939/**
    3040 * A dummy {@link Connection}, for testing purposes.
     
    274284        throws SQLException {
    275285        return prepareStatement(sql);
    276286    }
     287/* JDBC_3_ANT_KEY_END */
     288/* JDBC_4_ANT_KEY_BEGIN */
    277289
    278 /* JDBC_3_ANT_KEY_END */
     290    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     291        throw new SQLException("Not implemented.");
     292    }
     293
     294    public <T> T unwrap(Class<T> iface) throws SQLException {
     295        throw new SQLException("Not implemented.");
     296    }
     297
     298    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     299        throw new SQLException("Not implemented.");
     300    }
     301
     302    public Blob createBlob() throws SQLException {
     303        throw new SQLException("Not implemented.");
     304    }
     305
     306    public Clob createClob() throws SQLException {
     307        throw new SQLException("Not implemented.");
     308    }
     309
     310    public NClob createNClob() throws SQLException {
     311        throw new SQLException("Not implemented.");
     312    }
     313
     314    public SQLXML createSQLXML() throws SQLException {
     315        throw new SQLException("Not implemented.");
     316    }
     317
     318    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     319        throw new SQLException("Not implemented.");
     320    }
     321
     322    public boolean isValid(int timeout) throws SQLException {
     323        throw new SQLException("Not implemented.");
     324    }
     325
     326    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     327        throw new SQLClientInfoException();
     328    }
     329
     330    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     331        throw new SQLClientInfoException();
     332    }
     333
     334    public Properties getClientInfo() throws SQLException {
     335        throw new SQLException("Not implemented.");
     336    }
     337
     338    public String getClientInfo(String name) throws SQLException {
     339        throw new SQLException("Not implemented.");
     340    }
     341/* JDBC_4_ANT_KEY_END */
    279342}
  • src/test/org/apache/commons/dbcp/TesterStatement.java

     
    268268        throw new SQLException("Not implemented.");
    269269    }
    270270/* JDBC_3_ANT_KEY_END */
     271/* JDBC_4_ANT_KEY_BEGIN */
    271272
     273    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     274        throw new SQLException("Not implemented.");
     275    }
     276
     277    public <T> T unwrap(Class<T> iface) throws SQLException {
     278        throw new SQLException("Not implemented.");
     279    }
     280
     281    public boolean isClosed() throws SQLException {
     282        throw new SQLException("Not implemented.");
     283    }
     284
     285    public void setPoolable(boolean poolable) throws SQLException {
     286        throw new SQLException("Not implemented.");
     287    }
     288
     289    public boolean isPoolable() throws SQLException {
     290        throw new SQLException("Not implemented.");
     291    }
     292/* JDBC_4_ANT_KEY_END */
    272293}
  • src/java/org/apache/commons/dbcp/DelegatingCallableStatement.java

     
    3232import java.io.InputStream;
    3333import java.io.Reader;
    3434import java.sql.SQLException;
     35/* JDBC_4_ANT_KEY_BEGIN */
     36import java.sql.NClob;
     37import java.sql.RowId;
     38import java.sql.SQLXML;
     39/* JDBC_4_ANT_KEY_END */
    3540
    3641/**
    3742 * A base delegating implementation of {@link CallableStatement}.
     
    332337
    333338    public URL getURL(String parameterName) throws SQLException
    334339    { checkOpen(); try { return _stmt.getURL(parameterName); } catch (SQLException e) { handleException(e); return null; } }
     340/* JDBC_3_ANT_KEY_END */
     341/* JDBC_4_ANT_KEY_BEGIN */
    335342
    336 /* JDBC_3_ANT_KEY_END */
     343    public RowId getRowId(int parameterIndex) throws SQLException {
     344        checkOpen();
     345        try {
     346            return _stmt.getRowId(parameterIndex);
     347        }
     348        catch (SQLException e) {
     349            handleException(e);
     350            return null;
     351        }
     352    }
     353
     354    public RowId getRowId(String parameterName) throws SQLException {
     355        checkOpen();
     356        try {
     357            return _stmt.getRowId(parameterName);
     358        }
     359        catch (SQLException e) {
     360            handleException(e);
     361            return null;
     362        }
     363    }
     364
     365    public void setRowId(String parameterName, RowId value) throws SQLException {
     366        checkOpen();
     367        try {
     368            _stmt.setRowId(parameterName, value);
     369        }
     370        catch (SQLException e) {
     371            handleException(e);
     372        }
     373    }
     374
     375    public void setNString(String parameterName, String value) throws SQLException {
     376        checkOpen();
     377        try {
     378            _stmt.setNString(parameterName, value);
     379        }
     380        catch (SQLException e) {
     381            handleException(e);
     382        }
     383    }
     384
     385    public void setNCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     386        checkOpen();
     387        try {
     388            _stmt.setNCharacterStream(parameterName, reader, length);
     389        }
     390        catch (SQLException e) {
     391            handleException(e);
     392        }
     393    }
     394
     395    public void setNClob(String parameterName, NClob value) throws SQLException {
     396        checkOpen();
     397        try {
     398            _stmt.setNClob(parameterName, value);
     399        }
     400        catch (SQLException e) {
     401            handleException(e);
     402        }
     403    }
     404
     405    public void setClob(String parameterName, Reader reader, long length) throws SQLException {
     406        checkOpen();
     407        try {
     408            _stmt.setClob(parameterName, reader, length);
     409        }
     410        catch (SQLException e) {
     411            handleException(e);
     412        }
     413    }
     414
     415    public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
     416        checkOpen();
     417        try {
     418            _stmt.setBlob(parameterName, inputStream, length);
     419        }
     420        catch (SQLException e) {
     421            handleException(e);
     422        }
     423    }
     424
     425    public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
     426        checkOpen();
     427        try {
     428            _stmt.setNClob(parameterName, reader, length);
     429        }
     430        catch (SQLException e) {
     431            handleException(e);
     432        }
     433    }
     434
     435    public NClob getNClob(int parameterIndex) throws SQLException {
     436        checkOpen();
     437        try {
     438            return _stmt.getNClob(parameterIndex);
     439        }
     440        catch (SQLException e) {
     441            handleException(e);
     442            return null;
     443        }
     444    }
     445
     446    public NClob getNClob(String parameterName) throws SQLException {
     447        checkOpen();
     448        try {
     449            return _stmt.getNClob(parameterName);
     450        }
     451        catch (SQLException e) {
     452            handleException(e);
     453            return null;
     454        }
     455    }
     456
     457    public void setSQLXML(String parameterName, SQLXML value) throws SQLException {
     458        checkOpen();
     459        try {
     460            _stmt.setSQLXML(parameterName, value);
     461        }
     462        catch (SQLException e) {
     463            handleException(e);
     464        }
     465    }
     466
     467    public SQLXML getSQLXML(int parameterIndex) throws SQLException {
     468        checkOpen();
     469        try {
     470            return _stmt.getSQLXML(parameterIndex);
     471        }
     472        catch (SQLException e) {
     473            handleException(e);
     474            return null;
     475        }
     476    }
     477
     478    public SQLXML getSQLXML(String parameterName) throws SQLException {
     479        checkOpen();
     480        try {
     481            return _stmt.getSQLXML(parameterName);
     482        }
     483        catch (SQLException e) {
     484            handleException(e);
     485            return null;
     486        }
     487    }
     488
     489    public String getNString(int parameterIndex) throws SQLException {
     490        checkOpen();
     491        try {
     492            return _stmt.getNString(parameterIndex);
     493        }
     494        catch (SQLException e) {
     495            handleException(e);
     496            return null;
     497        }
     498    }
     499
     500    public String getNString(String parameterName) throws SQLException {
     501        checkOpen();
     502        try {
     503            return _stmt.getNString(parameterName);
     504        }
     505        catch (SQLException e) {
     506            handleException(e);
     507            return null;
     508        }
     509    }
     510
     511    public Reader getNCharacterStream(int parameterIndex) throws SQLException {
     512        checkOpen();
     513        try {
     514            return _stmt.getNCharacterStream(parameterIndex);
     515        }
     516        catch (SQLException e) {
     517            handleException(e);
     518            return null;
     519        }
     520    }
     521
     522    public Reader getNCharacterStream(String parameterName) throws SQLException {
     523        checkOpen();
     524        try {
     525            return _stmt.getNCharacterStream(parameterName);
     526        }
     527        catch (SQLException e) {
     528            handleException(e);
     529            return null;
     530        }
     531    }
     532
     533    public Reader getCharacterStream(int parameterIndex) throws SQLException {
     534        checkOpen();
     535        try {
     536            return _stmt.getCharacterStream(parameterIndex);
     537        }
     538        catch (SQLException e) {
     539            handleException(e);
     540            return null;
     541        }
     542    }
     543
     544    public Reader getCharacterStream(String parameterName) throws SQLException {
     545        checkOpen();
     546        try {
     547            return _stmt.getCharacterStream(parameterName);
     548        }
     549        catch (SQLException e) {
     550            handleException(e);
     551            return null;
     552        }
     553    }
     554
     555    public void setBlob(String parameterName, Blob blob) throws SQLException {
     556        checkOpen();
     557        try {
     558            _stmt.setBlob(parameterName, blob);
     559        }
     560        catch (SQLException e) {
     561            handleException(e);
     562        }
     563    }
     564
     565    public void setClob(String parameterName, Clob clob) throws SQLException {
     566        checkOpen();
     567        try {
     568            _stmt.setClob(parameterName, clob);
     569        }
     570        catch (SQLException e) {
     571            handleException(e);
     572        }
     573    }
     574
     575    public void setAsciiStream(String parameterName, InputStream inputStream, long length) throws SQLException {
     576        checkOpen();
     577        try {
     578            _stmt.setAsciiStream(parameterName, inputStream, length);
     579        }
     580        catch (SQLException e) {
     581            handleException(e);
     582        }
     583    }
     584
     585    public void setBinaryStream(String parameterName, InputStream inputStream, long length) throws SQLException {
     586        checkOpen();
     587        try {
     588            _stmt.setBinaryStream(parameterName, inputStream, length);
     589        }
     590        catch (SQLException e) {
     591            handleException(e);
     592        }
     593    }
     594
     595    public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     596        checkOpen();
     597        try {
     598            _stmt.setCharacterStream(parameterName, reader, length);
     599        }
     600        catch (SQLException e) {
     601            handleException(e);
     602        }
     603    }
     604
     605    public void setAsciiStream(String parameterName, InputStream inputStream) throws SQLException {
     606        checkOpen();
     607        try {
     608            _stmt.setAsciiStream(parameterName, inputStream);
     609        }
     610        catch (SQLException e) {
     611            handleException(e);
     612        }
     613    }
     614
     615    public void setBinaryStream(String parameterName, InputStream inputStream) throws SQLException {
     616        checkOpen();
     617        try {
     618            _stmt.setBinaryStream(parameterName, inputStream);
     619        }
     620        catch (SQLException e) {
     621            handleException(e);
     622        }
     623    }
     624
     625    public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
     626        checkOpen();
     627        try {
     628            _stmt.setCharacterStream(parameterName, reader);
     629        }
     630        catch (SQLException e) {
     631            handleException(e);
     632        }
     633    }
     634
     635    public void setNCharacterStream(String parameterName, Reader reader) throws SQLException {
     636        checkOpen();
     637        try {
     638            _stmt.setNCharacterStream(parameterName, reader);
     639        }
     640        catch (SQLException e) {
     641            handleException(e);
     642        }
     643    }
     644
     645    public void setClob(String parameterName, Reader reader) throws SQLException {
     646        checkOpen();
     647        try {
     648            _stmt.setClob(parameterName, reader);
     649        }
     650        catch (SQLException e) {
     651            handleException(e);
     652        }    }
     653
     654    public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
     655        checkOpen();
     656        try {
     657            _stmt.setBlob(parameterName, inputStream);
     658        }
     659        catch (SQLException e) {
     660            handleException(e);
     661        }    }
     662
     663    public void setNClob(String parameterName, Reader reader) throws SQLException {
     664        checkOpen();
     665        try {
     666            _stmt.setNClob(parameterName, reader);
     667        }
     668        catch (SQLException e) {
     669            handleException(e);
     670        }
     671    }
     672/* JDBC_4_ANT_KEY_END */
    337673}
  • src/java/org/apache/commons/dbcp/cpdsadapter/ConnectionImpl.java

     
    2525import java.sql.Statement;
    2626import java.sql.SQLWarning;
    2727import java.sql.SQLException;
     28/* JDBC_4_ANT_KEY_BEGIN */
     29import java.sql.Array;
     30import java.sql.Blob;
     31import java.sql.ClientInfoStatus;
     32import java.sql.Clob;
     33import java.sql.NClob;
     34import java.sql.SQLClientInfoException;
     35import java.sql.SQLXML;
     36import java.sql.Struct;
     37import java.util.Collections;
     38import java.util.Map;
     39import java.util.Properties;
     40/* JDBC_4_ANT_KEY_END */
    2841
    2942/**
    3043 * This class is the <code>Connection</code> that will be returned
     
    4255    private static final String CLOSED
    4356            = "Attempted to use Connection after closed() was called.";
    4457
     58/* JDBC_4_ANT_KEY_BEGIN */
     59    private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =
     60        Collections.<String, ClientInfoStatus>emptyMap();
     61/* JDBC_4_ANT_KEY_END */
     62
    4563    /** The JDBC database connection. */
    4664    private Connection connection;
    4765
     
    453471        assertOpen();
    454472        return connection.prepareStatement(sql, columnNames);
    455473    }
     474/* JDBC_3_ANT_KEY_END */
     475/* JDBC_4_ANT_KEY_BEGIN */
    456476
    457 /* JDBC_3_ANT_KEY_END */
     477    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     478        return connection.isWrapperFor(iface);
     479    }
     480
     481    public <T> T unwrap(Class<T> iface) throws SQLException {
     482        return connection.unwrap(iface);
     483    }
     484
     485    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     486        assertOpen();
     487        return connection.createArrayOf(typeName, elements);
     488    }
     489
     490    public Blob createBlob() throws SQLException {
     491        assertOpen();
     492        return connection.createBlob();
     493    }
     494
     495    public Clob createClob() throws SQLException {
     496        assertOpen();
     497        return connection.createClob();
     498    }
     499
     500    public NClob createNClob() throws SQLException {
     501        assertOpen();
     502        return connection.createNClob();
     503    }
     504
     505    public SQLXML createSQLXML() throws SQLException {
     506        assertOpen();
     507        return connection.createSQLXML();
     508    }
     509
     510    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     511        assertOpen();
     512        return connection.createStruct(typeName, attributes);
     513    }
     514
     515    public boolean isValid(int timeout) throws SQLException {
     516        assertOpen();
     517        return connection.isValid(timeout);
     518    }
     519
     520    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     521        try {
     522            assertOpen();
     523            connection.setClientInfo(name, value);
     524        }
     525        catch (SQLClientInfoException e) {
     526            throw e;
     527        }
     528        catch (SQLException e) {
     529            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     530        }
     531    }
     532
     533    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     534        try {
     535            assertOpen();
     536            connection.setClientInfo(properties);
     537        }
     538        catch (SQLClientInfoException e) {
     539            throw e;
     540        }
     541        catch (SQLException e) {
     542            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     543        }
     544    }
     545
     546    public Properties getClientInfo() throws SQLException {
     547        assertOpen();
     548        return connection.getClientInfo();
     549    }
     550
     551    public String getClientInfo(String name) throws SQLException {
     552        assertOpen();
     553        return connection.getClientInfo(name);
     554    }
     555/* JDBC_4_ANT_KEY_END */
    458556}
  • src/java/org/apache/commons/dbcp/cpdsadapter/PooledConnectionImpl.java

     
    2626import javax.sql.ConnectionEvent;
    2727import javax.sql.ConnectionEventListener;
    2828import javax.sql.PooledConnection;
     29import javax.sql.StatementEventListener;
    2930
    3031import org.apache.commons.dbcp.DelegatingConnection;
    3132import org.apache.commons.dbcp.DelegatingPreparedStatement;
     
    6667    private Vector eventListeners;
    6768
    6869    /**
     70     * StatementEventListeners
     71     */
     72    private Vector statementEventListeners;
     73
     74    /**
    6975     * flag set to true, once close() is called.
    7076     */
    7177    boolean isClosed;
     
    101107        }
    102108    }
    103109
     110    public void addStatementEventListener(StatementEventListener listener) {
     111        if (!statementEventListeners.contains(listener)) {
     112            statementEventListeners.add(listener);
     113        }
     114    }
     115
    104116    /**
    105117     * Closes the physical connection and marks this
    106118     * <code>PooledConnection</code> so that it may not be used
     
    169181        eventListeners.remove(listener);
    170182    }
    171183
     184    public void removeStatementEventListener(StatementEventListener listener) {
     185        statementEventListeners.remove(listener);
     186    }
     187
    172188    /**
    173189     * Closes the physical connection and checks that the logical connection
    174190     * was closed as well.
  • src/java/org/apache/commons/dbcp/DelegatingPreparedStatement.java

     
    2727import java.sql.ResultSetMetaData;
    2828import java.sql.SQLException;
    2929import java.util.Calendar;
     30/* JDBC_4_ANT_KEY_BEGIN */
     31import java.io.InputStream;
     32import java.io.Reader;
     33import java.sql.NClob;
     34import java.sql.RowId;
     35import java.sql.SQLXML;
     36/* JDBC_4_ANT_KEY_END */
    3037
    3138/**
    3239 * A base delegating implementation of {@link PreparedStatement}.
     
    221228
    222229    public java.sql.ParameterMetaData getParameterMetaData() throws SQLException
    223230    { checkOpen(); try { return _stmt.getParameterMetaData(); } catch (SQLException e) { handleException(e); return null; } }
     231/* JDBC_3_ANT_KEY_END */
     232/* JDBC_4_ANT_KEY_BEGIN */
    224233
    225 /* JDBC_3_ANT_KEY_END */
     234    public void setRowId(int parameterIndex, RowId value) throws SQLException {
     235        checkOpen();
     236        try {
     237            _stmt.setRowId(parameterIndex, value);
     238        }
     239        catch (SQLException e) {
     240            handleException(e);
     241        }
     242    }
     243
     244    public void setNString(int parameterIndex, String value) throws SQLException {
     245        checkOpen();
     246        try {
     247            _stmt.setNString(parameterIndex, value);
     248        }
     249        catch (SQLException e) {
     250            handleException(e);
     251        }
     252    }
     253
     254    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     255        checkOpen();
     256        try {
     257            _stmt.setNCharacterStream(parameterIndex, value, length);
     258        }
     259        catch (SQLException e) {
     260            handleException(e);
     261        }
     262    }
     263
     264    public void setNClob(int parameterIndex, NClob value) throws SQLException {
     265        checkOpen();
     266        try {
     267            _stmt.setNClob(parameterIndex, value);
     268        }
     269        catch (SQLException e) {
     270            handleException(e);
     271        }
     272    }
     273
     274    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     275        checkOpen();
     276        try {
     277            _stmt.setClob(parameterIndex, reader, length);
     278        }
     279        catch (SQLException e) {
     280            handleException(e);
     281        }
     282    }
     283
     284    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     285        checkOpen();
     286        try {
     287            _stmt.setBlob(parameterIndex, inputStream, length);
     288        }
     289        catch (SQLException e) {
     290            handleException(e);
     291        }
     292    }
     293
     294    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     295        checkOpen();
     296        try {
     297            _stmt.setNClob(parameterIndex, reader, length);
     298        }
     299        catch (SQLException e) {
     300            handleException(e);
     301        }
     302    }
     303
     304    public void setSQLXML(int parameterIndex, SQLXML value) throws SQLException {
     305        checkOpen();
     306        try {
     307            _stmt.setSQLXML(parameterIndex, value);
     308        }
     309        catch (SQLException e) {
     310            handleException(e);
     311        }
     312    }
     313
     314    public void setAsciiStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     315        checkOpen();
     316        try {
     317            _stmt.setAsciiStream(parameterIndex, inputStream, length);
     318        }
     319        catch (SQLException e) {
     320            handleException(e);
     321        }
     322    }
     323
     324    public void setBinaryStream(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     325        checkOpen();
     326        try {
     327            _stmt.setBinaryStream(parameterIndex, inputStream, length);
     328        }
     329        catch (SQLException e) {
     330            handleException(e);
     331        }
     332    }
     333
     334    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     335        checkOpen();
     336        try {
     337            _stmt.setCharacterStream(parameterIndex, reader, length);
     338        }
     339        catch (SQLException e) {
     340            handleException(e);
     341        }
     342    }
     343
     344    public void setAsciiStream(int parameterIndex, InputStream inputStream) throws SQLException {
     345        checkOpen();
     346        try {
     347            _stmt.setAsciiStream(parameterIndex, inputStream);
     348        }
     349        catch (SQLException e) {
     350            handleException(e);
     351        }
     352    }
     353
     354    public void setBinaryStream(int parameterIndex, InputStream inputStream) throws SQLException {
     355        checkOpen();
     356        try {
     357            _stmt.setBinaryStream(parameterIndex, inputStream);
     358        }
     359        catch (SQLException e) {
     360            handleException(e);
     361        }
     362    }
     363
     364    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     365        checkOpen();
     366        try {
     367            _stmt.setCharacterStream(parameterIndex, reader);
     368        }
     369        catch (SQLException e) {
     370            handleException(e);
     371        }
     372    }
     373
     374    public void setNCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     375        checkOpen();
     376        try {
     377            _stmt.setNCharacterStream(parameterIndex, reader);
     378        }
     379        catch (SQLException e) {
     380            handleException(e);
     381        }
     382    }
     383
     384    public void setClob(int parameterIndex, Reader reader) throws SQLException {
     385        checkOpen();
     386        try {
     387            _stmt.setClob(parameterIndex, reader);
     388        }
     389        catch (SQLException e) {
     390            handleException(e);
     391        }
     392    }
     393
     394    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     395        checkOpen();
     396        try {
     397            _stmt.setBlob(parameterIndex, inputStream);
     398        }
     399        catch (SQLException e) {
     400            handleException(e);
     401        }
     402    }
     403
     404    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     405        checkOpen();
     406        try {
     407            _stmt.setNClob(parameterIndex, reader);
     408        }
     409        catch (SQLException e) {
     410            handleException(e);
     411        }
     412    }
     413/* JDBC_4_ANT_KEY_END */
    226414}
  • src/java/org/apache/commons/dbcp/DelegatingResultSet.java

     
    3434import java.sql.Clob;
    3535import java.sql.Array;
    3636import java.util.Calendar;
     37/* JDBC_4_ANT_KEY_BEGIN */
     38import java.sql.NClob;
     39import java.sql.RowId;
     40import java.sql.SQLXML;
     41/* JDBC_4_ANT_KEY_END */
    3742
    3843/**
    3944 * A base delegating implementation of {@link ResultSet}.
     
    585590
    586591    public void updateArray(String columnName, java.sql.Array x) throws SQLException
    587592    { try { _res.updateArray(columnName, x); } catch (SQLException e) { handleException(e); } }
     593/* JDBC_3_ANT_KEY_END */
     594/* JDBC_4_ANT_KEY_BEGIN */
    588595
    589 /* JDBC_3_ANT_KEY_END */
     596    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     597        return _res.isWrapperFor(iface);
     598    }
     599
     600    public <T> T unwrap(Class<T> iface) throws SQLException {
     601        return _res.unwrap(iface);
     602    }
     603
     604    public RowId getRowId(int columnIndex) throws SQLException {
     605        try {
     606            return _res.getRowId(columnIndex);
     607        }
     608        catch (SQLException e) {
     609            handleException(e);
     610            return null;
     611        }
     612    }
     613
     614    public RowId getRowId(String columnLabel) throws SQLException {
     615        try {
     616            return _res.getRowId(columnLabel);
     617        }
     618        catch (SQLException e) {
     619            handleException(e);
     620            return null;
     621        }
     622    }
     623
     624    public void updateRowId(int columnIndex, RowId value) throws SQLException {
     625        try {
     626            _res.updateRowId(columnIndex, value);
     627        }
     628        catch (SQLException e) {
     629            handleException(e);
     630        }
     631    }
     632
     633    public void updateRowId(String columnLabel, RowId value) throws SQLException {
     634        try {
     635            _res.updateRowId(columnLabel, value);
     636        }
     637        catch (SQLException e) {
     638            handleException(e);
     639        }
     640    }
     641
     642    public int getHoldability() throws SQLException {
     643        try {
     644            return _res.getHoldability();
     645        }
     646        catch (SQLException e) {
     647            handleException(e);
     648            return 0;
     649        }
     650    }
     651
     652    public boolean isClosed() throws SQLException {
     653        try {
     654            return _res.isClosed();
     655        }
     656        catch (SQLException e) {
     657            handleException(e);
     658            return false;
     659        }
     660    }
     661
     662    public void updateNString(int columnIndex, String value) throws SQLException {
     663        try {
     664            _res.updateNString(columnIndex, value);
     665        }
     666        catch (SQLException e) {
     667            handleException(e);
     668        }
     669    }
     670
     671    public void updateNString(String columnLabel, String value) throws SQLException {
     672        try {
     673            _res.updateNString(columnLabel, value);
     674        }
     675        catch (SQLException e) {
     676            handleException(e);
     677        }
     678    }
     679
     680    public void updateNClob(int columnIndex, NClob value) throws SQLException {
     681        try {
     682            _res.updateNClob(columnIndex, value);
     683        }
     684        catch (SQLException e) {
     685            handleException(e);
     686        }
     687    }
     688
     689    public void updateNClob(String columnLabel, NClob value) throws SQLException {
     690        try {
     691            _res.updateNClob(columnLabel, value);
     692        }
     693        catch (SQLException e) {
     694            handleException(e);
     695        }
     696    }
     697
     698    public NClob getNClob(int columnIndex) throws SQLException {
     699        try {
     700            return _res.getNClob(columnIndex);
     701        }
     702        catch (SQLException e) {
     703            handleException(e);
     704            return null;
     705        }
     706    }
     707
     708    public NClob getNClob(String columnLabel) throws SQLException {
     709        try {
     710            return _res.getNClob(columnLabel);
     711        }
     712        catch (SQLException e) {
     713            handleException(e);
     714            return null;
     715        }
     716    }
     717
     718    public SQLXML getSQLXML(int columnIndex) throws SQLException {
     719        try {
     720            return _res.getSQLXML(columnIndex);
     721        }
     722        catch (SQLException e) {
     723            handleException(e);
     724            return null;
     725        }
     726    }
     727
     728    public SQLXML getSQLXML(String columnLabel) throws SQLException {
     729        try {
     730            return _res.getSQLXML(columnLabel);
     731        }
     732        catch (SQLException e) {
     733            handleException(e);
     734            return null;
     735        }
     736    }
     737
     738    public void updateSQLXML(int columnIndex, SQLXML value) throws SQLException {
     739        try {
     740            _res.updateSQLXML(columnIndex, value);
     741        }
     742        catch (SQLException e) {
     743            handleException(e);
     744        }
     745    }
     746
     747    public void updateSQLXML(String columnLabel, SQLXML value) throws SQLException {
     748        try {
     749            _res.updateSQLXML(columnLabel, value);
     750        }
     751        catch (SQLException e) {
     752            handleException(e);
     753        }
     754    }
     755
     756    public String getNString(int columnIndex) throws SQLException {
     757        try {
     758            return _res.getNString(columnIndex);
     759        }
     760        catch (SQLException e) {
     761            handleException(e);
     762            return null;
     763        }
     764    }
     765
     766    public String getNString(String columnLabel) throws SQLException {
     767        try {
     768            return _res.getNString(columnLabel);
     769        }
     770        catch (SQLException e) {
     771            handleException(e);
     772            return null;
     773        }
     774    }
     775
     776    public Reader getNCharacterStream(int columnIndex) throws SQLException {
     777        try {
     778            return _res.getNCharacterStream(columnIndex);
     779        }
     780        catch (SQLException e) {
     781            handleException(e);
     782            return null;
     783        }
     784    }
     785
     786    public Reader getNCharacterStream(String columnLabel) throws SQLException {
     787        try {
     788            return _res.getNCharacterStream(columnLabel);
     789        }
     790        catch (SQLException e) {
     791            handleException(e);
     792            return null;
     793        }
     794    }
     795
     796    public void updateNCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     797        try {
     798            _res.updateNCharacterStream(columnIndex, reader, length);
     799        }
     800        catch (SQLException e) {
     801            handleException(e);
     802        }
     803    }
     804
     805    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     806        try {
     807            _res.updateNCharacterStream(columnLabel, reader, length);
     808        }
     809        catch (SQLException e) {
     810            handleException(e);
     811        }
     812    }
     813
     814    public void updateAsciiStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     815        try {
     816            _res.updateAsciiStream(columnIndex, inputStream, length);
     817        }
     818        catch (SQLException e) {
     819            handleException(e);
     820        }
     821    }
     822
     823    public void updateBinaryStream(int columnIndex, InputStream inputStream, long length) throws SQLException {
     824        try {
     825            _res.updateBinaryStream(columnIndex, inputStream, length);
     826        }
     827        catch (SQLException e) {
     828            handleException(e);
     829        }
     830    }
     831
     832    public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException {
     833        try {
     834            _res.updateCharacterStream(columnIndex, reader, length);
     835        }
     836        catch (SQLException e) {
     837            handleException(e);
     838        }
     839    }
     840
     841    public void updateAsciiStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     842        try {
     843            _res.updateAsciiStream(columnLabel, inputStream, length);
     844        }
     845        catch (SQLException e) {
     846            handleException(e);
     847        }
     848    }
     849
     850    public void updateBinaryStream(String columnLabel, InputStream inputStream, long length) throws SQLException {
     851        try {
     852            _res.updateBinaryStream(columnLabel, inputStream, length);
     853        }
     854        catch (SQLException e) {
     855            handleException(e);
     856        }
     857    }
     858
     859    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
     860        try {
     861            _res.updateCharacterStream(columnLabel, reader, length);
     862        }
     863        catch (SQLException e) {
     864            handleException(e);
     865        }
     866    }
     867
     868    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
     869        try {
     870            _res.updateBlob(columnIndex, inputStream, length);
     871        }
     872        catch (SQLException e) {
     873            handleException(e);
     874        }
     875    }
     876
     877    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
     878        try {
     879            _res.updateBlob(columnLabel, inputStream, length);
     880        }
     881        catch (SQLException e) {
     882            handleException(e);
     883        }
     884    }
     885
     886    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
     887        try {
     888            _res.updateClob(columnIndex, reader, length);
     889        }
     890        catch (SQLException e) {
     891            handleException(e);
     892        }
     893    }
     894
     895    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
     896        try {
     897            _res.updateClob(columnLabel, reader, length);
     898        }
     899        catch (SQLException e) {
     900            handleException(e);
     901        }
     902    }
     903
     904    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
     905        try {
     906            _res.updateNClob(columnIndex, reader, length);
     907        }
     908        catch (SQLException e) {
     909            handleException(e);
     910        }
     911    }
     912
     913    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
     914        try {
     915            _res.updateNClob(columnLabel, reader, length);
     916        }
     917        catch (SQLException e) {
     918            handleException(e);
     919        }
     920    }
     921
     922    public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException {
     923        try {
     924            _res.updateNCharacterStream(columnIndex, reader);
     925        }
     926        catch (SQLException e) {
     927            handleException(e);
     928        }
     929    }
     930
     931    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
     932        try {
     933            _res.updateNCharacterStream(columnLabel, reader);
     934        }
     935        catch (SQLException e) {
     936            handleException(e);
     937        }
     938    }
     939
     940    public void updateAsciiStream(int columnIndex, InputStream inputStream) throws SQLException {
     941        try {
     942            _res.updateAsciiStream(columnIndex, inputStream);
     943        }
     944        catch (SQLException e) {
     945            handleException(e);
     946        }
     947    }
     948
     949    public void updateBinaryStream(int columnIndex, InputStream inputStream) throws SQLException {
     950        try {
     951            _res.updateBinaryStream(columnIndex, inputStream);
     952        }
     953        catch (SQLException e) {
     954            handleException(e);
     955        }
     956    }
     957
     958    public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException {
     959        try {
     960            _res.updateCharacterStream(columnIndex, reader);
     961        }
     962        catch (SQLException e) {
     963            handleException(e);
     964        }
     965    }
     966
     967    public void updateAsciiStream(String columnLabel, InputStream inputStream) throws SQLException {
     968        try {
     969            _res.updateAsciiStream(columnLabel, inputStream);
     970        }
     971        catch (SQLException e) {
     972            handleException(e);
     973        }
     974    }
     975
     976    public void updateBinaryStream(String columnLabel, InputStream inputStream) throws SQLException {
     977        try {
     978            _res.updateBinaryStream(columnLabel, inputStream);
     979        }
     980        catch (SQLException e) {
     981            handleException(e);
     982        }
     983    }
     984
     985    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
     986        try {
     987            _res.updateCharacterStream(columnLabel, reader);
     988        }
     989        catch (SQLException e) {
     990            handleException(e);
     991        }
     992    }
     993
     994    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
     995        try {
     996            _res.updateBlob(columnIndex, inputStream);
     997        }
     998        catch (SQLException e) {
     999            handleException(e);
     1000        }
     1001    }
     1002
     1003    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
     1004        try {
     1005            _res.updateBlob(columnLabel, inputStream);
     1006        }
     1007        catch (SQLException e) {
     1008            handleException(e);
     1009        }
     1010    }
     1011
     1012    public void updateClob(int columnIndex, Reader reader) throws SQLException {
     1013        try {
     1014            _res.updateClob(columnIndex, reader);
     1015        }
     1016        catch (SQLException e) {
     1017            handleException(e);
     1018        }
     1019    }
     1020
     1021    public void updateClob(String columnLabel, Reader reader) throws SQLException {
     1022        try {
     1023            _res.updateClob(columnLabel, reader);
     1024        }
     1025        catch (SQLException e) {
     1026            handleException(e);
     1027        }
     1028    }
     1029
     1030    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
     1031        try {
     1032            _res.updateNClob(columnIndex, reader);
     1033        }
     1034        catch (SQLException e) {
     1035            handleException(e);
     1036        }
     1037    }
     1038
     1039    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
     1040        try {
     1041            _res.updateNClob(columnLabel, reader);
     1042        }
     1043        catch (SQLException e) {
     1044            handleException(e);
     1045        }
     1046    }
     1047/* JDBC_4_ANT_KEY_END */
    5901048}
  • src/java/org/apache/commons/dbcp/PoolingDataSource.java

     
    8484    public void setAccessToUnderlyingConnectionAllowed(boolean allow) {
    8585        this.accessToUnderlyingConnectionAllowed = allow;
    8686    }
     87
     88    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     89        return false;
     90    }
     91
     92    public <T> T unwrap(Class<T> iface) throws SQLException {
     93        throw new SQLException("PoolingDataSource is not a wrapper.");
     94    }
    8795   
    8896    //--- DataSource methods -----------------------------------------
    8997
  • src/java/org/apache/commons/dbcp/DelegatingConnection.java

     
    2626import java.sql.Statement;
    2727import java.util.List;
    2828import java.util.Map;
     29/* JDBC_4_ANT_KEY_BEGIN */
     30import java.sql.Array;
     31import java.sql.Blob;
     32import java.sql.ClientInfoStatus;
     33import java.sql.Clob;
     34import java.sql.NClob;
     35import java.sql.SQLClientInfoException;
     36import java.sql.SQLXML;
     37import java.sql.Struct;
     38import java.util.Collections;
     39import java.util.Map;
     40import java.util.Properties;
     41/* JDBC_4_ANT_KEY_END */
    2942
    3043/**
    3144 * A base delegating implementation of {@link Connection}.
     
    5063 */
    5164public class DelegatingConnection extends AbandonedTrace
    5265        implements Connection {
     66/* JDBC_4_ANT_KEY_BEGIN */
     67    private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =
     68        Collections.<String, ClientInfoStatus>emptyMap();
     69/* JDBC_4_ANT_KEY_END */
    5370    /** My delegate {@link Connection}. */
    5471    protected Connection _conn = null;
    5572
     
    495512        }
    496513    }
    497514/* JDBC_3_ANT_KEY_END */
     515/* JDBC_4_ANT_KEY_BEGIN */
     516
     517    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     518        return _conn.isWrapperFor(iface);
     519    }
     520
     521    public <T> T unwrap(Class<T> iface) throws SQLException {
     522        return _conn.unwrap(iface);
     523    }
     524
     525    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     526        checkOpen();
     527        try {
     528            return _conn.createArrayOf(typeName, elements);
     529        }
     530        catch (SQLException e) {
     531            handleException(e);
     532            return null;
     533        }
     534    }
     535
     536    public Blob createBlob() throws SQLException {
     537        checkOpen();
     538        try {
     539            return _conn.createBlob();
     540        }
     541        catch (SQLException e) {
     542            handleException(e);
     543            return null;
     544        }
     545    }
     546
     547    public Clob createClob() throws SQLException {
     548        checkOpen();
     549        try {
     550            return _conn.createClob();
     551        }
     552        catch (SQLException e) {
     553            handleException(e);
     554            return null;
     555        }
     556    }
     557
     558    public NClob createNClob() throws SQLException {
     559        checkOpen();
     560        try {
     561            return _conn.createNClob();
     562        }
     563        catch (SQLException e) {
     564            handleException(e);
     565            return null;
     566        }
     567    }
     568
     569    public SQLXML createSQLXML() throws SQLException {
     570        checkOpen();
     571        try {
     572            return _conn.createSQLXML();
     573        }
     574        catch (SQLException e) {
     575            handleException(e);
     576            return null;
     577        }
     578    }
     579
     580    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     581        checkOpen();
     582        try {
     583            return _conn.createStruct(typeName, attributes);
     584        }
     585        catch (SQLException e) {
     586            handleException(e);
     587            return null;
     588        }
     589    }
     590
     591    public boolean isValid(int timeout) throws SQLException {
     592        checkOpen();
     593        try {
     594            return _conn.isValid(timeout);
     595        }
     596        catch (SQLException e) {
     597            handleException(e);
     598            return false;
     599        }
     600    }
     601
     602    public void setClientInfo(String name, String value) throws SQLClientInfoException {
     603        try {
     604            checkOpen();
     605            _conn.setClientInfo(name, value);
     606        }
     607        catch (SQLClientInfoException e) {
     608            throw e;
     609        }
     610        catch (SQLException e) {
     611            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     612        }
     613    }
     614
     615    public void setClientInfo(Properties properties) throws SQLClientInfoException {
     616        try {
     617            checkOpen();
     618            _conn.setClientInfo(properties);
     619        }
     620        catch (SQLClientInfoException e) {
     621            throw e;
     622        }
     623        catch (SQLException e) {
     624            throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
     625        }
     626    }
     627
     628    public Properties getClientInfo() throws SQLException {
     629        checkOpen();
     630        try {
     631            return _conn.getClientInfo();
     632        }
     633        catch (SQLException e) {
     634            handleException(e);
     635            return null;
     636        }
     637    }
     638
     639    public String getClientInfo(String name) throws SQLException {
     640        checkOpen();
     641        try {
     642            return _conn.getClientInfo(name);
     643        }
     644        catch (SQLException e) {
     645            handleException(e);
     646            return null;
     647        }
     648    }
     649/* JDBC_4_ANT_KEY_END */
    498650}
  • src/java/org/apache/commons/dbcp/DelegatingStatement.java

     
    128128
    129129    protected boolean _closed = false;
    130130
    131     protected boolean isClosed() {
    132         return _closed;
    133     }
    134 
    135131    protected void checkOpen() throws SQLException {
    136132        if(isClosed()) {
    137133            throw new SQLException
     
    346342    { checkOpen(); try { return _stmt.getResultSetHoldability(); } catch (SQLException e) { handleException(e); return 0; } }
    347343
    348344/* JDBC_3_ANT_KEY_END */
     345/* JDBC_4_ANT_KEY_BEGIN */
     346
     347    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     348        return _conn.isWrapperFor(iface);
     349    }
     350
     351    public <T> T unwrap(Class<T> iface) throws SQLException {
     352        return _conn.unwrap(iface);
     353    }
     354
     355    public boolean isClosed() throws SQLException {
     356        return _closed;
     357    }
     358
     359    public void setPoolable(boolean poolable) throws SQLException {
     360        checkOpen();
     361        try {
     362            _stmt.setPoolable(poolable);
     363        }
     364        catch (SQLException e) {
     365            handleException(e);
     366        }
     367    }
     368
     369    public boolean isPoolable() throws SQLException {
     370        checkOpen();
     371        try {
     372            return _stmt.isPoolable();
     373        }
     374        catch (SQLException e) {
     375            handleException(e);
     376            return false;
     377        }
     378    }
     379/* JDBC_4_ANT_KEY_END */
    349380}
  • src/java/org/apache/commons/dbcp/BasicDataSource.java

     
    11151115        }
    11161116    }
    11171117
     1118    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1119        return false;
     1120    }
    11181121
     1122    public <T> T unwrap(Class<T> iface) throws SQLException {
     1123        throw new SQLException("BasicDataSource is not a wrapper.");
     1124    }
     1125
    11191126    // ------------------------------------------------------ Protected Methods
    11201127
    11211128
  • src/java/org/apache/commons/dbcp/datasources/InstanceKeyDataSource.java

     
    154154     */
    155155    public abstract void close() throws Exception;
    156156
     157    public boolean isWrapperFor(Class<?> iface) throws SQLException {
     158        return false;
     159    }
     160
     161    public <T> T unwrap(Class<T> iface) throws SQLException {
     162        throw new SQLException("InstanceKeyDataSource is not a wrapper.");
     163    }
     164
    157165    // -------------------------------------------------------------------
    158166    // Properties
    159167
  • project.properties

     
    3030maven.xdoc.developmentProcessUrl=http://jakarta.apache.org/commons/charter.html
    3131
    3232# JDK level
    33 maven.compile.source=1.3
    34 maven.compile.target=1.3
     33maven.compile.source=1.6
     34maven.compile.target=1.6
    3535
    3636# Merge in a file containing just Built-By attribute
    3737maven.jar.manifest=${basedir}/manifestMods.txt
Note: See TracBrowser for help on using the repository browser.