Index: files/patch-JDK-1.6.diff
===================================================================
--- files/patch-JDK-1.6.diff	(révision 0)
+++ files/patch-JDK-1.6.diff	(révision 0)
@@ -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();
++	}
+ }
Index: Portfile
===================================================================
--- Portfile	(révision 52433)
+++ Portfile	(copie de travail)
@@ -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.check regex
 livecheck.url   http://dev.mysql.com/downloads/connector/j/5.0.html
 livecheck.regex "${name}-(\\d+\\.\\d+(\\.\\d+)?).tar.gz"
