--- 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,9 +25,16 @@
 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;
@@ -2619,4 +2627,58 @@
 	public Properties getProperties() {
 		return this.mc.getProperties();
 	}
+
+	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();
+	}
 }
\ No newline at end of file
--- 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();
+	}
 }
