[61130] trunk/dports/java/mysql-connector-java
nox at macports.org
nox at macports.org
Wed Dec 2 13:51:21 PST 2009
Revision: 61130
http://trac.macports.org/changeset/61130
Author: nox at macports.org
Date: 2009-12-02 13:51:18 -0800 (Wed, 02 Dec 2009)
Log Message:
-----------
Add Snow Leopard support to mysql-connector-java
mysql-connector-java 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.
Modified Paths:
--------------
trunk/dports/java/mysql-connector-java/Portfile
Added Paths:
-----------
trunk/dports/java/mysql-connector-java/files/patch-JDK-1.6.diff
Modified: trunk/dports/java/mysql-connector-java/Portfile
===================================================================
--- trunk/dports/java/mysql-connector-java/Portfile 2009-12-02 19:56:57 UTC (rev 61129)
+++ trunk/dports/java/mysql-connector-java/Portfile 2009-12-02 21:51:18 UTC (rev 61130)
@@ -3,7 +3,7 @@
PortSystem 1.0
name mysql-connector-java
-version 5.0.7
+version 5.1.10
categories java
maintainers jberry openmaintainer
@@ -21,9 +21,9 @@
homepage http://dev.mysql.com/doc/refman/5.0/en/connector-j.html
master_sites http://ftp.plusline.de/mysql/Downloads/Connector-J/
-checksums md5 d177ce7397b119f013458cec0418ad2d \
- sha1 df3b78d1108f89485fb8c9711ee39c376d0391eb \
- rmd160 eae7454d156c7726ab2e96017e8b6f4fe0c61ab9
+checksums md5 f9da616de868ddd1acf1428334f3313d \
+ sha1 32938f3004c70a657a7481496bc3813b85df20de \
+ rmd160 ef5b6cf4cceaac0c6d32858920c362bab6004bc1
patchfiles patch-build.xml
@@ -50,6 +50,15 @@
file copy ${worksrcpath}/docs ${destroot}${prefix}/share/doc/${name}
}
+platform darwin 10 {
+ post-patch {
+ reinplace -E {/name="compile"/s/compile-testsuite, //} \
+ ${worksrcpath}/build.xml
+ }
+
+ patchfiles-append patch-JDK-1.6.diff
+}
+
livecheck.type regex
livecheck.url http://dev.mysql.com/downloads/connector/j/5.0.html
livecheck.regex "${name}-(\\d+\\.\\d+(\\.\\d+)?).tar.gz"
Added: trunk/dports/java/mysql-connector-java/files/patch-JDK-1.6.diff
===================================================================
--- trunk/dports/java/mysql-connector-java/files/patch-JDK-1.6.diff (rev 0)
+++ trunk/dports/java/mysql-connector-java/files/patch-JDK-1.6.diff 2009-12-02 21:51:18 UTC (rev 61130)
@@ -0,0 +1,3109 @@
+--- src/com/mysql/jdbc/CallableStatement.java.orig 2009-11-28 20:29:56.000000000 +0100
++++ src/com/mysql/jdbc/CallableStatement.java 2009-11-28 23:57:51.000000000 +0100
+@@ -32,10 +32,13 @@
+ import java.sql.Blob;
+ import java.sql.Clob;
+ import java.sql.Date;
++import java.sql.NClob;
+ import java.sql.ParameterMetaData;
+ import java.sql.Ref;
+ import java.sql.ResultSet;
++import java.sql.RowId;
+ import java.sql.SQLException;
++import java.sql.SQLXML;
+ import java.sql.Statement;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+@@ -2441,5 +2444,86 @@
+ return (super.checkReadOnlySafeStatement() || this.checkReadOnlyProcedure());
+ }
+
++ public void setNClob(String parameterName, Reader reader)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Reader getCharacterStream(String parameterName) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Reader getCharacterStream(int parameterIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public String getNString(String parameterName) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public String getNString(int parameterIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Reader getNCharacterStream(String parameterName)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Reader getNCharacterStream(int parameterIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public SQLXML getSQLXML(String parameterName) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public SQLXML getSQLXML(int parameterIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setSQLXML(String parameterName, SQLXML xmlObject)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public NClob getNClob(String parameterName) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public NClob getNClob(int parameterIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setNClob(String parameterName, Reader reader, long length)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setNClob(String parameterName, NClob value)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setNString(String parameterName, String value)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setRowId(String parameterName, RowId x)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public RowId getRowId(String parameterName)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public RowId getRowId(int parameterIndex)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
+
+ }
+--- src/com/mysql/jdbc/ConnectionImpl.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/ConnectionImpl.java 2009-11-29 00:56:52.000000000 +0100
+@@ -34,11 +34,16 @@
+ import java.nio.charset.Charset;
+ import java.nio.charset.CharsetEncoder;
+ import java.sql.Blob;
++import java.sql.Clob;
+ import java.sql.DatabaseMetaData;
++import java.sql.NClob;
+ import java.sql.ResultSet;
++import java.sql.SQLClientInfoException;
+ import java.sql.SQLException;
+ import java.sql.SQLWarning;
++import java.sql.SQLXML;
+ import java.sql.Savepoint;
++import java.sql.Struct;
+ import java.util.ArrayList;
+ import java.util.Calendar;
+ import java.util.GregorianCalendar;
+@@ -5699,4 +5704,60 @@
+ public boolean getRequiresEscapingEncoder() {
+ return requiresEscapingEncoder;
+ }
++
++ public Struct createStruct(String typeName, Object[] attributes)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public java.sql.Array createArrayOf(String typeName, Object[] elements)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Properties getClientInfo() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public String getClientInfo(String name) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setClientInfo(Properties properties)
++ throws SQLClientInfoException {
++ throw new SQLClientInfoException();
++ }
++
++ public void setClientInfo(String name, String value)
++ throws SQLClientInfoException {
++ throw new SQLClientInfoException();
++ }
++
++ public boolean isValid(int timeout) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public SQLXML createSQLXML() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public NClob createNClob() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Blob createBlob() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Clob createClob() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/DatabaseMetaData.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/DatabaseMetaData.java 2009-11-28 23:31:07.000000000 +0100
+@@ -27,6 +27,7 @@
+ import java.io.UnsupportedEncodingException;
+ import java.lang.reflect.Constructor;
+ import java.sql.ResultSet;
++import java.sql.RowIdLifetime;
+ import java.sql.SQLException;
+ import java.sql.Statement;
+ import java.sql.Types;
+@@ -8158,4 +8159,29 @@
+
+ return pStmt;
+ }
++
++ public ResultSet getFunctions(String catalog, String schemaPattern,
++ String functionNamePattern) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public ResultSet getClientInfoProperties() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public RowIdLifetime getRowIdLifetime() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java.orig 2009-11-28 22:41:30.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java 2009-11-29 01:26:01.000000000 +0100
+@@ -34,8 +34,11 @@
+ import java.sql.CallableStatement;
+ import java.sql.Clob;
+ import java.sql.Date;
++import java.sql.NClob;
+ import java.sql.Ref;
++import java.sql.RowId;
+ import java.sql.SQLException;
++import java.sql.SQLXML;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+ import java.util.Calendar;
+@@ -1800,817 +1803,817 @@
+
+ return null;
+ }
+-//
+-// public Reader getCharacterStream(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getCharacterStream(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public Reader getCharacterStream(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getCharacterStream(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public Reader getNCharacterStream(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getCharacterStream(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public Reader getNCharacterStream(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getNCharacterStream(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public NClob getNClob(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getNClob(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public NClob getNClob(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getNClob(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public String getNString(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getNString(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public String getNString(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getNString(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public RowId getRowId(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getRowId(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public RowId getRowId(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getRowId(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public SQLXML getSQLXML(int parameterIndex) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getSQLXML(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public SQLXML getSQLXML(String parameterName) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .getSQLXML(parameterName);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return null;
+-// }
+-//
+-// public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setAsciiStream(parameterName, x) ;
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setAsciiStream(parameterName, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBinaryStream(parameterName, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBinaryStream(parameterName, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(String parameterName, Blob x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBlob(parameterName, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBlob(parameterName, inputStream);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBlob(parameterName, inputStream, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setCharacterStream(parameterName, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setCharacterStream(parameterName, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(String parameterName, Clob x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setClob(parameterName, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(String parameterName, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setClob(parameterName, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setClob(parameterName, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNCharacterStream(parameterName, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNCharacterStream(parameterName, value, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(String parameterName, NClob value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterName, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(String parameterName, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterName, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterName, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNString(String parameterName, String value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNString(parameterName, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setRowId(String parameterName, RowId x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setRowId(parameterName, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setSQLXML(parameterName, xmlObject);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setAsciiStream(parameterIndex, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setAsciiStream(parameterIndex, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBinaryStream(parameterIndex, x) ;
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBinaryStream(parameterIndex, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBlob(parameterIndex, inputStream);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setBlob(parameterIndex, inputStream, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setCharacterStream(parameterIndex, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .getCharacterStream(parameterIndex);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(int parameterIndex, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setClob(parameterIndex, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setClob(parameterIndex, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNCharacterStream(parameterIndex, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// }
+-//
+-// public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNCharacterStream(parameterIndex, value, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, NClob value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterIndex, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterIndex, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNClob(parameterIndex, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNString(int parameterIndex, String value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setNString(parameterIndex, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setRowId(int parameterIndex, RowId x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setRowId(parameterIndex, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((CallableStatement) this.wrappedStmt)
+-// .setSQLXML(parameterIndex, xmlObject);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// }
+-//
+-// public boolean isClosed() throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// .isClosed();
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return true;
+-// }
+-//
+-// public boolean isPoolable() throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((CallableStatement) this.wrappedStmt)
+-// . isPoolable();
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return false;
+-// }
+-//
++
++ public Reader getCharacterStream(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getCharacterStream(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public Reader getCharacterStream(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getCharacterStream(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public Reader getNCharacterStream(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getCharacterStream(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public Reader getNCharacterStream(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getNCharacterStream(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public NClob getNClob(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getNClob(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public NClob getNClob(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getNClob(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public String getNString(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getNString(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public String getNString(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getNString(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public RowId getRowId(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getRowId(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public RowId getRowId(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getRowId(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public SQLXML getSQLXML(int parameterIndex) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getSQLXML(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public SQLXML getSQLXML(String parameterName) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .getSQLXML(parameterName);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return null;
++ }
++
++ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setAsciiStream(parameterName, x) ;
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setAsciiStream(parameterName, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBinaryStream(parameterName, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBinaryStream(parameterName, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(String parameterName, Blob x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBlob(parameterName, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBlob(parameterName, inputStream);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBlob(parameterName, inputStream, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setCharacterStream(parameterName, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setCharacterStream(parameterName, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(String parameterName, Clob x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setClob(parameterName, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(String parameterName, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setClob(parameterName, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setClob(parameterName, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNCharacterStream(parameterName, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNCharacterStream(parameterName, value, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(String parameterName, NClob value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterName, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(String parameterName, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterName, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterName, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNString(String parameterName, String value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNString(parameterName, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setRowId(String parameterName, RowId x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setRowId(parameterName, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setSQLXML(parameterName, xmlObject);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setAsciiStream(parameterIndex, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setAsciiStream(parameterIndex, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBinaryStream(parameterIndex, x) ;
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBinaryStream(parameterIndex, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBlob(parameterIndex, inputStream);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setBlob(parameterIndex, inputStream, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setCharacterStream(parameterIndex, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .getCharacterStream(parameterIndex);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(int parameterIndex, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setClob(parameterIndex, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setClob(parameterIndex, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNCharacterStream(parameterIndex, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ }
++
++ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNCharacterStream(parameterIndex, value, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, NClob value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterIndex, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterIndex, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNClob(parameterIndex, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNString(int parameterIndex, String value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setNString(parameterIndex, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setRowId(int parameterIndex, RowId x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setRowId(parameterIndex, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((CallableStatement) this.wrappedStmt)
++ .setSQLXML(parameterIndex, xmlObject);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ }
++
++ public boolean isClosed() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ .isClosed();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return true;
++ }
++
++ public boolean isPoolable() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((CallableStatement) this.wrappedStmt)
++ . isPoolable();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return false;
++ }
++
+ // public void setPoolable(boolean poolable) throws SQLException {
+ // try {
+ // if (this.wrappedStmt != null) {
+--- src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java 2009-11-29 01:26:55.000000000 +0100
+@@ -25,10 +25,18 @@
+ package com.mysql.jdbc.jdbc2.optional;
+
+ import java.lang.reflect.Constructor;
++import java.sql.Array;
++import java.sql.Blob;
++import java.sql.Clob;
++import java.sql.NClob;
++import java.sql.SQLClientInfoException;
+ import java.sql.SQLException;
++import java.sql.SQLXML;
+ import java.sql.Savepoint;
+ import java.sql.Statement;
++import java.sql.Struct;
+ import java.util.Map;
++import java.util.Properties;
+ import java.util.TimeZone;
+
+ import com.mysql.jdbc.Connection;
+@@ -2619,4 +2627,58 @@
+ boolean queryTimeoutKillsConnection) {
+ this.mc.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
+ }
++
++ public boolean isValid(int timeout) throws SQLException {
++ return this.isValid(timeout);
++ }
++
++ public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
++ return this.mc.createArrayOf(typeName, elements);
++ }
++
++ public Blob createBlob() throws SQLException {
++ return this.mc.createBlob();
++ }
++
++ public Clob createClob() throws SQLException {
++ return this.mc.createClob();
++ }
++
++ public NClob createNClob() throws SQLException {
++ return this.mc.createNClob();
++ }
++
++ public SQLXML createSQLXML() throws SQLException {
++ return this.mc.createSQLXML();
++ }
++
++ public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
++ return this.mc.createStruct(typeName, attributes);
++ }
++
++ public Properties getClientInfo() throws SQLException {
++ return this.mc.getClientInfo();
++ }
++
++ public String getClientInfo(String name) throws SQLException {
++ return this.mc.getClientInfo(name);
++ }
++
++ public void setClientInfo(Properties properties)
++ throws SQLClientInfoException {
++ this.mc.setClientInfo(properties);
++ }
++
++ public void setClientInfo(String name, String value)
++ throws SQLClientInfoException {
++ this.mc.setClientInfo(name, value);
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java 2009-11-29 01:15:15.000000000 +0100
+@@ -38,6 +38,7 @@
+
+ import com.mysql.jdbc.ConnectionPropertiesImpl;
+ import com.mysql.jdbc.NonRegisteringDriver;
++import com.mysql.jdbc.SQLError;
+
+ /**
+ * A JNDI DataSource for a Mysql JDBC connection
+@@ -438,12 +439,12 @@
+
+ return mysqlDriver.connect(jdbcUrlToUse, props);
+ }
+-//
+-// public boolean isWrapperFor(Class<?> iface) throws SQLException {
+-// throw SQLError.notImplemented();
+-// }
+-//
+-// public <T> T unwrap(Class<T> iface) throws SQLException {
+-// throw SQLError.notImplemented();
+-// }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java 2009-11-29 01:20:09.000000000 +0100
+@@ -33,6 +33,7 @@
+ import javax.sql.ConnectionEvent;
+ import javax.sql.ConnectionEventListener;
+ import javax.sql.PooledConnection;
++import javax.sql.StatementEventListener;
+
+ import com.mysql.jdbc.ConnectionImpl;
+ import com.mysql.jdbc.ExceptionInterceptor;
+@@ -255,4 +256,10 @@
+ protected ExceptionInterceptor getExceptionInterceptor() {
+ return this.exceptionInterceptor;
+ }
++
++ public void addStatementEventListener(StatementEventListener listener) {
++ }
++
++ public void removeStatementEventListener(StatementEventListener listener) {
++ }
+ }
+\ No newline at end of file
+--- src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java.orig 2009-11-28 21:35:25.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java 2009-11-29 01:24:42.000000000 +0100
+@@ -33,12 +33,15 @@
+ import java.sql.Blob;
+ import java.sql.Clob;
+ import java.sql.Date;
++import java.sql.NClob;
+ import java.sql.ParameterMetaData;
+ import java.sql.PreparedStatement;
+ import java.sql.Ref;
+ import java.sql.ResultSet;
+ import java.sql.ResultSetMetaData;
++import java.sql.RowId;
+ import java.sql.SQLException;
++import java.sql.SQLXML;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+ import java.util.Calendar;
+@@ -885,323 +888,323 @@
+
+ // that out
+ }
+-//
+-// public void setAsciiStream(int parameterIndex, InputStream x)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setAsciiStream(
+-// parameterIndex, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setAsciiStream(int parameterIndex, InputStream x, long length)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setAsciiStream(
+-// parameterIndex, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(int parameterIndex, InputStream x)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setBinaryStream(
+-// parameterIndex, x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBinaryStream(int parameterIndex, InputStream x, long length)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setBinaryStream(
+-// parameterIndex, x, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(int parameterIndex, InputStream inputStream)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
+-// inputStream);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setBlob(int parameterIndex, InputStream inputStream, long length)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
+-// inputStream, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(int parameterIndex, Reader reader)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setCharacterStream(
+-// parameterIndex, reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setCharacterStream(int parameterIndex, Reader reader,
+-// long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setCharacterStream(
+-// parameterIndex, reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(int parameterIndex, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
+-// reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setClob(int parameterIndex, Reader reader, long length)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
+-// reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNCharacterStream(int parameterIndex, Reader value)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
+-// parameterIndex, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNCharacterStream(int parameterIndex, Reader value,
+-// long length) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
+-// parameterIndex, value, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, NClob value) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
+-// value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
+-// reader);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNClob(int parameterIndex, Reader reader, long length)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
+-// reader, length);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setNString(int parameterIndex, String value)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setNString(
+-// parameterIndex, value);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setRowId(int parameterIndex, RowId x) throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
+-// x);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public void setSQLXML(int parameterIndex, SQLXML xmlObject)
+-// throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// ((PreparedStatement) this.wrappedStmt).setSQLXML(
+-// parameterIndex, xmlObject);
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-// }
+-//
+-// public boolean isClosed() throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((PreparedStatement) this.wrappedStmt).isClosed();
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return true;
+-// }
+-//
+-// public boolean isPoolable() throws SQLException {
+-// try {
+-// if (this.wrappedStmt != null) {
+-// return ((PreparedStatement) this.wrappedStmt).isPoolable();
+-// } else {
+-// throw SQLError.createSQLException(
+-// "No operations allowed after statement closed",
+-// SQLError.SQL_STATE_GENERAL_ERROR);
+-// }
+-// } catch (SQLException sqlEx) {
+-// checkAndFireConnectionError(sqlEx);
+-// }
+-//
+-// return false;
+-// }
+-//
++
++ public void setAsciiStream(int parameterIndex, InputStream x)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setAsciiStream(
++ parameterIndex, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setAsciiStream(int parameterIndex, InputStream x, long length)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setAsciiStream(
++ parameterIndex, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(int parameterIndex, InputStream x)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setBinaryStream(
++ parameterIndex, x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBinaryStream(int parameterIndex, InputStream x, long length)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setBinaryStream(
++ parameterIndex, x, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(int parameterIndex, InputStream inputStream)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
++ inputStream);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setBlob(int parameterIndex, InputStream inputStream, long length)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
++ inputStream, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(int parameterIndex, Reader reader)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setCharacterStream(
++ parameterIndex, reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setCharacterStream(int parameterIndex, Reader reader,
++ long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setCharacterStream(
++ parameterIndex, reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(int parameterIndex, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
++ reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setClob(int parameterIndex, Reader reader, long length)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
++ reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNCharacterStream(int parameterIndex, Reader value)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
++ parameterIndex, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNCharacterStream(int parameterIndex, Reader value,
++ long length) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
++ parameterIndex, value, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, NClob value) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
++ value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
++ reader);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNClob(int parameterIndex, Reader reader, long length)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
++ reader, length);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setNString(int parameterIndex, String value)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setNString(
++ parameterIndex, value);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setRowId(int parameterIndex, RowId x) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
++ x);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public void setSQLXML(int parameterIndex, SQLXML xmlObject)
++ throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ ((PreparedStatement) this.wrappedStmt).setSQLXML(
++ parameterIndex, xmlObject);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public boolean isClosed() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((PreparedStatement) this.wrappedStmt).isClosed();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return true;
++ }
++
++ public boolean isPoolable() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return ((PreparedStatement) this.wrappedStmt).isPoolable();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return false;
++ }
++
+ // public void setPoolable(boolean poolable) throws SQLException {
+ // try {
+ // if (this.wrappedStmt != null) {
+--- src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java 2009-11-29 01:26:15.000000000 +0100
+@@ -864,4 +864,58 @@
+ checkAndFireConnectionError(sqlEx);
+ }
+ }
++
++ public boolean isPoolable() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return this.wrappedStmt.isPoolable();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return false;
++ }
++
++ public void setPoolable(boolean poolable) throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ this.wrappedStmt.setPoolable(poolable);
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++ }
++
++ public boolean isClosed() throws SQLException {
++ try {
++ if (this.wrappedStmt != null) {
++ return this.wrappedStmt.isClosed();
++ } else {
++ throw SQLError.createSQLException(
++ "No operations allowed after statement closed",
++ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
++ }
++ } catch (SQLException sqlEx) {
++ checkAndFireConnectionError(sqlEx);
++ }
++
++ return true;
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/PreparedStatement.java.orig 2009-11-28 21:58:03.000000000 +0100
++++ src/com/mysql/jdbc/PreparedStatement.java 2009-11-28 23:30:09.000000000 +0100
+@@ -44,10 +44,13 @@
+ import java.sql.Clob;
+ import java.sql.DatabaseMetaData;
+ import java.sql.Date;
++import java.sql.NClob;
+ import java.sql.ParameterMetaData;
+ import java.sql.Ref;
+ import java.sql.ResultSet;
++import java.sql.RowId;
+ import java.sql.SQLException;
++import java.sql.SQLXML;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+ import java.sql.Types;
+@@ -5595,4 +5598,19 @@
+ statementStartPos, sql, "SELECT", "\"'`",
+ "\"'`", false) == -1 && rewritableOdku;
+ }
++
++ public void setSQLXML(int parameterIndex, SQLXML xmlObject)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setNClob(int parameterIndex, NClob value)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void setRowId(int parameterIndex, RowId x)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
+--- src/com/mysql/jdbc/ReplicationConnection.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/ReplicationConnection.java 2009-11-29 00:59:02.000000000 +0100
+@@ -21,13 +21,20 @@
+ */
+ package com.mysql.jdbc;
+
++import java.sql.Array;
++import java.sql.Blob;
+ import java.sql.CallableStatement;
++import java.sql.Clob;
+ import java.sql.DatabaseMetaData;
++import java.sql.NClob;
+ import java.sql.PreparedStatement;
++import java.sql.SQLClientInfoException;
+ import java.sql.SQLException;
+ import java.sql.SQLWarning;
++import java.sql.SQLXML;
+ import java.sql.Savepoint;
+ import java.sql.Statement;
++import java.sql.Struct;
+ import java.util.Map;
+ import java.util.Properties;
+ import java.util.TimeZone;
+@@ -2412,4 +2419,60 @@
+ boolean queryTimeoutKillsConnection) {
+ this.currentConnection.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
+ }
++
++ public boolean isValid(int timeout) throws SQLException {
++ return this.currentConnection.isValid(timeout);
++ }
++
++ public Properties getClientInfo() throws SQLException {
++ return this.currentConnection.getClientInfo();
++ }
++
++ public String getClientInfo(String name) throws SQLException {
++ return this.currentConnection.getClientInfo(name);
++ }
++
++ public void setClientInfo(Properties properties)
++ throws SQLClientInfoException {
++ this.currentConnection.setClientInfo(properties);
++ }
++
++ public void setClientInfo(String name, String value)
++ throws SQLClientInfoException {
++ this.currentConnection.setClientInfo(name, value);
++ }
++
++ public Array createArrayOf(String typeName, Object[] elements)
++ throws SQLException {
++ return this.currentConnection.createArrayOf(typeName, elements);
++ }
++
++ public Blob createBlob() throws SQLException {
++ return this.currentConnection.createBlob();
++ }
++
++ public Clob createClob() throws SQLException {
++ return this.currentConnection.createClob();
++ }
++
++ public NClob createNClob() throws SQLException {
++ return this.currentConnection.createNClob();
++ }
++
++ public SQLXML createSQLXML() throws SQLException {
++ return this.currentConnection.createSQLXML();
++ }
++
++ public Struct createStruct(String typeName, Object[] attributes)
++ throws SQLException {
++ return this.currentConnection.createStruct(typeName, attributes);
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ return this.currentConnection.isWrapperFor(iface);
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ return this.currentConnection.unwrap(iface);
++ }
+ }
+--- src/com/mysql/jdbc/ResultSetImpl.java.orig 2009-11-28 18:58:49.000000000 +0100
++++ src/com/mysql/jdbc/ResultSetImpl.java 2009-11-29 01:21:22.000000000 +0100
+@@ -25,6 +25,7 @@
+ package com.mysql.jdbc;
+
+ import java.io.ByteArrayInputStream;
++import java.io.Reader;
+ import java.io.IOException;
+ import java.io.InputStream;
+ import java.io.ObjectInputStream;
+@@ -36,10 +37,14 @@
+ import java.net.MalformedURLException;
+ import java.net.URL;
+ import java.sql.Array;
++import java.sql.Clob;
+ import java.sql.Date;
++import java.sql.NClob;
+ import java.sql.Ref;
++import java.sql.RowId;
+ import java.sql.SQLException;
+ import java.sql.SQLWarning;
++import java.sql.SQLXML;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+ import java.sql.Types;
+@@ -8779,4 +8784,244 @@
+ protected ExceptionInterceptor getExceptionInterceptor() {
+ return this.exceptionInterceptor;
+ }
++
++ public boolean isClosed() throws SQLException {
++ return this.isClosed;
++ }
++
++ public int getHoldability() throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public void updateAsciiStream(int columnIndex, InputStream inputStream)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateAsciiStream(String columnLabel, InputStream inputStream)
++ throws SQLException {
++ updateAsciiStream(findColumn(columnLabel), inputStream);
++ }
++
++ public void updateAsciiStream(int columnIndex, InputStream inputStream,
++ long length) throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateAsciiStream(String columnLabel, InputStream inputStream,
++ long length) throws SQLException {
++ updateAsciiStream(findColumn(columnLabel), inputStream, length);
++ }
++
++ public void updateBinaryStream(int columnIndex, InputStream inputStream)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateBinaryStream(String columnLabel,
++ InputStream inputStream) throws SQLException {
++ updateBinaryStream(findColumn(columnLabel), inputStream);
++ }
++
++ public void updateBinaryStream(int columnIndex, InputStream inputStream,
++ long length) throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateBinaryStream(String columnLabel, InputStream inputStream,
++ long length) throws SQLException {
++ updateBinaryStream(findColumn(columnLabel), inputStream, length);
++ }
++
++ public void updateBlob(int columnIndex, InputStream inputStream)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateBlob(String columnLabel, InputStream inputStream)
++ throws SQLException {
++ updateBlob(findColumn(columnLabel), inputStream);
++ }
++
++ public void updateBlob(int columnIndex, InputStream inputStream,
++ long length) throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateBlob(String columnLabel, InputStream inputStream,
++ long length) throws SQLException {
++ updateBlob(findColumn(columnLabel), inputStream, length);
++ }
++
++ public void updateCharacterStream(int columnIndex, Reader reader)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateCharacterStream(String columnLabel, Reader reader)
++ throws SQLException {
++ updateCharacterStream(findColumn(columnLabel), reader);
++ }
++
++ public void updateCharacterStream(int columnIndex, Reader reader,
++ long length) throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateCharacterStream(String columnLabel, Reader reader,
++ long length) throws SQLException {
++ updateCharacterStream(findColumn(columnLabel), reader, length);
++ }
++
++ public void updateClob(int columnIndex, Reader reader)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateClob(String columnLabel, Reader reader)
++ throws SQLException {
++ updateClob(findColumn(columnLabel), reader);
++ }
++
++ public void updateClob(int columnIndex, Reader reader, long length)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateClob(String columnLabel, Reader reader, long length)
++ throws SQLException {
++ updateClob(findColumn(columnLabel), reader, length);
++ }
++
++ public Reader getNCharacterStream(int columnIndex)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public Reader getNCharacterStream(String columnLabel)
++ throws SQLException {
++ return getNCharacterStream(findColumn(columnLabel));
++ }
++
++ public void updateNCharacterStream(int columnIndex, Reader reader)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNCharacterStream(String columnLabel, Reader reader)
++ throws SQLException {
++ updateNCharacterStream(findColumn(columnLabel), reader);
++ }
++
++ public void updateNCharacterStream(int columnIndex, Reader reader,
++ long length) throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNCharacterStream(String columnLabel, Reader reader,
++ long length) throws SQLException {
++ updateNCharacterStream(findColumn(columnLabel), reader, length);
++ }
++
++ public NClob getNClob(int columnIndex)
++ throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public NClob getNClob(String columnLabel)
++ throws SQLException {
++ return getNClob(findColumn(columnLabel));
++ }
++
++ public void updateNClob(int columnIndex, NClob value)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNClob(String columnLabel, NClob value)
++ throws SQLException {
++ updateNClob(findColumn(columnLabel), value);
++ }
++
++ public void updateNClob(int columnIndex, Reader reader)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNClob(String columnLabel, Reader reader)
++ throws SQLException {
++ updateNClob(findColumn(columnLabel), reader);
++ }
++
++ public void updateNClob(int columnIndex, Reader reader, long length)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNClob(String columnLabel, Reader reader, long length)
++ throws SQLException {
++ updateNClob(findColumn(columnLabel), reader, length);
++ }
++
++ public String getNString(int columnIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public String getNString(String columnLabel) throws SQLException {
++ return getNString(findColumn(columnLabel));
++ }
++
++ public void updateNString(int columnIndex, String value)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateNString(String columnLabel, String value)
++ throws SQLException {
++ updateNString(findColumn(columnLabel), value);
++ }
++
++ public SQLXML getSQLXML(int columnIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public SQLXML getSQLXML(String columnLabel) throws SQLException {
++ return getSQLXML(findColumn(columnLabel));
++ }
++
++ public void updateSQLXML(int columnIndex, SQLXML xmlObject)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateSQLXML(String columnLabel, SQLXML xmlObject)
++ throws SQLException {
++ updateSQLXML(findColumn(columnLabel), xmlObject);
++ }
++
++ public RowId getRowId(int columnIndex) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public RowId getRowId(String columnLabel) throws SQLException {
++ return getRowId(findColumn(columnLabel));
++ }
++
++ public void updateRowId(int columnIndex, RowId x)
++ throws SQLException {
++ throw new NotUpdatable();
++ }
++
++ public void updateRowId(String columnLabel, RowId x)
++ throws SQLException {
++ updateRowId(findColumn(columnLabel), x);
++ }
++
++ public boolean isWrapperFor(Class<?> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
++
++ public <T> T unwrap(Class<T> iface) throws SQLException {
++ throw SQLError.notImplemented();
++ }
+ }
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.macosforge.org/pipermail/macports-changes/attachments/20091202/06475afc/attachment-0001.html>
More information about the macports-changes
mailing list