Repository: commons-dbcp
Updated Branches:
  refs/heads/master c510b94ad -> 21d75a867


[DBCP-506] Support JDBC 4.2: new PreparedStatement methods.

Project: http://git-wip-us.apache.org/repos/asf/commons-dbcp/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-dbcp/commit/21d75a86
Tree: http://git-wip-us.apache.org/repos/asf/commons-dbcp/tree/21d75a86
Diff: http://git-wip-us.apache.org/repos/asf/commons-dbcp/diff/21d75a86

Branch: refs/heads/master
Commit: 21d75a867ed4659b6796406ea26510f683f3ee42
Parents: c510b94
Author: Gary Gregory <garydgreg...@gmail.com>
Authored: Sun Jun 17 09:56:59 2018 -0600
Committer: Gary Gregory <garydgreg...@gmail.com>
Committed: Sun Jun 17 09:56:59 2018 -0600

----------------------------------------------------------------------
 .../dbcp2/DelegatingPreparedStatement.java      | 306 ++++++++++---------
 .../commons/dbcp2/TesterPreparedStatement.java  |  11 +
 2 files changed, 180 insertions(+), 137 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/21d75a86/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
----------------------------------------------------------------------
diff --git 
a/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java 
b/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
index 2fe7460..b7e91f4 100644
--- a/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
+++ b/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
@@ -31,6 +31,7 @@ import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.RowId;
 import java.sql.SQLException;
+import java.sql.SQLType;
 import java.sql.SQLXML;
 import java.sql.Statement;
 import java.sql.Time;
@@ -64,6 +65,51 @@ public class DelegatingPreparedStatement extends 
DelegatingStatement implements
     }
 
     @Override
+    public void addBatch() throws SQLException {
+        checkOpen();
+        try {
+            getDelegatePreparedStatement().addBatch();
+        } catch (final SQLException e) {
+            handleException(e);
+        }
+    }
+
+    @Override
+    public void clearParameters() throws SQLException {
+        checkOpen();
+        try {
+            getDelegatePreparedStatement().clearParameters();
+        } catch (final SQLException e) {
+            handleException(e);
+        }
+    }
+
+    @Override
+    public boolean execute() throws SQLException {
+        checkOpen();
+        if (getConnectionInternal() != null) {
+            getConnectionInternal().setLastUsed();
+        }
+        try {
+            return getDelegatePreparedStatement().execute();
+        } catch (final SQLException e) {
+            handleException(e);
+            return false;
+        }
+    }
+
+    @Override
+    public long executeLargeUpdate() throws SQLException {
+        checkOpen();
+        try {
+            return getDelegatePreparedStatement().executeLargeUpdate();
+        } catch (final SQLException e) {
+            handleException(e);
+            return 0;
+        }
+    }
+
+    @Override
     public ResultSet executeQuery() throws SQLException {
         checkOpen();
         if (getConnectionInternal() != null) {
@@ -96,559 +142,545 @@ public class DelegatingPreparedStatement extends 
DelegatingStatement implements
     }
 
     @Override
-    public void setNull(final int parameterIndex, final int sqlType) throws 
SQLException {
+    public ResultSetMetaData getMetaData() throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNull(parameterIndex, sqlType);
+            return getDelegatePreparedStatement().getMetaData();
         } catch (final SQLException e) {
             handleException(e);
+            throw new AssertionError();
         }
     }
 
     @Override
-    public void setBoolean(final int parameterIndex, final boolean x) throws 
SQLException {
+    public java.sql.ParameterMetaData getParameterMetaData() throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBoolean(parameterIndex, x);
+            return getDelegatePreparedStatement().getParameterMetaData();
         } catch (final SQLException e) {
             handleException(e);
+            throw new AssertionError();
         }
     }
 
     @Override
-    public void setByte(final int parameterIndex, final byte x) throws 
SQLException {
+    public void setArray(final int i, final Array x) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setByte(parameterIndex, x);
+            getDelegatePreparedStatement().setArray(i, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setShort(final int parameterIndex, final short x) throws 
SQLException {
+    public void setAsciiStream(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setShort(parameterIndex, x);
+            getDelegatePreparedStatement().setAsciiStream(parameterIndex, 
inputStream);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setInt(final int parameterIndex, final int x) throws 
SQLException {
+    public void setAsciiStream(final int parameterIndex, final InputStream x, 
final int length) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setInt(parameterIndex, x);
+            getDelegatePreparedStatement().setAsciiStream(parameterIndex, x, 
length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setLong(final int parameterIndex, final long x) throws 
SQLException {
+    public void setAsciiStream(final int parameterIndex, final InputStream 
inputStream, final long length)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setLong(parameterIndex, x);
+            getDelegatePreparedStatement().setAsciiStream(parameterIndex, 
inputStream, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setFloat(final int parameterIndex, final float x) throws 
SQLException {
+    public void setBigDecimal(final int parameterIndex, final BigDecimal x) 
throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setFloat(parameterIndex, x);
+            getDelegatePreparedStatement().setBigDecimal(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setDouble(final int parameterIndex, final double x) throws 
SQLException {
+    public void setBinaryStream(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setDouble(parameterIndex, x);
+            getDelegatePreparedStatement().setBinaryStream(parameterIndex, 
inputStream);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBigDecimal(final int parameterIndex, final BigDecimal x) 
throws SQLException {
+    public void setBinaryStream(final int parameterIndex, final InputStream x, 
final int length) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBigDecimal(parameterIndex, x);
+            getDelegatePreparedStatement().setBinaryStream(parameterIndex, x, 
length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setString(final int parameterIndex, final String x) throws 
SQLException {
+    public void setBinaryStream(final int parameterIndex, final InputStream 
inputStream, final long length)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setString(parameterIndex, x);
+            getDelegatePreparedStatement().setBinaryStream(parameterIndex, 
inputStream, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBytes(final int parameterIndex, final byte[] x) throws 
SQLException {
+    public void setBlob(final int i, final Blob x) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBytes(parameterIndex, x);
+            getDelegatePreparedStatement().setBlob(i, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setDate(final int parameterIndex, final Date x) throws 
SQLException {
+    public void setBlob(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setDate(parameterIndex, x);
+            getDelegatePreparedStatement().setBlob(parameterIndex, 
inputStream);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setTime(final int parameterIndex, final Time x) throws 
SQLException {
+    public void setBlob(final int parameterIndex, final InputStream 
inputStream, final long length)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setTime(parameterIndex, x);
+            getDelegatePreparedStatement().setBlob(parameterIndex, 
inputStream, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setTimestamp(final int parameterIndex, final Timestamp x) 
throws SQLException {
+    public void setBoolean(final int parameterIndex, final boolean x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setTimestamp(parameterIndex, x);
+            getDelegatePreparedStatement().setBoolean(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setAsciiStream(final int parameterIndex, final InputStream x, 
final int length) throws SQLException {
+    public void setByte(final int parameterIndex, final byte x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setAsciiStream(parameterIndex, x, 
length);
+            getDelegatePreparedStatement().setByte(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
-    /** @deprecated Use setAsciiStream(), setCharacterStream() or 
setNCharacterStream() */
-    @Deprecated
     @Override
-    public void setUnicodeStream(final int parameterIndex, final InputStream 
x, final int length) throws SQLException {
+    public void setBytes(final int parameterIndex, final byte[] x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setUnicodeStream(parameterIndex, x, 
length);
+            getDelegatePreparedStatement().setBytes(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBinaryStream(final int parameterIndex, final InputStream x, 
final int length) throws SQLException {
+    public void setCharacterStream(final int parameterIndex, final Reader 
reader) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBinaryStream(parameterIndex, x, 
length);
+            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void clearParameters() throws SQLException {
+    public void setCharacterStream(final int parameterIndex, final Reader 
reader, final int length)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().clearParameters();
+            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setObject(final int parameterIndex, final Object x, final int 
targetSqlType, final int scale)
+    public void setCharacterStream(final int parameterIndex, final Reader 
reader, final long length)
             throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType, scale);
+            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setObject(final int parameterIndex, final Object x, final int 
targetSqlType) throws SQLException {
+    public void setClob(final int i, final Clob x) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType);
+            getDelegatePreparedStatement().setClob(i, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setObject(final int parameterIndex, final Object x) throws 
SQLException {
+    public void setClob(final int parameterIndex, final Reader reader) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setObject(parameterIndex, x);
+            getDelegatePreparedStatement().setClob(parameterIndex, reader);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public boolean execute() throws SQLException {
+    public void setClob(final int parameterIndex, final Reader reader, final 
long length) throws SQLException {
         checkOpen();
-        if (getConnectionInternal() != null) {
-            getConnectionInternal().setLastUsed();
-        }
         try {
-            return getDelegatePreparedStatement().execute();
+            getDelegatePreparedStatement().setClob(parameterIndex, reader, 
length);
         } catch (final SQLException e) {
             handleException(e);
-            return false;
         }
     }
 
     @Override
-    public void addBatch() throws SQLException {
+    public void setDate(final int parameterIndex, final Date x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().addBatch();
+            getDelegatePreparedStatement().setDate(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setCharacterStream(final int parameterIndex, final Reader 
reader, final int length)
-            throws SQLException {
+    public void setDate(final int parameterIndex, final Date x, final Calendar 
cal) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader, length);
+            getDelegatePreparedStatement().setDate(parameterIndex, x, cal);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setRef(final int i, final Ref x) throws SQLException {
+    public void setDouble(final int parameterIndex, final double x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setRef(i, x);
+            getDelegatePreparedStatement().setDouble(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBlob(final int i, final Blob x) throws SQLException {
+    public void setFloat(final int parameterIndex, final float x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBlob(i, x);
+            getDelegatePreparedStatement().setFloat(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setClob(final int i, final Clob x) throws SQLException {
+    public void setInt(final int parameterIndex, final int x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setClob(i, x);
+            getDelegatePreparedStatement().setInt(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setArray(final int i, final Array x) throws SQLException {
+    public void setLong(final int parameterIndex, final long x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setArray(i, x);
+            getDelegatePreparedStatement().setLong(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public ResultSetMetaData getMetaData() throws SQLException {
+    public void setNCharacterStream(final int parameterIndex, final Reader 
reader) throws SQLException {
         checkOpen();
         try {
-            return getDelegatePreparedStatement().getMetaData();
+            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, 
reader);
         } catch (final SQLException e) {
             handleException(e);
-            throw new AssertionError();
         }
     }
 
     @Override
-    public void setDate(final int parameterIndex, final Date x, final Calendar 
cal) throws SQLException {
+    public void setNCharacterStream(final int parameterIndex, final Reader 
value, final long length)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setDate(parameterIndex, x, cal);
+            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, 
value, length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setTime(final int parameterIndex, final Time x, final Calendar 
cal) throws SQLException {
+    public void setNClob(final int parameterIndex, final NClob value) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setTime(parameterIndex, x, cal);
+            getDelegatePreparedStatement().setNClob(parameterIndex, value);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setTimestamp(final int parameterIndex, final Timestamp x, 
final Calendar cal) throws SQLException {
+    public void setNClob(final int parameterIndex, final Reader reader) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setTimestamp(parameterIndex, x, 
cal);
+            getDelegatePreparedStatement().setNClob(parameterIndex, reader);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNull(final int paramIndex, final int sqlType, final String 
typeName) throws SQLException {
+    public void setNClob(final int parameterIndex, final Reader reader, final 
long length) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNull(paramIndex, sqlType, 
typeName);
+            getDelegatePreparedStatement().setNClob(parameterIndex, reader, 
length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
-    /**
-     * Returns a String representation of this object.
-     *
-     * @return String
-     */
-    @SuppressWarnings("resource")
     @Override
-    public String toString() {
-        final Statement statement = getDelegate();
-        return statement == null ? "NULL" : statement.toString();
-    }
-
-    @Override
-    public void setURL(final int parameterIndex, final java.net.URL x) throws 
SQLException {
+    public void setNString(final int parameterIndex, final String value) 
throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setURL(parameterIndex, x);
+            getDelegatePreparedStatement().setNString(parameterIndex, value);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public java.sql.ParameterMetaData getParameterMetaData() throws 
SQLException {
+    public void setNull(final int parameterIndex, final int sqlType) throws 
SQLException {
         checkOpen();
         try {
-            return getDelegatePreparedStatement().getParameterMetaData();
+            getDelegatePreparedStatement().setNull(parameterIndex, sqlType);
         } catch (final SQLException e) {
             handleException(e);
-            throw new AssertionError();
         }
     }
 
     @Override
-    public void setRowId(final int parameterIndex, final RowId value) throws 
SQLException {
+    public void setNull(final int paramIndex, final int sqlType, final String 
typeName) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setRowId(parameterIndex, value);
+            getDelegatePreparedStatement().setNull(paramIndex, sqlType, 
typeName);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNString(final int parameterIndex, final String value) 
throws SQLException {
+    public void setObject(final int parameterIndex, final Object x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNString(parameterIndex, value);
+            getDelegatePreparedStatement().setObject(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNCharacterStream(final int parameterIndex, final Reader 
value, final long length)
-            throws SQLException {
+    public void setObject(final int parameterIndex, final Object x, final int 
targetSqlType) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, 
value, length);
+            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNClob(final int parameterIndex, final NClob value) throws 
SQLException {
+    public void setObject(final int parameterIndex, final Object x, final int 
targetSqlType, final int scale)
+            throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNClob(parameterIndex, value);
+            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType, scale);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setClob(final int parameterIndex, final Reader reader, final 
long length) throws SQLException {
+    public void setObject(int parameterIndex, Object x, SQLType targetSqlType) 
throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setClob(parameterIndex, reader, 
length);
+            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBlob(final int parameterIndex, final InputStream 
inputStream, final long length)
-            throws SQLException {
+    public void setObject(int parameterIndex, Object x, SQLType targetSqlType, 
int scaleOrLength) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBlob(parameterIndex, 
inputStream, length);
+            getDelegatePreparedStatement().setObject(parameterIndex, x, 
targetSqlType, scaleOrLength);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNClob(final int parameterIndex, final Reader reader, final 
long length) throws SQLException {
+    public void setRef(final int i, final Ref x) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNClob(parameterIndex, reader, 
length);
+            getDelegatePreparedStatement().setRef(i, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setSQLXML(final int parameterIndex, final SQLXML value) throws 
SQLException {
+    public void setRowId(final int parameterIndex, final RowId value) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setSQLXML(parameterIndex, value);
+            getDelegatePreparedStatement().setRowId(parameterIndex, value);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setAsciiStream(final int parameterIndex, final InputStream 
inputStream, final long length)
-            throws SQLException {
+    public void setShort(final int parameterIndex, final short x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setAsciiStream(parameterIndex, 
inputStream, length);
+            getDelegatePreparedStatement().setShort(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBinaryStream(final int parameterIndex, final InputStream 
inputStream, final long length)
-            throws SQLException {
+    public void setSQLXML(final int parameterIndex, final SQLXML value) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBinaryStream(parameterIndex, 
inputStream, length);
+            getDelegatePreparedStatement().setSQLXML(parameterIndex, value);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setCharacterStream(final int parameterIndex, final Reader 
reader, final long length)
-            throws SQLException {
+    public void setString(final int parameterIndex, final String x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader, length);
+            getDelegatePreparedStatement().setString(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setAsciiStream(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
+    public void setTime(final int parameterIndex, final Time x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setAsciiStream(parameterIndex, 
inputStream);
+            getDelegatePreparedStatement().setTime(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBinaryStream(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
+    public void setTime(final int parameterIndex, final Time x, final Calendar 
cal) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBinaryStream(parameterIndex, 
inputStream);
+            getDelegatePreparedStatement().setTime(parameterIndex, x, cal);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setCharacterStream(final int parameterIndex, final Reader 
reader) throws SQLException {
+    public void setTimestamp(final int parameterIndex, final Timestamp x) 
throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setCharacterStream(parameterIndex, 
reader);
+            getDelegatePreparedStatement().setTimestamp(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setNCharacterStream(final int parameterIndex, final Reader 
reader) throws SQLException {
+    public void setTimestamp(final int parameterIndex, final Timestamp x, 
final Calendar cal) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, 
reader);
+            getDelegatePreparedStatement().setTimestamp(parameterIndex, x, 
cal);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
+    /** @deprecated Use setAsciiStream(), setCharacterStream() or 
setNCharacterStream() */
+    @Deprecated
     @Override
-    public void setClob(final int parameterIndex, final Reader reader) throws 
SQLException {
+    public void setUnicodeStream(final int parameterIndex, final InputStream 
x, final int length) throws SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setClob(parameterIndex, reader);
+            getDelegatePreparedStatement().setUnicodeStream(parameterIndex, x, 
length);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
     @Override
-    public void setBlob(final int parameterIndex, final InputStream 
inputStream) throws SQLException {
+    public void setURL(final int parameterIndex, final java.net.URL x) throws 
SQLException {
         checkOpen();
         try {
-            getDelegatePreparedStatement().setBlob(parameterIndex, 
inputStream);
+            getDelegatePreparedStatement().setURL(parameterIndex, x);
         } catch (final SQLException e) {
             handleException(e);
         }
     }
 
+    /**
+     * Returns a String representation of this object.
+     *
+     * @return String
+     */
+    @SuppressWarnings("resource")
     @Override
-    public void setNClob(final int parameterIndex, final Reader reader) throws 
SQLException {
-        checkOpen();
-        try {
-            getDelegatePreparedStatement().setNClob(parameterIndex, reader);
-        } catch (final SQLException e) {
-            handleException(e);
-        }
+    public String toString() {
+        final Statement statement = getDelegate();
+        return statement == null ? "NULL" : statement.toString();
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/21d75a86/src/test/java/org/apache/commons/dbcp2/TesterPreparedStatement.java
----------------------------------------------------------------------
diff --git 
a/src/test/java/org/apache/commons/dbcp2/TesterPreparedStatement.java 
b/src/test/java/org/apache/commons/dbcp2/TesterPreparedStatement.java
index 6aae73c..a3d12fa 100644
--- a/src/test/java/org/apache/commons/dbcp2/TesterPreparedStatement.java
+++ b/src/test/java/org/apache/commons/dbcp2/TesterPreparedStatement.java
@@ -27,6 +27,7 @@ import java.sql.Ref;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.sql.SQLType;
 import java.util.Calendar;
 import java.io.InputStream;
 import java.io.Reader;
@@ -463,6 +464,16 @@ public class TesterPreparedStatement extends 
TesterStatement implements Prepared
     }
 
     @Override
+    public void setObject(int parameterIndex, Object x, SQLType targetSqlType) 
throws SQLException {
+        checkOpen();
+    }
+
+    @Override
+    public void setObject(int parameterIndex, Object x, SQLType targetSqlType, 
int scaleOrLength) throws SQLException {
+        checkOpen();
+    }
+
+    @Override
     public void setRef (final int i, final Ref x) throws SQLException {
         checkOpen();
     }

Reply via email to