diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/CachedCallableStatement.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/CachedCallableStatement.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/CachedCallableStatement.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/CachedCallableStatement.java	2007-06-22 10:26:08.000000000 -0400
@@ -36,6 +36,9 @@
 import java.sql.Timestamp;
 import java.util.Calendar;
 import java.util.Map;
+import java.sql.NClob;
+import java.sql.RowId;
+import java.sql.SQLXML;
 
 /**
  * A cache wrapper for java.sql.CallableStatement
@@ -450,4 +453,215 @@
       cs.setTimestamp(parameterName, x, cal);
    }
 
+   public void setNClob(String parameterIndex, NClob value) throws SQLException
+   {
+     cs.setNClob(parameterIndex, value);
+   }
+
+   public void setNClob(String parameterIndex, Reader reader) throws SQLException
+   {
+     cs.setNClob(parameterIndex, reader);
+   }
+
+   public void setNClob(String parameterIndex, Reader reader, long l)
+                                                        throws SQLException
+   {
+     cs.setNClob(parameterIndex, reader, l);
+   }
+
+   public void setBlob(String parameterIndex, java.io.InputStream inputStream,
+                                          long length) throws SQLException
+   {
+     cs.setBlob(parameterIndex, inputStream, length);
+   }
+
+   public void setBlob(String parameterIndex, java.io.InputStream inputStream)
+                                                        throws SQLException
+   {
+     cs.setBlob(parameterIndex, inputStream);
+   }
+
+   public void setBlob(String parameterIndex, Blob b) throws SQLException
+   {
+     cs.setBlob(parameterIndex, b);
+   }
+
+   public void setClob(String i, Reader reader) throws SQLException
+   {
+     cs.setClob(i, reader);
+   }
+
+   public void setNCharacterStream(String parameterIndex, Reader value,
+                                                       long length)
+                                                       throws SQLException
+   {
+     cs.setNCharacterStream(parameterIndex, value, length);
+   }
+  
+   public void setNCharacterStream(String parameterIndex, Reader value)
+                                                         throws SQLException
+   {
+     cs.setNCharacterStream(parameterIndex, value);
+   }
+
+   public void setNString(String parameterIndex, String value)
+                                                        throws SQLException
+   {
+     cs.setNString(parameterIndex, value);
+   }
+
+   public void setCharacterStream(String parameterIndex,
+                                  java.io.Reader reader) throws SQLException
+   {
+      cs.setCharacterStream(parameterIndex, reader);
+   }
+
+   public void setBinaryStream(String i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      cs.setBinaryStream(i, input);
+   }
+
+   public void setAsciiStream(String i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      cs.setAsciiStream(i, input);
+   }
+
+   public void setCharacterStream(String i, Reader reader, long l)
+                                                throws SQLException
+   {
+      cs.setCharacterStream(i, reader, l);
+   }
+
+   public void setBinaryStream(String i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      cs.setBinaryStream(i, input, l);
+   }
+
+   public void setAsciiStream(String i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      cs.setAsciiStream(i, input, l);
+   }
+
+   public void setSQLXML(String i,java.sql.SQLXML x) throws SQLException
+   {
+      cs.setSQLXML(i, x);
+   }   
+
+   public void setClob(String i, Reader reader, long l) throws SQLException
+   {
+      cs.setClob(i, reader, l);
+   }
+
+   public void setClob(String i, Clob l) throws SQLException
+   {
+      cs.setClob(i, l);
+   }
+
+   public boolean isClosed()
+                 throws SQLException
+   {
+      return cs.isClosed();
+   }
+
+   public void setPoolable(boolean p) throws SQLException
+   {
+      cs.setPoolable(p);
+   }
+
+   public boolean isPoolable() throws SQLException
+   {
+      return cs.isPoolable();
+   }
+
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      return cs.isWrapperFor(iface);
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                         throws SQLException
+   {
+      return cs.unwrap(iface);
+   }
+
+   public Reader getCharacterStream(String parameterName)
+          		                throws SQLException 
+   {
+      return cs.getCharacterStream(parameterName);
+   }
+
+   public Reader getCharacterStream(int parameterName)
+                                        throws SQLException
+   {
+      return cs.getCharacterStream(parameterName);
+   }
+
+   public Reader getNCharacterStream(String parameterName)
+                                        throws SQLException
+   {
+      return cs.getNCharacterStream(parameterName);
+   }
+
+   public Reader getNCharacterStream(int parameterName)
+                                        throws SQLException
+   {
+      return cs.getNCharacterStream(parameterName);
+   }
+
+   public String getNString(String parameterName)
+                                        throws SQLException
+   {
+      return cs.getNString(parameterName);
+   }
+
+   public String getNString(int parameterName)
+                                        throws SQLException
+   {
+      return cs.getNString(parameterName);
+   }
+
+   public SQLXML getSQLXML(int parameterIndex)
+		                 throws SQLException   
+   {
+      return cs.getSQLXML(parameterIndex);
+   }
+
+   public SQLXML getSQLXML(String parameterIndex)
+                                 throws SQLException
+   {
+      return cs.getSQLXML(parameterIndex);
+   }
+
+   public NClob getNClob(int parameterIndex)
+		               throws SQLException
+   {
+      return cs.getNClob(parameterIndex);
+   }
+
+   public NClob getNClob(String parameterIndex)
+                               throws SQLException
+   {
+      return cs.getNClob(parameterIndex);
+   }
+ 
+   public void setRowId(String parameterName, RowId x)
+			              throws SQLException
+   {
+      cs.setRowId(parameterName, x);
+   }
+
+   public RowId getRowId(String par) throws SQLException
+   {
+      return cs.getRowId(par);
+   }   
+
+   public RowId getRowId(int par) throws SQLException
+   {
+      return cs.getRowId(par);
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/CachedPreparedStatement.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/CachedPreparedStatement.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/CachedPreparedStatement.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/CachedPreparedStatement.java	2007-06-22 10:09:08.000000000 -0400
@@ -32,8 +32,12 @@
 import java.sql.ParameterMetaData;
 import java.sql.SQLWarning;
 import java.sql.Connection;
+import java.sql.NClob;
+import java.io.Reader;
 import java.math.BigDecimal;
 import java.util.Calendar;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.RowId;
 
 import EDU.oswego.cs.dl.util.concurrent.SynchronizedBoolean;
 import EDU.oswego.cs.dl.util.concurrent.SynchronizedInt;
@@ -527,4 +531,135 @@
    {
       return ps.getResultSetHoldability();
    }
+
+   public void setNClob(int parameterIndex, NClob value) throws SQLException
+   {
+     ps.setNClob(parameterIndex, value);
+   }
+
+   public void setNClob(int parameterIndex, Reader reader) throws SQLException
+   {
+     ps.setNClob(parameterIndex, reader);
+   }
+
+   public void setNClob(int parameterIndex, Reader reader, long l) 
+							throws SQLException
+   {
+     ps.setNClob(parameterIndex, reader, l);
+   }
+
+   public void setBlob(int parameterIndex, java.io.InputStream inputStream,
+				          long length) throws SQLException
+   {
+     ps.setBlob(parameterIndex, inputStream, length);
+   }
+
+   public void setBlob(int parameterIndex, java.io.InputStream inputStream)
+						        throws SQLException
+   {
+     ps.setBlob(parameterIndex, inputStream);
+   }
+
+   public void setClob(int i, Reader reader) throws SQLException
+   {
+     ps.setClob(i, reader);
+   }
+
+   public void setNCharacterStream(int parameterIndex, Reader value,
+						       long length)
+				                       throws SQLException
+   {
+     ps.setNCharacterStream(parameterIndex, value, length);
+   }
+
+   public void setNCharacterStream(int parameterIndex, Reader value)
+ 				                         throws SQLException
+   {
+     ps.setNCharacterStream(parameterIndex, value);
+   }
+  
+   public void setNString(int parameterIndex, String value)
+					                throws SQLException
+   {
+     ps.setNString(parameterIndex, value);
+   }
+
+   public void setCharacterStream(int parameterIndex,
+                                  java.io.Reader reader) throws SQLException
+   {
+      ps.setCharacterStream(parameterIndex, reader);
+   }
+
+   public void setBinaryStream(int i, java.io.InputStream input) 
+						throws SQLException
+   {
+      ps.setBinaryStream(i, input);
+   }   
+
+   public void setAsciiStream(int i, java.io.InputStream input)
+						throws SQLException
+   {
+      ps.setAsciiStream(i, input);
+   }
+
+   public void setCharacterStream(int i, Reader reader, long l)
+						throws SQLException
+   {
+      ps.setCharacterStream(i, reader, l);
+   }
+
+   public void setBinaryStream(int i, java.io.InputStream input, long l)
+						throws SQLException
+   {
+      ps.setBinaryStream(i, input, l);
+   }
+
+   public void setAsciiStream(int i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      ps.setAsciiStream(i, input, l);
+   }
+
+   public void setSQLXML(int i,java.sql.SQLXML x) throws SQLException
+   {
+      ps.setSQLXML(i, x);
+   }
+
+   public void setClob(int i, Reader reader, long l) throws SQLException
+   {
+     ps.setClob(i, reader, l);
+   }
+
+   public void setRowId(int i, RowId r) throws SQLException
+   {
+      ps.setRowId(i, r);
+   }
+
+   public boolean isClosed()
+                 throws SQLException
+   {
+      return ps.isClosed();
+   }
+
+   public void setPoolable(boolean p) throws SQLException
+   {
+      ps.setPoolable(p);
+   }
+
+   public boolean isPoolable() throws SQLException
+   {
+      return ps.isPoolable();
+   }
+
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      return ps.isWrapperFor(iface);
+   }
+
+   public <T> T unwrap(Class<T> iface)
+		         throws SQLException
+   {
+      return ps.unwrap(iface);
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableParameterMetaData.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableParameterMetaData.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableParameterMetaData.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableParameterMetaData.java	2007-06-22 11:06:34.000000000 -0400
@@ -171,6 +171,20 @@
    {
       return null;
    }
+
+   public boolean isWrapperFor(Class<?> iface)
+   		                  throws SQLException
+   {
+      // TODO: implement this
+      return false;
+   }
+   
+   public <T> T unwrap(Class<T> iface)
+   		                   throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
 }
 
 
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableResultSetMetaData.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableResultSetMetaData.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableResultSetMetaData.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/remote/SerializableResultSetMetaData.java	2007-06-22 11:07:37.000000000 -0400
@@ -168,4 +168,18 @@
    {
       return columnData[column].className;
    }
+
+   public boolean isWrapperFor(Class<?> iface)
+	                     throws SQLException
+   {
+      // TODO: implement this
+      return false;
+   }
+   
+   public <T> T unwrap(Class<T> iface)
+                                 throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedCallableStatement.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedCallableStatement.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedCallableStatement.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedCallableStatement.java	2007-06-22 10:47:52.000000000 -0400
@@ -36,6 +36,9 @@
 import java.sql.Timestamp;
 import java.util.Calendar;
 import java.util.Map;
+import java.sql.NClob;
+import java.sql.RowId;
+import java.sql.SQLXML;
 
 /**
  * WrappedCallableStatement
@@ -1083,4 +1086,512 @@
          throw checkException(t);
       }
    }
+
+   public void setNClob(String parameterIndex, NClob value) throws SQLException
+   {
+     checkState();
+      try
+      {
+        cs.setNClob(parameterIndex, value);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setNClob(String parameterIndex, Reader reader) throws SQLException
+   {
+      checkState();
+      try
+      {   
+         cs.setNClob(parameterIndex, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setNClob(String parameterIndex, Reader reader, long l)
+                                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setNClob(parameterIndex, reader, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }   
+   }
+
+   public void setBlob(String parameterIndex, java.io.InputStream inputStream,
+                                          long length) throws SQLException
+   {
+     checkState();
+      try
+      {
+         cs.setBlob(parameterIndex, inputStream, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setBlob(String parameterIndex, java.io.InputStream inputStream)
+                                                        throws SQLException
+   {
+     checkState();
+      try
+      {
+         cs.setBlob(parameterIndex, inputStream);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setBlob(String parameterIndex, Blob b) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setBlob(parameterIndex, b);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setClob(String i, Reader reader) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setClob(i, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setNCharacterStream(String parameterIndex, Reader value,
+                                                       long length)
+                                                       throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setNCharacterStream(parameterIndex, value, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setNCharacterStream(String parameterIndex, Reader value)
+                                                         throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setNCharacterStream(parameterIndex, value);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setNString(String parameterIndex, String value)
+                                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setNString(parameterIndex, value);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setCharacterStream(String parameterIndex,
+                                  java.io.Reader reader) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setCharacterStream(parameterIndex, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setBinaryStream(String i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setBinaryStream(i, input);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setCharacterStream(String i, Reader reader, long l)
+                                                throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setCharacterStream(i, reader, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setBinaryStream(String i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setBinaryStream(i, input, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setAsciiStream(String i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setAsciiStream(i, input);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setAsciiStream(String i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setAsciiStream(i, input, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setSQLXML(String i,java.sql.SQLXML x) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setSQLXML(i, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setClob(String i, Reader reader, long l) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setClob(i, reader, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setClob(String i, Clob l) throws SQLException
+   {
+      checkState(); 
+      try
+      {
+         cs.setClob(i, l);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public boolean isClosed()
+                 throws SQLException
+   {
+      checkState(); 
+      try
+      {
+         return cs.isClosed();
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setPoolable(boolean p) throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setPoolable(p);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public boolean isPoolable() throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.isPoolable();
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.isWrapperFor(iface);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                         throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.unwrap(iface);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getCharacterStream(String parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getCharacterStream(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getCharacterStream(int parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getCharacterStream(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getNCharacterStream(String parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNCharacterStream(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getNCharacterStream(int parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNCharacterStream(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public String getNString(String parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNString(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public String getNString(int parameterName)
+                                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNString(parameterName);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public SQLXML getSQLXML(int parameterIndex)
+                                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getSQLXML(parameterIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public SQLXML getSQLXML(String parameterIndex)
+                                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getSQLXML(parameterIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public NClob getNClob(int parameterIndex)
+                               throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNClob(parameterIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public NClob getNClob(String parameterIndex)
+                               throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getNClob(parameterIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void setRowId(String parameterName, RowId x)
+                                      throws SQLException
+   {
+      checkState();
+      try
+      {
+         cs.setRowId(parameterName, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public RowId getRowId(String par) throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getRowId(par);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public RowId getRowId(int par) throws SQLException
+   {
+      checkState();
+      try
+      {
+         return cs.getRowId(par);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedConnection.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedConnection.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedConnection.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedConnection.java	2007-06-22 11:04:05.000000000 -0400
@@ -21,18 +21,11 @@
  */
 package org.jboss.resource.adapter.jdbc;
 
-import java.sql.CallableStatement;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.SQLWarning;
-import java.sql.Savepoint;
-import java.sql.Statement;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Properties;
+import java.sql.*;
 
 import org.jboss.logging.Logger;
 import org.jboss.util.NestedSQLException;
@@ -613,4 +606,86 @@
    {
       return log;
    }
+
+   public Clob createClob() throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public Blob createBlob() throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public NClob createNClob() throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public SQLXML createSQLXML() throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public boolean isValid(int timeout) throws SQLException
+   {
+      // TODO: implement this
+      return false;
+   }
+
+   public void setClientInfo(String name, String value)
+		                   throws SQLClientInfoException
+   {
+      // TODO: implement this
+   }
+
+   public void setClientInfo(Properties properties)
+          		         throws SQLClientInfoException
+   {
+      // TODO: implement this
+   }
+
+   public String getClientInfo(String name) throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public Properties getClientInfo() throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public Array createArrayOf(String typeName, Object[] elements)
+				                    throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+
+   public Struct createStruct(String typeName, Object[] attributes)
+				                    throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
+   
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      // TODO: implement this
+      return false;
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                         throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedPreparedStatement.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedPreparedStatement.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedPreparedStatement.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedPreparedStatement.java	2007-06-22 10:21:47.000000000 -0400
@@ -39,6 +39,8 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.Calendar;
+import java.sql.NClob;
+import java.sql.RowId;
 
 /**
  * A wrapper for a prepared statement.
@@ -560,4 +562,135 @@
          throw checkException(t);
       }
    }
+
+   public void setNClob(int parameterIndex, NClob value) throws SQLException
+   {
+     ps.setNClob(parameterIndex, value);
+   }
+
+   public void setNClob(int parameterIndex, Reader reader) throws SQLException
+   {
+     ps.setNClob(parameterIndex, reader);
+   }
+
+   public void setNClob(int parameterIndex, Reader reader, long l)
+                                                        throws SQLException
+   {
+     ps.setNClob(parameterIndex, reader, l);
+   }
+
+   public void setBlob(int parameterIndex, java.io.InputStream inputStream,
+                                          long length) throws SQLException
+   {
+     ps.setBlob(parameterIndex, inputStream, length);
+   }
+
+   public void setBlob(int parameterIndex, java.io.InputStream inputStream)
+                                                        throws SQLException
+   {
+     ps.setBlob(parameterIndex, inputStream);
+   }
+
+   public void setClob(int i, Reader reader) throws SQLException
+   {
+     ps.setClob(i, reader);
+   }
+
+   public void setNCharacterStream(int parameterIndex, Reader value,
+                                                       long length)
+                                                       throws SQLException
+   {
+     ps.setNCharacterStream(parameterIndex, value, length);
+   }
+
+   public void setNCharacterStream(int parameterIndex, Reader value)
+                                                         throws SQLException
+   {
+     ps.setNCharacterStream(parameterIndex, value);
+   }
+
+   public void setNString(int parameterIndex, String value)
+                                                        throws SQLException
+   {
+     ps.setNString(parameterIndex, value);
+   }
+
+   public void setCharacterStream(int parameterIndex,
+                                  java.io.Reader reader) throws SQLException
+   {
+      ps.setCharacterStream(parameterIndex, reader);
+   }
+
+   public void setBinaryStream(int i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      ps.setBinaryStream(i, input);
+   }
+
+   public void setAsciiStream(int i, java.io.InputStream input)
+                                                throws SQLException
+   {
+      ps.setAsciiStream(i, input);
+   }
+
+   public void setCharacterStream(int i, Reader reader, long l)
+                                                throws SQLException
+   {
+      ps.setCharacterStream(i, reader, l);
+   }
+
+   public void setBinaryStream(int i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      ps.setBinaryStream(i, input, l);
+   }
+
+   public void setAsciiStream(int i, java.io.InputStream input, long l)
+                                                throws SQLException
+   {
+      ps.setAsciiStream(i, input, l);
+   }
+
+   public void setSQLXML(int i,java.sql.SQLXML x) throws SQLException
+   {
+      ps.setSQLXML(i, x);
+   }
+
+   public void setClob(int i, Reader reader, long l) throws SQLException
+   {
+     ps.setClob(i, reader, l);
+   }
+
+   public void setRowId(int i, RowId r) throws SQLException
+   {
+      ps.setRowId(i, r);
+   }
+
+   public boolean isClosed()
+                 throws SQLException
+   {
+      return ps.isClosed();
+   }
+
+   public void setPoolable(boolean p) throws SQLException
+   {
+      ps.setPoolable(p);
+   }
+
+   public boolean isPoolable() throws SQLException
+   {
+      return ps.isPoolable();
+   }
+
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      return ps.isWrapperFor(iface);
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                         throws SQLException
+   {
+      return ps.unwrap(iface);
+   } 
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedResultSet.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedResultSet.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedResultSet.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedResultSet.java	2007-06-22 11:45:13.000000000 -0400
@@ -25,18 +25,7 @@
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
-import java.sql.Array;
-import java.sql.Blob;
-import java.sql.Clob;
-import java.sql.Date;
-import java.sql.Ref;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.sql.SQLWarning;
-import java.sql.Statement;
-import java.sql.Time;
-import java.sql.Timestamp;
+import java.sql.*;
 import java.util.Calendar;
 import java.util.Map;
 
@@ -1917,6 +1906,703 @@
       }
    }
 
+   public RowId getRowId(int columnIndex)
+          		     throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getRowId(columnIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public RowId getRowId(String columnLabel)
+          			     throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getRowId(columnLabel);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateRowId(int columnIndex, RowId x)
+			                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateRowId(columnIndex, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      } 
+   }
+
+   public void updateRowId(String columnLabel, RowId x)
+			                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateRowId(columnLabel, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public int getHoldability() throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getHoldability();
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public boolean isClosed() throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.isClosed();
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNString(int columnIndex, String nString)
+				                   throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNString(columnIndex, nString);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNString(String columnLabel, String nString)
+				                   throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNString(columnLabel, nString);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(int columnIndex, NClob nClob)
+			                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnIndex, nClob);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(String columnLabel, NClob nClob)
+				                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnLabel, nClob);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public NClob getNClob(int columnIndex) throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getNClob(columnIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public NClob getNClob(String columnLabel)
+		               throws SQLException
+   {    
+      checkState();
+      try
+      {
+         return resultSet.getNClob(columnLabel);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public SQLXML getSQLXML(int columnIndex)
+          		       throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getSQLXML(columnIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public SQLXML getSQLXML(String columnLabel)
+		                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getSQLXML(columnLabel);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateSQLXML(int columnIndex, SQLXML xmlObject)
+				                  throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateSQLXML(columnIndex, xmlObject);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateSQLXML(String columnLabel, SQLXML xmlObject)
+				                  throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateSQLXML(columnLabel, xmlObject);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public String getNString(int columnIndex)
+          		        throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getNString(columnIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public String getNString(String columnLabel)
+		                  throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.getNString(columnLabel);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getNCharacterStream(int columnIndex)
+          		                 throws SQLException
+   {
+      checkState();
+      try 
+      {
+         return resultSet.getNCharacterStream(columnIndex);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public Reader getNCharacterStream(String columnLabel)
+		                           throws SQLException
+   {
+      checkState();
+      try 
+      {
+         return resultSet.getNCharacterStream(columnLabel);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNCharacterStream(int columnIndex, Reader x,
+		                      long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateNCharacterStream(columnIndex, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNCharacterStream(String columnLabel, Reader reader,
+	                            long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateNCharacterStream(columnLabel, reader, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateAsciiStream(int columnIndex, InputStream x,
+	                       long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateAsciiStream(columnIndex, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBinaryStream(int columnIndex, InputStream x,
+		                        long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateBinaryStream(columnIndex, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateCharacterStream(int columnIndex, Reader x,
+	                           long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateCharacterStream(columnIndex, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateAsciiStream(String columnLabel, InputStream x,
+	  	                     long length) throws SQLException
+   {
+      checkState();
+      try 
+      {
+         resultSet.updateAsciiStream(columnLabel, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBinaryStream(String columnLabel, InputStream x,
+		                        long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBinaryStream(columnLabel, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateCharacterStream(String columnLabel, Reader x,
+		                           long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateCharacterStream(columnLabel, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+ 
+   public void updateBlob(int columnIndex, InputStream x,
+			                long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBlob(columnIndex, x, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBlob(String columnLabel, InputStream inputStream,
+			                long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBlob(columnLabel, inputStream, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   } 
+
+   public void updateClob(int columnIndex, Reader reader,
+		                long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateClob(columnIndex, reader, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateClob(String columnLabel, Reader reader,
+		                long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateClob(columnLabel, reader, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(int columnIndex, Reader reader,
+		                 long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnIndex, reader, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(String columnLabel, Reader reader,
+		                 long length) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnLabel, reader, length);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNCharacterStream(int columnIndex, Reader x)
+			                            throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNCharacterStream(columnIndex, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNCharacterStream(String columnLabel,
+	                            Reader reader) throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNCharacterStream(columnLabel, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateAsciiStream(int columnIndex, InputStream x)
+			                       throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateAsciiStream(columnIndex, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBinaryStream(int columnIndex, InputStream x)
+			                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBinaryStream(columnIndex, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateCharacterStream(int columnIndex, Reader x)
+			                           throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateCharacterStream(columnIndex, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateAsciiStream(String columnLabel, InputStream x)
+				                       throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateAsciiStream(columnLabel, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBinaryStream(String columnLabel, InputStream x)
+				                        throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBinaryStream(columnLabel, x);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateCharacterStream(String columnLabel, Reader reader)
+			                           throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateCharacterStream(columnLabel, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBlob(int columnIndex, InputStream inputStream)
+				                throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBlob(columnIndex, inputStream);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateBlob(String columnLabel, InputStream inputStream)
+				                throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateBlob(columnLabel, inputStream);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateClob(int columnIndex, Reader reader)
+			                throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateClob(columnIndex, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateClob(String columnLabel, Reader reader)
+				                throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateClob(columnLabel, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(int columnIndex, Reader reader)
+			                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnIndex, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public void updateNClob(String columnLabel, Reader reader)
+				                 throws SQLException
+   {
+      checkState();
+      try
+      {
+         resultSet.updateNClob(columnLabel, reader);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public <T> T unwrap(Class<T> iface)
+		         throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.unwrap(iface);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
+   public boolean isWrapperFor(Class<?> iface)
+            		         throws SQLException
+   {
+      checkState();
+      try
+      {
+         return resultSet.isWrapperFor(iface);
+      }
+      catch (Throwable t)
+      {
+         throw checkException(t);
+      }
+   }
+
    SQLException checkException(Throwable t) throws SQLException
    {
       throw statement.checkException(t);
@@ -1939,4 +2625,4 @@
             throw new SQLException("The result set is closed.");
       }
    }
-}
\ No newline at end of file
+}
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedStatement.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedStatement.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedStatement.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrappedStatement.java	2007-06-22 10:16:23.000000000 -0400
@@ -663,4 +663,30 @@
          resultSets.clear();
       }
    }
+
+   public boolean isPoolable() throws SQLException
+   {
+      return s.isPoolable();
+   }
+
+   public void setPoolable(boolean p) throws SQLException
+   {
+      s.setPoolable(p);
+   }
+
+   public boolean isClosed() throws SQLException
+   {
+      return s.isClosed();
+   }
+
+   public boolean isWrapperFor(Class<?> iface) throws SQLException
+   {
+      return s.isWrapperFor(iface);
+   }
+
+   public <T> T unwrap(Class<T> iface)
+		         throws SQLException
+   {
+      return s.unwrap(iface);
+   }
 }
diff -ru jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java
--- jboss-orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java	2006-09-26 08:01:23.000000000 -0400
+++ jboss/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java	2007-06-22 11:03:08.000000000 -0400
@@ -144,4 +144,17 @@
          throw new NestedSQLException(e);
       }
    }
+   public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+   {
+      // TODO: implement this
+      return false;
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                         throws SQLException
+   {
+      // TODO: implement this
+      return null;
+   }
 }
diff -ru jboss-orig/varia/src/main/org/jboss/varia/stats/DataSourceInterceptor.java jboss/varia/src/main/org/jboss/varia/stats/DataSourceInterceptor.java
--- jboss-orig/varia/src/main/org/jboss/varia/stats/DataSourceInterceptor.java	2006-09-26 08:29:11.000000000 -0400
+++ jboss/varia/src/main/org/jboss/varia/stats/DataSourceInterceptor.java	2007-06-22 14:53:36.000000000 -0400
@@ -46,10 +46,16 @@
 import java.sql.ResultSetMetaData;
 import java.sql.Time;
 import java.sql.Timestamp;
-
+import java.sql.NClob;
+import java.sql.SQLXML;
+import java.sql.Struct;
+import java.sql.Array;
+import java.sql.SQLException;
 import java.sql.Savepoint;
 import java.sql.ParameterMetaData;
 
+import java.util.Properties;
+import java.sql.SQLClientInfoException;
 import java.io.PrintWriter;
 import java.io.InputStream;
 import java.io.Reader;
@@ -93,6 +99,18 @@
       return statsCollector;
    }
 
+   public boolean isWrapperFor(Class<?> iface)
+                                throws SQLException
+   {
+      return target.isWrapperFor(iface);
+   }
+
+   public <T> T unwrap(Class<T> iface)
+                        throws SQLException
+   {
+      return target.unwrap(iface);
+   }
+
    /**
     * @jmx.managed-attribute
     */
@@ -198,12 +216,80 @@
          this.target = target;
       }
 
-      
+ 
       public int getHoldability() throws SQLException
       {
          return target.getHoldability();
       }
+
+      public Clob createClob() throws SQLException
+      {
+         return target.createClob();
+      }
+
+      public Blob createBlob() throws SQLException
+      {
+        return target.createBlob();
+      }
+
+      public NClob createNClob() throws SQLException
+      {
+        return target.createNClob();
+      }
+
+      public SQLXML createSQLXML() throws SQLException
+      {
+        return target.createSQLXML();
+      }
+
+      public boolean isValid(int timeout) throws SQLException
+      {
+        return target.isValid(timeout);
+      }
+
+      public void setClientInfo(String name, String value) 
+				throws SQLClientInfoException
+      {
+        target.setClientInfo(name, value);
+      }
       
+      public void setClientInfo(Properties properties) 
+				 throws SQLClientInfoException
+      {
+        target.setClientInfo(properties);
+      }
+
+      public String getClientInfo(String name) throws SQLException
+      {
+        return target.getClientInfo(name);
+      }
+
+      public Properties getClientInfo() throws SQLException
+      {
+        return target.getClientInfo();
+      }
+
+      public Array createArrayOf(String typeName, Object[] elements) 
+                                                      throws SQLException
+      {
+        return target.createArrayOf(typeName, elements);
+      }
+
+      public Struct createStruct(String typeName, Object[] attributes) 
+                                  							throws SQLException
+      {
+        return target.createStruct(typeName, attributes);
+      }
+
+      public boolean isWrapperFor(Class<?> iface) throws SQLException
+      {
+        return target.isWrapperFor(iface);
+      }
+
+      public <T> T unwrap(Class<T> iface) throws SQLException      
+      {
+        return target.unwrap(iface);
+      }
 
       public int getTransactionIsolation() throws SQLException
       {
@@ -433,11 +519,38 @@
          this.target = target;
       }
 
+      public <T> T unwrap(Class<T> iface)
+                           throws SQLException
+      {
+         return target.unwrap(iface);
+      }
+
+      public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+      {
+         return target.isWrapperFor(iface);
+      }
+
       public int getFetchDirection() throws SQLException
       {
          return target.getFetchDirection();
       }
 
+      public boolean isPoolable() throws SQLException
+      {
+         return target.isPoolable();
+      }
+
+      public void setPoolable(boolean p) throws SQLException
+      {
+         target.setPoolable(p);
+      }
+
+      public boolean isClosed() throws SQLException
+      {
+         return target.isClosed();
+      }
+
       public int getFetchSize() throws SQLException
       {
          return target.getFetchSize();
@@ -796,17 +909,48 @@
          target.setClob(i, x);
       }
 
+      public void setClob(int i, Reader x, long l) throws SQLException
+      {
+         target.setClob(i, x, l);
+      }
+
       public void setDate(int parameterIndex, Date x) throws SQLException
       {
          target.setDate(parameterIndex, x);
       }
 
+      public boolean isClosed()
+                 throws SQLException
+      {
+         return target.isClosed();
+      }
+
+      public void setPoolable(boolean p) throws SQLException
+      {
+         target.setPoolable(p);
+      }
+
+      public boolean isPoolable() throws SQLException
+      {
+         return target.isPoolable();
+      }
       
       public ParameterMetaData getParameterMetaData() throws SQLException
       {
          return target.getParameterMetaData();
       }
-      
+     
+      public <T> T unwrap(Class<T> iface)
+                      	   throws SQLException
+      {
+         return target.unwrap(iface);
+      }
+
+      public boolean isWrapperFor(Class<?> iface)
+                     throws SQLException
+      {
+         return target.isWrapperFor(iface);
+      } 
 
       public void setRef(int i, Ref x) throws SQLException
       {
@@ -847,6 +991,104 @@
       {
          target.setTimestamp(parameterIndex, x, cal);
       }
+
+      public void setNClob(int parameterIndex, NClob value) throws SQLException
+      {
+         target.setNClob(parameterIndex, value);
+      }
+
+      public void setNClob(int parameterIndex, Reader reader) throws SQLException
+      {
+         target.setNClob(parameterIndex, reader);
+      }
+
+      public void setNClob(int parameterIndex, Reader reader, long l)
+                                                        throws SQLException
+      {
+         target.setNClob(parameterIndex, reader, l);
+      }
+
+      public void setBlob(int parameterIndex, java.io.InputStream inputStream,
+                                          long length) throws SQLException
+      {
+         target.setBlob(parameterIndex, inputStream, length);
+      }
+
+      public void setBlob(int parameterIndex, java.io.InputStream inputStream)
+                                                        throws SQLException
+      {
+         target.setBlob(parameterIndex, inputStream);
+      }
+
+      public void setClob(int i, Reader reader) throws SQLException
+      {
+         target.setClob(i, reader);
+      }
+
+      public void setNCharacterStream(int parameterIndex, Reader value,
+                                                       long length)
+                                                       throws SQLException
+      {
+         target.setNCharacterStream(parameterIndex, value, length);
+      }
+
+      public void setNCharacterStream(int parameterIndex, Reader value)
+                                                         throws SQLException
+      {
+         target.setNCharacterStream(parameterIndex, value);
+      }
+
+      public void setNString(int parameterIndex, String value)
+                                                        throws SQLException
+      {
+         target.setNString(parameterIndex, value);
+      }
+
+      public void setCharacterStream(int parameterIndex,
+                                  java.io.Reader reader) throws SQLException
+      {
+         target.setCharacterStream(parameterIndex, reader);
+      }
+
+      public void setBinaryStream(int i, java.io.InputStream input)
+                                                throws SQLException
+      {
+         target.setBinaryStream(i, input);
+      }
+
+      public void setAsciiStream(int i, java.io.InputStream input)
+                                                throws SQLException
+      {
+         target.setAsciiStream(i, input);
+      }
+
+      public void setCharacterStream(int i, Reader reader, long l)
+                                                throws SQLException
+      {
+         target.setCharacterStream(i, reader, l);
+      }
+
+      public void setBinaryStream(int i, java.io.InputStream input, long l)
+                                                throws SQLException
+      {
+         target.setBinaryStream(i, input, l);
+      }
+
+      public void setAsciiStream(int i, java.io.InputStream input, long l)
+                                                throws SQLException
+      {
+         target.setAsciiStream(i, input, l);
+      }
+
+      public void setSQLXML(int i,java.sql.SQLXML x) throws SQLException
+      {
+         target.setSQLXML(i, x);
+      }
+
+      public void setRowId(int i, java.sql.RowId d) throws SQLException
+      {
+         target.setRowId(i, d);
+      }
    }
 
    // Private
