1 /*
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.sql;
27
28 import java.math.BigDecimal;
29 import java.util.Calendar;
30 import java.io.Reader;
31 import java.io.InputStream;
32
33 /**
34 * The interface used to execute SQL stored procedures. The JDBC API
35 * provides a stored procedure SQL escape syntax that allows stored procedures
36 * to be called in a standard way for all RDBMSs. This escape syntax has one
37 * form that includes a result parameter and one that does not. If used, the result
38 * parameter must be registered as an OUT parameter. The other parameters
39 * can be used for input, output or both. Parameters are referred to
40 * sequentially, by number, with the first parameter being 1.
41 * <PRE>
42 * {?= call <procedure-name>[(<arg1>,<arg2>, ...)]}
43 * {call <procedure-name>[(<arg1>,<arg2>, ...)]}
44 * </PRE>
45 * <P>
46 * IN parameter values are set using the <code>set</code> methods inherited from
47 * {@link PreparedStatement}. The type of all OUT parameters must be
48 * registered prior to executing the stored procedure; their values
49 * are retrieved after execution via the <code>get</code> methods provided here.
50 * <P>
51 * A <code>CallableStatement</code> can return one {@link ResultSet} object or
52 * multiple <code>ResultSet</code> objects. Multiple
53 * <code>ResultSet</code> objects are handled using operations
54 * inherited from {@link Statement}.
55 * <P>
56 * For maximum portability, a call's <code>ResultSet</code> objects and
57 * update counts should be processed prior to getting the values of output
58 * parameters.
59 *
60 *
61 * @see Connection#prepareCall
62 * @see ResultSet
63 */
64
65 public interface CallableStatement extends PreparedStatement {
66
67 /**
68 * Registers the OUT parameter in ordinal position
69 * <code>parameterIndex</code> to the JDBC type
70 * <code>sqlType</code>. All OUT parameters must be registered
71 * before a stored procedure is executed.
72 * <p>
73 * The JDBC type specified by <code>sqlType</code> for an OUT
74 * parameter determines the Java type that must be used
75 * in the <code>get</code> method to read the value of that parameter.
76 * <p>
77 * If the JDBC type expected to be returned to this output parameter
78 * is specific to this particular database, <code>sqlType</code>
79 * should be <code>java.sql.Types.OTHER</code>. The method
80 * {@link #getObject} retrieves the value.
81 *
82 * @param parameterIndex the first parameter is 1, the second is 2,
83 * and so on
84 * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
85 * If the parameter is of JDBC type <code>NUMERIC</code>
86 * or <code>DECIMAL</code>, the version of
87 * <code>registerOutParameter</code> that accepts a scale value
88 * should be used.
89 *
90 * @exception SQLException if the parameterIndex is not valid;
91 * if a database access error occurs or
92 * this method is called on a closed <code>CallableStatement</code>
93 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
94 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
95 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
96 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
97 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
98 * or <code>STRUCT</code> data type and the JDBC driver does not support
99 * this data type
100 * @see Types
101 */
102 void registerOutParameter(int parameterIndex, int sqlType)
103 throws SQLException;
104
105 /**
106 * Registers the parameter in ordinal position
107 * <code>parameterIndex</code> to be of JDBC type
108 * <code>sqlType</code>. All OUT parameters must be registered
109 * before a stored procedure is executed.
110 * <p>
111 * The JDBC type specified by <code>sqlType</code> for an OUT
112 * parameter determines the Java type that must be used
113 * in the <code>get</code> method to read the value of that parameter.
114 * <p>
115 * This version of <code>registerOutParameter</code> should be
116 * used when the parameter is of JDBC type <code>NUMERIC</code>
117 * or <code>DECIMAL</code>.
118 *
119 * @param parameterIndex the first parameter is 1, the second is 2,
120 * and so on
121 * @param sqlType the SQL type code defined by <code>java.sql.Types</code>.
122 * @param scale the desired number of digits to the right of the
123 * decimal point. It must be greater than or equal to zero.
124 * @exception SQLException if the parameterIndex is not valid;
125 * if a database access error occurs or
126 * this method is called on a closed <code>CallableStatement</code>
127 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
128 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
129 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
130 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
131 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
132 * or <code>STRUCT</code> data type and the JDBC driver does not support
133 * this data type
134 * @see Types
135 */
136 void registerOutParameter(int parameterIndex, int sqlType, int scale)
137 throws SQLException;
138
139 /**
140 * Retrieves whether the last OUT parameter read had the value of
141 * SQL <code>NULL</code>. Note that this method should be called only after
142 * calling a getter method; otherwise, there is no value to use in
143 * determining whether it is <code>null</code> or not.
144 *
145 * @return <code>true</code> if the last parameter read was SQL
146 * <code>NULL</code>; <code>false</code> otherwise
147 * @exception SQLException if a database access error occurs or
148 * this method is called on a closed <code>CallableStatement</code>
149 */
150 boolean wasNull() throws SQLException;
151
152 /**
153 * Retrieves the value of the designated JDBC <code>CHAR</code>,
154 * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> parameter as a
155 * <code>String</code> in the Java programming language.
156 * <p>
157 * For the fixed-length type JDBC <code>CHAR</code>,
158 * the <code>String</code> object
159 * returned has exactly the same value the SQL
160 * <code>CHAR</code> value had in the
161 * database, including any padding added by the database.
162 *
163 * @param parameterIndex the first parameter is 1, the second is 2,
164 * and so on
165 * @return the parameter value. If the value is SQL <code>NULL</code>,
166 * the result
167 * is <code>null</code>.
168 * @exception SQLException if the parameterIndex is not valid;
169 * if a database access error occurs or
170 * this method is called on a closed <code>CallableStatement</code>
171 * @see #setString
172 */
173 String getString(int parameterIndex) throws SQLException;
174
175 /**
176 * Retrieves the value of the designated JDBC <code>BIT</code>
177 * or <code>BOOLEAN</code> parameter as a
178 * <code>boolean</code> in the Java programming language.
179 *
180 * @param parameterIndex the first parameter is 1, the second is 2,
181 * and so on
182 * @return the parameter value. If the value is SQL <code>NULL</code>,
183 * the result is <code>false</code>.
184 * @exception SQLException if the parameterIndex is not valid;
185 * if a database access error occurs or
186 * this method is called on a closed <code>CallableStatement</code>
187 * @see #setBoolean
188 */
189 boolean getBoolean(int parameterIndex) throws SQLException;
190
191 /**
192 * Retrieves the value of the designated JDBC <code>TINYINT</code> parameter
193 * as a <code>byte</code> in the Java programming language.
194 *
195 * @param parameterIndex the first parameter is 1, the second is 2,
196 * and so on
197 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
198 * is <code>0</code>.
199 * @exception SQLException if the parameterIndex is not valid;
200 * if a database access error occurs or
201 * this method is called on a closed <code>CallableStatement</code>
202 * @see #setByte
203 */
204 byte getByte(int parameterIndex) throws SQLException;
205
206 /**
207 * Retrieves the value of the designated JDBC <code>SMALLINT</code> parameter
208 * as a <code>short</code> in the Java programming language.
209 *
210 * @param parameterIndex the first parameter is 1, the second is 2,
211 * and so on
212 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
213 * is <code>0</code>.
214 * @exception SQLException if the parameterIndex is not valid;
215 * if a database access error occurs or
216 * this method is called on a closed <code>CallableStatement</code>
217 * @see #setShort
218 */
219 short getShort(int parameterIndex) throws SQLException;
220
221 /**
222 * Retrieves the value of the designated JDBC <code>INTEGER</code> parameter
223 * as an <code>int</code> in the Java programming language.
224 *
225 * @param parameterIndex the first parameter is 1, the second is 2,
226 * and so on
227 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
228 * is <code>0</code>.
229 * @exception SQLException if the parameterIndex is not valid;
230 * if a database access error occurs or
231 * this method is called on a closed <code>CallableStatement</code>
232 * @see #setInt
233 */
234 int getInt(int parameterIndex) throws SQLException;
235
236 /**
237 * Retrieves the value of the designated JDBC <code>BIGINT</code> parameter
238 * as a <code>long</code> in the Java programming language.
239 *
240 * @param parameterIndex the first parameter is 1, the second is 2,
241 * and so on
242 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
243 * is <code>0</code>.
244 * @exception SQLException if the parameterIndex is not valid;
245 * if a database access error occurs or
246 * this method is called on a closed <code>CallableStatement</code>
247 * @see #setLong
248 */
249 long getLong(int parameterIndex) throws SQLException;
250
251 /**
252 * Retrieves the value of the designated JDBC <code>FLOAT</code> parameter
253 * as a <code>float</code> in the Java programming language.
254 *
255 * @param parameterIndex the first parameter is 1, the second is 2,
256 * and so on
257 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
258 * is <code>0</code>.
259 * @exception SQLException if the parameterIndex is not valid;
260 * if a database access error occurs or
261 * this method is called on a closed <code>CallableStatement</code>
262 * @see #setFloat
263 */
264 float getFloat(int parameterIndex) throws SQLException;
265
266 /**
267 * Retrieves the value of the designated JDBC <code>DOUBLE</code> parameter as a <code>double</code>
268 * in the Java programming language.
269 * @param parameterIndex the first parameter is 1, the second is 2,
270 * and so on
271 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
272 * is <code>0</code>.
273 * @exception SQLException if the parameterIndex is not valid;
274 * if a database access error occurs or
275 * this method is called on a closed <code>CallableStatement</code>
276 * @see #setDouble
277 */
278 double getDouble(int parameterIndex) throws SQLException;
279
280 /**
281 * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a
282 * <code>java.math.BigDecimal</code> object with <i>scale</i> digits to
283 * the right of the decimal point.
284 * @param parameterIndex the first parameter is 1, the second is 2,
285 * and so on
286 * @param scale the number of digits to the right of the decimal point
287 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
288 * is <code>null</code>.
289 * @exception SQLException if the parameterIndex is not valid;
290 * if a database access error occurs or
291 * this method is called on a closed <code>CallableStatement</code>
292 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
293 * this method
294 * @deprecated use <code>getBigDecimal(int parameterIndex)</code>
295 * or <code>getBigDecimal(String parameterName)</code>
296 * @see #setBigDecimal
297 */
298 @Deprecated
299 BigDecimal getBigDecimal(int parameterIndex, int scale)
300 throws SQLException;
301
302 /**
303 * Retrieves the value of the designated JDBC <code>BINARY</code> or
304 * <code>VARBINARY</code> parameter as an array of <code>byte</code>
305 * values in the Java programming language.
306 * @param parameterIndex the first parameter is 1, the second is 2,
307 * and so on
308 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
309 * is <code>null</code>.
310 * @exception SQLException if the parameterIndex is not valid;
311 * if a database access error occurs or
312 * this method is called on a closed <code>CallableStatement</code>
313 * @see #setBytes
314 */
315 byte[] getBytes(int parameterIndex) throws SQLException;
316
317 /**
318 * Retrieves the value of the designated JDBC <code>DATE</code> parameter as a
319 * <code>java.sql.Date</code> object.
320 * @param parameterIndex the first parameter is 1, the second is 2,
321 * and so on
322 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
323 * is <code>null</code>.
324 * @exception SQLException if the parameterIndex is not valid;
325 * if a database access error occurs or
326 * this method is called on a closed <code>CallableStatement</code>
327 * @see #setDate
328 */
329 java.sql.Date getDate(int parameterIndex) throws SQLException;
330
331 /**
332 * Retrieves the value of the designated JDBC <code>TIME</code> parameter as a
333 * <code>java.sql.Time</code> object.
334 *
335 * @param parameterIndex the first parameter is 1, the second is 2,
336 * and so on
337 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
338 * is <code>null</code>.
339 * @exception SQLException if the parameterIndex is not valid;
340 * if a database access error occurs or
341 * this method is called on a closed <code>CallableStatement</code>
342 * @see #setTime
343 */
344 java.sql.Time getTime(int parameterIndex) throws SQLException;
345
346 /**
347 * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a
348 * <code>java.sql.Timestamp</code> object.
349 *
350 * @param parameterIndex the first parameter is 1, the second is 2,
351 * and so on
352 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
353 * is <code>null</code>.
354 * @exception SQLException if the parameterIndex is not valid;
355 * if a database access error occurs or
356 * this method is called on a closed <code>CallableStatement</code>
357 * @see #setTimestamp
358 */
359 java.sql.Timestamp getTimestamp(int parameterIndex)
360 throws SQLException;
361
362 //----------------------------------------------------------------------
363 // Advanced features:
364
365
366 /**
367 * Retrieves the value of the designated parameter as an <code>Object</code>
368 * in the Java programming language. If the value is an SQL <code>NULL</code>,
369 * the driver returns a Java <code>null</code>.
370 * <p>
371 * This method returns a Java object whose type corresponds to the JDBC
372 * type that was registered for this parameter using the method
373 * <code>registerOutParameter</code>. By registering the target JDBC
374 * type as <code>java.sql.Types.OTHER</code>, this method can be used
375 * to read database-specific abstract data types.
376 *
377 * @param parameterIndex the first parameter is 1, the second is 2,
378 * and so on
379 * @return A <code>java.lang.Object</code> holding the OUT parameter value
380 * @exception SQLException if the parameterIndex is not valid;
381 * if a database access error occurs or
382 * this method is called on a closed <code>CallableStatement</code>
383 * @see Types
384 * @see #setObject
385 */
386 Object getObject(int parameterIndex) throws SQLException;
387
388
389 //--------------------------JDBC 2.0-----------------------------
390
391 /**
392 * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a
393 * <code>java.math.BigDecimal</code> object with as many digits to the
394 * right of the decimal point as the value contains.
395 * @param parameterIndex the first parameter is 1, the second is 2,
396 * and so on
397 * @return the parameter value in full precision. If the value is
398 * SQL <code>NULL</code>, the result is <code>null</code>.
399 * @exception SQLException if the parameterIndex is not valid;
400 * if a database access error occurs or
401 * this method is called on a closed <code>CallableStatement</code>
402 * @see #setBigDecimal
403 * @since 1.2
404 */
405 BigDecimal getBigDecimal(int parameterIndex) throws SQLException;
406
407 /**
408 * Returns an object representing the value of OUT parameter
409 * <code>parameterIndex</code> and uses <code>map</code> for the custom
410 * mapping of the parameter value.
411 * <p>
412 * This method returns a Java object whose type corresponds to the
413 * JDBC type that was registered for this parameter using the method
414 * <code>registerOutParameter</code>. By registering the target
415 * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
416 * be used to read database-specific abstract data types.
417 * @param parameterIndex the first parameter is 1, the second is 2, and so on
418 * @param map the mapping from SQL type names to Java classes
419 * @return a <code>java.lang.Object</code> holding the OUT parameter value
420 * @exception SQLException if the parameterIndex is not valid;
421 * if a database access error occurs or
422 * this method is called on a closed <code>CallableStatement</code>
423 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
424 * this method
425 * @see #setObject
426 * @since 1.2
427 */
428 Object getObject(int parameterIndex, java.util.Map<String,Class<?>> map)
429 throws SQLException;
430
431 /**
432 * Retrieves the value of the designated JDBC <code>REF(<structured-type>)</code>
433 * parameter as a {@link java.sql.Ref} object in the Java programming language.
434 * @param parameterIndex the first parameter is 1, the second is 2,
435 * and so on
436 * @return the parameter value as a <code>Ref</code> object in the
437 * Java programming language. If the value was SQL <code>NULL</code>, the value
438 * <code>null</code> is returned.
439 * @exception SQLException if the parameterIndex is not valid;
440 * if a database access error occurs or
441 * this method is called on a closed <code>CallableStatement</code>
442 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
443 * this method
444 * @since 1.2
445 */
446 Ref getRef (int parameterIndex) throws SQLException;
447
448 /**
449 * Retrieves the value of the designated JDBC <code>BLOB</code> parameter as a
450 * {@link java.sql.Blob} object in the Java programming language.
451 * @param parameterIndex the first parameter is 1, the second is 2, and so on
452 * @return the parameter value as a <code>Blob</code> object in the
453 * Java programming language. If the value was SQL <code>NULL</code>, the value
454 * <code>null</code> is returned.
455 * @exception SQLException if the parameterIndex is not valid;
456 * if a database access error occurs or
457 * this method is called on a closed <code>CallableStatement</code>
458 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
459 * this method
460 * @since 1.2
461 */
462 Blob getBlob (int parameterIndex) throws SQLException;
463
464 /**
465 * Retrieves the value of the designated JDBC <code>CLOB</code> parameter as a
466 * <code>java.sql.Clob</code> object in the Java programming language.
467 * @param parameterIndex the first parameter is 1, the second is 2, and
468 * so on
469 * @return the parameter value as a <code>Clob</code> object in the
470 * Java programming language. If the value was SQL <code>NULL</code>, the
471 * value <code>null</code> is returned.
472 * @exception SQLException if the parameterIndex is not valid;
473 * if a database access error occurs or
474 * this method is called on a closed <code>CallableStatement</code>
475 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
476 * this method
477 * @since 1.2
478 */
479 Clob getClob (int parameterIndex) throws SQLException;
480
481 /**
482 *
483 * Retrieves the value of the designated JDBC <code>ARRAY</code> parameter as an
484 * {@link java.sql.Array} object in the Java programming language.
485 * @param parameterIndex the first parameter is 1, the second is 2, and
486 * so on
487 * @return the parameter value as an <code>Array</code> object in
488 * the Java programming language. If the value was SQL <code>NULL</code>, the
489 * value <code>null</code> is returned.
490 * @exception SQLException if the parameterIndex is not valid;
491 * if a database access error occurs or
492 * this method is called on a closed <code>CallableStatement</code>
493 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
494 * this method
495 * @since 1.2
496 */
497 Array getArray (int parameterIndex) throws SQLException;
498
499 /**
500 * Retrieves the value of the designated JDBC <code>DATE</code> parameter as a
501 * <code>java.sql.Date</code> object, using
502 * the given <code>Calendar</code> object
503 * to construct the date.
504 * With a <code>Calendar</code> object, the driver
505 * can calculate the date taking into account a custom timezone and locale.
506 * If no <code>Calendar</code> object is specified, the driver uses the
507 * default timezone and locale.
508 *
509 * @param parameterIndex the first parameter is 1, the second is 2,
510 * and so on
511 * @param cal the <code>Calendar</code> object the driver will use
512 * to construct the date
513 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
514 * is <code>null</code>.
515 * @exception SQLException if the parameterIndex is not valid;
516 * if a database access error occurs or
517 * this method is called on a closed <code>CallableStatement</code>
518 * @see #setDate
519 * @since 1.2
520 */
521 java.sql.Date getDate(int parameterIndex, Calendar cal)
522 throws SQLException;
523
524 /**
525 * Retrieves the value of the designated JDBC <code>TIME</code> parameter as a
526 * <code>java.sql.Time</code> object, using
527 * the given <code>Calendar</code> object
528 * to construct the time.
529 * With a <code>Calendar</code> object, the driver
530 * can calculate the time taking into account a custom timezone and locale.
531 * If no <code>Calendar</code> object is specified, the driver uses the
532 * default timezone and locale.
533 *
534 * @param parameterIndex the first parameter is 1, the second is 2,
535 * and so on
536 * @param cal the <code>Calendar</code> object the driver will use
537 * to construct the time
538 * @return the parameter value; if the value is SQL <code>NULL</code>, the result
539 * is <code>null</code>.
540 * @exception SQLException if the parameterIndex is not valid;
541 * if a database access error occurs or
542 * this method is called on a closed <code>CallableStatement</code>
543 * @see #setTime
544 * @since 1.2
545 */
546 java.sql.Time getTime(int parameterIndex, Calendar cal)
547 throws SQLException;
548
549 /**
550 * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a
551 * <code>java.sql.Timestamp</code> object, using
552 * the given <code>Calendar</code> object to construct
553 * the <code>Timestamp</code> object.
554 * With a <code>Calendar</code> object, the driver
555 * can calculate the timestamp taking into account a custom timezone and locale.
556 * If no <code>Calendar</code> object is specified, the driver uses the
557 * default timezone and locale.
558 *
559 *
560 * @param parameterIndex the first parameter is 1, the second is 2,
561 * and so on
562 * @param cal the <code>Calendar</code> object the driver will use
563 * to construct the timestamp
564 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
565 * is <code>null</code>.
566 * @exception SQLException if the parameterIndex is not valid;
567 * if a database access error occurs or
568 * this method is called on a closed <code>CallableStatement</code>
569 * @see #setTimestamp
570 * @since 1.2
571 */
572 java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal)
573 throws SQLException;
574
575
576 /**
577 * Registers the designated output parameter.
578 * This version of
579 * the method <code>registerOutParameter</code>
580 * should be used for a user-defined or <code>REF</code> output parameter. Examples
581 * of user-defined types include: <code>STRUCT</code>, <code>DISTINCT</code>,
582 * <code>JAVA_OBJECT</code>, and named array types.
583 *<p>
584 * All OUT parameters must be registered
585 * before a stored procedure is executed.
586 * <p> For a user-defined parameter, the fully-qualified SQL
587 * type name of the parameter should also be given, while a <code>REF</code>
588 * parameter requires that the fully-qualified type name of the
589 * referenced type be given. A JDBC driver that does not need the
590 * type code and type name information may ignore it. To be portable,
591 * however, applications should always provide these values for
592 * user-defined and <code>REF</code> parameters.
593 *
594 * Although it is intended for user-defined and <code>REF</code> parameters,
595 * this method may be used to register a parameter of any JDBC type.
596 * If the parameter does not have a user-defined or <code>REF</code> type, the
597 * <i>typeName</i> parameter is ignored.
598 *
599 * <P><B>Note:</B> When reading the value of an out parameter, you
600 * must use the getter method whose Java type corresponds to the
601 * parameter's registered SQL type.
602 *
603 * @param parameterIndex the first parameter is 1, the second is 2,...
604 * @param sqlType a value from {@link java.sql.Types}
605 * @param typeName the fully-qualified name of an SQL structured type
606 * @exception SQLException if the parameterIndex is not valid;
607 * if a database access error occurs or
608 * this method is called on a closed <code>CallableStatement</code>
609 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
610 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
611 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
612 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
613 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
614 * or <code>STRUCT</code> data type and the JDBC driver does not support
615 * this data type
616 * @see Types
617 * @since 1.2
618 */
619 void registerOutParameter (int parameterIndex, int sqlType, String typeName)
620 throws SQLException;
621
622 //--------------------------JDBC 3.0-----------------------------
623
624 /**
625 * Registers the OUT parameter named
626 * <code>parameterName</code> to the JDBC type
627 * <code>sqlType</code>. All OUT parameters must be registered
628 * before a stored procedure is executed.
629 * <p>
630 * The JDBC type specified by <code>sqlType</code> for an OUT
631 * parameter determines the Java type that must be used
632 * in the <code>get</code> method to read the value of that parameter.
633 * <p>
634 * If the JDBC type expected to be returned to this output parameter
635 * is specific to this particular database, <code>sqlType</code>
636 * should be <code>java.sql.Types.OTHER</code>. The method
637 * {@link #getObject} retrieves the value.
638 * @param parameterName the name of the parameter
639 * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
640 * If the parameter is of JDBC type <code>NUMERIC</code>
641 * or <code>DECIMAL</code>, the version of
642 * <code>registerOutParameter</code> that accepts a scale value
643 * should be used.
644 * @exception SQLException if parameterName does not correspond to a named
645 * parameter; if a database access error occurs or
646 * this method is called on a closed <code>CallableStatement</code>
647 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
648 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
649 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
650 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
651 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
652 * or <code>STRUCT</code> data type and the JDBC driver does not support
653 * this data type or if the JDBC driver does not support
654 * this method
655 * @since 1.4
656 * @see Types
657 */
658 void registerOutParameter(String parameterName, int sqlType)
659 throws SQLException;
660
661 /**
662 * Registers the parameter named
663 * <code>parameterName</code> to be of JDBC type
664 * <code>sqlType</code>. All OUT parameters must be registered
665 * before a stored procedure is executed.
666 * <p>
667 * The JDBC type specified by <code>sqlType</code> for an OUT
668 * parameter determines the Java type that must be used
669 * in the <code>get</code> method to read the value of that parameter.
670 * <p>
671 * This version of <code>registerOutParameter</code> should be
672 * used when the parameter is of JDBC type <code>NUMERIC</code>
673 * or <code>DECIMAL</code>.
674 *
675 * @param parameterName the name of the parameter
676 * @param sqlType SQL type code defined by <code>java.sql.Types</code>.
677 * @param scale the desired number of digits to the right of the
678 * decimal point. It must be greater than or equal to zero.
679 * @exception SQLException if parameterName does not correspond to a named
680 * parameter; if a database access error occurs or
681 * this method is called on a closed <code>CallableStatement</code>
682 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
683 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
684 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
685 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
686 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
687 * or <code>STRUCT</code> data type and the JDBC driver does not support
688 * this data type or if the JDBC driver does not support
689 * this method
690 * @since 1.4
691 * @see Types
692 */
693 void registerOutParameter(String parameterName, int sqlType, int scale)
694 throws SQLException;
695
696 /**
697 * Registers the designated output parameter. This version of
698 * the method <code>registerOutParameter</code>
699 * should be used for a user-named or REF output parameter. Examples
700 * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
701 * named array types.
702 *<p>
703 * All OUT parameters must be registered
704 * before a stored procedure is executed.
705 * <p>
706 * For a user-named parameter the fully-qualified SQL
707 * type name of the parameter should also be given, while a REF
708 * parameter requires that the fully-qualified type name of the
709 * referenced type be given. A JDBC driver that does not need the
710 * type code and type name information may ignore it. To be portable,
711 * however, applications should always provide these values for
712 * user-named and REF parameters.
713 *
714 * Although it is intended for user-named and REF parameters,
715 * this method may be used to register a parameter of any JDBC type.
716 * If the parameter does not have a user-named or REF type, the
717 * typeName parameter is ignored.
718 *
719 * <P><B>Note:</B> When reading the value of an out parameter, you
720 * must use the <code>getXXX</code> method whose Java type XXX corresponds to the
721 * parameter's registered SQL type.
722 *
723 * @param parameterName the name of the parameter
724 * @param sqlType a value from {@link java.sql.Types}
725 * @param typeName the fully-qualified name of an SQL structured type
726 * @exception SQLException if parameterName does not correspond to a named
727 * parameter; if a database access error occurs or
728 * this method is called on a closed <code>CallableStatement</code>
729 * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is
730 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
731 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
732 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
733 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
734 * or <code>STRUCT</code> data type and the JDBC driver does not support
735 * this data type or if the JDBC driver does not support
736 * this method
737 * @see Types
738 * @since 1.4
739 */
740 void registerOutParameter (String parameterName, int sqlType, String typeName)
741 throws SQLException;
742
743 /**
744 * Retrieves the value of the designated JDBC <code>DATALINK</code> parameter as a
745 * <code>java.net.URL</code> object.
746 *
747 * @param parameterIndex the first parameter is 1, the second is 2,...
748 * @return a <code>java.net.URL</code> object that represents the
749 * JDBC <code>DATALINK</code> value used as the designated
750 * parameter
751 * @exception SQLException if the parameterIndex is not valid;
752 * if a database access error occurs,
753 * this method is called on a closed <code>CallableStatement</code>,
754 * or if the URL being returned is
755 * not a valid URL on the Java platform
756 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
757 * this method
758 * @see #setURL
759 * @since 1.4
760 */
761 java.net.URL getURL(int parameterIndex) throws SQLException;
762
763 /**
764 * Sets the designated parameter to the given <code>java.net.URL</code> object.
765 * The driver converts this to an SQL <code>DATALINK</code> value when
766 * it sends it to the database.
767 *
768 * @param parameterName the name of the parameter
769 * @param val the parameter value
770 * @exception SQLException if parameterName does not correspond to a named
771 * parameter; if a database access error occurs;
772 * this method is called on a closed <code>CallableStatement</code>
773 * or if a URL is malformed
774 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
775 * this method
776 * @see #getURL
777 * @since 1.4
778 */
779 void setURL(String parameterName, java.net.URL val) throws SQLException;
780
781 /**
782 * Sets the designated parameter to SQL <code>NULL</code>.
783 *
784 * <P><B>Note:</B> You must specify the parameter's SQL type.
785 *
786 * @param parameterName the name of the parameter
787 * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
788 * @exception SQLException if parameterName does not correspond to a named
789 * parameter; if a database access error occurs or
790 * this method is called on a closed <code>CallableStatement</code>
791 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
792 * this method
793 * @since 1.4
794 */
795 void setNull(String parameterName, int sqlType) throws SQLException;
796
797 /**
798 * Sets the designated parameter to the given Java <code>boolean</code> value.
799 * The driver converts this
800 * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
801 *
802 * @param parameterName the name of the parameter
803 * @param x the parameter value
804 * @exception SQLException if parameterName does not correspond to a named
805 * parameter; if a database access error occurs or
806 * this method is called on a closed <code>CallableStatement</code>
807 * @see #getBoolean
808 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
809 * this method
810 * @since 1.4
811 */
812 void setBoolean(String parameterName, boolean x) throws SQLException;
813
814 /**
815 * Sets the designated parameter to the given Java <code>byte</code> value.
816 * The driver converts this
817 * to an SQL <code>TINYINT</code> value when it sends it to the database.
818 *
819 * @param parameterName the name of the parameter
820 * @param x the parameter value
821 * @exception SQLException if parameterName does not correspond to a named
822 * parameter; if a database access error occurs or
823 * this method is called on a closed <code>CallableStatement</code>
824 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
825 * this method
826 * @see #getByte
827 * @since 1.4
828 */
829 void setByte(String parameterName, byte x) throws SQLException;
830
831 /**
832 * Sets the designated parameter to the given Java <code>short</code> value.
833 * The driver converts this
834 * to an SQL <code>SMALLINT</code> value when it sends it to the database.
835 *
836 * @param parameterName the name of the parameter
837 * @param x the parameter value
838 * @exception SQLException if parameterName does not correspond to a named
839 * parameter; if a database access error occurs or
840 * this method is called on a closed <code>CallableStatement</code>
841 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
842 * this method
843 * @see #getShort
844 * @since 1.4
845 */
846 void setShort(String parameterName, short x) throws SQLException;
847
848 /**
849 * Sets the designated parameter to the given Java <code>int</code> value.
850 * The driver converts this
851 * to an SQL <code>INTEGER</code> value when it sends it to the database.
852 *
853 * @param parameterName the name of the parameter
854 * @param x the parameter value
855 * @exception SQLException if parameterName does not correspond to a named
856 * parameter; if a database access error occurs or
857 * this method is called on a closed <code>CallableStatement</code>
858 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
859 * this method
860 * @see #getInt
861 * @since 1.4
862 */
863 void setInt(String parameterName, int x) throws SQLException;
864
865 /**
866 * Sets the designated parameter to the given Java <code>long</code> value.
867 * The driver converts this
868 * to an SQL <code>BIGINT</code> value when it sends it to the database.
869 *
870 * @param parameterName the name of the parameter
871 * @param x the parameter value
872 * @exception SQLException if parameterName does not correspond to a named
873 * parameter; if a database access error occurs or
874 * this method is called on a closed <code>CallableStatement</code>
875 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
876 * this method
877 * @see #getLong
878 * @since 1.4
879 */
880 void setLong(String parameterName, long x) throws SQLException;
881
882 /**
883 * Sets the designated parameter to the given Java <code>float</code> value.
884 * The driver converts this
885 * to an SQL <code>FLOAT</code> value when it sends it to the database.
886 *
887 * @param parameterName the name of the parameter
888 * @param x the parameter value
889 * @exception SQLException if parameterName does not correspond to a named
890 * parameter; if a database access error occurs or
891 * this method is called on a closed <code>CallableStatement</code>
892 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
893 * this method
894 * @see #getFloat
895 * @since 1.4
896 */
897 void setFloat(String parameterName, float x) throws SQLException;
898
899 /**
900 * Sets the designated parameter to the given Java <code>double</code> value.
901 * The driver converts this
902 * to an SQL <code>DOUBLE</code> value when it sends it to the database.
903 *
904 * @param parameterName the name of the parameter
905 * @param x the parameter value
906 * @exception SQLException if parameterName does not correspond to a named
907 * parameter; if a database access error occurs or
908 * this method is called on a closed <code>CallableStatement</code>
909 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
910 * this method
911 * @see #getDouble
912 * @since 1.4
913 */
914 void setDouble(String parameterName, double x) throws SQLException;
915
916 /**
917 * Sets the designated parameter to the given
918 * <code>java.math.BigDecimal</code> value.
919 * The driver converts this to an SQL <code>NUMERIC</code> value when
920 * it sends it to the database.
921 *
922 * @param parameterName the name of the parameter
923 * @param x the parameter value
924 * @exception SQLException if parameterName does not correspond to a named
925 * parameter; if a database access error occurs or
926 * this method is called on a closed <code>CallableStatement</code>
927 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
928 * this method
929 * @see #getBigDecimal
930 * @since 1.4
931 */
932 void setBigDecimal(String parameterName, BigDecimal x) throws SQLException;
933
934 /**
935 * Sets the designated parameter to the given Java <code>String</code> value.
936 * The driver converts this
937 * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
938 * (depending on the argument's
939 * size relative to the driver's limits on <code>VARCHAR</code> values)
940 * when it sends it to the database.
941 *
942 * @param parameterName the name of the parameter
943 * @param x the parameter value
944 * @exception SQLException if parameterName does not correspond to a named
945 * parameter; if a database access error occurs or
946 * this method is called on a closed <code>CallableStatement</code>
947 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
948 * this method
949 * @see #getString
950 * @since 1.4
951 */
952 void setString(String parameterName, String x) throws SQLException;
953
954 /**
955 * Sets the designated parameter to the given Java array of bytes.
956 * The driver converts this to an SQL <code>VARBINARY</code> or
957 * <code>LONGVARBINARY</code> (depending on the argument's size relative
958 * to the driver's limits on <code>VARBINARY</code> values) when it sends
959 * it to the database.
960 *
961 * @param parameterName the name of the parameter
962 * @param x the parameter value
963 * @exception SQLException if parameterName does not correspond to a named
964 * parameter; if a database access error occurs or
965 * this method is called on a closed <code>CallableStatement</code>
966 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
967 * this method
968 * @see #getBytes
969 * @since 1.4
970 */
971 void setBytes(String parameterName, byte x[]) throws SQLException;
972
973 /**
974 * Sets the designated parameter to the given <code>java.sql.Date</code> value
975 * using the default time zone of the virtual machine that is running
976 * the application.
977 * The driver converts this
978 * to an SQL <code>DATE</code> value when it sends it to the database.
979 *
980 * @param parameterName the name of the parameter
981 * @param x the parameter value
982 * @exception SQLException if parameterName does not correspond to a named
983 * parameter; if a database access error occurs or
984 * this method is called on a closed <code>CallableStatement</code>
985 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
986 * this method
987 * @see #getDate
988 * @since 1.4
989 */
990 void setDate(String parameterName, java.sql.Date x)
991 throws SQLException;
992
993 /**
994 * Sets the designated parameter to the given <code>java.sql.Time</code> value.
995 * The driver converts this
996 * to an SQL <code>TIME</code> value when it sends it to the database.
997 *
998 * @param parameterName the name of the parameter
999 * @param x the parameter value
1000 * @exception SQLException if parameterName does not correspond to a named
1001 * parameter; if a database access error occurs or
1002 * this method is called on a closed <code>CallableStatement</code>
1003 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1004 * this method
1005 * @see #getTime
1006 * @since 1.4
1007 */
1008 void setTime(String parameterName, java.sql.Time x)
1009 throws SQLException;
1010
1011 /**
1012 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
1013 * The driver
1014 * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
1015 * database.
1016 *
1017 * @param parameterName the name of the parameter
1018 * @param x the parameter value
1019 * @exception SQLException if parameterName does not correspond to a named
1020 * parameter; if a database access error occurs or
1021 * this method is called on a closed <code>CallableStatement</code>
1022 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1023 * this method
1024 * @see #getTimestamp
1025 * @since 1.4
1026 */
1027 void setTimestamp(String parameterName, java.sql.Timestamp x)
1028 throws SQLException;
1029
1030 /**
1031 * Sets the designated parameter to the given input stream, which will have
1032 * the specified number of bytes.
1033 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
1034 * parameter, it may be more practical to send it via a
1035 * <code>java.io.InputStream</code>. Data will be read from the stream
1036 * as needed until end-of-file is reached. The JDBC driver will
1037 * do any necessary conversion from ASCII to the database char format.
1038 *
1039 * <P><B>Note:</B> This stream object can either be a standard
1040 * Java stream object or your own subclass that implements the
1041 * standard interface.
1042 *
1043 * @param parameterName the name of the parameter
1044 * @param x the Java input stream that contains the ASCII parameter value
1045 * @param length the number of bytes in the stream
1046 * @exception SQLException if parameterName does not correspond to a named
1047 * parameter; if a database access error occurs or
1048 * this method is called on a closed <code>CallableStatement</code>
1049 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1050 * this method
1051 * @since 1.4
1052 */
1053 void setAsciiStream(String parameterName, java.io.InputStream x, int length)
1054 throws SQLException;
1055
1056 /**
1057 * Sets the designated parameter to the given input stream, which will have
1058 * the specified number of bytes.
1059 * When a very large binary value is input to a <code>LONGVARBINARY</code>
1060 * parameter, it may be more practical to send it via a
1061 * <code>java.io.InputStream</code> object. The data will be read from the stream
1062 * as needed until end-of-file is reached.
1063 *
1064 * <P><B>Note:</B> This stream object can either be a standard
1065 * Java stream object or your own subclass that implements the
1066 * standard interface.
1067 *
1068 * @param parameterName the name of the parameter
1069 * @param x the java input stream which contains the binary parameter value
1070 * @param length the number of bytes in the stream
1071 * @exception SQLException if parameterName does not correspond to a named
1072 * parameter; if a database access error occurs or
1073 * this method is called on a closed <code>CallableStatement</code>
1074 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1075 * this method
1076 * @since 1.4
1077 */
1078 void setBinaryStream(String parameterName, java.io.InputStream x,
1079 int length) throws SQLException;
1080
1081 /**
1082 * Sets the value of the designated parameter with the given object.
1083 *
1084 * <p>The given Java object will be converted to the given targetSqlType
1085 * before being sent to the database.
1086 *
1087 * If the object has a custom mapping (is of a class implementing the
1088 * interface <code>SQLData</code>),
1089 * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
1090 * to the SQL data stream.
1091 * If, on the other hand, the object is of a class implementing
1092 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
1093 * <code>Struct</code>, <code>java.net.URL</code>,
1094 * or <code>Array</code>, the driver should pass it to the database as a
1095 * value of the corresponding SQL type.
1096 * <P>
1097 * Note that this method may be used to pass datatabase-
1098 * specific abstract data types.
1099 *
1100 * @param parameterName the name of the parameter
1101 * @param x the object containing the input parameter value
1102 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
1103 * sent to the database. The scale argument may further qualify this type.
1104 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
1105 * this is the number of digits after the decimal point. For all other
1106 * types, this value will be ignored.
1107 * @exception SQLException if parameterName does not correspond to a named
1108 * parameter; if a database access error occurs or
1109 * this method is called on a closed <code>CallableStatement</code>
1110 * @exception SQLFeatureNotSupportedException if
1111 * the JDBC driver does not support the specified targetSqlType
1112 * @see Types
1113 * @see #getObject
1114 * @since 1.4
1115 */
1116 void setObject(String parameterName, Object x, int targetSqlType, int scale)
1117 throws SQLException;
1118
1119 /**
1120 * Sets the value of the designated parameter with the given object.
1121 *
1122 * This method is similar to {@link #setObject(String parameterName,
1123 * Object x, int targetSqlType, int scaleOrLength)},
1124 * except that it assumes a scale of zero.
1125 *
1126 * @param parameterName the name of the parameter
1127 * @param x the object containing the input parameter value
1128 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
1129 * sent to the database
1130 * @exception SQLException if parameterName does not correspond to a named
1131 * parameter; if a database access error occurs or
1132 * this method is called on a closed <code>CallableStatement</code>
1133 * @exception SQLFeatureNotSupportedException if
1134 * the JDBC driver does not support the specified targetSqlType
1135 * @see #getObject
1136 * @since 1.4
1137 */
1138 void setObject(String parameterName, Object x, int targetSqlType)
1139 throws SQLException;
1140
1141 /**
1142 * Sets the value of the designated parameter with the given object.
1143 *
1144 * <p>The JDBC specification specifies a standard mapping from
1145 * Java <code>Object</code> types to SQL types. The given argument
1146 * will be converted to the corresponding SQL type before being
1147 * sent to the database.
1148 * <p>Note that this method may be used to pass datatabase-
1149 * specific abstract data types, by using a driver-specific Java
1150 * type.
1151 *
1152 * If the object is of a class implementing the interface <code>SQLData</code>,
1153 * the JDBC driver should call the method <code>SQLData.writeSQL</code>
1154 * to write it to the SQL data stream.
1155 * If, on the other hand, the object is of a class implementing
1156 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
1157 * <code>Struct</code>, <code>java.net.URL</code>,
1158 * or <code>Array</code>, the driver should pass it to the database as a
1159 * value of the corresponding SQL type.
1160 * <P>
1161 * This method throws an exception if there is an ambiguity, for example, if the
1162 * object is of a class implementing more than one of the interfaces named above.
1163 * <p>
1164 *<b>Note:</b> Not all databases allow for a non-typed Null to be sent to
1165 * the backend. For maximum portability, the <code>setNull</code> or the
1166 * <code>setObject(String parameterName, Object x, int sqlType)</code>
1167 * method should be used
1168 * instead of <code>setObject(String parameterName, Object x)</code>.
1169 *
1170 * @param parameterName the name of the parameter
1171 * @param x the object containing the input parameter value
1172 * @exception SQLException if parameterName does not correspond to a named
1173 * parameter; if a database access error occurs,
1174 * this method is called on a closed <code>CallableStatement</code> or if the given
1175 * <code>Object</code> parameter is ambiguous
1176 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1177 * this method
1178 * @see #getObject
1179 * @since 1.4
1180 */
1181 void setObject(String parameterName, Object x) throws SQLException;
1182
1183
1184 /**
1185 * Sets the designated parameter to the given <code>Reader</code>
1186 * object, which is the given number of characters long.
1187 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
1188 * parameter, it may be more practical to send it via a
1189 * <code>java.io.Reader</code> object. The data will be read from the stream
1190 * as needed until end-of-file is reached. The JDBC driver will
1191 * do any necessary conversion from UNICODE to the database char format.
1192 *
1193 * <P><B>Note:</B> This stream object can either be a standard
1194 * Java stream object or your own subclass that implements the
1195 * standard interface.
1196 *
1197 * @param parameterName the name of the parameter
1198 * @param reader the <code>java.io.Reader</code> object that
1199 * contains the UNICODE data used as the designated parameter
1200 * @param length the number of characters in the stream
1201 * @exception SQLException if parameterName does not correspond to a named
1202 * parameter; if a database access error occurs or
1203 * this method is called on a closed <code>CallableStatement</code>
1204 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1205 * this method
1206 * @since 1.4
1207 */
1208 void setCharacterStream(String parameterName,
1209 java.io.Reader reader,
1210 int length) throws SQLException;
1211
1212 /**
1213 * Sets the designated parameter to the given <code>java.sql.Date</code> value,
1214 * using the given <code>Calendar</code> object. The driver uses
1215 * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
1216 * which the driver then sends to the database. With a
1217 * a <code>Calendar</code> object, the driver can calculate the date
1218 * taking into account a custom timezone. If no
1219 * <code>Calendar</code> object is specified, the driver uses the default
1220 * timezone, which is that of the virtual machine running the application.
1221 *
1222 * @param parameterName the name of the parameter
1223 * @param x the parameter value
1224 * @param cal the <code>Calendar</code> object the driver will use
1225 * to construct the date
1226 * @exception SQLException if parameterName does not correspond to a named
1227 * parameter; if a database access error occurs or
1228 * this method is called on a closed <code>CallableStatement</code>
1229 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1230 * this method
1231 * @see #getDate
1232 * @since 1.4
1233 */
1234 void setDate(String parameterName, java.sql.Date x, Calendar cal)
1235 throws SQLException;
1236
1237 /**
1238 * Sets the designated parameter to the given <code>java.sql.Time</code> value,
1239 * using the given <code>Calendar</code> object. The driver uses
1240 * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
1241 * which the driver then sends to the database. With a
1242 * a <code>Calendar</code> object, the driver can calculate the time
1243 * taking into account a custom timezone. If no
1244 * <code>Calendar</code> object is specified, the driver uses the default
1245 * timezone, which is that of the virtual machine running the application.
1246 *
1247 * @param parameterName the name of the parameter
1248 * @param x the parameter value
1249 * @param cal the <code>Calendar</code> object the driver will use
1250 * to construct the time
1251 * @exception SQLException if parameterName does not correspond to a named
1252 * parameter; if a database access error occurs or
1253 * this method is called on a closed <code>CallableStatement</code>
1254 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1255 * this method
1256 * @see #getTime
1257 * @since 1.4
1258 */
1259 void setTime(String parameterName, java.sql.Time x, Calendar cal)
1260 throws SQLException;
1261
1262 /**
1263 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
1264 * using the given <code>Calendar</code> object. The driver uses
1265 * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
1266 * which the driver then sends to the database. With a
1267 * a <code>Calendar</code> object, the driver can calculate the timestamp
1268 * taking into account a custom timezone. If no
1269 * <code>Calendar</code> object is specified, the driver uses the default
1270 * timezone, which is that of the virtual machine running the application.
1271 *
1272 * @param parameterName the name of the parameter
1273 * @param x the parameter value
1274 * @param cal the <code>Calendar</code> object the driver will use
1275 * to construct the timestamp
1276 * @exception SQLException if parameterName does not correspond to a named
1277 * parameter; if a database access error occurs or
1278 * this method is called on a closed <code>CallableStatement</code>
1279 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1280 * this method
1281 * @see #getTimestamp
1282 * @since 1.4
1283 */
1284 void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
1285 throws SQLException;
1286
1287 /**
1288 * Sets the designated parameter to SQL <code>NULL</code>.
1289 * This version of the method <code>setNull</code> should
1290 * be used for user-defined types and REF type parameters. Examples
1291 * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
1292 * named array types.
1293 *
1294 * <P><B>Note:</B> To be portable, applications must give the
1295 * SQL type code and the fully-qualified SQL type name when specifying
1296 * a NULL user-defined or REF parameter. In the case of a user-defined type
1297 * the name is the type name of the parameter itself. For a REF
1298 * parameter, the name is the type name of the referenced type.
1299 * <p>
1300 * Although it is intended for user-defined and Ref parameters,
1301 * this method may be used to set a null parameter of any JDBC type.
1302 * If the parameter does not have a user-defined or REF type, the given
1303 * typeName is ignored.
1304 *
1305 *
1306 * @param parameterName the name of the parameter
1307 * @param sqlType a value from <code>java.sql.Types</code>
1308 * @param typeName the fully-qualified name of an SQL user-defined type;
1309 * ignored if the parameter is not a user-defined type or
1310 * SQL <code>REF</code> value
1311 * @exception SQLException if parameterName does not correspond to a named
1312 * parameter; if a database access error occurs or
1313 * this method is called on a closed <code>CallableStatement</code>
1314 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1315 * this method
1316 * @since 1.4
1317 */
1318 void setNull (String parameterName, int sqlType, String typeName)
1319 throws SQLException;
1320
1321 /**
1322 * Retrieves the value of a JDBC <code>CHAR</code>, <code>VARCHAR</code>,
1323 * or <code>LONGVARCHAR</code> parameter as a <code>String</code> in
1324 * the Java programming language.
1325 * <p>
1326 * For the fixed-length type JDBC <code>CHAR</code>,
1327 * the <code>String</code> object
1328 * returned has exactly the same value the SQL
1329 * <code>CHAR</code> value had in the
1330 * database, including any padding added by the database.
1331 * @param parameterName the name of the parameter
1332 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1333 * is <code>null</code>.
1334 * @exception SQLException if parameterName does not correspond to a named
1335 * parameter; if a database access error occurs or
1336 * this method is called on a closed <code>CallableStatement</code>
1337 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1338 * this method
1339 * @see #setString
1340 * @since 1.4
1341 */
1342 String getString(String parameterName) throws SQLException;
1343
1344 /**
1345 * Retrieves the value of a JDBC <code>BIT</code> or <code>BOOLEAN</code>
1346 * parameter as a
1347 * <code>boolean</code> in the Java programming language.
1348 * @param parameterName the name of the parameter
1349 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1350 * is <code>false</code>.
1351 * @exception SQLException if parameterName does not correspond to a named
1352 * parameter; if a database access error occurs or
1353 * this method is called on a closed <code>CallableStatement</code>
1354 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1355 * this method
1356 * @see #setBoolean
1357 * @since 1.4
1358 */
1359 boolean getBoolean(String parameterName) throws SQLException;
1360
1361 /**
1362 * Retrieves the value of a JDBC <code>TINYINT</code> parameter as a <code>byte</code>
1363 * in the Java programming language.
1364 * @param parameterName the name of the parameter
1365 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1366 * is <code>0</code>.
1367 * @exception SQLException if parameterName does not correspond to a named
1368 * parameter; if a database access error occurs or
1369 * this method is called on a closed <code>CallableStatement</code>
1370 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1371 * this method
1372 * @see #setByte
1373 * @since 1.4
1374 */
1375 byte getByte(String parameterName) throws SQLException;
1376
1377 /**
1378 * Retrieves the value of a JDBC <code>SMALLINT</code> parameter as a <code>short</code>
1379 * in the Java programming language.
1380 * @param parameterName the name of the parameter
1381 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1382 * is <code>0</code>.
1383 * @exception SQLException if parameterName does not correspond to a named
1384 * parameter; if a database access error occurs or
1385 * this method is called on a closed <code>CallableStatement</code>
1386 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1387 * this method
1388 * @see #setShort
1389 * @since 1.4
1390 */
1391 short getShort(String parameterName) throws SQLException;
1392
1393 /**
1394 * Retrieves the value of a JDBC <code>INTEGER</code> parameter as an <code>int</code>
1395 * in the Java programming language.
1396 *
1397 * @param parameterName the name of the parameter
1398 * @return the parameter value. If the value is SQL <code>NULL</code>,
1399 * the result is <code>0</code>.
1400 * @exception SQLException if parameterName does not correspond to a named
1401 * parameter; if a database access error occurs or
1402 * this method is called on a closed <code>CallableStatement</code>
1403 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1404 * this method
1405 * @see #setInt
1406 * @since 1.4
1407 */
1408 int getInt(String parameterName) throws SQLException;
1409
1410 /**
1411 * Retrieves the value of a JDBC <code>BIGINT</code> parameter as a <code>long</code>
1412 * in the Java programming language.
1413 *
1414 * @param parameterName the name of the parameter
1415 * @return the parameter value. If the value is SQL <code>NULL</code>,
1416 * the result is <code>0</code>.
1417 * @exception SQLException if parameterName does not correspond to a named
1418 * parameter; if a database access error occurs or
1419 * this method is called on a closed <code>CallableStatement</code>
1420 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1421 * this method
1422 * @see #setLong
1423 * @since 1.4
1424 */
1425 long getLong(String parameterName) throws SQLException;
1426
1427 /**
1428 * Retrieves the value of a JDBC <code>FLOAT</code> parameter as a <code>float</code>
1429 * in the Java programming language.
1430 * @param parameterName the name of the parameter
1431 * @return the parameter value. If the value is SQL <code>NULL</code>,
1432 * the result is <code>0</code>.
1433 * @exception SQLException if parameterName does not correspond to a named
1434 * parameter; if a database access error occurs or
1435 * this method is called on a closed <code>CallableStatement</code>
1436 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1437 * this method
1438 * @see #setFloat
1439 * @since 1.4
1440 */
1441 float getFloat(String parameterName) throws SQLException;
1442
1443 /**
1444 * Retrieves the value of a JDBC <code>DOUBLE</code> parameter as a <code>double</code>
1445 * in the Java programming language.
1446 * @param parameterName the name of the parameter
1447 * @return the parameter value. If the value is SQL <code>NULL</code>,
1448 * the result is <code>0</code>.
1449 * @exception SQLException if parameterName does not correspond to a named
1450 * parameter; if a database access error occurs or
1451 * this method is called on a closed <code>CallableStatement</code>
1452 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1453 * this method
1454 * @see #setDouble
1455 * @since 1.4
1456 */
1457 double getDouble(String parameterName) throws SQLException;
1458
1459 /**
1460 * Retrieves the value of a JDBC <code>BINARY</code> or <code>VARBINARY</code>
1461 * parameter as an array of <code>byte</code> values in the Java
1462 * programming language.
1463 * @param parameterName the name of the parameter
1464 * @return the parameter value. If the value is SQL <code>NULL</code>, the result is
1465 * <code>null</code>.
1466 * @exception SQLException if parameterName does not correspond to a named
1467 * parameter; if a database access error occurs or
1468 * this method is called on a closed <code>CallableStatement</code>
1469 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1470 * this method
1471 * @see #setBytes
1472 * @since 1.4
1473 */
1474 byte[] getBytes(String parameterName) throws SQLException;
1475
1476 /**
1477 * Retrieves the value of a JDBC <code>DATE</code> parameter as a
1478 * <code>java.sql.Date</code> object.
1479 * @param parameterName the name of the parameter
1480 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1481 * is <code>null</code>.
1482 * @exception SQLException if parameterName does not correspond to a named
1483 * parameter; if a database access error occurs or
1484 * this method is called on a closed <code>CallableStatement</code>
1485 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1486 * this method
1487 * @see #setDate
1488 * @since 1.4
1489 */
1490 java.sql.Date getDate(String parameterName) throws SQLException;
1491
1492 /**
1493 * Retrieves the value of a JDBC <code>TIME</code> parameter as a
1494 * <code>java.sql.Time</code> object.
1495 * @param parameterName the name of the parameter
1496 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1497 * is <code>null</code>.
1498 * @exception SQLException if parameterName does not correspond to a named
1499 * parameter; if a database access error occurs or
1500 * this method is called on a closed <code>CallableStatement</code>
1501 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1502 * this method
1503 * @see #setTime
1504 * @since 1.4
1505 */
1506 java.sql.Time getTime(String parameterName) throws SQLException;
1507
1508 /**
1509 * Retrieves the value of a JDBC <code>TIMESTAMP</code> parameter as a
1510 * <code>java.sql.Timestamp</code> object.
1511 * @param parameterName the name of the parameter
1512 * @return the parameter value. If the value is SQL <code>NULL</code>, the result
1513 * is <code>null</code>.
1514 * @exception SQLException if parameterName does not correspond to a named
1515 * parameter; if a database access error occurs or
1516 * this method is called on a closed <code>CallableStatement</code>
1517 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1518 * this method
1519 * @see #setTimestamp
1520 * @since 1.4
1521 */
1522 java.sql.Timestamp getTimestamp(String parameterName) throws SQLException;
1523
1524 /**
1525 * Retrieves the value of a parameter as an <code>Object</code> in the Java
1526 * programming language. If the value is an SQL <code>NULL</code>, the
1527 * driver returns a Java <code>null</code>.
1528 * <p>
1529 * This method returns a Java object whose type corresponds to the JDBC
1530 * type that was registered for this parameter using the method
1531 * <code>registerOutParameter</code>. By registering the target JDBC
1532 * type as <code>java.sql.Types.OTHER</code>, this method can be used
1533 * to read database-specific abstract data types.
1534 * @param parameterName the name of the parameter
1535 * @return A <code>java.lang.Object</code> holding the OUT parameter value.
1536 * @exception SQLException if parameterName does not correspond to a named
1537 * parameter; if a database access error occurs or
1538 * this method is called on a closed <code>CallableStatement</code>
1539 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1540 * this method
1541 * @see Types
1542 * @see #setObject
1543 * @since 1.4
1544 */
1545 Object getObject(String parameterName) throws SQLException;
1546
1547 /**
1548 * Retrieves the value of a JDBC <code>NUMERIC</code> parameter as a
1549 * <code>java.math.BigDecimal</code> object with as many digits to the
1550 * right of the decimal point as the value contains.
1551 * @param parameterName the name of the parameter
1552 * @return the parameter value in full precision. If the value is
1553 * SQL <code>NULL</code>, the result is <code>null</code>.
1554 * @exception SQLException if parameterName does not correspond to a named
1555 * parameter; if a database access error occurs or
1556 * this method is called on a closed <code>CallableStatement</code>
1557 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1558 * this method
1559 * @see #setBigDecimal
1560 * @since 1.4
1561 */
1562 BigDecimal getBigDecimal(String parameterName) throws SQLException;
1563
1564 /**
1565 * Returns an object representing the value of OUT parameter
1566 * <code>parameterName</code> and uses <code>map</code> for the custom
1567 * mapping of the parameter value.
1568 * <p>
1569 * This method returns a Java object whose type corresponds to the
1570 * JDBC type that was registered for this parameter using the method
1571 * <code>registerOutParameter</code>. By registering the target
1572 * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
1573 * be used to read database-specific abstract data types.
1574 * @param parameterName the name of the parameter
1575 * @param map the mapping from SQL type names to Java classes
1576 * @return a <code>java.lang.Object</code> holding the OUT parameter value
1577 * @exception SQLException if parameterName does not correspond to a named
1578 * parameter; if a database access error occurs or
1579 * this method is called on a closed <code>CallableStatement</code>
1580 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1581 * this method
1582 * @see #setObject
1583 * @since 1.4
1584 */
1585 Object getObject(String parameterName, java.util.Map<String,Class<?>> map)
1586 throws SQLException;
1587
1588 /**
1589 * Retrieves the value of a JDBC <code>REF(<structured-type>)</code>
1590 * parameter as a {@link java.sql.Ref} object in the Java programming language.
1591 *
1592 * @param parameterName the name of the parameter
1593 * @return the parameter value as a <code>Ref</code> object in the
1594 * Java programming language. If the value was SQL <code>NULL</code>,
1595 * the value <code>null</code> is returned.
1596 * @exception SQLException if parameterName does not correspond to a named
1597 * parameter; if a database access error occurs or
1598 * this method is called on a closed <code>CallableStatement</code>
1599 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1600 * this method
1601 * @since 1.4
1602 */
1603 Ref getRef (String parameterName) throws SQLException;
1604
1605 /**
1606 * Retrieves the value of a JDBC <code>BLOB</code> parameter as a
1607 * {@link java.sql.Blob} object in the Java programming language.
1608 *
1609 * @param parameterName the name of the parameter
1610 * @return the parameter value as a <code>Blob</code> object in the
1611 * Java programming language. If the value was SQL <code>NULL</code>,
1612 * the value <code>null</code> is returned.
1613 * @exception SQLException if parameterName does not correspond to a named
1614 * parameter; if a database access error occurs or
1615 * this method is called on a closed <code>CallableStatement</code>
1616 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1617 * this method
1618 * @since 1.4
1619 */
1620 Blob getBlob (String parameterName) throws SQLException;
1621
1622 /**
1623 * Retrieves the value of a JDBC <code>CLOB</code> parameter as a
1624 * <code>java.sql.Clob</code> object in the Java programming language.
1625 * @param parameterName the name of the parameter
1626 * @return the parameter value as a <code>Clob</code> object in the
1627 * Java programming language. If the value was SQL <code>NULL</code>,
1628 * the value <code>null</code> is returned.
1629 * @exception SQLException if parameterName does not correspond to a named
1630 * parameter; if a database access error occurs or
1631 * this method is called on a closed <code>CallableStatement</code>
1632 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1633 * this method
1634 * @since 1.4
1635 */
1636 Clob getClob (String parameterName) throws SQLException;
1637
1638 /**
1639 * Retrieves the value of a JDBC <code>ARRAY</code> parameter as an
1640 * {@link java.sql.Array} object in the Java programming language.
1641 *
1642 * @param parameterName the name of the parameter
1643 * @return the parameter value as an <code>Array</code> object in
1644 * Java programming language. If the value was SQL <code>NULL</code>,
1645 * the value <code>null</code> is returned.
1646 * @exception SQLException if parameterName does not correspond to a named
1647 * parameter; if a database access error occurs or
1648 * this method is called on a closed <code>CallableStatement</code>
1649 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1650 * this method
1651 * @since 1.4
1652 */
1653 Array getArray (String parameterName) throws SQLException;
1654
1655 /**
1656 * Retrieves the value of a JDBC <code>DATE</code> parameter as a
1657 * <code>java.sql.Date</code> object, using
1658 * the given <code>Calendar</code> object
1659 * to construct the date.
1660 * With a <code>Calendar</code> object, the driver
1661 * can calculate the date taking into account a custom timezone and locale.
1662 * If no <code>Calendar</code> object is specified, the driver uses the
1663 * default timezone and locale.
1664 *
1665 * @param parameterName the name of the parameter
1666 * @param cal the <code>Calendar</code> object the driver will use
1667 * to construct the date
1668 * @return the parameter value. If the value is SQL <code>NULL</code>,
1669 * the result is <code>null</code>.
1670 * @exception SQLException if parameterName does not correspond to a named
1671 * parameter; if a database access error occurs or
1672 * this method is called on a closed <code>CallableStatement</code>
1673 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1674 * this method
1675 * @see #setDate
1676 * @since 1.4
1677 */
1678 java.sql.Date getDate(String parameterName, Calendar cal)
1679 throws SQLException;
1680
1681 /**
1682 * Retrieves the value of a JDBC <code>TIME</code> parameter as a
1683 * <code>java.sql.Time</code> object, using
1684 * the given <code>Calendar</code> object
1685 * to construct the time.
1686 * With a <code>Calendar</code> object, the driver
1687 * can calculate the time taking into account a custom timezone and locale.
1688 * If no <code>Calendar</code> object is specified, the driver uses the
1689 * default timezone and locale.
1690 *
1691 * @param parameterName the name of the parameter
1692 * @param cal the <code>Calendar</code> object the driver will use
1693 * to construct the time
1694 * @return the parameter value; if the value is SQL <code>NULL</code>, the result is
1695 * <code>null</code>.
1696 * @exception SQLException if parameterName does not correspond to a named
1697 * parameter; if a database access error occurs or
1698 * this method is called on a closed <code>CallableStatement</code>
1699 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1700 * this method
1701 * @see #setTime
1702 * @since 1.4
1703 */
1704 java.sql.Time getTime(String parameterName, Calendar cal)
1705 throws SQLException;
1706
1707 /**
1708 * Retrieves the value of a JDBC <code>TIMESTAMP</code> parameter as a
1709 * <code>java.sql.Timestamp</code> object, using
1710 * the given <code>Calendar</code> object to construct
1711 * the <code>Timestamp</code> object.
1712 * With a <code>Calendar</code> object, the driver
1713 * can calculate the timestamp taking into account a custom timezone and locale.
1714 * If no <code>Calendar</code> object is specified, the driver uses the
1715 * default timezone and locale.
1716 *
1717 *
1718 * @param parameterName the name of the parameter
1719 * @param cal the <code>Calendar</code> object the driver will use
1720 * to construct the timestamp
1721 * @return the parameter value. If the value is SQL <code>NULL</code>, the result is
1722 * <code>null</code>.
1723 * @exception SQLException if parameterName does not correspond to a named
1724 * parameter; if a database access error occurs or
1725 * this method is called on a closed <code>CallableStatement</code>
1726 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1727 * this method
1728 * @see #setTimestamp
1729 * @since 1.4
1730 */
1731 java.sql.Timestamp getTimestamp(String parameterName, Calendar cal)
1732 throws SQLException;
1733
1734 /**
1735 * Retrieves the value of a JDBC <code>DATALINK</code> parameter as a
1736 * <code>java.net.URL</code> object.
1737 *
1738 * @param parameterName the name of the parameter
1739 * @return the parameter value as a <code>java.net.URL</code> object in the
1740 * Java programming language. If the value was SQL <code>NULL</code>, the
1741 * value <code>null</code> is returned.
1742 * @exception SQLException if parameterName does not correspond to a named
1743 * parameter; if a database access error occurs,
1744 * this method is called on a closed <code>CallableStatement</code>,
1745 * or if there is a problem with the URL
1746 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1747 * this method
1748 * @see #setURL
1749 * @since 1.4
1750 */
1751 java.net.URL getURL(String parameterName) throws SQLException;
1752
1753 //------------------------- JDBC 4.0 -----------------------------------
1754
1755 /**
1756 * Retrieves the value of the designated JDBC <code>ROWID</code> parameter as a
1757 * <code>java.sql.RowId</code> object.
1758 *
1759 * @param parameterIndex the first parameter is 1, the second is 2,...
1760 * @return a <code>RowId</code> object that represents the JDBC <code>ROWID</code>
1761 * value is used as the designated parameter. If the parameter contains
1762 * a SQL <code>NULL</code>, then a <code>null</code> value is returned.
1763 * @throws SQLException if the parameterIndex is not valid;
1764 * if a database access error occurs or
1765 * this method is called on a closed <code>CallableStatement</code>
1766 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1767 * this method
1768 * @since 1.6
1769 */
1770 RowId getRowId(int parameterIndex) throws SQLException;
1771
1772 /**
1773 * Retrieves the value of the designated JDBC <code>ROWID</code> parameter as a
1774 * <code>java.sql.RowId</code> object.
1775 *
1776 * @param parameterName the name of the parameter
1777 * @return a <code>RowId</code> object that represents the JDBC <code>ROWID</code>
1778 * value is used as the designated parameter. If the parameter contains
1779 * a SQL <code>NULL</code>, then a <code>null</code> value is returned.
1780 * @throws SQLException if parameterName does not correspond to a named
1781 * parameter; if a database access error occurs or
1782 * this method is called on a closed <code>CallableStatement</code>
1783 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1784 * this method
1785 * @since 1.6
1786 */
1787 RowId getRowId(String parameterName) throws SQLException;
1788
1789 /**
1790 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
1791 * driver converts this to a SQL <code>ROWID</code> when it sends it to the
1792 * database.
1793 *
1794 * @param parameterName the name of the parameter
1795 * @param x the parameter value
1796 * @throws SQLException if parameterName does not correspond to a named
1797 * parameter; if a database access error occurs or
1798 * this method is called on a closed <code>CallableStatement</code>
1799 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1800 * this method
1801 * @since 1.6
1802 */
1803 void setRowId(String parameterName, RowId x) throws SQLException;
1804
1805 /**
1806 * Sets the designated parameter to the given <code>String</code> object.
1807 * The driver converts this to a SQL <code>NCHAR</code> or
1808 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
1809 * @param parameterName the name of the parameter to be set
1810 * @param value the parameter value
1811 * @throws SQLException if parameterName does not correspond to a named
1812 * parameter; if the driver does not support national
1813 * character sets; if the driver can detect that a data conversion
1814 * error could occur; if a database access error occurs or
1815 * this method is called on a closed <code>CallableStatement</code>
1816 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1817 * this method
1818 * @since 1.6
1819 */
1820 void setNString(String parameterName, String value)
1821 throws SQLException;
1822
1823 /**
1824 * Sets the designated parameter to a <code>Reader</code> object. The
1825 * <code>Reader</code> reads the data till end-of-file is reached. The
1826 * driver does the necessary conversion from Java character format to
1827 * the national character set in the database.
1828 * @param parameterName the name of the parameter to be set
1829 * @param value the parameter value
1830 * @param length the number of characters in the parameter data.
1831 * @throws SQLException if parameterName does not correspond to a named
1832 * parameter; if the driver does not support national
1833 * character sets; if the driver can detect that a data conversion
1834 * error could occur; if a database access error occurs or
1835 * this method is called on a closed <code>CallableStatement</code>
1836 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1837 * this method
1838 * @since 1.6
1839 */
1840 void setNCharacterStream(String parameterName, Reader value, long length)
1841 throws SQLException;
1842
1843 /**
1844 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
1845 * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
1846 * object maps to a SQL <code>NCLOB</code>.
1847 * @param parameterName the name of the parameter to be set
1848 * @param value the parameter value
1849 * @throws SQLException if parameterName does not correspond to a named
1850 * parameter; if the driver does not support national
1851 * character sets; if the driver can detect that a data conversion
1852 * error could occur; if a database access error occurs or
1853 * this method is called on a closed <code>CallableStatement</code>
1854 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1855 * this method
1856 * @since 1.6
1857 */
1858 void setNClob(String parameterName, NClob value) throws SQLException;
1859
1860 /**
1861 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
1862 * of characters specified by length otherwise a <code>SQLException</code> will be
1863 * generated when the <code>CallableStatement</code> is executed.
1864 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
1865 * because it informs the driver that the parameter value should be sent to
1866 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
1867 * driver may have to do extra work to determine whether the parameter
1868 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
1869 * @param parameterName the name of the parameter to be set
1870 * @param reader An object that contains the data to set the parameter value to.
1871 * @param length the number of characters in the parameter data.
1872 * @throws SQLException if parameterName does not correspond to a named
1873 * parameter; if the length specified is less than zero;
1874 * a database access error occurs or
1875 * this method is called on a closed <code>CallableStatement</code>
1876 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1877 * this method
1878 *
1879 * @since 1.6
1880 */
1881 void setClob(String parameterName, Reader reader, long length)
1882 throws SQLException;
1883
1884 /**
1885 * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number
1886 * of characters specified by length, otherwise a <code>SQLException</code> will be
1887 * generated when the <code>CallableStatement</code> is executed.
1888 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
1889 * method because it informs the driver that the parameter value should be
1890 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
1891 * the driver may have to do extra work to determine whether the parameter
1892 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
1893 *
1894 * @param parameterName the name of the parameter to be set
1895 * the second is 2, ...
1896 *
1897 * @param inputStream An object that contains the data to set the parameter
1898 * value to.
1899 * @param length the number of bytes in the parameter data.
1900 * @throws SQLException if parameterName does not correspond to a named
1901 * parameter; if the length specified
1902 * is less than zero; if the number of bytes in the inputstream does not match
1903 * the specified length; if a database access error occurs or
1904 * this method is called on a closed <code>CallableStatement</code>
1905 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1906 * this method
1907 *
1908 * @since 1.6
1909 */
1910 void setBlob(String parameterName, InputStream inputStream, long length)
1911 throws SQLException;
1912 /**
1913 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
1914 * of characters specified by length otherwise a <code>SQLException</code> will be
1915 * generated when the <code>CallableStatement</code> is executed.
1916 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
1917 * because it informs the driver that the parameter value should be sent to
1918 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
1919 * driver may have to do extra work to determine whether the parameter
1920 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
1921 *
1922 * @param parameterName the name of the parameter to be set
1923 * @param reader An object that contains the data to set the parameter value to.
1924 * @param length the number of characters in the parameter data.
1925 * @throws SQLException if parameterName does not correspond to a named
1926 * parameter; if the length specified is less than zero;
1927 * if the driver does not support national
1928 * character sets; if the driver can detect that a data conversion
1929 * error could occur; if a database access error occurs or
1930 * this method is called on a closed <code>CallableStatement</code>
1931 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1932 * this method
1933 * @since 1.6
1934 */
1935 void setNClob(String parameterName, Reader reader, long length)
1936 throws SQLException;
1937
1938 /**
1939 * Retrieves the value of the designated JDBC <code>NCLOB</code> parameter as a
1940 * <code>java.sql.NClob</code> object in the Java programming language.
1941 *
1942 * @param parameterIndex the first parameter is 1, the second is 2, and
1943 * so on
1944 * @return the parameter value as a <code>NClob</code> object in the
1945 * Java programming language. If the value was SQL <code>NULL</code>, the
1946 * value <code>null</code> is returned.
1947 * @exception SQLException if the parameterIndex is not valid;
1948 * if the driver does not support national
1949 * character sets; if the driver can detect that a data conversion
1950 * error could occur; if a database access error occurs or
1951 * this method is called on a closed <code>CallableStatement</code>
1952 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1953 * this method
1954 * @since 1.6
1955 */
1956 NClob getNClob (int parameterIndex) throws SQLException;
1957
1958
1959 /**
1960 * Retrieves the value of a JDBC <code>NCLOB</code> parameter as a
1961 * <code>java.sql.NClob</code> object in the Java programming language.
1962 * @param parameterName the name of the parameter
1963 * @return the parameter value as a <code>NClob</code> object in the
1964 * Java programming language. If the value was SQL <code>NULL</code>,
1965 * the value <code>null</code> is returned.
1966 * @exception SQLException if parameterName does not correspond to a named
1967 * parameter; if the driver does not support national
1968 * character sets; if the driver can detect that a data conversion
1969 * error could occur; if a database access error occurs or
1970 * this method is called on a closed <code>CallableStatement</code>
1971 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1972 * this method
1973 * @since 1.6
1974 */
1975 NClob getNClob (String parameterName) throws SQLException;
1976
1977 /**
1978 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
1979 * <code>SQL XML</code> value when it sends it to the database.
1980 *
1981 * @param parameterName the name of the parameter
1982 * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
1983 * @throws SQLException if parameterName does not correspond to a named
1984 * parameter; if a database access error occurs;
1985 * this method is called on a closed <code>CallableStatement</code> or
1986 * the <code>java.xml.transform.Result</code>,
1987 * <code>Writer</code> or <code>OutputStream</code> has not been closed for the <code>SQLXML</code> object
1988 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
1989 * this method
1990 *
1991 * @since 1.6
1992 */
1993 void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException;
1994
1995 /**
1996 * Retrieves the value of the designated <code>SQL XML</code> parameter as a
1997 * <code>java.sql.SQLXML</code> object in the Java programming language.
1998 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
1999 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
2000 * @throws SQLException if the parameterIndex is not valid;
2001 * if a database access error occurs or
2002 * this method is called on a closed <code>CallableStatement</code>
2003 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2004 * this method
2005 * @since 1.6
2006 */
2007 SQLXML getSQLXML(int parameterIndex) throws SQLException;
2008
2009 /**
2010 * Retrieves the value of the designated <code>SQL XML</code> parameter as a
2011 * <code>java.sql.SQLXML</code> object in the Java programming language.
2012 * @param parameterName the name of the parameter
2013 * @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
2014 * @throws SQLException if parameterName does not correspond to a named
2015 * parameter; if a database access error occurs or
2016 * this method is called on a closed <code>CallableStatement</code>
2017 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2018 * this method
2019 * @since 1.6
2020 */
2021 SQLXML getSQLXML(String parameterName) throws SQLException;
2022
2023 /**
2024 * Retrieves the value of the designated <code>NCHAR</code>,
2025 * <code>NVARCHAR</code>
2026 * or <code>LONGNVARCHAR</code> parameter as
2027 * a <code>String</code> in the Java programming language.
2028 * <p>
2029 * For the fixed-length type JDBC <code>NCHAR</code>,
2030 * the <code>String</code> object
2031 * returned has exactly the same value the SQL
2032 * <code>NCHAR</code> value had in the
2033 * database, including any padding added by the database.
2034 *
2035 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
2036 * @return a <code>String</code> object that maps an
2037 * <code>NCHAR</code>, <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
2038 * @exception SQLException if the parameterIndex is not valid;
2039 * if a database access error occurs or
2040 * this method is called on a closed <code>CallableStatement</code>
2041 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2042 * this method
2043 * @since 1.6
2044 * @see #setNString
2045 */
2046 String getNString(int parameterIndex) throws SQLException;
2047
2048
2049 /**
2050 * Retrieves the value of the designated <code>NCHAR</code>,
2051 * <code>NVARCHAR</code>
2052 * or <code>LONGNVARCHAR</code> parameter as
2053 * a <code>String</code> in the Java programming language.
2054 * <p>
2055 * For the fixed-length type JDBC <code>NCHAR</code>,
2056 * the <code>String</code> object
2057 * returned has exactly the same value the SQL
2058 * <code>NCHAR</code> value had in the
2059 * database, including any padding added by the database.
2060 *
2061 * @param parameterName the name of the parameter
2062 * @return a <code>String</code> object that maps an
2063 * <code>NCHAR</code>, <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
2064 * @exception SQLException if parameterName does not correspond to a named
2065 * parameter;
2066 * if a database access error occurs or
2067 * this method is called on a closed <code>CallableStatement</code>
2068 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2069 * this method
2070 * @since 1.6
2071 * @see #setNString
2072 */
2073 String getNString(String parameterName) throws SQLException;
2074
2075 /**
2076 * Retrieves the value of the designated parameter as a
2077 * <code>java.io.Reader</code> object in the Java programming language.
2078 * It is intended for use when
2079 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
2080 * and <code>LONGNVARCHAR</code> parameters.
2081 *
2082 * @return a <code>java.io.Reader</code> object that contains the parameter
2083 * value; if the value is SQL <code>NULL</code>, the value returned is
2084 * <code>null</code> in the Java programming language.
2085 * @param parameterIndex the first parameter is 1, the second is 2, ...
2086 * @exception SQLException if the parameterIndex is not valid;
2087 * if a database access error occurs or
2088 * this method is called on a closed <code>CallableStatement</code>
2089 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2090 * this method
2091 * @since 1.6
2092 */
2093 java.io.Reader getNCharacterStream(int parameterIndex) throws SQLException;
2094
2095 /**
2096 * Retrieves the value of the designated parameter as a
2097 * <code>java.io.Reader</code> object in the Java programming language.
2098 * It is intended for use when
2099 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
2100 * and <code>LONGNVARCHAR</code> parameters.
2101 *
2102 * @param parameterName the name of the parameter
2103 * @return a <code>java.io.Reader</code> object that contains the parameter
2104 * value; if the value is SQL <code>NULL</code>, the value returned is
2105 * <code>null</code> in the Java programming language
2106 * @exception SQLException if parameterName does not correspond to a named
2107 * parameter; if a database access error occurs or
2108 * this method is called on a closed <code>CallableStatement</code>
2109 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2110 * this method
2111 * @since 1.6
2112 */
2113 java.io.Reader getNCharacterStream(String parameterName) throws SQLException;
2114
2115 /**
2116 * Retrieves the value of the designated parameter as a
2117 * <code>java.io.Reader</code> object in the Java programming language.
2118 *
2119 * @return a <code>java.io.Reader</code> object that contains the parameter
2120 * value; if the value is SQL <code>NULL</code>, the value returned is
2121 * <code>null</code> in the Java programming language.
2122 * @param parameterIndex the first parameter is 1, the second is 2, ...
2123 * @exception SQLException if the parameterIndex is not valid; if a database access error occurs or
2124 * this method is called on a closed <code>CallableStatement</code>
2125 * @since 1.6
2126 */
2127 java.io.Reader getCharacterStream(int parameterIndex) throws SQLException;
2128
2129 /**
2130 * Retrieves the value of the designated parameter as a
2131 * <code>java.io.Reader</code> object in the Java programming language.
2132 *
2133 * @param parameterName the name of the parameter
2134 * @return a <code>java.io.Reader</code> object that contains the parameter
2135 * value; if the value is SQL <code>NULL</code>, the value returned is
2136 * <code>null</code> in the Java programming language
2137 * @exception SQLException if parameterName does not correspond to a named
2138 * parameter; if a database access error occurs or
2139 * this method is called on a closed <code>CallableStatement</code>
2140 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2141 * this method
2142 * @since 1.6
2143 */
2144 java.io.Reader getCharacterStream(String parameterName) throws SQLException;
2145
2146 /**
2147 * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
2148 * The driver converts this to an SQL <code>BLOB</code> value when it
2149 * sends it to the database.
2150 *
2151 * @param parameterName the name of the parameter
2152 * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
2153 * @exception SQLException if parameterName does not correspond to a named
2154 * parameter; if a database access error occurs or
2155 * this method is called on a closed <code>CallableStatement</code>
2156 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2157 * this method
2158 * @since 1.6
2159 */
2160 void setBlob (String parameterName, Blob x) throws SQLException;
2161
2162 /**
2163 * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
2164 * The driver converts this to an SQL <code>CLOB</code> value when it
2165 * sends it to the database.
2166 *
2167 * @param parameterName the name of the parameter
2168 * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
2169 * @exception SQLException if parameterName does not correspond to a named
2170 * parameter; if a database access error occurs or
2171 * this method is called on a closed <code>CallableStatement</code>
2172 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2173 * this method
2174 * @since 1.6
2175 */
2176 void setClob (String parameterName, Clob x) throws SQLException;
2177 /**
2178 * Sets the designated parameter to the given input stream, which will have
2179 * the specified number of bytes.
2180 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2181 * parameter, it may be more practical to send it via a
2182 * <code>java.io.InputStream</code>. Data will be read from the stream
2183 * as needed until end-of-file is reached. The JDBC driver will
2184 * do any necessary conversion from ASCII to the database char format.
2185 *
2186 * <P><B>Note:</B> This stream object can either be a standard
2187 * Java stream object or your own subclass that implements the
2188 * standard interface.
2189 *
2190 * @param parameterName the name of the parameter
2191 * @param x the Java input stream that contains the ASCII parameter value
2192 * @param length the number of bytes in the stream
2193 * @exception SQLException if parameterName does not correspond to a named
2194 * parameter; if a database access error occurs or
2195 * this method is called on a closed <code>CallableStatement</code>
2196 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2197 * this method
2198 * @since 1.6
2199 */
2200 void setAsciiStream(String parameterName, java.io.InputStream x, long length)
2201 throws SQLException;
2202
2203 /**
2204 * Sets the designated parameter to the given input stream, which will have
2205 * the specified number of bytes.
2206 * When a very large binary value is input to a <code>LONGVARBINARY</code>
2207 * parameter, it may be more practical to send it via a
2208 * <code>java.io.InputStream</code> object. The data will be read from the stream
2209 * as needed until end-of-file is reached.
2210 *
2211 * <P><B>Note:</B> This stream object can either be a standard
2212 * Java stream object or your own subclass that implements the
2213 * standard interface.
2214 *
2215 * @param parameterName the name of the parameter
2216 * @param x the java input stream which contains the binary parameter value
2217 * @param length the number of bytes in the stream
2218 * @exception SQLException if parameterName does not correspond to a named
2219 * parameter; if a database access error occurs or
2220 * this method is called on a closed <code>CallableStatement</code>
2221 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2222 * this method
2223 * @since 1.6
2224 */
2225 void setBinaryStream(String parameterName, java.io.InputStream x,
2226 long length) throws SQLException;
2227 /**
2228 * Sets the designated parameter to the given <code>Reader</code>
2229 * object, which is the given number of characters long.
2230 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
2231 * parameter, it may be more practical to send it via a
2232 * <code>java.io.Reader</code> object. The data will be read from the stream
2233 * as needed until end-of-file is reached. The JDBC driver will
2234 * do any necessary conversion from UNICODE to the database char format.
2235 *
2236 * <P><B>Note:</B> This stream object can either be a standard
2237 * Java stream object or your own subclass that implements the
2238 * standard interface.
2239 *
2240 * @param parameterName the name of the parameter
2241 * @param reader the <code>java.io.Reader</code> object that
2242 * contains the UNICODE data used as the designated parameter
2243 * @param length the number of characters in the stream
2244 * @exception SQLException if parameterName does not correspond to a named
2245 * parameter; if a database access error occurs or
2246 * this method is called on a closed <code>CallableStatement</code>
2247 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
2248 * this method
2249 * @since 1.6
2250 */
2251 void setCharacterStream(String parameterName,
2252 java.io.Reader reader,
2253 long length) throws SQLException;
2254 //--
2255 /**
2256 * Sets the designated parameter to the given input stream.
2257 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2258 * parameter, it may be more practical to send it via a
2259 * <code>java.io.InputStream</code>. Data will be read from the stream
2260 * as needed until end-of-file is reached. The JDBC driver will
2261 * do any necessary conversion from ASCII to the database char format.
2262 *
2263 * <P><B>Note:</B> This stream object can either be a standard
2264 * Java stream object or your own subclass that implements the
2265 * standard interface.
2266 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2267 * it might be more efficient to use a version of
2268 * <code>setAsciiStream</code> which takes a length parameter.
2269 *
2270 * @param parameterName the name of the parameter
2271 * @param x the Java input stream that contains the ASCII parameter value
2272 * @exception SQLException if parameterName does not correspond to a named
2273 * parameter; if a database access error occurs or
2274 * this method is called on a closed <code>CallableStatement</code>
2275 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2276 * @since 1.6
2277 */
2278 void setAsciiStream(String parameterName, java.io.InputStream x)
2279 throws SQLException;
2280 /**
2281 * Sets the designated parameter to the given input stream.
2282 * When a very large binary value is input to a <code>LONGVARBINARY</code>
2283 * parameter, it may be more practical to send it via a
2284 * <code>java.io.InputStream</code> object. The data will be read from the
2285 * stream as needed until end-of-file is reached.
2286 *
2287 * <P><B>Note:</B> This stream object can either be a standard
2288 * Java stream object or your own subclass that implements the
2289 * standard interface.
2290 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2291 * it might be more efficient to use a version of
2292 * <code>setBinaryStream</code> which takes a length parameter.
2293 *
2294 * @param parameterName the name of the parameter
2295 * @param x the java input stream which contains the binary parameter value
2296 * @exception SQLException if parameterName does not correspond to a named
2297 * parameter; if a database access error occurs or
2298 * this method is called on a closed <code>CallableStatement</code>
2299 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2300 * @since 1.6
2301 */
2302 void setBinaryStream(String parameterName, java.io.InputStream x)
2303 throws SQLException;
2304 /**
2305 * Sets the designated parameter to the given <code>Reader</code>
2306 * object.
2307 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
2308 * parameter, it may be more practical to send it via a
2309 * <code>java.io.Reader</code> object. The data will be read from the stream
2310 * as needed until end-of-file is reached. The JDBC driver will
2311 * do any necessary conversion from UNICODE to the database char format.
2312 *
2313 * <P><B>Note:</B> This stream object can either be a standard
2314 * Java stream object or your own subclass that implements the
2315 * standard interface.
2316 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2317 * it might be more efficient to use a version of
2318 * <code>setCharacterStream</code> which takes a length parameter.
2319 *
2320 * @param parameterName the name of the parameter
2321 * @param reader the <code>java.io.Reader</code> object that contains the
2322 * Unicode data
2323 * @exception SQLException if parameterName does not correspond to a named
2324 * parameter; if a database access error occurs or
2325 * this method is called on a closed <code>CallableStatement</code>
2326 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2327 * @since 1.6
2328 */
2329 void setCharacterStream(String parameterName,
2330 java.io.Reader reader) throws SQLException;
2331 /**
2332 * Sets the designated parameter to a <code>Reader</code> object. The
2333 * <code>Reader</code> reads the data till end-of-file is reached. The
2334 * driver does the necessary conversion from Java character format to
2335 * the national character set in the database.
2336
2337 * <P><B>Note:</B> This stream object can either be a standard
2338 * Java stream object or your own subclass that implements the
2339 * standard interface.
2340 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2341 * it might be more efficient to use a version of
2342 * <code>setNCharacterStream</code> which takes a length parameter.
2343 *
2344 * @param parameterName the name of the parameter
2345 * @param value the parameter value
2346 * @throws SQLException if parameterName does not correspond to a named
2347 * parameter; if the driver does not support national
2348 * character sets; if the driver can detect that a data conversion
2349 * error could occur; if a database access error occurs; or
2350 * this method is called on a closed <code>CallableStatement</code>
2351 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2352 * @since 1.6
2353 */
2354 void setNCharacterStream(String parameterName, Reader value) throws SQLException;
2355
2356 /**
2357 * Sets the designated parameter to a <code>Reader</code> object.
2358 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
2359 * because it informs the driver that the parameter value should be sent to
2360 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
2361 * driver may have to do extra work to determine whether the parameter
2362 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
2363 *
2364 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2365 * it might be more efficient to use a version of
2366 * <code>setClob</code> which takes a length parameter.
2367 *
2368 * @param parameterName the name of the parameter
2369 * @param reader An object that contains the data to set the parameter value to.
2370 * @throws SQLException if parameterName does not correspond to a named
2371 * parameter; if a database access error occurs or this method is called on
2372 * a closed <code>CallableStatement</code>
2373 *
2374 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2375 * @since 1.6
2376 */
2377 void setClob(String parameterName, Reader reader)
2378 throws SQLException;
2379
2380 /**
2381 * Sets the designated parameter to a <code>InputStream</code> object.
2382 * This method differs from the <code>setBinaryStream (int, InputStream)</code>
2383 * method because it informs the driver that the parameter value should be
2384 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
2385 * the driver may have to do extra work to determine whether the parameter
2386 * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
2387 *
2388 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2389 * it might be more efficient to use a version of
2390 * <code>setBlob</code> which takes a length parameter.
2391 *
2392 * @param parameterName the name of the parameter
2393 * @param inputStream An object that contains the data to set the parameter
2394 * value to.
2395 * @throws SQLException if parameterName does not correspond to a named
2396 * parameter; if a database access error occurs or
2397 * this method is called on a closed <code>CallableStatement</code>
2398 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2399 *
2400 * @since 1.6
2401 */
2402 void setBlob(String parameterName, InputStream inputStream)
2403 throws SQLException;
2404 /**
2405 * Sets the designated parameter to a <code>Reader</code> object.
2406 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
2407 * because it informs the driver that the parameter value should be sent to
2408 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
2409 * driver may have to do extra work to determine whether the parameter
2410 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
2411 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2412 * it might be more efficient to use a version of
2413 * <code>setNClob</code> which takes a length parameter.
2414 *
2415 * @param parameterName the name of the parameter
2416 * @param reader An object that contains the data to set the parameter value to.
2417 * @throws SQLException if parameterName does not correspond to a named
2418 * parameter; if the driver does not support national character sets;
2419 * if the driver can detect that a data conversion
2420 * error could occur; if a database access error occurs or
2421 * this method is called on a closed <code>CallableStatement</code>
2422 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
2423 *
2424 * @since 1.6
2425 */
2426 void setNClob(String parameterName, Reader reader)
2427 throws SQLException;
2428
2429 //------------------------- JDBC 4.1 -----------------------------------
2430
2431
2432 /**
2433 *<p>Returns an object representing the value of OUT parameter
2434 * {@code parameterIndex} and will convert from the
2435 * SQL type of the parameter to the requested Java data type, if the
2436 * conversion is supported. If the conversion is not
2437 * supported or null is specified for the type, a
2438 * <code>SQLException</code> is thrown.
2439 *<p>
2440 * At a minimum, an implementation must support the conversions defined in
2441 * Appendix B, Table B-3 and conversion of appropriate user defined SQL
2442 * types to a Java type which implements {@code SQLData}, or {@code Struct}.
2443 * Additional conversions may be supported and are vendor defined.
2444 *
2445 * @param parameterIndex the first parameter is 1, the second is 2, and so on
2446 * @param type Class representing the Java data type to convert the
2447 * designated parameter to.
2448 * @param <T> the type of the class modeled by this Class object
2449 * @return an instance of {@code type} holding the OUT parameter value
2450 * @throws SQLException if conversion is not supported, type is null or
2451 * another error occurs. The getCause() method of the
2452 * exception may provide a more detailed exception, for example, if
2453 * a conversion error occurs
2454 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
2455 * this method
2456 * @since 1.7
2457 */
2458 public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException;
2459
2460
2461 /**
2462 *<p>Returns an object representing the value of OUT parameter
2463 * {@code parameterName} and will convert from the
2464 * SQL type of the parameter to the requested Java data type, if the
2465 * conversion is supported. If the conversion is not
2466 * supported or null is specified for the type, a
2467 * <code>SQLException</code> is thrown.
2468 *<p>
2469 * At a minimum, an implementation must support the conversions defined in
2470 * Appendix B, Table B-3 and conversion of appropriate user defined SQL
2471 * types to a Java type which implements {@code SQLData}, or {@code Struct}.
2472 * Additional conversions may be supported and are vendor defined.
2473 *
2474 * @param parameterName the name of the parameter
2475 * @param type Class representing the Java data type to convert
2476 * the designated parameter to.
2477 * @param <T> the type of the class modeled by this Class object
2478 * @return an instance of {@code type} holding the OUT parameter
2479 * value
2480 * @throws SQLException if conversion is not supported, type is null or
2481 * another error occurs. The getCause() method of the
2482 * exception may provide a more detailed exception, for example, if
2483 * a conversion error occurs
2484 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
2485 * this method
2486 * @since 1.7
2487 */
2488 public <T> T getObject(String parameterName, Class<T> type) throws SQLException;
2489
2490 //------------------------- JDBC 4.2 -----------------------------------
2491
2492 /**
2493 * <p>Sets the value of the designated parameter with the given object.
2494 *
2495 * If the second argument is an {@code InputStream} then the stream
2496 * must contain the number of bytes specified by scaleOrLength.
2497 * If the second argument is a {@code Reader} then the reader must
2498 * contain the number of characters specified
2499 * by scaleOrLength. If these conditions are not true the driver
2500 * will generate a
2501 * {@code SQLException} when the prepared statement is executed.
2502 *
2503 * <p>The given Java object will be converted to the given targetSqlType
2504 * before being sent to the database.
2505 *
2506 * If the object has a custom mapping (is of a class implementing the
2507 * interface {@code SQLData}),
2508 * the JDBC driver should call the method {@code SQLData.writeSQL} to
2509 * write it to the SQL data stream.
2510 * If, on the other hand, the object is of a class implementing
2511 * {@code Ref}, {@code Blob}, {@code Clob}, {@code NClob},
2512 * {@code Struct}, {@code java.net.URL},
2513 * or {@code Array}, the driver should pass it to the database as a
2514 * value of the corresponding SQL type.
2515 *
2516 * <p>Note that this method may be used to pass database-specific
2517 * abstract data types.
2518 *<P>
2519 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2520 *
2521 * @param parameterName the name of the parameter
2522 * @param x the object containing the input parameter value
2523 * @param targetSqlType the SQL type to be
2524 * sent to the database. The scale argument may further qualify this type.
2525 * @param scaleOrLength for {@code java.sql.JDBCType.DECIMAL}
2526 * or {@code java.sql.JDBCType.NUMERIC types},
2527 * this is the number of digits after the decimal point. For
2528 * Java Object types {@code InputStream} and {@code Reader},
2529 * this is the length
2530 * of the data in the stream or reader. For all other types,
2531 * this value will be ignored.
2532 * @exception SQLException if parameterName does not correspond to a named
2533 * parameter; if a database access error occurs
2534 * or this method is called on a closed {@code CallableStatement} or
2535 * if the Java Object specified by x is an InputStream
2536 * or Reader object and the value of the scale parameter is less
2537 * than zero
2538 * @exception SQLFeatureNotSupportedException if
2539 * the JDBC driver does not support the specified targetSqlType
2540 * @see JDBCType
2541 * @see SQLType
2542 *
2543 * @since 1.8
2544 */
2545 default void setObject(String parameterName, Object x, SQLType targetSqlType,
2546 int scaleOrLength) throws SQLException {
2547 throw new SQLFeatureNotSupportedException("setObject not implemented");
2548 }
2549 /**
2550 * Sets the value of the designated parameter with the given object.
2551 *
2552 * This method is similar to {@link #setObject(String parameterName,
2553 * Object x, SQLType targetSqlType, int scaleOrLength)},
2554 * except that it assumes a scale of zero.
2555 *<P>
2556 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2557 *
2558 * @param parameterName the name of the parameter
2559 * @param x the object containing the input parameter value
2560 * @param targetSqlType the SQL type to be sent to the database
2561 * @exception SQLException if parameterName does not correspond to a named
2562 * parameter; if a database access error occurs
2563 * or this method is called on a closed {@code CallableStatement}
2564 * @exception SQLFeatureNotSupportedException if
2565 * the JDBC driver does not support the specified targetSqlType
2566 * @see JDBCType
2567 * @see SQLType
2568 * @since 1.8
2569 */
2570 default void setObject(String parameterName, Object x, SQLType targetSqlType)
2571 throws SQLException {
2572 throw new SQLFeatureNotSupportedException("setObject not implemented");
2573 }
2574
2575 /**
2576 * Registers the OUT parameter in ordinal position
2577 * {@code parameterIndex} to the JDBC type
2578 * {@code sqlType}. All OUT parameters must be registered
2579 * before a stored procedure is executed.
2580 * <p>
2581 * The JDBC type specified by {@code sqlType} for an OUT
2582 * parameter determines the Java type that must be used
2583 * in the {@code get} method to read the value of that parameter.
2584 * <p>
2585 * If the JDBC type expected to be returned to this output parameter
2586 * is specific to this particular database, {@code sqlType}
2587 * may be {@code JDBCType.OTHER} or a {@code SQLType} that is supported by
2588 * the JDBC driver. The method
2589 * {@link #getObject} retrieves the value.
2590 *<P>
2591 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2592 *
2593 * @param parameterIndex the first parameter is 1, the second is 2,
2594 * and so on
2595 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2596 * register the OUT Parameter.
2597 * If the parameter is of JDBC type {@code JDBCType.NUMERIC}
2598 * or {@code JDBCType.DECIMAL}, the version of
2599 * {@code registerOutParameter} that accepts a scale value
2600 * should be used.
2601 *
2602 * @exception SQLException if the parameterIndex is not valid;
2603 * if a database access error occurs or
2604 * this method is called on a closed {@code CallableStatement}
2605 * @exception SQLFeatureNotSupportedException if
2606 * the JDBC driver does not support the specified sqlType
2607 * @see JDBCType
2608 * @see SQLType
2609 * @since 1.8
2610 */
2611 default void registerOutParameter(int parameterIndex, SQLType sqlType)
2612 throws SQLException {
2613 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2614 }
2615
2616 /**
2617 * Registers the parameter in ordinal position
2618 * {@code parameterIndex} to be of JDBC type
2619 * {@code sqlType}. All OUT parameters must be registered
2620 * before a stored procedure is executed.
2621 * <p>
2622 * The JDBC type specified by {@code sqlType} for an OUT
2623 * parameter determines the Java type that must be used
2624 * in the {@code get} method to read the value of that parameter.
2625 * <p>
2626 * This version of {@code registerOutParameter} should be
2627 * used when the parameter is of JDBC type {@code JDBCType.NUMERIC}
2628 * or {@code JDBCType.DECIMAL}.
2629 *<P>
2630 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2631 *
2632 * @param parameterIndex the first parameter is 1, the second is 2,
2633 * and so on
2634 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2635 * register the OUT Parameter.
2636 * @param scale the desired number of digits to the right of the
2637 * decimal point. It must be greater than or equal to zero.
2638 * @exception SQLException if the parameterIndex is not valid;
2639 * if a database access error occurs or
2640 * this method is called on a closed {@code CallableStatement}
2641 * @exception SQLFeatureNotSupportedException if
2642 * the JDBC driver does not support the specified sqlType
2643 * @see JDBCType
2644 * @see SQLType
2645 * @since 1.8
2646 */
2647 default void registerOutParameter(int parameterIndex, SQLType sqlType,
2648 int scale) throws SQLException {
2649 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2650 }
2651 /**
2652 * Registers the designated output parameter.
2653 * This version of
2654 * the method {@code registerOutParameter}
2655 * should be used for a user-defined or {@code REF} output parameter.
2656 * Examples
2657 * of user-defined types include: {@code STRUCT}, {@code DISTINCT},
2658 * {@code JAVA_OBJECT}, and named array types.
2659 *<p>
2660 * All OUT parameters must be registered
2661 * before a stored procedure is executed.
2662 * <p> For a user-defined parameter, the fully-qualified SQL
2663 * type name of the parameter should also be given, while a {@code REF}
2664 * parameter requires that the fully-qualified type name of the
2665 * referenced type be given. A JDBC driver that does not need the
2666 * type code and type name information may ignore it. To be portable,
2667 * however, applications should always provide these values for
2668 * user-defined and {@code REF} parameters.
2669 *
2670 * Although it is intended for user-defined and {@code REF} parameters,
2671 * this method may be used to register a parameter of any JDBC type.
2672 * If the parameter does not have a user-defined or {@code REF} type, the
2673 * <i>typeName</i> parameter is ignored.
2674 *
2675 * <P><B>Note:</B> When reading the value of an out parameter, you
2676 * must use the getter method whose Java type corresponds to the
2677 * parameter's registered SQL type.
2678 *<P>
2679 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2680 *
2681 * @param parameterIndex the first parameter is 1, the second is 2,...
2682 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2683 * register the OUT Parameter.
2684 * @param typeName the fully-qualified name of an SQL structured type
2685 * @exception SQLException if the parameterIndex is not valid;
2686 * if a database access error occurs or
2687 * this method is called on a closed {@code CallableStatement}
2688 * @exception SQLFeatureNotSupportedException if
2689 * the JDBC driver does not support the specified sqlType
2690 * @see JDBCType
2691 * @see SQLType
2692 * @since 1.8
2693 */
2694 default void registerOutParameter (int parameterIndex, SQLType sqlType,
2695 String typeName) throws SQLException {
2696 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2697 }
2698
2699 /**
2700 * Registers the OUT parameter named
2701 * <code>parameterName</code> to the JDBC type
2702 * {@code sqlType}. All OUT parameters must be registered
2703 * before a stored procedure is executed.
2704 * <p>
2705 * The JDBC type specified by {@code sqlType} for an OUT
2706 * parameter determines the Java type that must be used
2707 * in the {@code get} method to read the value of that parameter.
2708 * <p>
2709 * If the JDBC type expected to be returned to this output parameter
2710 * is specific to this particular database, {@code sqlType}
2711 * should be {@code JDBCType.OTHER} or a {@code SQLType} that is supported
2712 * by the JDBC driver.. The method
2713 * {@link #getObject} retrieves the value.
2714 *<P>
2715 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2716 *
2717 * @param parameterName the name of the parameter
2718 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2719 * register the OUT Parameter.
2720 * If the parameter is of JDBC type {@code JDBCType.NUMERIC}
2721 * or {@code JDBCType.DECIMAL}, the version of
2722 * {@code registerOutParameter} that accepts a scale value
2723 * should be used.
2724 * @exception SQLException if parameterName does not correspond to a named
2725 * parameter; if a database access error occurs or
2726 * this method is called on a closed {@code CallableStatement}
2727 * @exception SQLFeatureNotSupportedException if
2728 * the JDBC driver does not support the specified sqlType
2729 * or if the JDBC driver does not support
2730 * this method
2731 * @since 1.8
2732 * @see JDBCType
2733 * @see SQLType
2734 */
2735 default void registerOutParameter(String parameterName, SQLType sqlType)
2736 throws SQLException {
2737 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2738 }
2739
2740 /**
2741 * Registers the parameter named
2742 * <code>parameterName</code> to be of JDBC type
2743 * {@code sqlType}. All OUT parameters must be registered
2744 * before a stored procedure is executed.
2745 * <p>
2746 * The JDBC type specified by {@code sqlType} for an OUT
2747 * parameter determines the Java type that must be used
2748 * in the {@code get} method to read the value of that parameter.
2749 * <p>
2750 * This version of {@code registerOutParameter} should be
2751 * used when the parameter is of JDBC type {@code JDBCType.NUMERIC}
2752 * or {@code JDBCType.DECIMAL}.
2753 *<P>
2754 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2755 *
2756 * @param parameterName the name of the parameter
2757 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2758 * register the OUT Parameter.
2759 * @param scale the desired number of digits to the right of the
2760 * decimal point. It must be greater than or equal to zero.
2761 * @exception SQLException if parameterName does not correspond to a named
2762 * parameter; if a database access error occurs or
2763 * this method is called on a closed {@code CallableStatement}
2764 * @exception SQLFeatureNotSupportedException if
2765 * the JDBC driver does not support the specified sqlType
2766 * or if the JDBC driver does not support
2767 * this method
2768 * @since 1.8
2769 * @see JDBCType
2770 * @see SQLType
2771 */
2772 default void registerOutParameter(String parameterName, SQLType sqlType,
2773 int scale) throws SQLException {
2774 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2775 }
2776
2777 /**
2778 * Registers the designated output parameter. This version of
2779 * the method {@code registerOutParameter}
2780 * should be used for a user-named or REF output parameter. Examples
2781 * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
2782 * named array types.
2783 *<p>
2784 * All OUT parameters must be registered
2785 * before a stored procedure is executed.
2786 * </p>
2787 * For a user-named parameter the fully-qualified SQL
2788 * type name of the parameter should also be given, while a REF
2789 * parameter requires that the fully-qualified type name of the
2790 * referenced type be given. A JDBC driver that does not need the
2791 * type code and type name information may ignore it. To be portable,
2792 * however, applications should always provide these values for
2793 * user-named and REF parameters.
2794 *
2795 * Although it is intended for user-named and REF parameters,
2796 * this method may be used to register a parameter of any JDBC type.
2797 * If the parameter does not have a user-named or REF type, the
2798 * typeName parameter is ignored.
2799 *
2800 * <P><B>Note:</B> When reading the value of an out parameter, you
2801 * must use the {@code getXXX} method whose Java type XXX corresponds to the
2802 * parameter's registered SQL type.
2803 *<P>
2804 * The default implementation will throw {@code SQLFeatureNotSupportedException}
2805 *
2806 * @param parameterName the name of the parameter
2807 * @param sqlType the JDBC type code defined by {@code SQLType} to use to
2808 * register the OUT Parameter.
2809 * @param typeName the fully-qualified name of an SQL structured type
2810 * @exception SQLException if parameterName does not correspond to a named
2811 * parameter; if a database access error occurs or
2812 * this method is called on a closed {@code CallableStatement}
2813 * @exception SQLFeatureNotSupportedException if
2814 * the JDBC driver does not support the specified sqlType
2815 * or if the JDBC driver does not support this method
2816 * @see JDBCType
2817 * @see SQLType
2818 * @since 1.8
2819 */
2820 default void registerOutParameter (String parameterName, SQLType sqlType,
2821 String typeName) throws SQLException {
2822 throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
2823 }
2824 }