New Ticket     Wiki     Browse Source     Timeline     Roadmap     Ticket Reports     Search

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

File mysql-connector-java-JDK-1.6.diff, 99.6 KB (added by nox@…, 2 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"