Ticket #21549: mysql-connector-java-JDK-1.6.diff

File mysql-connector-java-JDK-1.6.diff, 99.6 KB (added by nox@…, 15 years ago)

A patch to make it work on Snow Leopard

  • files/patch-JDK-1.6.diff

     
     1--- src/com/mysql/jdbc/CallableStatement.java.orig      2009-11-28 20:29:56.000000000 +0100
     2+++ src/com/mysql/jdbc/CallableStatement.java   2009-11-28 23:57:51.000000000 +0100
     3@@ -32,10 +32,13 @@
     4 import java.sql.Blob;
     5 import java.sql.Clob;
     6 import java.sql.Date;
     7+import java.sql.NClob;
     8 import java.sql.ParameterMetaData;
     9 import java.sql.Ref;
     10 import java.sql.ResultSet;
     11+import java.sql.RowId;
     12 import java.sql.SQLException;
     13+import java.sql.SQLXML;
     14 import java.sql.Statement;
     15 import java.sql.Time;
     16 import java.sql.Timestamp;
     17@@ -2441,5 +2444,86 @@
     18                return (super.checkReadOnlySafeStatement() || this.checkReadOnlyProcedure());
     19        }
     20 
     21+       public void setNClob(String parameterName, Reader reader)
     22+                       throws SQLException {
     23+               throw SQLError.notImplemented();
     24+       }
     25+
     26+       public Reader getCharacterStream(String parameterName) throws SQLException {
     27+               throw SQLError.notImplemented();
     28+       }
     29+
     30+       public Reader getCharacterStream(int parameterIndex) throws SQLException {
     31+               throw SQLError.notImplemented();
     32+       }
     33+
     34+       public String getNString(String parameterName) throws SQLException {
     35+               throw SQLError.notImplemented();
     36+       }
     37+
     38+       public String getNString(int parameterIndex) throws SQLException {
     39+               throw SQLError.notImplemented();
     40+       }
     41+
     42+       public Reader getNCharacterStream(String parameterName)
     43+                       throws SQLException {
     44+               throw SQLError.notImplemented();
     45+       }
     46+
     47+       public Reader getNCharacterStream(int parameterIndex) throws SQLException {
     48+               throw SQLError.notImplemented();
     49+       }
     50+
     51+       public SQLXML getSQLXML(String parameterName) throws SQLException {
     52+               throw SQLError.notImplemented();
     53+       }
     54+
     55+       public SQLXML getSQLXML(int parameterIndex) throws SQLException {
     56+               throw SQLError.notImplemented();
     57+       }
     58+
     59+       public void setSQLXML(String parameterName, SQLXML xmlObject)
     60+                       throws SQLException {
     61+               throw SQLError.notImplemented();
     62+       }
     63+
     64+       public NClob getNClob(String parameterName) throws SQLException {
     65+               throw SQLError.notImplemented();
     66+       }
     67+
     68+       public NClob getNClob(int parameterIndex) throws SQLException {
     69+               throw SQLError.notImplemented();
     70+       }
     71+
     72+       public void setNClob(String parameterName, Reader reader, long length)
     73+                       throws SQLException {
     74+               throw SQLError.notImplemented();
     75+       }
     76+
     77+       public void setNClob(String parameterName, NClob value)
     78+                       throws SQLException {
     79+               throw SQLError.notImplemented();
     80+       }
     81+
     82+       public void setNString(String parameterName, String value)
     83+                       throws SQLException {
     84+               throw SQLError.notImplemented();
     85+       }
     86+
     87+       public void setRowId(String parameterName, RowId x)
     88+                       throws SQLException {
     89+               throw SQLError.notImplemented();
     90+       }
     91+
     92+       public RowId getRowId(String parameterName)
     93+                       throws SQLException {
     94+               throw SQLError.notImplemented();
     95+       }
     96+
     97+       public RowId getRowId(int parameterIndex)
     98+                       throws SQLException {
     99+               throw SQLError.notImplemented();
     100+       }
     101+
     102 
     103 }
     104--- src/com/mysql/jdbc/ConnectionImpl.java.orig 2009-11-28 18:58:49.000000000 +0100
     105+++ src/com/mysql/jdbc/ConnectionImpl.java      2009-11-29 00:56:52.000000000 +0100
     106@@ -34,11 +34,16 @@
     107 import java.nio.charset.Charset;
     108 import java.nio.charset.CharsetEncoder;
     109 import java.sql.Blob;
     110+import java.sql.Clob;
     111 import java.sql.DatabaseMetaData;
     112+import java.sql.NClob;
     113 import java.sql.ResultSet;
     114+import java.sql.SQLClientInfoException;
     115 import java.sql.SQLException;
     116 import java.sql.SQLWarning;
     117+import java.sql.SQLXML;
     118 import java.sql.Savepoint;
     119+import java.sql.Struct;
     120 import java.util.ArrayList;
     121 import java.util.Calendar;
     122 import java.util.GregorianCalendar;
     123@@ -5699,4 +5704,60 @@
     124        public boolean getRequiresEscapingEncoder() {
     125                return requiresEscapingEncoder;
     126        }
     127+
     128+       public Struct createStruct(String typeName, Object[] attributes)
     129+                       throws SQLException {
     130+               throw SQLError.notImplemented();
     131+       }
     132+
     133+       public java.sql.Array createArrayOf(String typeName, Object[] elements)
     134+                       throws SQLException {
     135+               throw SQLError.notImplemented();
     136+       }
     137+
     138+       public Properties getClientInfo() throws SQLException {
     139+               throw SQLError.notImplemented();
     140+       }
     141+
     142+       public String getClientInfo(String name) throws SQLException {
     143+               throw SQLError.notImplemented();
     144+       }
     145+
     146+       public void setClientInfo(Properties properties)
     147+                       throws SQLClientInfoException {
     148+               throw new SQLClientInfoException();
     149+       }
     150+
     151+       public void setClientInfo(String name, String value)
     152+                       throws SQLClientInfoException {
     153+               throw new SQLClientInfoException();
     154+       }
     155+
     156+       public boolean isValid(int timeout) throws SQLException {
     157+               throw SQLError.notImplemented();
     158+       }
     159+
     160+       public SQLXML createSQLXML() throws SQLException {
     161+               throw SQLError.notImplemented();
     162+       }
     163+
     164+       public NClob createNClob() throws SQLException {
     165+               throw SQLError.notImplemented();
     166+       }
     167+
     168+       public Blob createBlob() throws SQLException {
     169+               throw SQLError.notImplemented();
     170+       }
     171+
     172+       public Clob createClob() throws SQLException {
     173+               throw SQLError.notImplemented();
     174+       }
     175+
     176+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     177+               throw SQLError.notImplemented();
     178+       }
     179+
     180+       public <T> T unwrap(Class<T> iface) throws SQLException {
     181+               throw SQLError.notImplemented();
     182+       }
     183 }
     184--- src/com/mysql/jdbc/DatabaseMetaData.java.orig       2009-11-28 18:58:49.000000000 +0100
     185+++ src/com/mysql/jdbc/DatabaseMetaData.java    2009-11-28 23:31:07.000000000 +0100
     186@@ -27,6 +27,7 @@
     187 import java.io.UnsupportedEncodingException;
     188 import java.lang.reflect.Constructor;
     189 import java.sql.ResultSet;
     190+import java.sql.RowIdLifetime;
     191 import java.sql.SQLException;
     192 import java.sql.Statement;
     193 import java.sql.Types;
     194@@ -8158,4 +8159,29 @@
     195 
     196                return pStmt;
     197        }
     198+
     199+       public ResultSet getFunctions(String catalog, String schemaPattern,
     200+                       String functionNamePattern) throws SQLException {
     201+               throw SQLError.notImplemented();
     202+       }
     203+
     204+       public ResultSet getClientInfoProperties() throws SQLException {
     205+               throw SQLError.notImplemented();
     206+       }
     207+
     208+       public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
     209+               throw SQLError.notImplemented();
     210+       }
     211+
     212+       public RowIdLifetime getRowIdLifetime() throws SQLException {
     213+               throw SQLError.notImplemented();
     214+       }
     215+
     216+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     217+               throw SQLError.notImplemented();
     218+       }
     219+
     220+       public <T> T unwrap(Class<T> iface) throws SQLException {
     221+               throw SQLError.notImplemented();
     222+       }
     223 }
     224--- src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java.orig        2009-11-28 22:41:30.000000000 +0100
     225+++ src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java     2009-11-29 01:26:01.000000000 +0100
     226@@ -34,8 +34,11 @@
     227 import java.sql.CallableStatement;
     228 import java.sql.Clob;
     229 import java.sql.Date;
     230+import java.sql.NClob;
     231 import java.sql.Ref;
     232+import java.sql.RowId;
     233 import java.sql.SQLException;
     234+import java.sql.SQLXML;
     235 import java.sql.Time;
     236 import java.sql.Timestamp;
     237 import java.util.Calendar;
     238@@ -1800,817 +1803,817 @@
     239 
     240                return null;
     241        }
     242-//
     243-//     public Reader getCharacterStream(int parameterIndex) throws SQLException {
     244-//             try {
     245-//                     if (this.wrappedStmt != null) {
     246-//                             return ((CallableStatement) this.wrappedStmt)
     247-//                                             .getCharacterStream(parameterIndex);
     248-//                     } else {
     249-//                             throw SQLError.createSQLException(
     250-//                                             "No operations allowed after statement closed",
     251-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     252-//                     }
     253-//             } catch (SQLException sqlEx) {
     254-//                     checkAndFireConnectionError(sqlEx);
     255-//             }
     256-//             
     257-//             return null;
     258-//     }
     259-//
     260-//     public Reader getCharacterStream(String parameterName) throws SQLException {
     261-//             try {
     262-//                     if (this.wrappedStmt != null) {
     263-//                             return ((CallableStatement) this.wrappedStmt)
     264-//                                             .getCharacterStream(parameterName);
     265-//                     } else {
     266-//                             throw SQLError.createSQLException(
     267-//                                             "No operations allowed after statement closed",
     268-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     269-//                     }
     270-//             } catch (SQLException sqlEx) {
     271-//                     checkAndFireConnectionError(sqlEx);
     272-//             }
     273-//             
     274-//             return null;
     275-//     }
     276-//
     277-//     public Reader getNCharacterStream(int parameterIndex) throws SQLException {
     278-//             try {
     279-//                     if (this.wrappedStmt != null) {
     280-//                             return ((CallableStatement) this.wrappedStmt)
     281-//                                             .getCharacterStream(parameterIndex);
     282-//                     } else {
     283-//                             throw SQLError.createSQLException(
     284-//                                             "No operations allowed after statement closed",
     285-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     286-//                     }
     287-//             } catch (SQLException sqlEx) {
     288-//                     checkAndFireConnectionError(sqlEx);
     289-//             }
     290-//             
     291-//             return null;
     292-//     }
     293-//
     294-//     public Reader getNCharacterStream(String parameterName) throws SQLException {
     295-//             try {
     296-//                     if (this.wrappedStmt != null) {
     297-//                             return ((CallableStatement) this.wrappedStmt)
     298-//                                             .getNCharacterStream(parameterName);
     299-//                     } else {
     300-//                             throw SQLError.createSQLException(
     301-//                                             "No operations allowed after statement closed",
     302-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     303-//                     }
     304-//             } catch (SQLException sqlEx) {
     305-//                     checkAndFireConnectionError(sqlEx);
     306-//             }
     307-//             
     308-//             return null;
     309-//     }
     310-//
     311-//     public NClob getNClob(int parameterIndex) throws SQLException {
     312-//             try {
     313-//                     if (this.wrappedStmt != null) {
     314-//                             return ((CallableStatement) this.wrappedStmt)
     315-//                                             .getNClob(parameterIndex);
     316-//                     } else {
     317-//                             throw SQLError.createSQLException(
     318-//                                             "No operations allowed after statement closed",
     319-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     320-//                     }
     321-//             } catch (SQLException sqlEx) {
     322-//                     checkAndFireConnectionError(sqlEx);
     323-//             }
     324-//             
     325-//             return null;
     326-//     }
     327-//
     328-//     public NClob getNClob(String parameterName) throws SQLException {
     329-//             try {
     330-//                     if (this.wrappedStmt != null) {
     331-//                             return ((CallableStatement) this.wrappedStmt)
     332-//                                             .getNClob(parameterName);
     333-//                     } else {
     334-//                             throw SQLError.createSQLException(
     335-//                                             "No operations allowed after statement closed",
     336-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     337-//                     }
     338-//             } catch (SQLException sqlEx) {
     339-//                     checkAndFireConnectionError(sqlEx);
     340-//             }
     341-//             
     342-//             return null;
     343-//     }
     344-//
     345-//     public String getNString(int parameterIndex) throws SQLException {
     346-//             try {
     347-//                     if (this.wrappedStmt != null) {
     348-//                             return ((CallableStatement) this.wrappedStmt)
     349-//                                             .getNString(parameterIndex);
     350-//                     } else {
     351-//                             throw SQLError.createSQLException(
     352-//                                             "No operations allowed after statement closed",
     353-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     354-//                     }
     355-//             } catch (SQLException sqlEx) {
     356-//                     checkAndFireConnectionError(sqlEx);
     357-//             }
     358-//             
     359-//             return null;
     360-//     }
     361-//
     362-//     public String getNString(String parameterName) throws SQLException {
     363-//             try {
     364-//                     if (this.wrappedStmt != null) {
     365-//                             return ((CallableStatement) this.wrappedStmt)
     366-//                                             .getNString(parameterName);
     367-//                     } else {
     368-//                             throw SQLError.createSQLException(
     369-//                                             "No operations allowed after statement closed",
     370-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     371-//                     }
     372-//             } catch (SQLException sqlEx) {
     373-//                     checkAndFireConnectionError(sqlEx);
     374-//             }
     375-//             
     376-//             return null;
     377-//     }
     378-//
     379-//     public RowId getRowId(int parameterIndex) throws SQLException {
     380-//             try {
     381-//                     if (this.wrappedStmt != null) {
     382-//                             return ((CallableStatement) this.wrappedStmt)
     383-//                                             .getRowId(parameterIndex);
     384-//                     } else {
     385-//                             throw SQLError.createSQLException(
     386-//                                             "No operations allowed after statement closed",
     387-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     388-//                     }
     389-//             } catch (SQLException sqlEx) {
     390-//                     checkAndFireConnectionError(sqlEx);
     391-//             }
     392-//             
     393-//             return null;
     394-//     }
     395-//
     396-//     public RowId getRowId(String parameterName) throws SQLException {
     397-//             try {
     398-//                     if (this.wrappedStmt != null) {
     399-//                             return ((CallableStatement) this.wrappedStmt)
     400-//                                             .getRowId(parameterName);
     401-//                     } else {
     402-//                             throw SQLError.createSQLException(
     403-//                                             "No operations allowed after statement closed",
     404-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     405-//                     }
     406-//             } catch (SQLException sqlEx) {
     407-//                     checkAndFireConnectionError(sqlEx);
     408-//             }
     409-//             
     410-//             return null;
     411-//     }
     412-//
     413-//     public SQLXML getSQLXML(int parameterIndex) throws SQLException {
     414-//             try {
     415-//                     if (this.wrappedStmt != null) {
     416-//                             return ((CallableStatement) this.wrappedStmt)
     417-//                                             .getSQLXML(parameterIndex);
     418-//                     } else {
     419-//                             throw SQLError.createSQLException(
     420-//                                             "No operations allowed after statement closed",
     421-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     422-//                     }
     423-//             } catch (SQLException sqlEx) {
     424-//                     checkAndFireConnectionError(sqlEx);
     425-//             }
     426-//             
     427-//             return null;
     428-//     }
     429-//
     430-//     public SQLXML getSQLXML(String parameterName) throws SQLException {
     431-//             try {
     432-//                     if (this.wrappedStmt != null) {
     433-//                             return ((CallableStatement) this.wrappedStmt)
     434-//                                             .getSQLXML(parameterName);
     435-//                     } else {
     436-//                             throw SQLError.createSQLException(
     437-//                                             "No operations allowed after statement closed",
     438-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     439-//                     }
     440-//             } catch (SQLException sqlEx) {
     441-//                     checkAndFireConnectionError(sqlEx);
     442-//             }
     443-//             
     444-//             return null;
     445-//     }
     446-//
     447-//     public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
     448-//             try {
     449-//                     if (this.wrappedStmt != null) {
     450-//                             ((CallableStatement) this.wrappedStmt)
     451-//                                             .setAsciiStream(parameterName, x) ;
     452-//                     } else {
     453-//                             throw SQLError.createSQLException(
     454-//                                             "No operations allowed after statement closed",
     455-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     456-//                     }
     457-//             } catch (SQLException sqlEx) {
     458-//                     checkAndFireConnectionError(sqlEx);
     459-//             }
     460-//     }
     461-//
     462-//     public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
     463-//             try {
     464-//                     if (this.wrappedStmt != null) {
     465-//                             ((CallableStatement) this.wrappedStmt)
     466-//                                             .setAsciiStream(parameterName, x, length);
     467-//                     } else {
     468-//                             throw SQLError.createSQLException(
     469-//                                             "No operations allowed after statement closed",
     470-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     471-//                     }
     472-//             } catch (SQLException sqlEx) {
     473-//                     checkAndFireConnectionError(sqlEx);
     474-//             }
     475-//     }
     476-//
     477-//     public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
     478-//             try {
     479-//                     if (this.wrappedStmt != null) {
     480-//                             ((CallableStatement) this.wrappedStmt)
     481-//                                             .setBinaryStream(parameterName, x);
     482-//                     } else {
     483-//                             throw SQLError.createSQLException(
     484-//                                             "No operations allowed after statement closed",
     485-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     486-//                     }
     487-//             } catch (SQLException sqlEx) {
     488-//                     checkAndFireConnectionError(sqlEx);
     489-//             }
     490-//     }
     491-//
     492-//     public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
     493-//             try {
     494-//                     if (this.wrappedStmt != null) {
     495-//                             ((CallableStatement) this.wrappedStmt)
     496-//                                             .setBinaryStream(parameterName, x, length);
     497-//                     } else {
     498-//                             throw SQLError.createSQLException(
     499-//                                             "No operations allowed after statement closed",
     500-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     501-//                     }
     502-//             } catch (SQLException sqlEx) {
     503-//                     checkAndFireConnectionError(sqlEx);
     504-//             }
     505-//     }
     506-//
     507-//     public void setBlob(String parameterName, Blob x) throws SQLException {
     508-//             try {
     509-//                     if (this.wrappedStmt != null) {
     510-//                             ((CallableStatement) this.wrappedStmt)
     511-//                                             .setBlob(parameterName, x);
     512-//                     } else {
     513-//                             throw SQLError.createSQLException(
     514-//                                             "No operations allowed after statement closed",
     515-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     516-//                     }
     517-//             } catch (SQLException sqlEx) {
     518-//                     checkAndFireConnectionError(sqlEx);
     519-//             }
     520-//     }
     521-//
     522-//     public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
     523-//             try {
     524-//                     if (this.wrappedStmt != null) {
     525-//                             ((CallableStatement) this.wrappedStmt)
     526-//                                             .setBlob(parameterName, inputStream);
     527-//                     } else {
     528-//                             throw SQLError.createSQLException(
     529-//                                             "No operations allowed after statement closed",
     530-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     531-//                     }
     532-//             } catch (SQLException sqlEx) {
     533-//                     checkAndFireConnectionError(sqlEx);
     534-//             }
     535-//     }
     536-//
     537-//     public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
     538-//             try {
     539-//                     if (this.wrappedStmt != null) {
     540-//                             ((CallableStatement) this.wrappedStmt)
     541-//                                             .setBlob(parameterName, inputStream, length);
     542-//                     } else {
     543-//                             throw SQLError.createSQLException(
     544-//                                             "No operations allowed after statement closed",
     545-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     546-//                     }
     547-//             } catch (SQLException sqlEx) {
     548-//                     checkAndFireConnectionError(sqlEx);
     549-//             }
     550-//     }
     551-//
     552-//     public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
     553-//             try {
     554-//                     if (this.wrappedStmt != null) {
     555-//                             ((CallableStatement) this.wrappedStmt)
     556-//                                             .setCharacterStream(parameterName, reader);
     557-//                     } else {
     558-//                             throw SQLError.createSQLException(
     559-//                                             "No operations allowed after statement closed",
     560-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     561-//                     }
     562-//             } catch (SQLException sqlEx) {
     563-//                     checkAndFireConnectionError(sqlEx);
     564-//             }
     565-//     }
     566-//
     567-//     public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     568-//             try {
     569-//                     if (this.wrappedStmt != null) {
     570-//                             ((CallableStatement) this.wrappedStmt)
     571-//                                             .setCharacterStream(parameterName, reader, length);
     572-//                     } else {
     573-//                             throw SQLError.createSQLException(
     574-//                                             "No operations allowed after statement closed",
     575-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     576-//                     }
     577-//             } catch (SQLException sqlEx) {
     578-//                     checkAndFireConnectionError(sqlEx);
     579-//             }
     580-//     }
     581-//
     582-//     public void setClob(String parameterName, Clob x) throws SQLException {
     583-//             try {
     584-//                     if (this.wrappedStmt != null) {
     585-//                             ((CallableStatement) this.wrappedStmt)
     586-//                                             .setClob(parameterName, x);
     587-//                     } else {
     588-//                             throw SQLError.createSQLException(
     589-//                                             "No operations allowed after statement closed",
     590-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     591-//                     }
     592-//             } catch (SQLException sqlEx) {
     593-//                     checkAndFireConnectionError(sqlEx);
     594-//             }
     595-//     }
     596-//
     597-//     public void setClob(String parameterName, Reader reader) throws SQLException {
     598-//             try {
     599-//                     if (this.wrappedStmt != null) {
     600-//                             ((CallableStatement) this.wrappedStmt)
     601-//                                             .setClob(parameterName, reader);
     602-//                     } else {
     603-//                             throw SQLError.createSQLException(
     604-//                                             "No operations allowed after statement closed",
     605-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     606-//                     }
     607-//             } catch (SQLException sqlEx) {
     608-//                     checkAndFireConnectionError(sqlEx);
     609-//             }
     610-//     }
     611-//
     612-//     public void setClob(String parameterName, Reader reader, long length) throws SQLException {
     613-//             try {
     614-//                     if (this.wrappedStmt != null) {
     615-//                             ((CallableStatement) this.wrappedStmt)
     616-//                                             .setClob(parameterName, reader, length);
     617-//                     } else {
     618-//                             throw SQLError.createSQLException(
     619-//                                             "No operations allowed after statement closed",
     620-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     621-//                     }
     622-//             } catch (SQLException sqlEx) {
     623-//                     checkAndFireConnectionError(sqlEx);
     624-//             }
     625-//     }
     626-//
     627-//     public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
     628-//             try {
     629-//                     if (this.wrappedStmt != null) {
     630-//                             ((CallableStatement) this.wrappedStmt)
     631-//                                             .setNCharacterStream(parameterName, value);
     632-//                     } else {
     633-//                             throw SQLError.createSQLException(
     634-//                                             "No operations allowed after statement closed",
     635-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     636-//                     }
     637-//             } catch (SQLException sqlEx) {
     638-//                     checkAndFireConnectionError(sqlEx);
     639-//             }
     640-//     }
     641-//
     642-//     public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
     643-//             try {
     644-//                     if (this.wrappedStmt != null) {
     645-//                             ((CallableStatement) this.wrappedStmt)
     646-//                                             .setNCharacterStream(parameterName, value, length);
     647-//                     } else {
     648-//                             throw SQLError.createSQLException(
     649-//                                             "No operations allowed after statement closed",
     650-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     651-//                     }
     652-//             } catch (SQLException sqlEx) {
     653-//                     checkAndFireConnectionError(sqlEx);
     654-//             }
     655-//     }
     656-//
     657-//     public void setNClob(String parameterName, NClob value) throws SQLException {
     658-//             try {
     659-//                     if (this.wrappedStmt != null) {
     660-//                             ((CallableStatement) this.wrappedStmt)
     661-//                                             .setNClob(parameterName, value);
     662-//                     } else {
     663-//                             throw SQLError.createSQLException(
     664-//                                             "No operations allowed after statement closed",
     665-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     666-//                     }
     667-//             } catch (SQLException sqlEx) {
     668-//                     checkAndFireConnectionError(sqlEx);
     669-//             }
     670-//     }
     671-//
     672-//     public void setNClob(String parameterName, Reader reader) throws SQLException {
     673-//             try {
     674-//                     if (this.wrappedStmt != null) {
     675-//                             ((CallableStatement) this.wrappedStmt)
     676-//                                             .setNClob(parameterName, reader);
     677-//                     } else {
     678-//                             throw SQLError.createSQLException(
     679-//                                             "No operations allowed after statement closed",
     680-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     681-//                     }
     682-//             } catch (SQLException sqlEx) {
     683-//                     checkAndFireConnectionError(sqlEx);
     684-//             }
     685-//     }
     686-//
     687-//     public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
     688-//             try {
     689-//                     if (this.wrappedStmt != null) {
     690-//                             ((CallableStatement) this.wrappedStmt)
     691-//                                             .setNClob(parameterName, reader, length);
     692-//                     } else {
     693-//                             throw SQLError.createSQLException(
     694-//                                             "No operations allowed after statement closed",
     695-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     696-//                     }
     697-//             } catch (SQLException sqlEx) {
     698-//                     checkAndFireConnectionError(sqlEx);
     699-//             }
     700-//     }
     701-//
     702-//     public void setNString(String parameterName, String value) throws SQLException {
     703-//             try {
     704-//                     if (this.wrappedStmt != null) {
     705-//                             ((CallableStatement) this.wrappedStmt)
     706-//                                             .setNString(parameterName, value);
     707-//                     } else {
     708-//                             throw SQLError.createSQLException(
     709-//                                             "No operations allowed after statement closed",
     710-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     711-//                     }
     712-//             } catch (SQLException sqlEx) {
     713-//                     checkAndFireConnectionError(sqlEx);
     714-//             }
     715-//     }
     716-//
     717-//     public void setRowId(String parameterName, RowId x) throws SQLException {
     718-//             try {
     719-//                     if (this.wrappedStmt != null) {
     720-//                             ((CallableStatement) this.wrappedStmt)
     721-//                                             .setRowId(parameterName, x);
     722-//                     } else {
     723-//                             throw SQLError.createSQLException(
     724-//                                             "No operations allowed after statement closed",
     725-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     726-//                     }
     727-//             } catch (SQLException sqlEx) {
     728-//                     checkAndFireConnectionError(sqlEx);
     729-//             }
     730-//     }
     731-//
     732-//     public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
     733-//             try {
     734-//                     if (this.wrappedStmt != null) {
     735-//                             ((CallableStatement) this.wrappedStmt)
     736-//                                             .setSQLXML(parameterName, xmlObject);
     737-//                     } else {
     738-//                             throw SQLError.createSQLException(
     739-//                                             "No operations allowed after statement closed",
     740-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     741-//                     }
     742-//             } catch (SQLException sqlEx) {
     743-//                     checkAndFireConnectionError(sqlEx);
     744-//             }
     745-//     }
     746-//
     747-//     public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
     748-//             try {
     749-//                     if (this.wrappedStmt != null) {
     750-//                             ((CallableStatement) this.wrappedStmt)
     751-//                                             .setAsciiStream(parameterIndex, x);
     752-//                     } else {
     753-//                             throw SQLError.createSQLException(
     754-//                                             "No operations allowed after statement closed",
     755-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     756-//                     }
     757-//             } catch (SQLException sqlEx) {
     758-//                     checkAndFireConnectionError(sqlEx);
     759-//             }
     760-//     }
     761-//
     762-//     public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
     763-//             try {
     764-//                     if (this.wrappedStmt != null) {
     765-//                             ((CallableStatement) this.wrappedStmt)
     766-//                                             .setAsciiStream(parameterIndex, x, length);
     767-//                     } else {
     768-//                             throw SQLError.createSQLException(
     769-//                                             "No operations allowed after statement closed",
     770-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     771-//                     }
     772-//             } catch (SQLException sqlEx) {
     773-//                     checkAndFireConnectionError(sqlEx);
     774-//             }
     775-//     }
     776-//
     777-//     public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
     778-//             try {
     779-//                     if (this.wrappedStmt != null) {
     780-//                             ((CallableStatement) this.wrappedStmt)
     781-//                                             .setBinaryStream(parameterIndex, x) ;
     782-//                     } else {
     783-//                             throw SQLError.createSQLException(
     784-//                                             "No operations allowed after statement closed",
     785-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     786-//                     }
     787-//             } catch (SQLException sqlEx) {
     788-//                     checkAndFireConnectionError(sqlEx);
     789-//             }
     790-//     }
     791-//
     792-//     public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
     793-//             try {
     794-//                     if (this.wrappedStmt != null) {
     795-//                             ((CallableStatement) this.wrappedStmt)
     796-//                                             .setBinaryStream(parameterIndex, x, length);
     797-//                     } else {
     798-//                             throw SQLError.createSQLException(
     799-//                                             "No operations allowed after statement closed",
     800-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     801-//                     }
     802-//             } catch (SQLException sqlEx) {
     803-//                     checkAndFireConnectionError(sqlEx);
     804-//             }
     805-//     }
     806-//
     807-//     public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     808-//             try {
     809-//                     if (this.wrappedStmt != null) {
     810-//                             ((CallableStatement) this.wrappedStmt)
     811-//                                             .setBlob(parameterIndex, inputStream);
     812-//                     } else {
     813-//                             throw SQLError.createSQLException(
     814-//                                             "No operations allowed after statement closed",
     815-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     816-//                     }
     817-//             } catch (SQLException sqlEx) {
     818-//                     checkAndFireConnectionError(sqlEx);
     819-//             }
     820-//     }
     821-//
     822-//     public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     823-//             try {
     824-//                     if (this.wrappedStmt != null) {
     825-//                             ((CallableStatement) this.wrappedStmt)
     826-//                                             .setBlob(parameterIndex, inputStream, length);
     827-//                     } else {
     828-//                             throw SQLError.createSQLException(
     829-//                                             "No operations allowed after statement closed",
     830-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     831-//                     }
     832-//             } catch (SQLException sqlEx) {
     833-//                     checkAndFireConnectionError(sqlEx);
     834-//             }
     835-//     }
     836-//
     837-//     public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     838-//             try {
     839-//                     if (this.wrappedStmt != null) {
     840-//                             ((CallableStatement) this.wrappedStmt)
     841-//                                             .setCharacterStream(parameterIndex, reader);
     842-//                     } else {
     843-//                             throw SQLError.createSQLException(
     844-//                                             "No operations allowed after statement closed",
     845-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     846-//                     }
     847-//             } catch (SQLException sqlEx) {
     848-//                     checkAndFireConnectionError(sqlEx);
     849-//             }
     850-//     }
     851-//
     852-//     public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     853-//             try {
     854-//                     if (this.wrappedStmt != null) {
     855-//                             ((CallableStatement) this.wrappedStmt)
     856-//                                             .getCharacterStream(parameterIndex);
     857-//                     } else {
     858-//                             throw SQLError.createSQLException(
     859-//                                             "No operations allowed after statement closed",
     860-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     861-//                     }
     862-//             } catch (SQLException sqlEx) {
     863-//                     checkAndFireConnectionError(sqlEx);
     864-//             }
     865-//     }
     866-//
     867-//     public void setClob(int parameterIndex, Reader reader) throws SQLException {
     868-//             try {
     869-//                     if (this.wrappedStmt != null) {
     870-//                             ((CallableStatement) this.wrappedStmt)
     871-//                                             .setClob(parameterIndex, reader);
     872-//                     } else {
     873-//                             throw SQLError.createSQLException(
     874-//                                             "No operations allowed after statement closed",
     875-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     876-//                     }
     877-//             } catch (SQLException sqlEx) {
     878-//                     checkAndFireConnectionError(sqlEx);
     879-//             }
     880-//     }
     881-//
     882-//     public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     883-//             try {
     884-//                     if (this.wrappedStmt != null) {
     885-//                             ((CallableStatement) this.wrappedStmt)
     886-//                                             .setClob(parameterIndex, reader, length);
     887-//                     } else {
     888-//                             throw SQLError.createSQLException(
     889-//                                             "No operations allowed after statement closed",
     890-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     891-//                     }
     892-//             } catch (SQLException sqlEx) {
     893-//                     checkAndFireConnectionError(sqlEx);
     894-//             }
     895-//     }
     896-//
     897-//     public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
     898-//             try {
     899-//                     if (this.wrappedStmt != null) {
     900-//                             ((CallableStatement) this.wrappedStmt)
     901-//                                             .setNCharacterStream(parameterIndex, value);
     902-//                     } else {
     903-//                             throw SQLError.createSQLException(
     904-//                                             "No operations allowed after statement closed",
     905-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     906-//                     }
     907-//             } catch (SQLException sqlEx) {
     908-//                     checkAndFireConnectionError(sqlEx);
     909-//             }
     910-//     
     911-//     }
     912-//
     913-//     public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     914-//             try {
     915-//                     if (this.wrappedStmt != null) {
     916-//                             ((CallableStatement) this.wrappedStmt)
     917-//                                             .setNCharacterStream(parameterIndex, value, length);
     918-//                     } else {
     919-//                             throw SQLError.createSQLException(
     920-//                                             "No operations allowed after statement closed",
     921-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     922-//                     }
     923-//             } catch (SQLException sqlEx) {
     924-//                     checkAndFireConnectionError(sqlEx);
     925-//             }
     926-//     }
     927-//
     928-//     public void setNClob(int parameterIndex, NClob value) throws SQLException {
     929-//             try {
     930-//                     if (this.wrappedStmt != null) {
     931-//                             ((CallableStatement) this.wrappedStmt)
     932-//                                             .setNClob(parameterIndex, value);
     933-//                     } else {
     934-//                             throw SQLError.createSQLException(
     935-//                                             "No operations allowed after statement closed",
     936-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     937-//                     }
     938-//             } catch (SQLException sqlEx) {
     939-//                     checkAndFireConnectionError(sqlEx);
     940-//             }
     941-//     }
     942-//
     943-//     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     944-//             try {
     945-//                     if (this.wrappedStmt != null) {
     946-//                             ((CallableStatement) this.wrappedStmt)
     947-//                                             .setNClob(parameterIndex, reader);
     948-//                     } else {
     949-//                             throw SQLError.createSQLException(
     950-//                                             "No operations allowed after statement closed",
     951-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     952-//                     }
     953-//             } catch (SQLException sqlEx) {
     954-//                     checkAndFireConnectionError(sqlEx);
     955-//             }
     956-//     }
     957-//
     958-//     public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     959-//             try {
     960-//                     if (this.wrappedStmt != null) {
     961-//                             ((CallableStatement) this.wrappedStmt)
     962-//                                             .setNClob(parameterIndex, reader, length);
     963-//                     } else {
     964-//                             throw SQLError.createSQLException(
     965-//                                             "No operations allowed after statement closed",
     966-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     967-//                     }
     968-//             } catch (SQLException sqlEx) {
     969-//                     checkAndFireConnectionError(sqlEx);
     970-//             }
     971-//     }
     972-//
     973-//     public void setNString(int parameterIndex, String value) throws SQLException {
     974-//             try {
     975-//                     if (this.wrappedStmt != null) {
     976-//                             ((CallableStatement) this.wrappedStmt)
     977-//                                             .setNString(parameterIndex, value);
     978-//                     } else {
     979-//                             throw SQLError.createSQLException(
     980-//                                             "No operations allowed after statement closed",
     981-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     982-//                     }
     983-//             } catch (SQLException sqlEx) {
     984-//                     checkAndFireConnectionError(sqlEx);
     985-//             }
     986-//     }
     987-//
     988-//     public void setRowId(int parameterIndex, RowId x) throws SQLException {
     989-//             try {
     990-//                     if (this.wrappedStmt != null) {
     991-//                             ((CallableStatement) this.wrappedStmt)
     992-//                                             .setRowId(parameterIndex, x);
     993-//                     } else {
     994-//                             throw SQLError.createSQLException(
     995-//                                             "No operations allowed after statement closed",
     996-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     997-//                     }
     998-//             } catch (SQLException sqlEx) {
     999-//                     checkAndFireConnectionError(sqlEx);
     1000-//             }
     1001-//     }
     1002-//
     1003-//     public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
     1004-//             try {
     1005-//                     if (this.wrappedStmt != null) {
     1006-//                             ((CallableStatement) this.wrappedStmt)
     1007-//                                             .setSQLXML(parameterIndex, xmlObject);
     1008-//                     } else {
     1009-//                             throw SQLError.createSQLException(
     1010-//                                             "No operations allowed after statement closed",
     1011-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1012-//                     }
     1013-//             } catch (SQLException sqlEx) {
     1014-//                     checkAndFireConnectionError(sqlEx);
     1015-//             }
     1016-//             
     1017-//     }
     1018-//
     1019-//     public boolean isClosed() throws SQLException {
     1020-//             try {
     1021-//                     if (this.wrappedStmt != null) {
     1022-//                             return ((CallableStatement) this.wrappedStmt)
     1023-//                                             .isClosed();
     1024-//                     } else {
     1025-//                             throw SQLError.createSQLException(
     1026-//                                             "No operations allowed after statement closed",
     1027-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1028-//                     }
     1029-//             } catch (SQLException sqlEx) {
     1030-//                     checkAndFireConnectionError(sqlEx);
     1031-//             }
     1032-//             
     1033-//             return true;
     1034-//     }
     1035-//
     1036-//     public boolean isPoolable() throws SQLException {
     1037-//             try {
     1038-//                     if (this.wrappedStmt != null) {
     1039-//                             return ((CallableStatement) this.wrappedStmt)
     1040-//                                             . isPoolable();
     1041-//                     } else {
     1042-//                             throw SQLError.createSQLException(
     1043-//                                             "No operations allowed after statement closed",
     1044-//                                             SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1045-//                     }
     1046-//             } catch (SQLException sqlEx) {
     1047-//                     checkAndFireConnectionError(sqlEx);
     1048-//             }
     1049-//             
     1050-//             return false;
     1051-//     }
     1052-//
     1053+
     1054+       public Reader getCharacterStream(int parameterIndex) throws SQLException {
     1055+               try {
     1056+                       if (this.wrappedStmt != null) {
     1057+                               return ((CallableStatement) this.wrappedStmt)
     1058+                                               .getCharacterStream(parameterIndex);
     1059+                       } else {
     1060+                               throw SQLError.createSQLException(
     1061+                                               "No operations allowed after statement closed",
     1062+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1063+                       }
     1064+               } catch (SQLException sqlEx) {
     1065+                       checkAndFireConnectionError(sqlEx);
     1066+               }
     1067+               
     1068+               return null;
     1069+       }
     1070+
     1071+       public Reader getCharacterStream(String parameterName) throws SQLException {
     1072+               try {
     1073+                       if (this.wrappedStmt != null) {
     1074+                               return ((CallableStatement) this.wrappedStmt)
     1075+                                               .getCharacterStream(parameterName);
     1076+                       } else {
     1077+                               throw SQLError.createSQLException(
     1078+                                               "No operations allowed after statement closed",
     1079+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1080+                       }
     1081+               } catch (SQLException sqlEx) {
     1082+                       checkAndFireConnectionError(sqlEx);
     1083+               }
     1084+               
     1085+               return null;
     1086+       }
     1087+
     1088+       public Reader getNCharacterStream(int parameterIndex) throws SQLException {
     1089+               try {
     1090+                       if (this.wrappedStmt != null) {
     1091+                               return ((CallableStatement) this.wrappedStmt)
     1092+                                               .getCharacterStream(parameterIndex);
     1093+                       } else {
     1094+                               throw SQLError.createSQLException(
     1095+                                               "No operations allowed after statement closed",
     1096+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1097+                       }
     1098+               } catch (SQLException sqlEx) {
     1099+                       checkAndFireConnectionError(sqlEx);
     1100+               }
     1101+               
     1102+               return null;
     1103+       }
     1104+
     1105+       public Reader getNCharacterStream(String parameterName) throws SQLException {
     1106+               try {
     1107+                       if (this.wrappedStmt != null) {
     1108+                               return ((CallableStatement) this.wrappedStmt)
     1109+                                               .getNCharacterStream(parameterName);
     1110+                       } else {
     1111+                               throw SQLError.createSQLException(
     1112+                                               "No operations allowed after statement closed",
     1113+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1114+                       }
     1115+               } catch (SQLException sqlEx) {
     1116+                       checkAndFireConnectionError(sqlEx);
     1117+               }
     1118+               
     1119+               return null;
     1120+       }
     1121+
     1122+       public NClob getNClob(int parameterIndex) throws SQLException {
     1123+               try {
     1124+                       if (this.wrappedStmt != null) {
     1125+                               return ((CallableStatement) this.wrappedStmt)
     1126+                                               .getNClob(parameterIndex);
     1127+                       } else {
     1128+                               throw SQLError.createSQLException(
     1129+                                               "No operations allowed after statement closed",
     1130+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1131+                       }
     1132+               } catch (SQLException sqlEx) {
     1133+                       checkAndFireConnectionError(sqlEx);
     1134+               }
     1135+               
     1136+               return null;
     1137+       }
     1138+
     1139+       public NClob getNClob(String parameterName) throws SQLException {
     1140+               try {
     1141+                       if (this.wrappedStmt != null) {
     1142+                               return ((CallableStatement) this.wrappedStmt)
     1143+                                               .getNClob(parameterName);
     1144+                       } else {
     1145+                               throw SQLError.createSQLException(
     1146+                                               "No operations allowed after statement closed",
     1147+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1148+                       }
     1149+               } catch (SQLException sqlEx) {
     1150+                       checkAndFireConnectionError(sqlEx);
     1151+               }
     1152+               
     1153+               return null;
     1154+       }
     1155+
     1156+       public String getNString(int parameterIndex) throws SQLException {
     1157+               try {
     1158+                       if (this.wrappedStmt != null) {
     1159+                               return ((CallableStatement) this.wrappedStmt)
     1160+                                               .getNString(parameterIndex);
     1161+                       } else {
     1162+                               throw SQLError.createSQLException(
     1163+                                               "No operations allowed after statement closed",
     1164+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1165+                       }
     1166+               } catch (SQLException sqlEx) {
     1167+                       checkAndFireConnectionError(sqlEx);
     1168+               }
     1169+               
     1170+               return null;
     1171+       }
     1172+
     1173+       public String getNString(String parameterName) throws SQLException {
     1174+               try {
     1175+                       if (this.wrappedStmt != null) {
     1176+                               return ((CallableStatement) this.wrappedStmt)
     1177+                                               .getNString(parameterName);
     1178+                       } else {
     1179+                               throw SQLError.createSQLException(
     1180+                                               "No operations allowed after statement closed",
     1181+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1182+                       }
     1183+               } catch (SQLException sqlEx) {
     1184+                       checkAndFireConnectionError(sqlEx);
     1185+               }
     1186+               
     1187+               return null;
     1188+       }
     1189+
     1190+       public RowId getRowId(int parameterIndex) throws SQLException {
     1191+               try {
     1192+                       if (this.wrappedStmt != null) {
     1193+                               return ((CallableStatement) this.wrappedStmt)
     1194+                                               .getRowId(parameterIndex);
     1195+                       } else {
     1196+                               throw SQLError.createSQLException(
     1197+                                               "No operations allowed after statement closed",
     1198+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1199+                       }
     1200+               } catch (SQLException sqlEx) {
     1201+                       checkAndFireConnectionError(sqlEx);
     1202+               }
     1203+               
     1204+               return null;
     1205+       }
     1206+
     1207+       public RowId getRowId(String parameterName) throws SQLException {
     1208+               try {
     1209+                       if (this.wrappedStmt != null) {
     1210+                               return ((CallableStatement) this.wrappedStmt)
     1211+                                               .getRowId(parameterName);
     1212+                       } else {
     1213+                               throw SQLError.createSQLException(
     1214+                                               "No operations allowed after statement closed",
     1215+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1216+                       }
     1217+               } catch (SQLException sqlEx) {
     1218+                       checkAndFireConnectionError(sqlEx);
     1219+               }
     1220+               
     1221+               return null;
     1222+       }
     1223+
     1224+       public SQLXML getSQLXML(int parameterIndex) throws SQLException {
     1225+               try {
     1226+                       if (this.wrappedStmt != null) {
     1227+                               return ((CallableStatement) this.wrappedStmt)
     1228+                                               .getSQLXML(parameterIndex);
     1229+                       } else {
     1230+                               throw SQLError.createSQLException(
     1231+                                               "No operations allowed after statement closed",
     1232+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1233+                       }
     1234+               } catch (SQLException sqlEx) {
     1235+                       checkAndFireConnectionError(sqlEx);
     1236+               }
     1237+               
     1238+               return null;
     1239+       }
     1240+
     1241+       public SQLXML getSQLXML(String parameterName) throws SQLException {
     1242+               try {
     1243+                       if (this.wrappedStmt != null) {
     1244+                               return ((CallableStatement) this.wrappedStmt)
     1245+                                               .getSQLXML(parameterName);
     1246+                       } else {
     1247+                               throw SQLError.createSQLException(
     1248+                                               "No operations allowed after statement closed",
     1249+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1250+                       }
     1251+               } catch (SQLException sqlEx) {
     1252+                       checkAndFireConnectionError(sqlEx);
     1253+               }
     1254+               
     1255+               return null;
     1256+       }
     1257+
     1258+       public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
     1259+               try {
     1260+                       if (this.wrappedStmt != null) {
     1261+                               ((CallableStatement) this.wrappedStmt)
     1262+                                               .setAsciiStream(parameterName, x) ;
     1263+                       } else {
     1264+                               throw SQLError.createSQLException(
     1265+                                               "No operations allowed after statement closed",
     1266+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1267+                       }
     1268+               } catch (SQLException sqlEx) {
     1269+                       checkAndFireConnectionError(sqlEx);
     1270+               }
     1271+       }
     1272+
     1273+       public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
     1274+               try {
     1275+                       if (this.wrappedStmt != null) {
     1276+                               ((CallableStatement) this.wrappedStmt)
     1277+                                               .setAsciiStream(parameterName, x, length);
     1278+                       } else {
     1279+                               throw SQLError.createSQLException(
     1280+                                               "No operations allowed after statement closed",
     1281+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1282+                       }
     1283+               } catch (SQLException sqlEx) {
     1284+                       checkAndFireConnectionError(sqlEx);
     1285+               }
     1286+       }
     1287+
     1288+       public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
     1289+               try {
     1290+                       if (this.wrappedStmt != null) {
     1291+                               ((CallableStatement) this.wrappedStmt)
     1292+                                               .setBinaryStream(parameterName, x);
     1293+                       } else {
     1294+                               throw SQLError.createSQLException(
     1295+                                               "No operations allowed after statement closed",
     1296+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1297+                       }
     1298+               } catch (SQLException sqlEx) {
     1299+                       checkAndFireConnectionError(sqlEx);
     1300+               }
     1301+       }
     1302+
     1303+       public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
     1304+               try {
     1305+                       if (this.wrappedStmt != null) {
     1306+                               ((CallableStatement) this.wrappedStmt)
     1307+                                               .setBinaryStream(parameterName, x, length);
     1308+                       } else {
     1309+                               throw SQLError.createSQLException(
     1310+                                               "No operations allowed after statement closed",
     1311+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1312+                       }
     1313+               } catch (SQLException sqlEx) {
     1314+                       checkAndFireConnectionError(sqlEx);
     1315+               }
     1316+       }
     1317+
     1318+       public void setBlob(String parameterName, Blob x) throws SQLException {
     1319+               try {
     1320+                       if (this.wrappedStmt != null) {
     1321+                               ((CallableStatement) this.wrappedStmt)
     1322+                                               .setBlob(parameterName, x);
     1323+                       } else {
     1324+                               throw SQLError.createSQLException(
     1325+                                               "No operations allowed after statement closed",
     1326+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1327+                       }
     1328+               } catch (SQLException sqlEx) {
     1329+                       checkAndFireConnectionError(sqlEx);
     1330+               }
     1331+       }
     1332+
     1333+       public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
     1334+               try {
     1335+                       if (this.wrappedStmt != null) {
     1336+                               ((CallableStatement) this.wrappedStmt)
     1337+                                               .setBlob(parameterName, inputStream);
     1338+                       } else {
     1339+                               throw SQLError.createSQLException(
     1340+                                               "No operations allowed after statement closed",
     1341+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1342+                       }
     1343+               } catch (SQLException sqlEx) {
     1344+                       checkAndFireConnectionError(sqlEx);
     1345+               }
     1346+       }
     1347+
     1348+       public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
     1349+               try {
     1350+                       if (this.wrappedStmt != null) {
     1351+                               ((CallableStatement) this.wrappedStmt)
     1352+                                               .setBlob(parameterName, inputStream, length);
     1353+                       } else {
     1354+                               throw SQLError.createSQLException(
     1355+                                               "No operations allowed after statement closed",
     1356+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1357+                       }
     1358+               } catch (SQLException sqlEx) {
     1359+                       checkAndFireConnectionError(sqlEx);
     1360+               }
     1361+       }
     1362+
     1363+       public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
     1364+               try {
     1365+                       if (this.wrappedStmt != null) {
     1366+                               ((CallableStatement) this.wrappedStmt)
     1367+                                               .setCharacterStream(parameterName, reader);
     1368+                       } else {
     1369+                               throw SQLError.createSQLException(
     1370+                                               "No operations allowed after statement closed",
     1371+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1372+                       }
     1373+               } catch (SQLException sqlEx) {
     1374+                       checkAndFireConnectionError(sqlEx);
     1375+               }
     1376+       }
     1377+
     1378+       public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
     1379+               try {
     1380+                       if (this.wrappedStmt != null) {
     1381+                               ((CallableStatement) this.wrappedStmt)
     1382+                                               .setCharacterStream(parameterName, reader, length);
     1383+                       } else {
     1384+                               throw SQLError.createSQLException(
     1385+                                               "No operations allowed after statement closed",
     1386+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1387+                       }
     1388+               } catch (SQLException sqlEx) {
     1389+                       checkAndFireConnectionError(sqlEx);
     1390+               }
     1391+       }
     1392+
     1393+       public void setClob(String parameterName, Clob x) throws SQLException {
     1394+               try {
     1395+                       if (this.wrappedStmt != null) {
     1396+                               ((CallableStatement) this.wrappedStmt)
     1397+                                               .setClob(parameterName, x);
     1398+                       } else {
     1399+                               throw SQLError.createSQLException(
     1400+                                               "No operations allowed after statement closed",
     1401+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1402+                       }
     1403+               } catch (SQLException sqlEx) {
     1404+                       checkAndFireConnectionError(sqlEx);
     1405+               }
     1406+       }
     1407+
     1408+       public void setClob(String parameterName, Reader reader) throws SQLException {
     1409+               try {
     1410+                       if (this.wrappedStmt != null) {
     1411+                               ((CallableStatement) this.wrappedStmt)
     1412+                                               .setClob(parameterName, reader);
     1413+                       } else {
     1414+                               throw SQLError.createSQLException(
     1415+                                               "No operations allowed after statement closed",
     1416+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1417+                       }
     1418+               } catch (SQLException sqlEx) {
     1419+                       checkAndFireConnectionError(sqlEx);
     1420+               }
     1421+       }
     1422+
     1423+       public void setClob(String parameterName, Reader reader, long length) throws SQLException {
     1424+               try {
     1425+                       if (this.wrappedStmt != null) {
     1426+                               ((CallableStatement) this.wrappedStmt)
     1427+                                               .setClob(parameterName, reader, length);
     1428+                       } else {
     1429+                               throw SQLError.createSQLException(
     1430+                                               "No operations allowed after statement closed",
     1431+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1432+                       }
     1433+               } catch (SQLException sqlEx) {
     1434+                       checkAndFireConnectionError(sqlEx);
     1435+               }
     1436+       }
     1437+
     1438+       public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
     1439+               try {
     1440+                       if (this.wrappedStmt != null) {
     1441+                               ((CallableStatement) this.wrappedStmt)
     1442+                                               .setNCharacterStream(parameterName, value);
     1443+                       } else {
     1444+                               throw SQLError.createSQLException(
     1445+                                               "No operations allowed after statement closed",
     1446+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1447+                       }
     1448+               } catch (SQLException sqlEx) {
     1449+                       checkAndFireConnectionError(sqlEx);
     1450+               }
     1451+       }
     1452+
     1453+       public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
     1454+               try {
     1455+                       if (this.wrappedStmt != null) {
     1456+                               ((CallableStatement) this.wrappedStmt)
     1457+                                               .setNCharacterStream(parameterName, value, length);
     1458+                       } else {
     1459+                               throw SQLError.createSQLException(
     1460+                                               "No operations allowed after statement closed",
     1461+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1462+                       }
     1463+               } catch (SQLException sqlEx) {
     1464+                       checkAndFireConnectionError(sqlEx);
     1465+               }
     1466+       }
     1467+
     1468+       public void setNClob(String parameterName, NClob value) throws SQLException {
     1469+               try {
     1470+                       if (this.wrappedStmt != null) {
     1471+                               ((CallableStatement) this.wrappedStmt)
     1472+                                               .setNClob(parameterName, value);
     1473+                       } else {
     1474+                               throw SQLError.createSQLException(
     1475+                                               "No operations allowed after statement closed",
     1476+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1477+                       }
     1478+               } catch (SQLException sqlEx) {
     1479+                       checkAndFireConnectionError(sqlEx);
     1480+               }
     1481+       }
     1482+
     1483+       public void setNClob(String parameterName, Reader reader) throws SQLException {
     1484+               try {
     1485+                       if (this.wrappedStmt != null) {
     1486+                               ((CallableStatement) this.wrappedStmt)
     1487+                                               .setNClob(parameterName, reader);
     1488+                       } else {
     1489+                               throw SQLError.createSQLException(
     1490+                                               "No operations allowed after statement closed",
     1491+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1492+                       }
     1493+               } catch (SQLException sqlEx) {
     1494+                       checkAndFireConnectionError(sqlEx);
     1495+               }
     1496+       }
     1497+
     1498+       public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
     1499+               try {
     1500+                       if (this.wrappedStmt != null) {
     1501+                               ((CallableStatement) this.wrappedStmt)
     1502+                                               .setNClob(parameterName, reader, length);
     1503+                       } else {
     1504+                               throw SQLError.createSQLException(
     1505+                                               "No operations allowed after statement closed",
     1506+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1507+                       }
     1508+               } catch (SQLException sqlEx) {
     1509+                       checkAndFireConnectionError(sqlEx);
     1510+               }
     1511+       }
     1512+
     1513+       public void setNString(String parameterName, String value) throws SQLException {
     1514+               try {
     1515+                       if (this.wrappedStmt != null) {
     1516+                               ((CallableStatement) this.wrappedStmt)
     1517+                                               .setNString(parameterName, value);
     1518+                       } else {
     1519+                               throw SQLError.createSQLException(
     1520+                                               "No operations allowed after statement closed",
     1521+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1522+                       }
     1523+               } catch (SQLException sqlEx) {
     1524+                       checkAndFireConnectionError(sqlEx);
     1525+               }
     1526+       }
     1527+
     1528+       public void setRowId(String parameterName, RowId x) throws SQLException {
     1529+               try {
     1530+                       if (this.wrappedStmt != null) {
     1531+                               ((CallableStatement) this.wrappedStmt)
     1532+                                               .setRowId(parameterName, x);
     1533+                       } else {
     1534+                               throw SQLError.createSQLException(
     1535+                                               "No operations allowed after statement closed",
     1536+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1537+                       }
     1538+               } catch (SQLException sqlEx) {
     1539+                       checkAndFireConnectionError(sqlEx);
     1540+               }
     1541+       }
     1542+
     1543+       public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
     1544+               try {
     1545+                       if (this.wrappedStmt != null) {
     1546+                               ((CallableStatement) this.wrappedStmt)
     1547+                                               .setSQLXML(parameterName, xmlObject);
     1548+                       } else {
     1549+                               throw SQLError.createSQLException(
     1550+                                               "No operations allowed after statement closed",
     1551+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1552+                       }
     1553+               } catch (SQLException sqlEx) {
     1554+                       checkAndFireConnectionError(sqlEx);
     1555+               }
     1556+       }
     1557+
     1558+       public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
     1559+               try {
     1560+                       if (this.wrappedStmt != null) {
     1561+                               ((CallableStatement) this.wrappedStmt)
     1562+                                               .setAsciiStream(parameterIndex, x);
     1563+                       } else {
     1564+                               throw SQLError.createSQLException(
     1565+                                               "No operations allowed after statement closed",
     1566+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1567+                       }
     1568+               } catch (SQLException sqlEx) {
     1569+                       checkAndFireConnectionError(sqlEx);
     1570+               }
     1571+       }
     1572+
     1573+       public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
     1574+               try {
     1575+                       if (this.wrappedStmt != null) {
     1576+                               ((CallableStatement) this.wrappedStmt)
     1577+                                               .setAsciiStream(parameterIndex, x, length);
     1578+                       } else {
     1579+                               throw SQLError.createSQLException(
     1580+                                               "No operations allowed after statement closed",
     1581+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1582+                       }
     1583+               } catch (SQLException sqlEx) {
     1584+                       checkAndFireConnectionError(sqlEx);
     1585+               }
     1586+       }
     1587+
     1588+       public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
     1589+               try {
     1590+                       if (this.wrappedStmt != null) {
     1591+                               ((CallableStatement) this.wrappedStmt)
     1592+                                               .setBinaryStream(parameterIndex, x) ;
     1593+                       } else {
     1594+                               throw SQLError.createSQLException(
     1595+                                               "No operations allowed after statement closed",
     1596+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1597+                       }
     1598+               } catch (SQLException sqlEx) {
     1599+                       checkAndFireConnectionError(sqlEx);
     1600+               }
     1601+       }
     1602+
     1603+       public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
     1604+               try {
     1605+                       if (this.wrappedStmt != null) {
     1606+                               ((CallableStatement) this.wrappedStmt)
     1607+                                               .setBinaryStream(parameterIndex, x, length);
     1608+                       } else {
     1609+                               throw SQLError.createSQLException(
     1610+                                               "No operations allowed after statement closed",
     1611+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1612+                       }
     1613+               } catch (SQLException sqlEx) {
     1614+                       checkAndFireConnectionError(sqlEx);
     1615+               }
     1616+       }
     1617+
     1618+       public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
     1619+               try {
     1620+                       if (this.wrappedStmt != null) {
     1621+                               ((CallableStatement) this.wrappedStmt)
     1622+                                               .setBlob(parameterIndex, inputStream);
     1623+                       } else {
     1624+                               throw SQLError.createSQLException(
     1625+                                               "No operations allowed after statement closed",
     1626+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1627+                       }
     1628+               } catch (SQLException sqlEx) {
     1629+                       checkAndFireConnectionError(sqlEx);
     1630+               }
     1631+       }
     1632+
     1633+       public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
     1634+               try {
     1635+                       if (this.wrappedStmt != null) {
     1636+                               ((CallableStatement) this.wrappedStmt)
     1637+                                               .setBlob(parameterIndex, inputStream, length);
     1638+                       } else {
     1639+                               throw SQLError.createSQLException(
     1640+                                               "No operations allowed after statement closed",
     1641+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1642+                       }
     1643+               } catch (SQLException sqlEx) {
     1644+                       checkAndFireConnectionError(sqlEx);
     1645+               }
     1646+       }
     1647+
     1648+       public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
     1649+               try {
     1650+                       if (this.wrappedStmt != null) {
     1651+                               ((CallableStatement) this.wrappedStmt)
     1652+                                               .setCharacterStream(parameterIndex, reader);
     1653+                       } else {
     1654+                               throw SQLError.createSQLException(
     1655+                                               "No operations allowed after statement closed",
     1656+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1657+                       }
     1658+               } catch (SQLException sqlEx) {
     1659+                       checkAndFireConnectionError(sqlEx);
     1660+               }
     1661+       }
     1662+
     1663+       public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
     1664+               try {
     1665+                       if (this.wrappedStmt != null) {
     1666+                               ((CallableStatement) this.wrappedStmt)
     1667+                                               .getCharacterStream(parameterIndex);
     1668+                       } else {
     1669+                               throw SQLError.createSQLException(
     1670+                                               "No operations allowed after statement closed",
     1671+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1672+                       }
     1673+               } catch (SQLException sqlEx) {
     1674+                       checkAndFireConnectionError(sqlEx);
     1675+               }
     1676+       }
     1677+
     1678+       public void setClob(int parameterIndex, Reader reader) throws SQLException {
     1679+               try {
     1680+                       if (this.wrappedStmt != null) {
     1681+                               ((CallableStatement) this.wrappedStmt)
     1682+                                               .setClob(parameterIndex, reader);
     1683+                       } else {
     1684+                               throw SQLError.createSQLException(
     1685+                                               "No operations allowed after statement closed",
     1686+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1687+                       }
     1688+               } catch (SQLException sqlEx) {
     1689+                       checkAndFireConnectionError(sqlEx);
     1690+               }
     1691+       }
     1692+
     1693+       public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
     1694+               try {
     1695+                       if (this.wrappedStmt != null) {
     1696+                               ((CallableStatement) this.wrappedStmt)
     1697+                                               .setClob(parameterIndex, reader, length);
     1698+                       } else {
     1699+                               throw SQLError.createSQLException(
     1700+                                               "No operations allowed after statement closed",
     1701+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1702+                       }
     1703+               } catch (SQLException sqlEx) {
     1704+                       checkAndFireConnectionError(sqlEx);
     1705+               }
     1706+       }
     1707+
     1708+       public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
     1709+               try {
     1710+                       if (this.wrappedStmt != null) {
     1711+                               ((CallableStatement) this.wrappedStmt)
     1712+                                               .setNCharacterStream(parameterIndex, value);
     1713+                       } else {
     1714+                               throw SQLError.createSQLException(
     1715+                                               "No operations allowed after statement closed",
     1716+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1717+                       }
     1718+               } catch (SQLException sqlEx) {
     1719+                       checkAndFireConnectionError(sqlEx);
     1720+               }
     1721+       
     1722+       }
     1723+
     1724+       public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
     1725+               try {
     1726+                       if (this.wrappedStmt != null) {
     1727+                               ((CallableStatement) this.wrappedStmt)
     1728+                                               .setNCharacterStream(parameterIndex, value, length);
     1729+                       } else {
     1730+                               throw SQLError.createSQLException(
     1731+                                               "No operations allowed after statement closed",
     1732+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1733+                       }
     1734+               } catch (SQLException sqlEx) {
     1735+                       checkAndFireConnectionError(sqlEx);
     1736+               }
     1737+       }
     1738+
     1739+       public void setNClob(int parameterIndex, NClob value) throws SQLException {
     1740+               try {
     1741+                       if (this.wrappedStmt != null) {
     1742+                               ((CallableStatement) this.wrappedStmt)
     1743+                                               .setNClob(parameterIndex, value);
     1744+                       } else {
     1745+                               throw SQLError.createSQLException(
     1746+                                               "No operations allowed after statement closed",
     1747+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1748+                       }
     1749+               } catch (SQLException sqlEx) {
     1750+                       checkAndFireConnectionError(sqlEx);
     1751+               }
     1752+       }
     1753+
     1754+       public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     1755+               try {
     1756+                       if (this.wrappedStmt != null) {
     1757+                               ((CallableStatement) this.wrappedStmt)
     1758+                                               .setNClob(parameterIndex, reader);
     1759+                       } else {
     1760+                               throw SQLError.createSQLException(
     1761+                                               "No operations allowed after statement closed",
     1762+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1763+                       }
     1764+               } catch (SQLException sqlEx) {
     1765+                       checkAndFireConnectionError(sqlEx);
     1766+               }
     1767+       }
     1768+
     1769+       public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
     1770+               try {
     1771+                       if (this.wrappedStmt != null) {
     1772+                               ((CallableStatement) this.wrappedStmt)
     1773+                                               .setNClob(parameterIndex, reader, length);
     1774+                       } else {
     1775+                               throw SQLError.createSQLException(
     1776+                                               "No operations allowed after statement closed",
     1777+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1778+                       }
     1779+               } catch (SQLException sqlEx) {
     1780+                       checkAndFireConnectionError(sqlEx);
     1781+               }
     1782+       }
     1783+
     1784+       public void setNString(int parameterIndex, String value) throws SQLException {
     1785+               try {
     1786+                       if (this.wrappedStmt != null) {
     1787+                               ((CallableStatement) this.wrappedStmt)
     1788+                                               .setNString(parameterIndex, value);
     1789+                       } else {
     1790+                               throw SQLError.createSQLException(
     1791+                                               "No operations allowed after statement closed",
     1792+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1793+                       }
     1794+               } catch (SQLException sqlEx) {
     1795+                       checkAndFireConnectionError(sqlEx);
     1796+               }
     1797+       }
     1798+
     1799+       public void setRowId(int parameterIndex, RowId x) throws SQLException {
     1800+               try {
     1801+                       if (this.wrappedStmt != null) {
     1802+                               ((CallableStatement) this.wrappedStmt)
     1803+                                               .setRowId(parameterIndex, x);
     1804+                       } else {
     1805+                               throw SQLError.createSQLException(
     1806+                                               "No operations allowed after statement closed",
     1807+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1808+                       }
     1809+               } catch (SQLException sqlEx) {
     1810+                       checkAndFireConnectionError(sqlEx);
     1811+               }
     1812+       }
     1813+
     1814+       public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
     1815+               try {
     1816+                       if (this.wrappedStmt != null) {
     1817+                               ((CallableStatement) this.wrappedStmt)
     1818+                                               .setSQLXML(parameterIndex, xmlObject);
     1819+                       } else {
     1820+                               throw SQLError.createSQLException(
     1821+                                               "No operations allowed after statement closed",
     1822+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1823+                       }
     1824+               } catch (SQLException sqlEx) {
     1825+                       checkAndFireConnectionError(sqlEx);
     1826+               }
     1827+               
     1828+       }
     1829+
     1830+       public boolean isClosed() throws SQLException {
     1831+               try {
     1832+                       if (this.wrappedStmt != null) {
     1833+                               return ((CallableStatement) this.wrappedStmt)
     1834+                                               .isClosed();
     1835+                       } else {
     1836+                               throw SQLError.createSQLException(
     1837+                                               "No operations allowed after statement closed",
     1838+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1839+                       }
     1840+               } catch (SQLException sqlEx) {
     1841+                       checkAndFireConnectionError(sqlEx);
     1842+               }
     1843+               
     1844+               return true;
     1845+       }
     1846+
     1847+       public boolean isPoolable() throws SQLException {
     1848+               try {
     1849+                       if (this.wrappedStmt != null) {
     1850+                               return ((CallableStatement) this.wrappedStmt)
     1851+                                               . isPoolable();
     1852+                       } else {
     1853+                               throw SQLError.createSQLException(
     1854+                                               "No operations allowed after statement closed",
     1855+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     1856+                       }
     1857+               } catch (SQLException sqlEx) {
     1858+                       checkAndFireConnectionError(sqlEx);
     1859+               }
     1860+               
     1861+               return false;
     1862+       }
     1863+
     1864 //     public void setPoolable(boolean poolable) throws SQLException {
     1865 //             try {
     1866 //                     if (this.wrappedStmt != null) {
     1867--- src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java.orig       2009-11-28 18:58:49.000000000 +0100
     1868+++ src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java    2009-11-29 01:26:55.000000000 +0100
     1869@@ -25,10 +25,18 @@
     1870 package com.mysql.jdbc.jdbc2.optional;
     1871 
     1872 import java.lang.reflect.Constructor;
     1873+import java.sql.Array;
     1874+import java.sql.Blob;
     1875+import java.sql.Clob;
     1876+import java.sql.NClob;
     1877+import java.sql.SQLClientInfoException;
     1878 import java.sql.SQLException;
     1879+import java.sql.SQLXML;
     1880 import java.sql.Savepoint;
     1881 import java.sql.Statement;
     1882+import java.sql.Struct;
     1883 import java.util.Map;
     1884+import java.util.Properties;
     1885 import java.util.TimeZone;
     1886 
     1887 import com.mysql.jdbc.Connection;
     1888@@ -2619,4 +2627,58 @@
     1889                        boolean queryTimeoutKillsConnection) {
     1890                this.mc.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
     1891        }
     1892+
     1893+       public boolean isValid(int timeout) throws SQLException {
     1894+               return this.isValid(timeout);
     1895+       }
     1896+
     1897+       public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     1898+               return this.mc.createArrayOf(typeName, elements);
     1899+       }
     1900+
     1901+       public Blob createBlob() throws SQLException {
     1902+               return this.mc.createBlob();
     1903+       }
     1904+
     1905+       public Clob createClob() throws SQLException {
     1906+               return this.mc.createClob();
     1907+       }
     1908+
     1909+       public NClob createNClob() throws SQLException {
     1910+               return this.mc.createNClob();
     1911+       }
     1912+
     1913+       public SQLXML createSQLXML() throws SQLException {
     1914+               return this.mc.createSQLXML();
     1915+       }
     1916+
     1917+       public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     1918+               return this.mc.createStruct(typeName, attributes);
     1919+       }
     1920+
     1921+       public Properties getClientInfo() throws SQLException {
     1922+               return this.mc.getClientInfo();
     1923+       }
     1924+
     1925+       public String getClientInfo(String name) throws SQLException {
     1926+               return this.mc.getClientInfo(name);
     1927+       }
     1928+
     1929+       public void setClientInfo(Properties properties)
     1930+                       throws SQLClientInfoException {
     1931+               this.mc.setClientInfo(properties);
     1932+       }
     1933+
     1934+       public void setClientInfo(String name, String value)
     1935+                       throws SQLClientInfoException {
     1936+               this.mc.setClientInfo(name, value);
     1937+       }
     1938+
     1939+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1940+               throw SQLError.notImplemented();
     1941+       }
     1942+
     1943+       public <T> T unwrap(Class<T> iface) throws SQLException {
     1944+               throw SQLError.notImplemented();
     1945+       }
     1946 }
     1947--- src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java.orig 2009-11-28 18:58:49.000000000 +0100
     1948+++ src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java      2009-11-29 01:15:15.000000000 +0100
     1949@@ -38,6 +38,7 @@
     1950 
     1951 import com.mysql.jdbc.ConnectionPropertiesImpl;
     1952 import com.mysql.jdbc.NonRegisteringDriver;
     1953+import com.mysql.jdbc.SQLError;
     1954 
     1955 /**
     1956  * A JNDI DataSource for a Mysql JDBC connection
     1957@@ -438,12 +439,12 @@
     1958               
     1959                return mysqlDriver.connect(jdbcUrlToUse, props);
     1960        }
     1961-//
     1962-//     public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1963-//             throw SQLError.notImplemented();
     1964-//     }
     1965-//
     1966-//     public <T> T unwrap(Class<T> iface) throws SQLException {
     1967-//             throw SQLError.notImplemented();
     1968-//     }
     1969+
     1970+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     1971+               throw SQLError.notImplemented();
     1972+       }
     1973+
     1974+       public <T> T unwrap(Class<T> iface) throws SQLException {
     1975+               throw SQLError.notImplemented();
     1976+       }
     1977 }
     1978--- src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java.orig   2009-11-28 18:58:49.000000000 +0100
     1979+++ src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java        2009-11-29 01:20:09.000000000 +0100
     1980@@ -33,6 +33,7 @@
     1981 import javax.sql.ConnectionEvent;
     1982 import javax.sql.ConnectionEventListener;
     1983 import javax.sql.PooledConnection;
     1984+import javax.sql.StatementEventListener;
     1985 
     1986 import com.mysql.jdbc.ConnectionImpl;
     1987 import com.mysql.jdbc.ExceptionInterceptor;
     1988@@ -255,4 +256,10 @@
     1989        protected ExceptionInterceptor getExceptionInterceptor() {
     1990                return this.exceptionInterceptor;
     1991        }
     1992+
     1993+       public void addStatementEventListener(StatementEventListener listener) {
     1994+       }
     1995+
     1996+       public void removeStatementEventListener(StatementEventListener listener) {
     1997+       }
     1998 }
     1999\ No newline at end of file
     2000--- src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java.orig        2009-11-28 21:35:25.000000000 +0100
     2001+++ src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java     2009-11-29 01:24:42.000000000 +0100
     2002@@ -33,12 +33,15 @@
     2003 import java.sql.Blob;
     2004 import java.sql.Clob;
     2005 import java.sql.Date;
     2006+import java.sql.NClob;
     2007 import java.sql.ParameterMetaData;
     2008 import java.sql.PreparedStatement;
     2009 import java.sql.Ref;
     2010 import java.sql.ResultSet;
     2011 import java.sql.ResultSetMetaData;
     2012+import java.sql.RowId;
     2013 import java.sql.SQLException;
     2014+import java.sql.SQLXML;
     2015 import java.sql.Time;
     2016 import java.sql.Timestamp;
     2017 import java.util.Calendar;
     2018@@ -885,323 +888,323 @@
     2019 
     2020                // that out
     2021        }
     2022-//
     2023-//     public void setAsciiStream(int parameterIndex, InputStream x)
     2024-//                     throws SQLException {
     2025-//             try {
     2026-//                     if (this.wrappedStmt != null) {
     2027-//                             ((PreparedStatement) this.wrappedStmt).setAsciiStream(
     2028-//                                             parameterIndex, x);
     2029-//                     } else {
     2030-//                             throw SQLError.createSQLException(
     2031-//                                             "No operations allowed after statement closed",
     2032-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2033-//                     }
     2034-//             } catch (SQLException sqlEx) {
     2035-//                     checkAndFireConnectionError(sqlEx);
     2036-//             }
     2037-//     }
     2038-//
     2039-//     public void setAsciiStream(int parameterIndex, InputStream x, long length)
     2040-//                     throws SQLException {
     2041-//             try {
     2042-//                     if (this.wrappedStmt != null) {
     2043-//                             ((PreparedStatement) this.wrappedStmt).setAsciiStream(
     2044-//                                             parameterIndex, x, length);
     2045-//                     } else {
     2046-//                             throw SQLError.createSQLException(
     2047-//                                             "No operations allowed after statement closed",
     2048-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2049-//                     }
     2050-//             } catch (SQLException sqlEx) {
     2051-//                     checkAndFireConnectionError(sqlEx);
     2052-//             }
     2053-//     }
     2054-//
     2055-//     public void setBinaryStream(int parameterIndex, InputStream x)
     2056-//                     throws SQLException {
     2057-//             try {
     2058-//                     if (this.wrappedStmt != null) {
     2059-//                             ((PreparedStatement) this.wrappedStmt).setBinaryStream(
     2060-//                                             parameterIndex, x);
     2061-//                     } else {
     2062-//                             throw SQLError.createSQLException(
     2063-//                                             "No operations allowed after statement closed",
     2064-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2065-//                     }
     2066-//             } catch (SQLException sqlEx) {
     2067-//                     checkAndFireConnectionError(sqlEx);
     2068-//             }
     2069-//     }
     2070-//
     2071-//     public void setBinaryStream(int parameterIndex, InputStream x, long length)
     2072-//                     throws SQLException {
     2073-//             try {
     2074-//                     if (this.wrappedStmt != null) {
     2075-//                             ((PreparedStatement) this.wrappedStmt).setBinaryStream(
     2076-//                                             parameterIndex, x, length);
     2077-//                     } else {
     2078-//                             throw SQLError.createSQLException(
     2079-//                                             "No operations allowed after statement closed",
     2080-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2081-//                     }
     2082-//             } catch (SQLException sqlEx) {
     2083-//                     checkAndFireConnectionError(sqlEx);
     2084-//             }
     2085-//     }
     2086-//
     2087-//     public void setBlob(int parameterIndex, InputStream inputStream)
     2088-//                     throws SQLException {
     2089-//             try {
     2090-//                     if (this.wrappedStmt != null) {
     2091-//                             ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
     2092-//                                             inputStream);
     2093-//                     } else {
     2094-//                             throw SQLError.createSQLException(
     2095-//                                             "No operations allowed after statement closed",
     2096-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2097-//                     }
     2098-//             } catch (SQLException sqlEx) {
     2099-//                     checkAndFireConnectionError(sqlEx);
     2100-//             }
     2101-//     }
     2102-//
     2103-//     public void setBlob(int parameterIndex, InputStream inputStream, long length)
     2104-//                     throws SQLException {
     2105-//             try {
     2106-//                     if (this.wrappedStmt != null) {
     2107-//                             ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
     2108-//                                             inputStream, length);
     2109-//                     } else {
     2110-//                             throw SQLError.createSQLException(
     2111-//                                             "No operations allowed after statement closed",
     2112-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2113-//                     }
     2114-//             } catch (SQLException sqlEx) {
     2115-//                     checkAndFireConnectionError(sqlEx);
     2116-//             }
     2117-//     }
     2118-//
     2119-//     public void setCharacterStream(int parameterIndex, Reader reader)
     2120-//                     throws SQLException {
     2121-//             try {
     2122-//                     if (this.wrappedStmt != null) {
     2123-//                             ((PreparedStatement) this.wrappedStmt).setCharacterStream(
     2124-//                                             parameterIndex, reader);
     2125-//                     } else {
     2126-//                             throw SQLError.createSQLException(
     2127-//                                             "No operations allowed after statement closed",
     2128-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2129-//                     }
     2130-//             } catch (SQLException sqlEx) {
     2131-//                     checkAndFireConnectionError(sqlEx);
     2132-//             }
     2133-//     }
     2134-//
     2135-//     public void setCharacterStream(int parameterIndex, Reader reader,
     2136-//                     long length) throws SQLException {
     2137-//             try {
     2138-//                     if (this.wrappedStmt != null) {
     2139-//                             ((PreparedStatement) this.wrappedStmt).setCharacterStream(
     2140-//                                             parameterIndex, reader, length);
     2141-//                     } else {
     2142-//                             throw SQLError.createSQLException(
     2143-//                                             "No operations allowed after statement closed",
     2144-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2145-//                     }
     2146-//             } catch (SQLException sqlEx) {
     2147-//                     checkAndFireConnectionError(sqlEx);
     2148-//             }
     2149-//     }
     2150-//
     2151-//     public void setClob(int parameterIndex, Reader reader) throws SQLException {
     2152-//             try {
     2153-//                     if (this.wrappedStmt != null) {
     2154-//                             ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
     2155-//                                             reader);
     2156-//                     } else {
     2157-//                             throw SQLError.createSQLException(
     2158-//                                             "No operations allowed after statement closed",
     2159-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2160-//                     }
     2161-//             } catch (SQLException sqlEx) {
     2162-//                     checkAndFireConnectionError(sqlEx);
     2163-//             }
     2164-//     }
     2165-//
     2166-//     public void setClob(int parameterIndex, Reader reader, long length)
     2167-//                     throws SQLException {
     2168-//             try {
     2169-//                     if (this.wrappedStmt != null) {
     2170-//                             ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
     2171-//                                             reader, length);
     2172-//                     } else {
     2173-//                             throw SQLError.createSQLException(
     2174-//                                             "No operations allowed after statement closed",
     2175-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2176-//                     }
     2177-//             } catch (SQLException sqlEx) {
     2178-//                     checkAndFireConnectionError(sqlEx);
     2179-//             }
     2180-//     }
     2181-//
     2182-//     public void setNCharacterStream(int parameterIndex, Reader value)
     2183-//                     throws SQLException {
     2184-//             try {
     2185-//                     if (this.wrappedStmt != null) {
     2186-//                             ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
     2187-//                                             parameterIndex, value);
     2188-//                     } else {
     2189-//                             throw SQLError.createSQLException(
     2190-//                                             "No operations allowed after statement closed",
     2191-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2192-//                     }
     2193-//             } catch (SQLException sqlEx) {
     2194-//                     checkAndFireConnectionError(sqlEx);
     2195-//             }
     2196-//     }
     2197-//
     2198-//     public void setNCharacterStream(int parameterIndex, Reader value,
     2199-//                     long length) throws SQLException {
     2200-//             try {
     2201-//                     if (this.wrappedStmt != null) {
     2202-//                             ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
     2203-//                                             parameterIndex, value, length);
     2204-//                     } else {
     2205-//                             throw SQLError.createSQLException(
     2206-//                                             "No operations allowed after statement closed",
     2207-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2208-//                     }
     2209-//             } catch (SQLException sqlEx) {
     2210-//                     checkAndFireConnectionError(sqlEx);
     2211-//             }
     2212-//     }
     2213-//
     2214-//     public void setNClob(int parameterIndex, NClob value) throws SQLException {
     2215-//             try {
     2216-//                     if (this.wrappedStmt != null) {
     2217-//                             ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2218-//                                             value);
     2219-//                     } else {
     2220-//                             throw SQLError.createSQLException(
     2221-//                                             "No operations allowed after statement closed",
     2222-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2223-//                     }
     2224-//             } catch (SQLException sqlEx) {
     2225-//                     checkAndFireConnectionError(sqlEx);
     2226-//             }
     2227-//     }
     2228-//
     2229-//     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     2230-//             try {
     2231-//                     if (this.wrappedStmt != null) {
     2232-//                             ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2233-//                                             reader);
     2234-//                     } else {
     2235-//                             throw SQLError.createSQLException(
     2236-//                                             "No operations allowed after statement closed",
     2237-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2238-//                     }
     2239-//             } catch (SQLException sqlEx) {
     2240-//                     checkAndFireConnectionError(sqlEx);
     2241-//             }
     2242-//     }
     2243-//
     2244-//     public void setNClob(int parameterIndex, Reader reader, long length)
     2245-//                     throws SQLException {
     2246-//             try {
     2247-//                     if (this.wrappedStmt != null) {
     2248-//                             ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2249-//                                             reader, length);
     2250-//                     } else {
     2251-//                             throw SQLError.createSQLException(
     2252-//                                             "No operations allowed after statement closed",
     2253-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2254-//                     }
     2255-//             } catch (SQLException sqlEx) {
     2256-//                     checkAndFireConnectionError(sqlEx);
     2257-//             }
     2258-//     }
     2259-//
     2260-//     public void setNString(int parameterIndex, String value)
     2261-//                     throws SQLException {
     2262-//             try {
     2263-//                     if (this.wrappedStmt != null) {
     2264-//                             ((PreparedStatement) this.wrappedStmt).setNString(
     2265-//                                             parameterIndex, value);
     2266-//                     } else {
     2267-//                             throw SQLError.createSQLException(
     2268-//                                             "No operations allowed after statement closed",
     2269-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2270-//                     }
     2271-//             } catch (SQLException sqlEx) {
     2272-//                     checkAndFireConnectionError(sqlEx);
     2273-//             }
     2274-//     }
     2275-//
     2276-//     public void setRowId(int parameterIndex, RowId x) throws SQLException {
     2277-//             try {
     2278-//                     if (this.wrappedStmt != null) {
     2279-//                             ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
     2280-//                                             x);
     2281-//                     } else {
     2282-//                             throw SQLError.createSQLException(
     2283-//                                             "No operations allowed after statement closed",
     2284-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2285-//                     }
     2286-//             } catch (SQLException sqlEx) {
     2287-//                     checkAndFireConnectionError(sqlEx);
     2288-//             }
     2289-//     }
     2290-//
     2291-//     public void setSQLXML(int parameterIndex, SQLXML xmlObject)
     2292-//                     throws SQLException {
     2293-//             try {
     2294-//                     if (this.wrappedStmt != null) {
     2295-//                             ((PreparedStatement) this.wrappedStmt).setSQLXML(
     2296-//                                             parameterIndex, xmlObject);
     2297-//                     } else {
     2298-//                             throw SQLError.createSQLException(
     2299-//                                             "No operations allowed after statement closed",
     2300-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2301-//                     }
     2302-//             } catch (SQLException sqlEx) {
     2303-//                     checkAndFireConnectionError(sqlEx);
     2304-//             }
     2305-//     }
     2306-//
     2307-//     public boolean isClosed() throws SQLException {
     2308-//             try {
     2309-//                     if (this.wrappedStmt != null) {
     2310-//                             return ((PreparedStatement) this.wrappedStmt).isClosed();
     2311-//                     } else {
     2312-//                             throw SQLError.createSQLException(
     2313-//                                             "No operations allowed after statement closed",
     2314-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2315-//                     }
     2316-//             } catch (SQLException sqlEx) {
     2317-//                     checkAndFireConnectionError(sqlEx);
     2318-//             }
     2319-//
     2320-//             return true;
     2321-//     }
     2322-//
     2323-//     public boolean isPoolable() throws SQLException {
     2324-//             try {
     2325-//                     if (this.wrappedStmt != null) {
     2326-//                             return ((PreparedStatement) this.wrappedStmt).isPoolable();
     2327-//                     } else {
     2328-//                             throw SQLError.createSQLException(
     2329-//                                             "No operations allowed after statement closed",
     2330-//                                             SQLError.SQL_STATE_GENERAL_ERROR);
     2331-//                     }
     2332-//             } catch (SQLException sqlEx) {
     2333-//                     checkAndFireConnectionError(sqlEx);
     2334-//             }
     2335-//
     2336-//             return false;
     2337-//     }
     2338-//
     2339+
     2340+       public void setAsciiStream(int parameterIndex, InputStream x)
     2341+                       throws SQLException {
     2342+               try {
     2343+                       if (this.wrappedStmt != null) {
     2344+                               ((PreparedStatement) this.wrappedStmt).setAsciiStream(
     2345+                                               parameterIndex, x);
     2346+                       } else {
     2347+                               throw SQLError.createSQLException(
     2348+                                               "No operations allowed after statement closed",
     2349+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2350+                       }
     2351+               } catch (SQLException sqlEx) {
     2352+                       checkAndFireConnectionError(sqlEx);
     2353+               }
     2354+       }
     2355+
     2356+       public void setAsciiStream(int parameterIndex, InputStream x, long length)
     2357+                       throws SQLException {
     2358+               try {
     2359+                       if (this.wrappedStmt != null) {
     2360+                               ((PreparedStatement) this.wrappedStmt).setAsciiStream(
     2361+                                               parameterIndex, x, length);
     2362+                       } else {
     2363+                               throw SQLError.createSQLException(
     2364+                                               "No operations allowed after statement closed",
     2365+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2366+                       }
     2367+               } catch (SQLException sqlEx) {
     2368+                       checkAndFireConnectionError(sqlEx);
     2369+               }
     2370+       }
     2371+
     2372+       public void setBinaryStream(int parameterIndex, InputStream x)
     2373+                       throws SQLException {
     2374+               try {
     2375+                       if (this.wrappedStmt != null) {
     2376+                               ((PreparedStatement) this.wrappedStmt).setBinaryStream(
     2377+                                               parameterIndex, x);
     2378+                       } else {
     2379+                               throw SQLError.createSQLException(
     2380+                                               "No operations allowed after statement closed",
     2381+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2382+                       }
     2383+               } catch (SQLException sqlEx) {
     2384+                       checkAndFireConnectionError(sqlEx);
     2385+               }
     2386+       }
     2387+
     2388+       public void setBinaryStream(int parameterIndex, InputStream x, long length)
     2389+                       throws SQLException {
     2390+               try {
     2391+                       if (this.wrappedStmt != null) {
     2392+                               ((PreparedStatement) this.wrappedStmt).setBinaryStream(
     2393+                                               parameterIndex, x, length);
     2394+                       } else {
     2395+                               throw SQLError.createSQLException(
     2396+                                               "No operations allowed after statement closed",
     2397+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2398+                       }
     2399+               } catch (SQLException sqlEx) {
     2400+                       checkAndFireConnectionError(sqlEx);
     2401+               }
     2402+       }
     2403+
     2404+       public void setBlob(int parameterIndex, InputStream inputStream)
     2405+                       throws SQLException {
     2406+               try {
     2407+                       if (this.wrappedStmt != null) {
     2408+                               ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
     2409+                                               inputStream);
     2410+                       } else {
     2411+                               throw SQLError.createSQLException(
     2412+                                               "No operations allowed after statement closed",
     2413+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2414+                       }
     2415+               } catch (SQLException sqlEx) {
     2416+                       checkAndFireConnectionError(sqlEx);
     2417+               }
     2418+       }
     2419+
     2420+       public void setBlob(int parameterIndex, InputStream inputStream, long length)
     2421+                       throws SQLException {
     2422+               try {
     2423+                       if (this.wrappedStmt != null) {
     2424+                               ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
     2425+                                               inputStream, length);
     2426+                       } else {
     2427+                               throw SQLError.createSQLException(
     2428+                                               "No operations allowed after statement closed",
     2429+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2430+                       }
     2431+               } catch (SQLException sqlEx) {
     2432+                       checkAndFireConnectionError(sqlEx);
     2433+               }
     2434+       }
     2435+
     2436+       public void setCharacterStream(int parameterIndex, Reader reader)
     2437+                       throws SQLException {
     2438+               try {
     2439+                       if (this.wrappedStmt != null) {
     2440+                               ((PreparedStatement) this.wrappedStmt).setCharacterStream(
     2441+                                               parameterIndex, reader);
     2442+                       } else {
     2443+                               throw SQLError.createSQLException(
     2444+                                               "No operations allowed after statement closed",
     2445+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2446+                       }
     2447+               } catch (SQLException sqlEx) {
     2448+                       checkAndFireConnectionError(sqlEx);
     2449+               }
     2450+       }
     2451+
     2452+       public void setCharacterStream(int parameterIndex, Reader reader,
     2453+                       long length) throws SQLException {
     2454+               try {
     2455+                       if (this.wrappedStmt != null) {
     2456+                               ((PreparedStatement) this.wrappedStmt).setCharacterStream(
     2457+                                               parameterIndex, reader, length);
     2458+                       } else {
     2459+                               throw SQLError.createSQLException(
     2460+                                               "No operations allowed after statement closed",
     2461+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2462+                       }
     2463+               } catch (SQLException sqlEx) {
     2464+                       checkAndFireConnectionError(sqlEx);
     2465+               }
     2466+       }
     2467+
     2468+       public void setClob(int parameterIndex, Reader reader) throws SQLException {
     2469+               try {
     2470+                       if (this.wrappedStmt != null) {
     2471+                               ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
     2472+                                               reader);
     2473+                       } else {
     2474+                               throw SQLError.createSQLException(
     2475+                                               "No operations allowed after statement closed",
     2476+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2477+                       }
     2478+               } catch (SQLException sqlEx) {
     2479+                       checkAndFireConnectionError(sqlEx);
     2480+               }
     2481+       }
     2482+
     2483+       public void setClob(int parameterIndex, Reader reader, long length)
     2484+                       throws SQLException {
     2485+               try {
     2486+                       if (this.wrappedStmt != null) {
     2487+                               ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
     2488+                                               reader, length);
     2489+                       } else {
     2490+                               throw SQLError.createSQLException(
     2491+                                               "No operations allowed after statement closed",
     2492+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2493+                       }
     2494+               } catch (SQLException sqlEx) {
     2495+                       checkAndFireConnectionError(sqlEx);
     2496+               }
     2497+       }
     2498+
     2499+       public void setNCharacterStream(int parameterIndex, Reader value)
     2500+                       throws SQLException {
     2501+               try {
     2502+                       if (this.wrappedStmt != null) {
     2503+                               ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
     2504+                                               parameterIndex, value);
     2505+                       } else {
     2506+                               throw SQLError.createSQLException(
     2507+                                               "No operations allowed after statement closed",
     2508+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2509+                       }
     2510+               } catch (SQLException sqlEx) {
     2511+                       checkAndFireConnectionError(sqlEx);
     2512+               }
     2513+       }
     2514+
     2515+       public void setNCharacterStream(int parameterIndex, Reader value,
     2516+                       long length) throws SQLException {
     2517+               try {
     2518+                       if (this.wrappedStmt != null) {
     2519+                               ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
     2520+                                               parameterIndex, value, length);
     2521+                       } else {
     2522+                               throw SQLError.createSQLException(
     2523+                                               "No operations allowed after statement closed",
     2524+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2525+                       }
     2526+               } catch (SQLException sqlEx) {
     2527+                       checkAndFireConnectionError(sqlEx);
     2528+               }
     2529+       }
     2530+
     2531+       public void setNClob(int parameterIndex, NClob value) throws SQLException {
     2532+               try {
     2533+                       if (this.wrappedStmt != null) {
     2534+                               ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2535+                                               value);
     2536+                       } else {
     2537+                               throw SQLError.createSQLException(
     2538+                                               "No operations allowed after statement closed",
     2539+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2540+                       }
     2541+               } catch (SQLException sqlEx) {
     2542+                       checkAndFireConnectionError(sqlEx);
     2543+               }
     2544+       }
     2545+
     2546+    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
     2547+        try {
     2548+            if (this.wrappedStmt != null) {
     2549+                ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2550+                        reader);
     2551+            } else {
     2552+                throw SQLError.createSQLException(
     2553+                        "No operations allowed after statement closed",
     2554+                        SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2555+            }
     2556+        } catch (SQLException sqlEx) {
     2557+            checkAndFireConnectionError(sqlEx);
     2558+        }
     2559+    }
     2560+
     2561+       public void setNClob(int parameterIndex, Reader reader, long length)
     2562+                       throws SQLException {
     2563+               try {
     2564+                       if (this.wrappedStmt != null) {
     2565+                               ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
     2566+                                               reader, length);
     2567+                       } else {
     2568+                               throw SQLError.createSQLException(
     2569+                                               "No operations allowed after statement closed",
     2570+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2571+                       }
     2572+               } catch (SQLException sqlEx) {
     2573+                       checkAndFireConnectionError(sqlEx);
     2574+               }
     2575+       }
     2576+
     2577+       public void setNString(int parameterIndex, String value)
     2578+                       throws SQLException {
     2579+               try {
     2580+                       if (this.wrappedStmt != null) {
     2581+                               ((PreparedStatement) this.wrappedStmt).setNString(
     2582+                                               parameterIndex, value);
     2583+                       } else {
     2584+                               throw SQLError.createSQLException(
     2585+                                               "No operations allowed after statement closed",
     2586+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2587+                       }
     2588+               } catch (SQLException sqlEx) {
     2589+                       checkAndFireConnectionError(sqlEx);
     2590+               }
     2591+       }
     2592+
     2593+       public void setRowId(int parameterIndex, RowId x) throws SQLException {
     2594+               try {
     2595+                       if (this.wrappedStmt != null) {
     2596+                               ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
     2597+                                               x);
     2598+                       } else {
     2599+                               throw SQLError.createSQLException(
     2600+                                               "No operations allowed after statement closed",
     2601+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2602+                       }
     2603+               } catch (SQLException sqlEx) {
     2604+                       checkAndFireConnectionError(sqlEx);
     2605+               }
     2606+       }
     2607+
     2608+       public void setSQLXML(int parameterIndex, SQLXML xmlObject)
     2609+                       throws SQLException {
     2610+               try {
     2611+                       if (this.wrappedStmt != null) {
     2612+                               ((PreparedStatement) this.wrappedStmt).setSQLXML(
     2613+                                               parameterIndex, xmlObject);
     2614+                       } else {
     2615+                               throw SQLError.createSQLException(
     2616+                                               "No operations allowed after statement closed",
     2617+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2618+                       }
     2619+               } catch (SQLException sqlEx) {
     2620+                       checkAndFireConnectionError(sqlEx);
     2621+               }
     2622+       }
     2623+
     2624+       public boolean isClosed() throws SQLException {
     2625+               try {
     2626+                       if (this.wrappedStmt != null) {
     2627+                               return ((PreparedStatement) this.wrappedStmt).isClosed();
     2628+                       } else {
     2629+                               throw SQLError.createSQLException(
     2630+                                               "No operations allowed after statement closed",
     2631+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2632+                       }
     2633+               } catch (SQLException sqlEx) {
     2634+                       checkAndFireConnectionError(sqlEx);
     2635+               }
     2636+
     2637+               return true;
     2638+       }
     2639+
     2640+       public boolean isPoolable() throws SQLException {
     2641+               try {
     2642+                       if (this.wrappedStmt != null) {
     2643+                               return ((PreparedStatement) this.wrappedStmt).isPoolable();
     2644+                       } else {
     2645+                               throw SQLError.createSQLException(
     2646+                                               "No operations allowed after statement closed",
     2647+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2648+                       }
     2649+               } catch (SQLException sqlEx) {
     2650+                       checkAndFireConnectionError(sqlEx);
     2651+               }
     2652+
     2653+               return false;
     2654+       }
     2655+
     2656 //     public void setPoolable(boolean poolable) throws SQLException {
     2657 //             try {
     2658 //                     if (this.wrappedStmt != null) {
     2659--- src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java.orig        2009-11-28 18:58:49.000000000 +0100
     2660+++ src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java     2009-11-29 01:26:15.000000000 +0100
     2661@@ -864,4 +864,58 @@
     2662                        checkAndFireConnectionError(sqlEx);
     2663                }
     2664        }
     2665+
     2666+       public boolean isPoolable() throws SQLException {
     2667+               try {
     2668+                       if (this.wrappedStmt != null) {
     2669+                               return this.wrappedStmt.isPoolable();
     2670+                       } else {
     2671+                               throw SQLError.createSQLException(
     2672+                                               "No operations allowed after statement closed",
     2673+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2674+                       }
     2675+               } catch (SQLException sqlEx) {
     2676+                       checkAndFireConnectionError(sqlEx);
     2677+               }
     2678+
     2679+               return false;
     2680+       }
     2681+
     2682+       public void setPoolable(boolean poolable) throws SQLException {
     2683+               try {
     2684+                       if (this.wrappedStmt != null) {
     2685+                               this.wrappedStmt.setPoolable(poolable);
     2686+                       } else {
     2687+                               throw SQLError.createSQLException(
     2688+                                               "No operations allowed after statement closed",
     2689+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2690+                       }
     2691+               } catch (SQLException sqlEx) {
     2692+                       checkAndFireConnectionError(sqlEx);
     2693+               }
     2694+       }
     2695+
     2696+       public boolean isClosed() throws SQLException {
     2697+               try {
     2698+                       if (this.wrappedStmt != null) {
     2699+                               return this.wrappedStmt.isClosed();
     2700+                       } else {
     2701+                               throw SQLError.createSQLException(
     2702+                                               "No operations allowed after statement closed",
     2703+                                               SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
     2704+                       }
     2705+               } catch (SQLException sqlEx) {
     2706+                       checkAndFireConnectionError(sqlEx);
     2707+               }
     2708+
     2709+               return true;
     2710+       }
     2711+
     2712+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     2713+               throw SQLError.notImplemented();
     2714+       }
     2715+
     2716+       public <T> T unwrap(Class<T> iface) throws SQLException {
     2717+               throw SQLError.notImplemented();
     2718+       }
     2719 }
     2720--- src/com/mysql/jdbc/PreparedStatement.java.orig      2009-11-28 21:58:03.000000000 +0100
     2721+++ src/com/mysql/jdbc/PreparedStatement.java   2009-11-28 23:30:09.000000000 +0100
     2722@@ -44,10 +44,13 @@
     2723 import java.sql.Clob;
     2724 import java.sql.DatabaseMetaData;
     2725 import java.sql.Date;
     2726+import java.sql.NClob;
     2727 import java.sql.ParameterMetaData;
     2728 import java.sql.Ref;
     2729 import java.sql.ResultSet;
     2730+import java.sql.RowId;
     2731 import java.sql.SQLException;
     2732+import java.sql.SQLXML;
     2733 import java.sql.Time;
     2734 import java.sql.Timestamp;
     2735 import java.sql.Types;
     2736@@ -5595,4 +5598,19 @@
     2737                                                statementStartPos, sql, "SELECT", "\"'`",
     2738                                                "\"'`", false) == -1 && rewritableOdku;
     2739        }
     2740+
     2741+       public void setSQLXML(int parameterIndex, SQLXML xmlObject)
     2742+                       throws SQLException {
     2743+               throw SQLError.notImplemented();
     2744+       }
     2745+
     2746+       public void setNClob(int parameterIndex, NClob value)
     2747+                       throws SQLException {
     2748+               throw SQLError.notImplemented();
     2749+       }
     2750+
     2751+       public void setRowId(int parameterIndex, RowId x)
     2752+                       throws SQLException {
     2753+               throw SQLError.notImplemented();
     2754+       }
     2755 }
     2756--- src/com/mysql/jdbc/ReplicationConnection.java.orig  2009-11-28 18:58:49.000000000 +0100
     2757+++ src/com/mysql/jdbc/ReplicationConnection.java       2009-11-29 00:59:02.000000000 +0100
     2758@@ -21,13 +21,20 @@
     2759  */
     2760 package com.mysql.jdbc;
     2761 
     2762+import java.sql.Array;
     2763+import java.sql.Blob;
     2764 import java.sql.CallableStatement;
     2765+import java.sql.Clob;
     2766 import java.sql.DatabaseMetaData;
     2767+import java.sql.NClob;
     2768 import java.sql.PreparedStatement;
     2769+import java.sql.SQLClientInfoException;
     2770 import java.sql.SQLException;
     2771 import java.sql.SQLWarning;
     2772+import java.sql.SQLXML;
     2773 import java.sql.Savepoint;
     2774 import java.sql.Statement;
     2775+import java.sql.Struct;
     2776 import java.util.Map;
     2777 import java.util.Properties;
     2778 import java.util.TimeZone;
     2779@@ -2412,4 +2419,60 @@
     2780                        boolean queryTimeoutKillsConnection) {
     2781                this.currentConnection.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
     2782        }
     2783+
     2784+       public boolean isValid(int timeout) throws SQLException {
     2785+               return this.currentConnection.isValid(timeout);
     2786+       }
     2787+
     2788+       public Properties getClientInfo() throws SQLException {
     2789+               return this.currentConnection.getClientInfo();
     2790+       }
     2791+
     2792+       public String getClientInfo(String name) throws SQLException {
     2793+               return this.currentConnection.getClientInfo(name);
     2794+       }
     2795+
     2796+       public void setClientInfo(Properties properties)
     2797+                       throws SQLClientInfoException {
     2798+               this.currentConnection.setClientInfo(properties);
     2799+       }
     2800+
     2801+       public void setClientInfo(String name, String value)
     2802+                       throws SQLClientInfoException {
     2803+               this.currentConnection.setClientInfo(name, value);
     2804+       }
     2805+
     2806+       public Array createArrayOf(String typeName, Object[] elements)
     2807+                       throws SQLException {
     2808+               return this.currentConnection.createArrayOf(typeName, elements);
     2809+       }
     2810+
     2811+       public Blob createBlob() throws SQLException {
     2812+               return this.currentConnection.createBlob();
     2813+       }
     2814+
     2815+       public Clob createClob() throws SQLException {
     2816+               return this.currentConnection.createClob();
     2817+       }
     2818+
     2819+       public NClob createNClob() throws SQLException {
     2820+               return this.currentConnection.createNClob();
     2821+       }
     2822+
     2823+       public SQLXML createSQLXML() throws SQLException {
     2824+               return this.currentConnection.createSQLXML();
     2825+       }
     2826+
     2827+       public Struct createStruct(String typeName, Object[] attributes)
     2828+                       throws SQLException {
     2829+               return this.currentConnection.createStruct(typeName, attributes);
     2830+       }
     2831+
     2832+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     2833+               return this.currentConnection.isWrapperFor(iface);
     2834+       }
     2835+
     2836+       public <T> T unwrap(Class<T> iface) throws SQLException {
     2837+               return this.currentConnection.unwrap(iface);
     2838+       }
     2839 }
     2840--- src/com/mysql/jdbc/ResultSetImpl.java.orig  2009-11-28 18:58:49.000000000 +0100
     2841+++ src/com/mysql/jdbc/ResultSetImpl.java       2009-11-29 01:21:22.000000000 +0100
     2842@@ -25,6 +25,7 @@
     2843 package com.mysql.jdbc;
     2844 
     2845 import java.io.ByteArrayInputStream;
     2846+import java.io.Reader;
     2847 import java.io.IOException;
     2848 import java.io.InputStream;
     2849 import java.io.ObjectInputStream;
     2850@@ -36,10 +37,14 @@
     2851 import java.net.MalformedURLException;
     2852 import java.net.URL;
     2853 import java.sql.Array;
     2854+import java.sql.Clob;
     2855 import java.sql.Date;
     2856+import java.sql.NClob;
     2857 import java.sql.Ref;
     2858+import java.sql.RowId;
     2859 import java.sql.SQLException;
     2860 import java.sql.SQLWarning;
     2861+import java.sql.SQLXML;
     2862 import java.sql.Time;
     2863 import java.sql.Timestamp;
     2864 import java.sql.Types;
     2865@@ -8779,4 +8784,244 @@
     2866        protected ExceptionInterceptor getExceptionInterceptor() {
     2867                return this.exceptionInterceptor;
     2868        }
     2869+
     2870+       public boolean isClosed() throws SQLException {
     2871+               return this.isClosed;
     2872+       }
     2873+
     2874+       public int getHoldability() throws SQLException {
     2875+               throw SQLError.notImplemented();
     2876+       }
     2877+
     2878+       public void updateAsciiStream(int columnIndex, InputStream inputStream)
     2879+                       throws SQLException {
     2880+               throw new NotUpdatable();
     2881+       }
     2882+
     2883+       public void updateAsciiStream(String columnLabel, InputStream inputStream)
     2884+                       throws SQLException {
     2885+               updateAsciiStream(findColumn(columnLabel), inputStream);
     2886+       }
     2887+
     2888+       public void updateAsciiStream(int columnIndex, InputStream inputStream,
     2889+                       long length) throws SQLException {
     2890+               throw new NotUpdatable();
     2891+       }
     2892+
     2893+       public void updateAsciiStream(String columnLabel, InputStream inputStream,
     2894+                       long length) throws SQLException {
     2895+               updateAsciiStream(findColumn(columnLabel), inputStream, length);
     2896+       }
     2897+
     2898+       public void updateBinaryStream(int columnIndex, InputStream inputStream)
     2899+                       throws SQLException {
     2900+               throw new NotUpdatable();
     2901+       }
     2902+
     2903+       public void updateBinaryStream(String columnLabel,
     2904+                       InputStream inputStream) throws SQLException {
     2905+               updateBinaryStream(findColumn(columnLabel), inputStream);
     2906+       }
     2907+
     2908+       public void updateBinaryStream(int columnIndex, InputStream inputStream,
     2909+                       long length) throws SQLException {
     2910+               throw new NotUpdatable();
     2911+       }
     2912+
     2913+       public void updateBinaryStream(String columnLabel, InputStream inputStream,
     2914+                       long length) throws SQLException {
     2915+               updateBinaryStream(findColumn(columnLabel), inputStream, length);
     2916+       }
     2917+
     2918+       public void updateBlob(int columnIndex, InputStream inputStream)
     2919+                       throws SQLException {
     2920+               throw new NotUpdatable();
     2921+       }
     2922+
     2923+       public void updateBlob(String columnLabel, InputStream inputStream)
     2924+                       throws SQLException {
     2925+               updateBlob(findColumn(columnLabel), inputStream);
     2926+       }
     2927+
     2928+       public void updateBlob(int columnIndex, InputStream inputStream,
     2929+                       long length) throws SQLException {
     2930+               throw new NotUpdatable();
     2931+       }
     2932+
     2933+       public void updateBlob(String columnLabel, InputStream inputStream,
     2934+                       long length) throws SQLException {
     2935+               updateBlob(findColumn(columnLabel), inputStream, length);
     2936+       }
     2937+
     2938+       public void updateCharacterStream(int columnIndex, Reader reader)
     2939+                       throws SQLException {
     2940+               throw new NotUpdatable();
     2941+       }
     2942+
     2943+       public void updateCharacterStream(String columnLabel, Reader reader)
     2944+                       throws SQLException {
     2945+               updateCharacterStream(findColumn(columnLabel), reader);
     2946+       }
     2947+
     2948+       public void updateCharacterStream(int columnIndex, Reader reader,
     2949+                       long length) throws SQLException {
     2950+               throw new NotUpdatable();
     2951+       }
     2952+
     2953+       public void updateCharacterStream(String columnLabel, Reader reader,
     2954+                       long length) throws SQLException {
     2955+               updateCharacterStream(findColumn(columnLabel), reader, length);
     2956+       }
     2957+
     2958+       public void updateClob(int columnIndex, Reader reader)
     2959+                       throws SQLException {
     2960+               throw new NotUpdatable();
     2961+       }
     2962+
     2963+       public void updateClob(String columnLabel, Reader reader)
     2964+                       throws SQLException {
     2965+               updateClob(findColumn(columnLabel), reader);
     2966+       }
     2967+
     2968+       public void updateClob(int columnIndex, Reader reader, long length)
     2969+                       throws SQLException {
     2970+               throw new NotUpdatable();
     2971+       }
     2972+
     2973+       public void updateClob(String columnLabel, Reader reader, long length)
     2974+                       throws SQLException {
     2975+               updateClob(findColumn(columnLabel), reader, length);
     2976+       }
     2977+
     2978+       public Reader getNCharacterStream(int columnIndex)
     2979+                       throws SQLException {
     2980+               throw SQLError.notImplemented();
     2981+       }
     2982+
     2983+       public Reader getNCharacterStream(String columnLabel)
     2984+                       throws SQLException {
     2985+               return getNCharacterStream(findColumn(columnLabel));
     2986+       }
     2987+
     2988+       public void updateNCharacterStream(int columnIndex, Reader reader)
     2989+                       throws SQLException {
     2990+               throw new NotUpdatable();
     2991+       }
     2992+
     2993+       public void updateNCharacterStream(String columnLabel, Reader reader)
     2994+                       throws SQLException {
     2995+               updateNCharacterStream(findColumn(columnLabel), reader);
     2996+       }
     2997+
     2998+       public void updateNCharacterStream(int columnIndex, Reader reader,
     2999+                       long length) throws SQLException {
     3000+               throw new NotUpdatable();
     3001+       }
     3002+
     3003+       public void updateNCharacterStream(String columnLabel, Reader reader,
     3004+                       long length) throws SQLException {
     3005+               updateNCharacterStream(findColumn(columnLabel), reader, length);
     3006+       }
     3007+
     3008+       public NClob getNClob(int columnIndex)
     3009+                       throws SQLException {
     3010+               throw SQLError.notImplemented();
     3011+       }
     3012+
     3013+       public NClob getNClob(String columnLabel)
     3014+                       throws SQLException {
     3015+               return getNClob(findColumn(columnLabel));
     3016+       }
     3017+
     3018+       public void updateNClob(int columnIndex, NClob value)
     3019+                       throws SQLException {
     3020+               throw new NotUpdatable();
     3021+       }
     3022+
     3023+       public void updateNClob(String columnLabel, NClob value)
     3024+                       throws SQLException {
     3025+               updateNClob(findColumn(columnLabel), value);
     3026+       }
     3027+
     3028+       public void updateNClob(int columnIndex, Reader reader)
     3029+                       throws SQLException {
     3030+               throw new NotUpdatable();
     3031+       }
     3032+
     3033+       public void updateNClob(String columnLabel, Reader reader)
     3034+                       throws SQLException {
     3035+               updateNClob(findColumn(columnLabel), reader);
     3036+       }
     3037+
     3038+       public void updateNClob(int columnIndex, Reader reader, long length)
     3039+                       throws SQLException {
     3040+               throw new NotUpdatable();
     3041+       }
     3042+
     3043+       public void updateNClob(String columnLabel, Reader reader, long length)
     3044+                       throws SQLException {
     3045+               updateNClob(findColumn(columnLabel), reader, length);
     3046+       }
     3047+
     3048+       public String getNString(int columnIndex) throws SQLException {
     3049+               throw SQLError.notImplemented();
     3050+       }
     3051+
     3052+       public String getNString(String columnLabel) throws SQLException {
     3053+               return getNString(findColumn(columnLabel));
     3054+       }
     3055+
     3056+       public void updateNString(int columnIndex, String value)
     3057+                       throws SQLException {
     3058+               throw new NotUpdatable();
     3059+       }
     3060+
     3061+       public void updateNString(String columnLabel, String value)
     3062+                       throws SQLException {
     3063+               updateNString(findColumn(columnLabel), value);
     3064+       }
     3065+
     3066+       public SQLXML getSQLXML(int columnIndex) throws SQLException {
     3067+               throw SQLError.notImplemented();
     3068+       }
     3069+
     3070+       public SQLXML getSQLXML(String columnLabel) throws SQLException {
     3071+               return getSQLXML(findColumn(columnLabel));
     3072+       }
     3073+
     3074+       public void updateSQLXML(int columnIndex, SQLXML xmlObject)
     3075+                       throws SQLException {
     3076+               throw new NotUpdatable();
     3077+       }
     3078+
     3079+       public void updateSQLXML(String columnLabel, SQLXML xmlObject)
     3080+                       throws SQLException {
     3081+               updateSQLXML(findColumn(columnLabel), xmlObject);
     3082+       }
     3083+
     3084+       public RowId getRowId(int columnIndex) throws SQLException {
     3085+               throw SQLError.notImplemented();
     3086+       }
     3087+
     3088+       public RowId getRowId(String columnLabel) throws SQLException {
     3089+               return getRowId(findColumn(columnLabel));
     3090+       }
     3091+
     3092+       public void updateRowId(int columnIndex, RowId x)
     3093+                       throws SQLException {
     3094+               throw new NotUpdatable();
     3095+       }
     3096+
     3097+       public void updateRowId(String columnLabel, RowId x)
     3098+                       throws SQLException {
     3099+               updateRowId(findColumn(columnLabel), x);
     3100+       }
     3101+
     3102+       public boolean isWrapperFor(Class<?> iface) throws SQLException {
     3103+               throw SQLError.notImplemented();
     3104+       }
     3105+
     3106+       public <T> T unwrap(Class<T> iface) throws SQLException {
     3107+               throw SQLError.notImplemented();
     3108+       }
     3109 }
  • Portfile

     
    33PortSystem 1.0
    44
    55name                            mysql-connector-java
    6 version                         5.0.7
     6version                         5.1.10
    77
    88categories                      java
    99maintainers                     jberry openmaintainer
     
    2121homepage                        http://dev.mysql.com/doc/refman/5.0/en/connector-j.html
    2222
    2323master_sites            http://ftp.plusline.de/mysql/Downloads/Connector-J/
    24 checksums                       md5 d177ce7397b119f013458cec0418ad2d \
    25                                 sha1 df3b78d1108f89485fb8c9711ee39c376d0391eb \
    26                                 rmd160 eae7454d156c7726ab2e96017e8b6f4fe0c61ab9
     24checksums           md5     f9da616de868ddd1acf1428334f3313d \
     25                    sha1    32938f3004c70a657a7481496bc3813b85df20de \
     26                    rmd160  ef5b6cf4cceaac0c6d32858920c362bab6004bc1
    2727
    2828patchfiles                      patch-build.xml
    2929
     
    5050        file copy ${worksrcpath}/docs ${destroot}${prefix}/share/doc/${name}
    5151}
    5252
     53platform darwin 10 {
     54        post-patch {
     55                reinplace -E {/name="compile"/s/compile-testsuite, //} \
     56                        ${worksrcpath}/build.xml
     57        }
     58
     59        patchfiles-append patch-JDK-1.6.diff
     60}
     61
    5362livecheck.check regex
    5463livecheck.url   http://dev.mysql.com/downloads/connector/j/5.0.html
    5564livecheck.regex "${name}-(\\d+\\.\\d+(\\.\\d+)?).tar.gz"