| | 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 | } |
