jdbcCallableStatement


1   /* Copyright (c) 2001-2005, The HSQL Development Group
2    * All rights reserved.
3    *
4    * Redistribution and use in source and binary forms, with or without
5    * modification, are permitted provided that the following conditions are met:
6    *
7    * Redistributions of source code must retain the above copyright notice, this
8    * list of conditions and the following disclaimer.
9    *
10   * Redistributions in binary form must reproduce the above copyright notice,
11   * this list of conditions and the following disclaimer in the documentation
12   * and/or other materials provided with the distribution.
13   *
14   * Neither the name of the HSQL Development Group nor the names of its
15   * contributors may be used to endorse or promote products derived from this
16   * software without specific prior written permission.
17   *
18   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21   * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
22   * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29   */
30  
31  
32  package org.hsqldb.jdbc;
33  
34  import java.math.BigDecimal  ;
35  import java.sql.CallableStatement  ;
36  import java.sql.Date  ;
37  import java.sql.Time  ;
38  import java.sql.Timestamp  ;
39  import java.sql.SQLException  ;
40  import java.util.Calendar  ;
41  
42  //#ifdef JAVA2
43  import java.sql.Array  ;
44  import java.sql.Blob  ;
45  import java.sql.Clob  ;
46  import java.sql.Ref  ;
47  import java.util.Map  ;
48  
49  //#endif JAVA2
50  import org.hsqldb.HsqlException;
51  import org.hsqldb.Trace;
52  import org.hsqldb.lib.IntValueHashMap;
53  
54  // boucherb@users patch 1.7.2 - CallableStatement impl removed
55  // from jdbcPreparedStatement and moved here; sundry changes elsewhere to
56  // comply
57  // TODO: 1.7.2 Alpha N :: DONE
58  //       maybe implement set-by-parameter-name.  We have an informal spec,
59  //       being "@p1" => 1, "@p2" => 2, etc.  Problems: return value is "@p0"
60  //       and there is no support for registering the return value as an out
61  //       parameter.
62  // TODO: 1.8.x
63  //       engine and client-side mechanisms for adding, retrieving,
64  //       navigating (and perhaps controlling holdability of) multiple
65  //       results generated from a single execution.
66  // boucherb@users 2004-03/04-xx - patch 1.7.2 - some minor code cleanup
67  //                                            - parameter map NPE correction
68  //                                            - embedded SQL/SQLCLI client usability
69  //                                              (parameter naming changed from @n to @pn)
70  // boucherb@users 2004-04-xx - doc 1.7.2 - javadocs added/updated
71  
72  /**
73   * <!-- start generic documentation -->
74   *
75   * The interface used to execute SQL stored procedures.  The JDBC API
76   * provides a stored procedure SQL escape syntax that allows stored
77   * procedures to be called in a standard way for all RDBMSs. This escape
78   * syntax has one form that includes a result parameter and one that does
79   * not. If used, the result parameter must be registered as an OUT parameter.
80   * The other parameters can be used for input, output or both. Parameters
81   * are referred to sequentially, by number, with the first parameter being 1.
82   * <PRE>
83   *   {?= call &lt;procedure-name&gt;[&lt;arg1&gt;,&lt;arg2&gt;, ...]}
84   *   {call &lt;procedure-name&gt;[&lt;arg1&gt;,&lt;arg2&gt;, ...]}
85   * </PRE>
86   * <P>
87   * IN parameter values are set using the <code>set</code> methods inherited from
88   * {@link PreparedStatement}.  The type of all OUT parameters must be
89   * registered prior to executing the stored procedure; their values
90   * are retrieved after execution via the <code>get</code> methods provided here.
91   * <P>
92   * A <code>CallableStatement</code> can return one {@link ResultSet} object or
93   * multiple <code>ResultSet</code> objects.  Multiple
94   * <code>ResultSet</code> objects are handled using operations
95   * inherited from {@link Statement}.
96   * <P>
97   * For maximum portability, a call's <code>ResultSet</code> objects and
98   * update counts should be processed prior to getting the values of output
99   * parameters.
100  * <P>
101  * <!-- end generic documentation -->
102  * <!-- start Release-specific documentation -->
103  * <div class="ReleaseSpecificDocumentation">
104  * <h3>HSQLDB-Specific Information:</h3> <p>
105  *
106  * Since 1.7.2, the JDBC CallableStatement interface implementation has been
107  * broken out of the jdbcPreparedStatement class into this one. <p>
108  *
109  * With 1.7.2, some of the previously unsupported features of this interface
110  * are now supported, such as the parameterName-based setter methods. <p>
111  *
112  * More importantly, jdbcCallableStatement objects are now backed by a true
113  * compiled parameteric representation. Hence, there are now significant
114  * performance gains to be had by using a CallableStatement object instead of
115  * a Statement object, if a short-running CALL statement is to be executed more
116  * than a small number of times.  Moreover, the recent work lays the foundation
117  * for work in a subsequenct release to support CallableStatement OUT and
118  * IN OUT style parameters, as well as the generation and retrieval of multiple
119  * results in response to the execution of a CallableStatement object. <p>
120  *
121  * For a more in-depth discussion of performance issues regarding 1.7.2
122  * prepared and callable statement objects, please see overview section of
123  * {@link jdbcPreparedStatement jdbcPreparedStatment}.
124  *
125  * <hr>
126  *
127  * As with many DBMS, HSQLDB support for stored procedures is not provided in
128  * a completely standard fashion. <p>
129  *
130  * Beyond the XOpen/ODBC extended scalar functions, stored procedures are
131  * typically supported in ways that vary greatly from one DBMS implementation
132  * to the next.  So, it is almost guaranteed that the code for a stored
133  * procedure written under a specific DBMS product will not work without
134  * at least some modification in the context of another vendor's product
135  * or even across a single vendor's product lines.  Moving stored procedures
136  * from one DBMS product line to another almost invariably involves complex
137  * porting issues and often may not be possible at all. <em>Be warned</em>. <p>
138  *
139  * At present, HSQLDB stored procedures map directly onto the methods of
140  * compiled Java classes found on the classpath of the engine at runtime. This
141  * is done in a non-standard but fairly efficient way by issuing a class
142  * grant (and possibly method aliases) of the form: <p>
143  *
144  * <PRE class="SqlCodeExample">
145  * GRANT ALL ON CLASS &quot;package.class&quot; TO [&lt;user-name&gt; | PUBLIC]
146  * CREATE ALIAS &ltcall-alias&gt; FOR &quot;package.class.method&quot; -- optional
147  * </PRE>
148  *
149  * This has the effect of allowing the specified user(s) to access the
150  * set of uniquely named public static methods of the specified class,
151  * in either the role of SQL functions or stored procedures.
152 
153  * For example: <p>
154  *
155  * <PRE class="SqlCodeExample">
156  * CONNECT &lt;admin-user&gt; PASSWORD &lt;admin-user-password&gt;;
157  * GRANT ALL ON CLASS &quot;org.myorg.MyClass&quot; TO PUBLIC;
158  * CREATE ALIAS sp_my_method FOR &quot;org.myorg.MyClass.myMethod&quot;
159  * CONNECT &lt;any-user&gt; PASSWORD &lt;any-user-password&gt;;
160  * SELECT &quot;org.myorg.MyClass.myMethod&quot;(column_1) FROM table_1;
161  * SELECT sp_my_method(column_1) FROM table_1;
162  * CALL 2 + &quot;org.myorg.MyClass.myMethod&quot;(-5);
163  * CALL 2 + sp_my_method(-5);
164  * </PRE>
165  *
166  * Please note the use of the term &quot;uniquely named&quot; above. Including
167  * 1.7.2, no support is provided to deterministically resolve overloaded
168  * method names, and there can be issues with inherited methods as well;
169  * currently, it is strongly recommended that developers creating stored
170  * procedure library classes for HSQLDB simply avoid designs such that SQL
171  * stored procedure calls attempt to resolve to: <p>
172  *
173  * <ol>
174  * <li>inherited public static methods
175  * <li>overloaded public static methods
176  * </ol>
177  *
178  * Also, please note that <code>OUT</code> and <code>IN OUT</code> parameters
179  * are not yet supported due to some unresolved low level support issues. <p>
180  *
181  * Including 1.7.2, the HSQLDB stored procedure call mechanism is essentially a
182  * thin wrap of the HSQLDB SQL function call mechanism, extended to include the
183  * more general HSQLDB SQL expression evaluation mechanism.  In addition to
184  * stored procedure calls that resolve directly to Java method invocations, the
185  * extention provides the ability to evaluate simple SQL expressions, possibly
186  * containing Java method invocations, outside any <code>INSERT</code>,
187  * <code>UPDATE</code>, <code>DELETE</code> or <code>SELECT</code> statement
188  * context. <p>
189  *
190  * With HSQLDB, executing a <code>CALL</code> statement that produces an opaque
191  * (OTHER) or known scalar object reference has virtually the same effect as:
192  *
193  * <PRE class="SqlCodeExample">
194  * CREATE TABLE DUAL (dummy VARCHAR);
195  * INSERT INTO DUAL VALUES(NULL);
196  * SELECT &lt;simple-expression&gt; FROM DUAL;
197  * </PRE>
198  *
199  * As a transitional measure, HSQLDB provides the ability to materialize a
200  * general result set in response to stored procedure execution.  In this case,
201  * the stored procedure's Java method descriptor must specify a return type of
202  * java.lang.Object for external use (although at any point in the devlopment
203  * cycle, other, proprietary return types may accepted internally for engine
204  * development purposes).
205 
206  * When HSQLDB detects that the runtime class of the resulting Object is
207  * elligible, an automatic internal unwrapping is performed to correctly
208  * expose the underlying result set to the client, whether local or remote. <p>
209  *
210  * Additionally, HSQLDB automatically detects if java.sql.Connection is
211  * the class of the first argument of any underlying Java method(s).  If so,
212  * then the engine transparently supplies the internal Connection object
213  * corresponding to the Session executing the call, adjusting the positions
214  * of other arguments to suite the SQL context. <p>
215  *
216  * The features above are not intended to be permanent.  Rather, the intention
217  * is to offer more general and powerful mechanisms in a future release;
218  * it is recommend to use them only as a temporary convenience. <p>
219  *
220  * For instance, one might be well advised to future-proof by writing
221  * HSQLDB-specific adapter methods that in turn call the real logic of an
222  * underlying generalized JDBC stored procedure library. <p>
223  *
224  * Here is a very simple example of an HSQLDB stored procedure generating a
225  * user-defined result set:
226  *
227  * <pre class="JavaCodeExample">
228  * <span class="JavaKeyWord">package</span> mypackage;
229  *
230  * <span class="JavaKeyWord">class</span> MyClass {
231  *
232  *      <span class="JavaKeyWord">public static</span> Object <b>mySp</b>(Connection conn) <span class="JavaKeyWord">throws</span> SQLException {
233  *          <span class="JavaKeyWord">return</span> conn.<b>createStatement</b>().<b>executeQuery</b>(<span class="JavaStringLiteral">"select * from my_table"</span>);
234  *      }
235  * }
236  * </pre>
237  *
238  * Here is a refinement demonstrating no more than the bare essence of the idea
239  * behind a more portable style:
240  *
241  * <pre class="JavaCodeExample">
242  * <span class="JavaKeyWord">package</span> mypackage;
243  *
244  * <span class="JavaKeyWord">import</span> java.sql.ResultSet;
245  * <span class="JavaKeyWord">import</span> java.sql.SQLException;
246  *
247  * <span class="JavaKeyWord">class</span> MyLibraryClass {
248  *
249  *      <span class="JavaKeyWord">public static</span> ResultSet <b>mySp()</b> <span class="JavaKeyWord">throws</span> SQLException {
250  *          <span class="JavaKeyWord">return</span> ctx.<b>getConnection</b>().<b>createStatement</b>().<b>executeQuery</b>(<span class="JavaStringLiteral">"select * from my_table"</span>);
251  *      }
252  * }
253  *
254  * //--
255  *
256  * <span class="JavaKeyWord">package</span> myadaptorpackage;
257  *
258  * <span class="JavaKeyWord">import</span> java.sql.Connection;
259  * <span class="JavaKeyWord">import</span> java.sql.SQLException;
260  *
261  * <span class="JavaKeyWord">class</span> MyAdaptorClass {
262  *
263  *      <span class="JavaKeyWord">public static</span> Object <b>mySp</b>(Connection conn) <span class="JavaKeyWord">throws</span> SQLException {
264  *          MyLibraryClass.<b>getCtx()</b>.<b>setConnection</b>(conn);
265  *          <span class="JavaKeyWord">return</span> MyLibraryClass.<b>mySp</b>();
266  *      }
267  * }
268  * </pre>
269  *
270  * In a future release, it is intended to provided some new features
271  * that will support writing fairly portable JDBC-based stored procedure
272  * code: <P>
273  *
274  * <ul>
275  *  <li> Support for the <span class="JavaStringLiteral">"jdbc:default:connection"</span>
276  *       standard database connection url. <p>
277  *
278  *  <li> A well-defined specification of the behaviour of the HSQLDB execution
279  *       stack under stored procedure calls. <p>
280  *
281  *  <li> A well-defined, pure JDBC specification for generating multiple
282  *       results from HSQLDB stored procedures for client retrieval.
283  * </ul>
284  *
285  * (boucherb@users)
286  * </div>
287  * <!-- end Release-specific documentation -->
288  *
289  * @author boucherb@users
290  * @version 1.7.2
291  * @since 1.7.2
292  * @see jdbcConnection#prepareCall
293  * @see jdbcResultSet
294  */
295 public class jdbcCallableStatement extends jdbcPreparedStatement
296 implements CallableStatement   {
297 
298     /** parameter name => parameter index */
299     private IntValueHashMap parameterNameMap;
300 
301     /** parameter index => registered OUT type */
302 
303     //    private IntKeyIntValueHashMap outRegistrationMap;
304 
305     /**
306      * Constructs a new jdbcCallableStatement with the specified connection and
307      * result type.
308      *
309      * @param  c the connection on which this statement will execute
310      * @param sql the SQL statement this object represents
311      * @param type the type of result this statement will produce
312      * @throws HsqlException if the statement is not accepted by the database
313      * @throws SQLException if preprocessing by driver fails
314      */
315     public jdbcCallableStatement(jdbcConnection c, String   sql,
316                                  int type)
317                                  throws HsqlException, SQLException   {
318 
319         super(c, sql, type);
320 
321         String  [] names;
322         String     name;
323 
324         // outRegistrationMap = new IntKeyIntValueHashMap();
325         parameterNameMap = new IntValueHashMap();
326 
327         if (pmdDescriptor != null && pmdDescriptor.metaData != null) {
328             names = pmdDescriptor.metaData.colNames;
329 
330             for (int i = 0; i < names.length; i++) {
331                 name = names[i];
332 
333                 // PRE:  should never happen in practice
334                 if (name == null || name.length() == 0) {
335                     continue;    // throw?
336                 }
337 
338                 parameterNameMap.put(name, i);
339             }
340         }
341     }
342 
343     /**
344      * Retrieves the parameter index corresponding to the given
345      * parameter name. <p>
346      *
347      * @param parameterName to look up
348      * @throws SQLException if not found
349      * @return index for name
350      */
351     int findParameterIndex(String   parameterName) throws SQLException   {
352 
353         checkClosed();
354 
355         int index = parameterNameMap.get(parameterName, -1);
356 
357         if (index >= 0) {
358             return index + 1;
359         }
360 
361         throw Util.sqlException(Trace.COLUMN_NOT_FOUND, parameterName);
362     }
363 
364     /**
365      * Does the specialized work required to free this object's resources and
366      * that of it's parent classes. <p>
367      *
368      * @throws SQLException if a database access error occurs
369      */
370     public void close() throws SQLException   {
371 
372         if (isClosed()) {
373             return;
374         }
375 
376         // outRegistrationMap = null;
377         parameterNameMap = null;
378 
379         super.close();
380     }
381 
382     /**
383      * Performs an internal check for OUT or IN OUT column index validity. <p>
384      *
385      * @param i the one-based column index to check
386      * @throws SQLException if there is no such OUT or IN OUT column
387      */
388     private void checkGetParameterIndex(int i) throws SQLException   {
389 
390         checkClosed();
391 
392         if (i < 1 || i > parameterModes.length) {
393             String   msg = "Parameter index out of bounds: " + i;
394 
395             throw Util.sqlException(Trace.INVALID_JDBC_ARGUMENT, msg);
396         }
397 /*
398         int mode = parameterModes[i - 1];
399 
400         switch (mode) {
401 
402             default :
403                 String msg = "Not OUT or IN OUT mode: " + mode
404                              + " for parameter: " + i;
405 
406                 throw Util.sqlException(Trace.INVALID_JDBC_ARGUMENT, msg);
407             case Expression.PARAM_IN_OUT :
408             case Expression.PARAM_OUT :
409                 break;
410 
411             // this is OK
412         }
413  */
414     }
415 
416     /**
417      * Checks if the parameter of the given index has been successfully
418      * registered as an OUT parameter. <p>
419      *
420      * @param parameterIndex to check
421      * @throws SQLException if not registered
422      */
423     /*
424     private void checkIsRegisteredParameterIndex(int parameterIndex)
425     throws SQLException {
426 
427         int    type;
428         String msg;
429 
430         checkClosed();
431 
432         type = outRegistrationMap.get(parameterIndex, Integer.MIN_VALUE);
433 
434         if (type == Integer.MIN_VALUE) {
435             msg = "Parameter not registered: " + parameterIndex;
436 
437             throw Util.sqlException(Trace.INVALID_JDBC_ARGUMENT, msg);
438         }
439     }
440     */
441 
442 // ----------------------------------- JDBC 1 ----------------------------------
443 
444     /**
445      * <!-- start generic documentation -->
446      * Registers the OUT parameter in ordinal position
447      * <code>parameterIndex</code> to the JDBC type
448      * <code>sqlType</code>.  All OUT parameters must be registered
449      * before a stored procedure is executed.
450      * <p>
451      * The JDBC type specified by <code>sqlType</code> for an OUT
452      * parameter determines the Java type that must be used
453      * in the <code>get</code> method to read the value of that parameter.
454      * <p>
455      * If the JDBC type expected to be returned to this output parameter
456      * is specific to this particular database, <code>sqlType</code>
457      * should be <code>java.sql.Types.OTHER</code>.  The method
458      * {@link #getObject} retrieves the value. <p>
459      * <!-- end generic documentation -->
460      *
461      * <!-- start release-specific documentation -->
462      * <div class="ReleaseSpecificDocumentation">
463      * <h3>HSQLDB-Specific Information:</h3> <p>
464      *
465      * HSQLDB 1.7.2 does not support this feature. <p>
466      *
467      * Calling this method always throws an <code>SQLException</code>.
468      * </div>
469      * <!-- end release-specific documentation -->
470      *
471      * @param parameterIndex the first parameter is 1, the second is 2,
472      *   and so on
473      * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
474      *   If the parameter is of JDBC type <code>NUMERIC</code>
475      *   or <code>DECIMAL</code>, the version of
476      *   <code>registerOutParameter</code> that accepts a scale value
477      *   should be used.
478      * @exception SQLException if a database access error occurs
479      * @see java.sql.Types
480      */
481     public void registerOutParameter(int parameterIndex,
482                                      int sqlType) throws SQLException   {
483         throw Util.notSupported();
484     }
485 
486     /**
487      * <!-- start generic documentation -->
488      * Registers the parameter in ordinal position
489      * <code>parameterIndex</code> to be of JDBC type
490      * <code>sqlType</code>.  This method must be called
491      * before a stored procedure is executed.
492      * <p>
493      * The JDBC type specified by <code>sqlType</code> for an OUT
494      * parameter determines the Java type that must be used
495      * in the <code>get</code> method to read the value of that parameter.
496      * <p>
497      * This version of <code>registerOutParameter</code> should be
498      * used when the parameter is of JDBC type <code>NUMERIC</code>
499      * or <code>DECIMAL</code>. <p>
500      * <!-- end generic documentation -->
501      *
502      * <!-- start release-specific documentation -->
503      * <div class="ReleaseSpecificDocumentation">
504      * <h3>HSQLDB-Specific Information:</h3> <p>
505      *
506      * HSQLDB 1.7.2 does not support this feature. <p>
507      *
508      * Calling this method always throws an <code>SQLException</code>.
509      * </div>
510      * <!-- end release-specific documentation -->
511      *
512      * @param parameterIndex the first parameter is 1, the second is 2,
513      * and so on
514      * @param sqlType the SQL type code defined by <code>java.sql.Types</code>.
515      * @param scale the desired number of digits to the right of the
516      * decimal point.  It must be greater than or equal to zero.
517      * @exception SQLException if a database access error occurs
518      * @see java.sql.Types
519      */
520     public void registerOutParameter(int parameterIndex, int sqlType,
521                                      int scale) throws SQLException   {
522         registerOutParameter(parameterIndex, sqlType);
523     }
524 
525     /**
526      * <!-- start generic documentation -->
527      * Retrieves whether the last OUT parameter read had the value of
528      * SQL <code>NULL</code>.  Note that this method should be called only
529      * after calling a getter method; otherwise, there is no value to use in
530      * determining whether it is <code>null</code> or not. <p>
531      * <!-- end generic documentation -->
532      *
533      * <!-- start release-specific documentation -->
534      * <div class="ReleaseSpecificDocumentation">
535      * <h3>HSQLDB-Specific Information:</h3> <p>
536      *
537      * HSQLDB 1.7.2 does not support this feature. <p>
538      *
539      * Calling this method always throws an <code>SQLException</code>.
540      * </div>
541      * <!-- end release-specific documentation -->
542      *
543      * @return <code>true</code> if the last parameter read was SQL
544      * <code>NULL</code>; <code>false</code> otherwise
545      * @exception SQLException if a database access error occurs
546      */
547     public boolean wasNull() throws SQLException   {
548         throw Util.notSupported();
549     }
550 
551     /**
552      * <!-- start generic documentation -->
553      * Retrieves the value of the designated JDBC <code>CHAR</code>,
554      * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> parameter as a
555      * <code>String</code> in the Java programming language.
556      * <p>
557      * For the fixed-length type JDBC <code>CHAR</code>,
558      * the <code>String</code> object
559      * returned has exactly the same value the (JDBC4 clarification:) SQL
560      * <code>CHAR</code> value had in the
561      * database, including any padding added by the database. <p>
562      * <!-- end generic documentation -->
563      *
564      * <!-- start release-specific documentation -->
565      * <div class="ReleaseSpecificDocumentation">
566      * <h3>HSQLDB-Specific Information:</h3> <p>
567      *
568      * HSQLDB 1.7.2 does not support this feature. <p>
569      *
570      * Calling this method always throws an <code>SQLException</code>.
571      * </div>
572      * <!-- end release-specific documentation -->
573      *
574      * @param parameterIndex the first parameter is 1, the second is 2,
575      * and so on
576      * @return the parameter value. If the value is SQL <code>NULL</code>,
577      *    the result
578      *    is <code>null</code>.
579      * @exception SQLException if a database access error occurs
580      * @see #setString
581      */
582     public String   getString(int parameterIndex) throws SQLException   {
583         throw Util.notSupported();
584     }
585 
586     /**
587      * <!-- start generic documentation -->
588      * Retrieves the value of the designated JDBC <code>BIT</code> parameter
589      * as a <code>boolean</code> in the Java programming language. <p>
590      * <!-- end generic documentation -->
591      *
592      * <!-- start release-specific documentation -->
593      * <div class="ReleaseSpecificDocumentation">
594      * <h3>HSQLDB-Specific Information:</h3> <p>
595      *
596      * HSQLDB 1.7.2 does not support this feature. <p>
597      *
598      * Calling this method always throws an <code>SQLException</code>.
599      * </div>
600      * <!-- end release-specific documentation -->
601      *
602      * @param parameterIndex the first parameter is 1, the second is 2,
603      *  and so on
604      * @return the parameter value.  If the value is SQL <code>NULL</code>,
605      *   the result is <code>false</code>.
606      * @exception SQLException if a database access error occurs
607      * @see #setBoolean
608      */
609     public boolean getBoolean(int parameterIndex) throws SQLException   {
610         throw Util.notSupported();
611     }
612 
613     /**
614      * <!-- start generic documentation -->
615      * Retrieves the value of the designated JDBC <code>TINYINT</code>
616      * parameter as a <code>byte</code> in the Java programming language. <p>
617      * <!-- end generic documentation -->
618      *
619      * <!-- start release-specific documentation -->
620      * <div class="ReleaseSpecificDocumentation">
621      * <h3>HSQLDB-Specific Information:</h3> <p>
622      *
623      * HSQLDB 1.7.2 does not support this feature. <p>
624      *
625      * Calling this method always throws an <code>SQLException</code>.
626      * </div>
627      * <!-- end release-specific documentation -->
628      *
629      * @param parameterIndex the first parameter is 1, the second is 2,
630      * and so on
631      * @return the parameter value.  If the value is SQL <code>NULL</code>,
632      * the result is <code>0</code>.
633      * @exception SQLException if a database access error occurs
634      * @see #setByte
635      */
636     public byte getByte(int parameterIndex) throws SQLException   {
637         throw Util.notSupported();
638     }
639 
640     /**
641      * <!-- start generic documentation -->
642      * Retrieves the value of the designated JDBC <code>SMALLINT</code>
643      * parameter as a <code>short</code> in the Java programming language. <p>
644      * <!-- end generic documentation -->
645      *
646      * <!-- start release-specific documentation -->
647      * <div class="ReleaseSpecificDocumentation">
648      * <h3>HSQLDB-Specific Information:</h3> <p>
649      *
650      * HSQLDB 1.7.2 does not support this feature. <p>
651      *
652      * Calling this method always throws an <code>SQLException</code>.
653      * </div>
654      * <!-- end release-specific documentation -->
655      *
656      * @param parameterIndex the first parameter is 1, the second is 2,
657      * and so on
658      * @return the parameter value.  If the value is SQL <code>NULL</code>,
659      * the result is <code>0</code>.
660      * @exception SQLException if a database access error occurs
661      * @see #setShort
662      */
663     public short getShort(int parameterIndex) throws SQLException   {
664         throw Util.notSupported();
665     }
666 
667     /**
668      * <!-- start generic documentation -->
669      * Retrieves the value of the designated JDBC <code>INTEGER</code>
670      * parameter as an <code>int</code> in the Java programming language. <p>
671      * <!-- end generic documentation -->
672      *
673      * <!-- start release-specific documentation -->
674      * <div class="ReleaseSpecificDocumentation">
675      * <h3>HSQLDB-Specific Information:</h3> <p>
676      *
677      * HSQLDB 1.7.2 does not support this feature. <p>
678      *
679      * Calling this method always throws an <code>SQLException</code>.
680      * </div>
681      * <!-- end release-specific documentation -->
682      *
683      * @param parameterIndex the first parameter is 1, the second is 2,
684      * and so on
685      * @return the parameter value.  If the value is SQL <code>NULL</code>,
686      * the result is <code>0</code>.
687      * @exception SQLException if a database access error occurs
688      * @see #setInt
689      */
690     public int getInt(int parameterIndex) throws SQLException   {
691         throw Util.notSupported();
692     }
693 
694     /**
695      * <!-- start generic documentation -->
696      * Retrieves the value of the designated JDBC <code>BIGINT</code>
697      * parameter as a <code>long</code> in the Java programming language. <p>
698      * <!-- end generic documentation -->
699      *
700      * <!-- start release-specific documentation -->
701      * <div class="ReleaseSpecificDocumentation">
702      * <h3>HSQLDB-Specific Information:</h3> <p>
703      *
704      * HSQLDB 1.7.2 does not support this feature. <p>
705      *
706      * Calling this method always throws an <code>SQLException</code>.
707      * </div>
708      * <!-- end release-specific documentation -->
709      *
710      * @param parameterIndex the first parameter is 1, the second is 2,
711      * and so on
712      * @return the parameter value.  If the value is SQL <code>NULL</code>,
713      * the result is <code>0</code>.
714      * @exception SQLException if a database access error occurs
715      * @see #setLong
716      */
717     public long getLong(int parameterIndex) throws SQLException   {
718         throw Util.notSupported();
719     }
720 
721     /**
722      * <!-- start generic documentation -->
723      * Retrieves the value of the designated JDBC <code>FLOAT</code>
724      * parameter as a <code>float</code> in the Java programming language. <p>
725      * <!-- end generic documentation -->
726      *
727      * <!-- start release-specific documentation -->
728      * <div class="ReleaseSpecificDocumentation">
729      * <h3>HSQLDB-Specific Information:</h3> <p>
730      *
731      * HSQLDB 1.7.2 does not support this feature. <p>
732      *
733      * Calling this method always throws an <code>SQLException</code>.
734      * </div>
735      * <!-- end release-specific documentation -->
736      *
737      * @param parameterIndex the first parameter is 1, the second is 2,
738      *  and so on
739      * @return the parameter value.  If the value is SQL <code>NULL</code>, the
740      *   result is <code>0</code>.
741      * @exception SQLException if a database access error occurs
742      * @see #setFloat
743      */
744     public float getFloat(int parameterIndex) throws SQLException   {
745         throw Util.notSupported();
746     }
747 
748     /**
749      * <!-- start generic documentation -->
750      * Retrieves the value of the designated JDBC <code>DOUBLE</code>
751      * parameter as a <code>double</code> in the Java programming language. <p>
752      * <!-- end generic documentation -->
753      *
754      * <!-- start release-specific documentation -->
755      * <div class="ReleaseSpecificDocumentation">
756      * <h3>HSQLDB-Specific Information:</h3> <p>
757      *
758      * HSQLDB 1.7.2 does not support this feature. <p>
759      *
760      * Calling this method always throws an <code>SQLException</code>.
761      * </div>
762      * <!-- end release-specific documentation -->
763      *
764      * @param parameterIndex the first parameter is 1, the second is 2,
765      *   and so on
766      * @return the parameter value.  If the value is SQL <code>NULL</code>,
767      *    the result is <code>0</code>.
768      * @exception SQLException if a database access error occurs
769      * @see #setDouble
770      */
771     public double getDouble(int parameterIndex) throws SQLException   {
772         throw Util.notSupported();
773     }
774 
775     /**
776      * <!-- start generic documentation -->
777      * Retrieves the value of the designated JDBC <code>NUMERIC</code>
778      * parameter as a <code>java.math.BigDecimal</code> object with
779      * <i>scale</i> digits to the right of the decimal point. <p>
780      * <!-- end generic documentation -->
781      *
782      * <!-- start release-specific documentation -->
783      * <div class="ReleaseSpecificDocumentation">
784      * <h3>HSQLDB-Specific Information:</h3> <p>
785      *
786      * HSQLDB 1.7.2 does not support this feature. <p>
787      *
788      * Calling this method always throws an <code>SQLException</code>.
789      * </div>
790      * <!-- end release-specific documentation -->
791      *
792      * @param parameterIndex the first parameter is 1, the second is 2,
793      *  and so on
794      * @param scale the number of digits to the right of the decimal point
795      * @return the parameter value.  If the value is SQL <code>NULL</code>,
796      *   the result is <code>null</code>.
797      * @exception SQLException if a database access error occurs
798      * @deprecated use <code>getBigDecimal(int parameterIndex)</code>
799      *       or <code>getBigDecimal(String parameterName)</code>
800      * @see #setBigDecimal
801      */
802 
803 //#ifdef DEPRECATEDJDBC
804     public BigDecimal   getBigDecimal(int parameterIndex,
805                                     int scale) throws SQLException   {
806         throw Util.notSupported();
807     }
808 
809 //#endif
810 
811     /**
812      * <!-- start generic documentation -->
813      * Retrieves the value of the designated JDBC <code>BINARY</code> or
814      * <code>VARBINARY</code> parameter as an array of <code>byte</code>
815      * values in the Java programming language. <p>
816      * <!-- end generic documentation -->
817      *
818      * <!-- start release-specific documentation -->
819      * <div class="ReleaseSpecificDocumentation">
820      * <h3>HSQLDB-Specific Information:</h3> <p>
821      *
822      * HSQLDB 1.7.2 does not support this feature. <p>
823      *
824      * Calling this method always throws an <code>SQLException</code>.
825      * </div>
826      * <!-- end release-specific documentation -->
827      * @param parameterIndex the first parameter is 1, the second is 2,
828      *   and so on
829      * @return the parameter value.  If the value is SQL <code>NULL</code>,
830      *    the result is <code>null</code>.
831      * @exception SQLException if a database access error occurs
832      * @see #setBytes
833      */
834     public byte[] getBytes(int parameterIndex) throws SQLException   {
835         throw Util.notSupported();
836     }
837 
838     /**
839      * <!-- start generic documentation -->
840      * Retrieves the value of the designated JDBC <code>DATE</code> parameter
841      * as a <code>java.sql.Date</code> object. <p>
842      * <!-- end generic documentation -->
843      *
844      * <!-- start release-specific documentation -->
845      * <div class="ReleaseSpecificDocumentation">
846      * <h3>HSQLDB-Specific Information:</h3> <p>
847      *
848      * HSQLDB 1.7.2 does not support this feature. <p>
849      *
850      * Calling this method always throws an <code>SQLException</code>.
851      * </div>
852      * <!-- end release-specific documentation -->
853      * @param parameterIndex the first parameter is 1, the second is 2,
854      *   and so on
855      * @return the parameter value.  If the value is SQL <code>NULL</code>, the
856      *    result is <code>null</code>.
857      * @exception SQLException if a database access error occurs
858      * @see #setDate
859      */
860     public Date   getDate(int parameterIndex) throws SQLException   {
861         throw Util.notSupported();
862     }
863 
864     /**
865      * <!-- start generic documentation -->
866      * Retrieves the value of the designated JDBC <code>TIME</code> parameter
867      * as a <code>java.sql.Time</code> object. <p>
868      * <!-- end generic documentation -->
869      *
870      * <!-- start release-specific documentation -->
871      * <div class="ReleaseSpecificDocumentation">
872      * <h3>HSQLDB-Specific Information:</h3> <p>
873      *
874      * HSQLDB 1.7.2 does not support this feature. <p>
875      *
876      * Calling this method always throws an <code>SQLException</code>.
877      * </div>
878      * <!-- end release-specific documentation -->
879      *
880      * @param parameterIndex the first parameter is 1, the second is 2,
881      *   and so on
882      * @return the parameter value.  If the value is SQL <code>NULL</code>,
883      *    the result is <code>null</code>.
884      * @exception SQLException if a database access error occurs
885      * @see #setTime
886      */
887     public Time   getTime(int parameterIndex) throws SQLException   {
888         throw Util.notSupported();
889     }
890 
891     /**
892      * <!-- start generic documentation -->
893      * Retrieves the value of the designated JDBC <code>TIMESTAMP</code>
894      * parameter as a <code>java.sql.Timestamp</code> object. <p>
895      * <!-- end generic documentation -->
896      *
897      * <!-- start release-specific documentation -->
898      * <div class="ReleaseSpecificDocumentation">
899      * <h3>HSQLDB-Specific Information:</h3> <p>
900      *
901      * HSQLDB 1.7.2 does not support this feature. <p>
902      *
903      * Calling this method always throws an <code>SQLException</code>.
904      * </div>
905      * <!-- end release-specific documentation -->
906      *
907      * @param parameterIndex the first parameter is 1, the second is 2,
908      *   and so on
909      * @return the parameter value.  If the value is SQL <code>NULL</code>,
910      *    the result is <code>null</code>.
911      * @exception SQLException if a database access error occurs
912      * @see #setTimestamp
913      */
914     public Timestamp   getTimestamp(int parameterIndex) throws SQLException   {
915         throw Util.notSupported();
916     }
917 
918     /**
919      * <!-- start generic documentation -->
920      * Retrieves the value of the designated parameter as an <code>Object</code>
921      * in the Java programming language. If the value is an SQL <code>NULL</code>,
922      * the driver returns a Java <code>null</code>.
923      * <p>
924      * This method returns a Java object whose type corresponds to the JDBC
925      * type that was registered for this parameter using the method
926      * <code>registerOutParameter</code>.  By registering the target JDBC
927      * type as <code>java.sql.Types.OTHER</code>, this method can be used
928      * to read database-specific abstract data types. <p>
929      * <!-- end generic documentation -->
930      *
931      * <!-- start release-specific documentation -->
932      * <div class="ReleaseSpecificDocumentation">
933      * <h3>HSQLDB-Specific Information:</h3> <p>
934      *
935      * HSQLDB 1.7.2 does not support this feature. <p>
936      * Calling this method always throws an <code>SQLException</code>.
937      * </div>
938      * <!-- end release-specific documentation -->
939      *
940      * @param parameterIndex the first parameter is 1, the second is 2,
941      *   and so on
942      * @return A <code>java.lang.Object</code> holding the OUT parameter value
943      * @exception SQLException if a database access error occurs
944      * @see java.sql.Types
945      * @see #setObject
946      */
947     public Object   getObject(int parameterIndex) throws SQLException   {
948         throw Util.notSupported();
949     }
950 
951 // ----------------------------------- JDBC 2 ----------------------------------
952 
953     /**
954      * <!-- start generic documentation -->
955      * Retrieves the value of the designated JDBC <code>NUMERIC</code>
956      * parameter as a <code>java.math.BigDecimal</code> object with as many
957      * digits to the right of the decimal point as the value contains. <p>
958      * <!-- end generic documentation -->
959      *
960      * <!-- start release-specific documentation -->
961      * <div class="ReleaseSpecificDocumentation">
962      * <h3>HSQLDB-Specific Information:</h3> <p>
963      *
964      * HSQLDB 1.7.2 does not support this feature. <p>
965      *
966      * Calling this method always throws an <code>SQLException</code>.
967      * </div>
968      * <!-- end release-specific documentation -->
969      *
970      * @param parameterIndex the first parameter is 1, the second is 2,
971      * and so on
972      * @return the parameter value in full precision.  If the value is
973      * SQL <code>NULL</code>, the result is <code>null</code>.
974      * @exception SQLException if a database access error occurs
975      * @see #setBigDecimal
976      * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
977      *  jdbcPreparedStatement)
978      */
979     public BigDecimal   getBigDecimal(int parameterIndex) throws SQLException   {
980         throw Util.notSupported();
981     }
982 
983     /**
984      * <!-- start generic documentation -->
985      * Returns an object representing the value of OUT parameter
986      * <code>parameterIndex</code> and uses <code>map</code> for the custom
987      * mapping of the parameter value.
988      * <p>
989      * This method returns a Java object whose type corresponds to the
990      * JDBC type that was registered for this parameter using the method
991      * <code>registerOutParameter</code>.  By registering the target
992      * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
993      * be used to read database-specific abstract data types. <p>
994      * <!-- end generic documentation -->
995      *
996      * <!-- start release-specific documentation -->
997      * <div class="ReleaseSpecificDocumentation">
998      * <h3>HSQLDB-Specific Information:</h3> <p>
999      *
1000     * HSQLDB 1.7.2 does not support this feature. <p>
1001     *
1002     * Calling this method always throws an <code>SQLException</code>.
1003     * </div>
1004     * <!-- end release-specific documentation -->
1005     *
1006     * @param parameterIndex the first parameter is 1, the second is 2, and so on
1007     * @param map the mapping from SQL type names to Java classes
1008     * @return a <code>java.lang.Object</code> holding the OUT parameter value
1009     * @exception SQLException if a database access error occurs
1010     * @see #setObject
1011     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1012     *   jdbcPreparedStatement)
1013     */
1014    public Object   getObject(int parameterIndex, Map   map) throws SQLException   {
1015        throw Util.notSupported();
1016    }
1017
1018    /**
1019     * <!-- start generic documentation -->
1020     * Retrieves the value of the designated JDBC
1021     * <code>REF(&lt;structured-type&gt;)</code> parameter as a
1022     * {@link java.sql.Ref} object in the Java programming language. <p>
1023     * <!-- end generic documentation -->
1024     *
1025     * <!-- start release-specific documentation -->
1026     * <div class="ReleaseSpecificDocumentation">
1027     * <h3>HSQLDB-Specific Information:</h3> <p>
1028     *
1029     * HSQLDB 1.7.2 does not support this feature. <p>
1030     *
1031     * Calling this method always throws an <code>SQLException</code>.
1032     * </div>
1033     * <!-- end release-specific documentation -->
1034     *
1035     * @param parameterIndex the first parameter is 1, the second is 2,
1036     * and so on
1037     * @return the parameter value as a <code>Ref</code> object in the
1038     * Java programming language.  If the value was SQL <code>NULL</code>,
1039     * the value <code>null</code> is returned.
1040     * @exception SQLException if a database access error occurs
1041     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1042     * jdbcPreparedStatement)
1043     */
1044    public Ref   getRef(int parameterIndex) throws SQLException   {
1045        throw Util.notSupported();
1046    }
1047
1048    /**
1049     * <!-- start generic documentation -->
1050     * Retrieves the value of the designated JDBC <code>BLOB</code>
1051     * parameter as a {@link java.sql.Blob} object in the Java
1052     * programming language. <p>
1053     * <!-- end generic documentation -->
1054     *
1055     * <!-- start release-specific documentation -->
1056     * <div class="ReleaseSpecificDocumentation">
1057     * <h3>HSQLDB-Specific Information:</h3> <p>
1058     *
1059     * HSQLDB 1.7.2 does not support this feature. <p>
1060     *
1061     * Calling this method always throws an <code>SQLException</code>.
1062     * </div>
1063     * <!-- end release-specific documentation -->
1064     *
1065     * @param parameterIndex the first parameter is 1, the second is 2,
1066     * and so on
1067     * @return the parameter value as a <code>Blob</code> object in the
1068     * Java programming language.  If the value was SQL <code>NULL</code>,
1069     * the value <code>null</code> is returned.
1070     * @exception SQLException if a database access error occurs
1071     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1072     *  jdbcPreparedStatement)
1073     */
1074    public Blob   getBlob(int parameterIndex) throws SQLException   {
1075        throw Util.notSupported();
1076    }
1077
1078    /**
1079     * <!-- start generic documentation -->
1080     * Retrieves the value of the designated JDBC <code>CLOB</code>
1081     * parameter as a {@link java.sql.Clob} object in the Java programming
1082     * language. <p>
1083     * <!-- end generic documentation -->
1084     *
1085     * <!-- start release-specific documentation -->
1086     * <div class="ReleaseSpecificDocumentation">
1087     * <h3>HSQLDB-Specific Information:</h3> <p>
1088     *
1089     * HSQLDB 1.7.2 does not support this feature. <p>
1090     *
1091     * Calling this method always throws an <code>SQLException</code>.
1092     * </div>
1093     * <!-- end release-specific documentation -->
1094     *
1095     * @param parameterIndex the first parameter is 1, the second is 2, and
1096     * so on
1097     * @return the parameter value as a <code>Clob</code> object in the
1098     * Java programming language.  If the value was SQL <code>NULL</code>, the
1099     * value <code>null</code> is returned.
1100     * @exception SQLException if a database access error occurs
1101     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1102     *  jdbcPreparedStatement)
1103     */
1104    public Clob   getClob(int parameterIndex) throws SQLException   {
1105        throw Util.notSupported();
1106    }
1107
1108    /**
1109     * <!-- start generic documentation -->
1110     * Retrieves the value of the designated JDBC <code>ARRAY</code>
1111     * parameter as an {@link java.sql.Array} object in the Java programming
1112     * language. <p>
1113     * <!-- end generic documentation -->
1114     *
1115     * <!-- start release-specific documentation -->
1116     * <div class="ReleaseSpecificDocumentation">
1117     * <h3>HSQLDB-Specific Information:</h3> <p>
1118     *
1119     * HSQLDB 1.7.2 does not support this feature. <p>
1120     *
1121     * Calling this method always throws an <code>SQLException</code>.
1122     * </div>
1123     * <!-- end release-specific documentation -->
1124     *
1125     * @param parameterIndex the first parameter is 1, the second is 2, and
1126     * so on
1127     * @return the parameter value as an <code>Array</code> object in
1128     * the Java programming language.  If the value was SQL <code>NULL</code>,
1129     * the value <code>null</code> is returned.
1130     * @exception SQLException if a database access error occurs
1131     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1132     *  jdbcPreparedStatement)
1133     */
1134    public Array   getArray(int parameterIndex) throws SQLException   {
1135        throw Util.notSupported();
1136    }
1137
1138    /**
1139     * <!-- start generic documentation -->
1140     * Retrieves the value of the designated JDBC <code>DATE</code>
1141     * parameter as a <code>java.sql.Date</code> object, using
1142     * the given <code>Calendar</code> object
1143     * to construct the date.
1144     * With a <code>Calendar</code> object, the driver
1145     * can calculate the date taking into account a custom timezone and
1146     * locale.  If no <code>Calendar</code> object is specified, the driver
1147     * uses the default timezone and locale. <p>
1148     * <!-- end generic documentation -->
1149     *
1150     * <!-- start release-specific documentation -->
1151     * <div class="ReleaseSpecificDocumentation">
1152     * <h3>HSQLDB-Specific Information:</h3> <p>
1153     *
1154     * HSQLDB 1.7.2 does not support this feature. <p>
1155     *
1156     * Calling this method always throws an <code>SQLException</code>.
1157     * </div>
1158     * <!-- end release-specific documentation -->
1159     *
1160     * @param parameterIndex the first parameter is 1, the second is 2,
1161     *      and so on
1162     * @param cal the <code>Calendar</code> object the driver will use
1163     *      to construct the date
1164     * @return the parameter value.  If the value is SQL <code>NULL</code>,
1165     *      the result is <code>null</code>.
1166     * @exception SQLException if a database access error occurs
1167     * @see #setDate
1168     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1169     *      jdbcPreparedStatement)
1170     */
1171    public Date   getDate(int parameterIndex,
1172                        Calendar   cal) throws SQLException   {
1173
1174        throw Util.notSupported();
1175
1176//        try {
1177//            return HsqlDateTime.getDate(getString(parameterIndex), cal);
1178//        } catch (Exception e) {
1179//            throw Util.sqlException(Trace.INVALID_ESCAPE,
1180//                                          e.getMessage());
1181//        }
1182    }
1183
1184    /**
1185     * <!-- start generic documentation -->
1186     * Retrieves the value of the designated JDBC <code>TIME</code>
1187     * parameter as a <code>java.sql.Time</code> object, using
1188     * the given <code>Calendar</code> object
1189     * to construct the time.
1190     * With a <code>Calendar</code> object, the driver
1191     * can calculate the time taking into account a custom timezone and locale.
1192     * If no <code>Calendar</code> object is specified, the driver uses the
1193     * default timezone and locale. <p>
1194     * <!-- end generic documentation -->
1195     *
1196     * <!-- start release-specific documentation -->
1197     * <div class="ReleaseSpecificDocumentation">
1198     * <h3>HSQLDB-Specific Information:</h3> <p>
1199     *
1200     * HSQLDB 1.7.2 does not support this feature. <p>
1201     *
1202     * Calling this method always throws an <code>SQLException</code>.
1203     * </div>
1204     * <!-- end release-specific documentation -->
1205     *
1206     * @param parameterIndex the first parameter is 1, the second is 2,
1207     * and so on
1208     * @param cal the <code>Calendar</code> object the driver will use
1209     *        to construct the time
1210     * @return the parameter value; if the value is SQL <code>NULL</code>,
1211     *     the result is <code>null</code>.
1212     * @exception SQLException if a database access error occurs
1213     * @see #setTime
1214     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1215     *    jdbcPreparedStatement)
1216     */
1217    public Time   getTime(int parameterIndex,
1218                        Calendar   cal) throws SQLException   {
1219
1220        throw Util.notSupported();
1221
1222//        try {
1223//            return HsqlDateTime.getTime(getString(parameterIndex), cal);
1224//        } catch (Exception e) {
1225//            throw Util.sqlException(Trace.INVALID_ESCAPE,
1226//                                          e.getMessage());
1227//        }
1228    }
1229
1230    /**
1231     * <!-- start generic documentation -->
1232     * Retrieves the value of the designated JDBC <code>TIMESTAMP</code>
1233     * parameter as a <code>java.sql.Timestamp</code> object, using
1234     * the given <code>Calendar</code> object to construct
1235     * the <code>Timestamp</code> object.
1236     * With a <code>Calendar</code> object, the driver
1237     * can calculate the timestamp taking into account a custom timezone and
1238     * locale. If no <code>Calendar</code> object is specified, the driver
1239     * uses the default timezone and locale. <p>
1240     * <!-- end generic documentation -->
1241     *
1242     * <!-- start release-specific documentation -->
1243     * <div class="ReleaseSpecificDocumentation">
1244     * <h3>HSQLDB-Specific Information:</h3> <p>
1245     *
1246     * HSQLDB 1.7.2 does not support this feature. <p>
1247     *
1248     * Calling this method always throws an <code>SQLException</code>.
1249     * </div>
1250     * <!-- end release-specific documentation -->
1251     *
1252     * @param parameterIndex the first parameter is 1, the second is 2,
1253     * and so on
1254     * @param cal the <code>Calendar</code> object the driver will use
1255     *        to construct the timestamp
1256     * @return the parameter value.  If the value is SQL <code>NULL</code>,
1257     *        the result is <code>null</code>.
1258     * @exception SQLException if a database access error occurs
1259     * @see #setTimestamp
1260     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1261     *    jdbcPreparedStatement)
1262     */
1263    public Timestamp   getTimestamp(int parameterIndex,
1264                                  Calendar   cal) throws SQLException   {
1265
1266        throw Util.notSupported();
1267
1268//        try {
1269//            return HsqlDateTime.getTimestamp(getString(parameterIndex), cal);
1270//        } catch (Exception e) {
1271//            throw Util.sqlException(Trace.INVALID_ESCAPE,
1272//                                          e.getMessage());
1273//        }
1274    }
1275
1276    /**
1277     * <!-- start generic documentation -->
1278     * Registers the designated output parameter.  This version of
1279     * the method <code>registerOutParameter</code>
1280     * should be used for a user-defined or <code>REF</code> output parameter.
1281     * Examples of user-defined types include: <code>STRUCT</code>,
1282     * <code>DISTINCT</code>, <code>JAVA_OBJECT</code>, and named array types.
1283     * <p>
1284     * (JDBC4 claraification:) All OUT parameters must be registered
1285     * before a stored procedure is executed.
1286     * <p> For a user-defined parameter, the fully-qualified SQL
1287     * type name of the parameter should also be given, while a
1288     * <code>REF</code> parameter requires that the fully-qualified type name
1289     * of the referenced type be given.  A JDBC driver that does not need the
1290     * type code and type name information may ignore it.   To be portable,
1291     * however, applications should always provide these values for
1292     * user-defined and <code>REF</code> parameters.
1293     *
1294     * Although it is intended for user-defined and <code>REF</code> parameters,
1295     * this method may be used to register a parameter of any JDBC type.
1296     * If the parameter does not have a user-defined or <code>REF</code> type,
1297     * the <i>typeName</i> parameter is ignored.
1298     *
1299     * <P><B>Note:</B> When reading the value of an out parameter, you
1300     * must use the getter method whose Java type corresponds to the
1301     * parameter's registered SQL type. <p>
1302     * <!-- end generic documentation -->
1303     *
1304     * <!-- start release-specific documentation -->
1305     * <div class="ReleaseSpecificDocumentation">
1306     * <h3>HSQLDB-Specific Information:</h3> <p>
1307     *
1308     * HSQLDB 1.7.2 does not support this feature. <p>
1309     *
1310     * Calling this method always throws an <code>SQLException</code>.
1311     * </div>
1312     * <!-- end release-specific documentation -->
1313     *
1314     * @param parameterIndex the first parameter is 1, the second is 2,...
1315     * @param sqlType a value from {@link java.sql.Types}
1316     * @param typeName the fully-qualified name of an SQL structured type
1317     * @exception SQLException if a database access error occurs
1318     * @see java.sql.Types
1319     * @since JDK 1.2 (JDK 1.1.x developers: read the new overview for
1320     *  jdbcPreparedStatement)
1321     *
1322     */
1323    public void registerOutParameter(int parameterIndex, int sqlType,
1324                                     String   typeName) throws SQLException   {
1325        registerOutParameter(parameterIndex, sqlType);
1326    }
1327
1328// ----------------------------------- JDBC 3 ----------------------------------
1329
1330    /**
1331     * <!-- start generic documentation -->
1332     * Registers the OUT parameter named
1333     * <code>parameterName</code> to the JDBC type
1334     * <code>sqlType</code>.  All OUT parameters must be registered
1335     * before a stored procedure is executed.
1336     * <p>
1337     * The JDBC type specified by <code>sqlType</code> for an OUT
1338     * parameter determines the Java type that must be used
1339     * in the <code>get</code> method to read the value of that parameter.
1340     * <p>
1341     * If the JDBC type expected to be returned to this output parameter
1342     * is specific to this particular database, <code>sqlType</code>
1343     * should be <code>java.sql.Types.OTHER</code>.  The method
1344     * {@link #getObject} retrieves the value. <p>
1345     * <!-- end generic documentation -->
1346     *
1347     * <!-- start release-specific documentation -->
1348     * <div class="ReleaseSpecificDocumentation">
1349     * <h3>HSQLDB-Specific Information:</h3> <p>
1350     *
1351     * HSQLDB 1.7.2 does not support this feature. <p>
1352     *
1353     * Calling this method always throws an <code>SQLException</code>.
1354     * </div>
1355     * <!-- end release-specific documentation -->
1356     *
1357     * @param parameterName the name of the parameter
1358     * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
1359     * If the parameter is of JDBC type <code>NUMERIC</code>
1360     * or <code>DECIMAL</code>, the version of
1361     * <code>registerOutParameter</code> that accepts a scale value
1362     * should be used.
1363     * @exception SQLException if a database access error occurs
1364     * @since JDK 1.4, HSQL 1.7.0
1365     * @see java.sql.Types
1366     */
1367//#ifdef JDBC3
1368    public void registerOutParameter(String   parameterName,
1369                                     int sqlType) throws SQLException   {
1370        registerOutParameter(findParameterIndex(parameterName), sqlType);
1371    }
1372
1373//#endif JDBC3
1374
1375    /**
1376     * <!-- start generic documentation -->
1377     * Registers the parameter named
1378     * <code>parameterName</code> to be of JDBC type
1379     * <code>sqlType</code>.  (JDBC4 clarification:) All OUT parameters must be registered
1380     * before a stored procedure is executed.
1381     * <p>
1382     * The JDBC type specified by <code>sqlType</code> for an OUT
1383     * parameter determines the Java type that must be used
1384     * in the <code>get</code> method to read the value of that parameter.
1385     * <p>
1386     * This version of <code>registerOutParameter</code> should be
1387     * used when the parameter is of JDBC type <code>NUMERIC</code>
1388     * or <code>DECIMAL</code>. <p>
1389     * <!-- end generic documentation -->
1390     *
1391     * <!-- start release-specific documentation -->
1392     * <div class="ReleaseSpecificDocumentation">
1393     * <h3>HSQLDB-Specific Information:</h3> <p>
1394     *
1395     * HSQLDB 1.7.2 does not support this feature. <p>
1396     *
1397     * Calling this method always throws an <code>SQLException</code>.
1398     * </div>
1399     * <!-- end release-specific documentation -->
1400     *
1401     * @param parameterName the name of the parameter
1402     * @param sqlType SQL type code defined by <code>java.sql.Types</code>.
1403     * @param scale the desired number of digits to the right of the
1404     * decimal point.  It must be greater than or equal to zero.
1405     * @exception SQLException if a database access error occurs
1406     * @since JDK 1.4, HSQLDB 1.7.0
1407     * @see java.sql.Types
1408     */
1409//#ifdef JDBC3
1410    public void registerOutParameter(String   parameterName, int sqlType,
1411                                     int scale) throws SQLException   {
1412        registerOutParameter(findParameterIndex(parameterName), sqlType);
1413    }
1414
1415//#endif JDBC3
1416
1417    /**
1418     * <!-- start generic documentation -->
1419     * Registers the designated output parameter.  This version of
1420     * the method <code>registerOutParameter</code>
1421     * should be used for a user-named or REF output parameter.  Examples
1422     * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
1423     * named array types. <p>
1424     *
1425     * (JDBC4 clarification:) All OUT parameters must be registered
1426     * before a stored procedure is executed.
1427     * <p>
1428     * For a user-named parameter the fully-qualified SQL
1429     * type name of the parameter should also be given, while a REF
1430     * parameter requires that the fully-qualified type name of the
1431     * referenced type be given.  A JDBC driver that does not need the
1432     * type code and type name information may ignore it.   To be portable,
1433     * however, applications should always provide these values for
1434     * user-named and REF parameters.
1435     *
1436     * Although it is intended for user-named and REF parameters,
1437     * this method may be used to register a parameter of any JDBC type.
1438     * If the parameter does not have a user-named or REF type, the
1439     * typeName parameter is ignored.
1440     *
1441     * <P><B>Note:</B> When reading the value of an out parameter, you
1442     * must use the <code>getXXX</code> method whose Java type XXX corresponds
1443     * to the parameter's registered SQL type. <p>
1444     * <!-- end generic documentation -->
1445     *
1446     * <!-- start release-specific documentation -->
1447     * <div class="ReleaseSpecificDocumentation">
1448     * <h3>HSQLDB-Specific Information:</h3> <p>
1449     *
1450     * HSQLDB 1.7.2 does not support this feature. <p>
1451     *
1452     * Calling this method always throws an <code>SQLException</code>.
1453     * </div>
1454     * <!-- end release-specific documentation -->
1455     *
1456     * @param parameterName the name of the parameter
1457     * @param sqlType a value from {@link java.sql.Types}
1458     * @param typeName the fully-qualified name of an SQL structured type
1459     * @exception SQLException if a database access error occurs
1460     * @see java.sql.Types
1461     * @since JDK 1.4, HSQL 1.7.0
1462     */
1463//#ifdef JDBC3
1464    public void registerOutParameter(String   parameterName, int sqlType,
1465                                     String   typeName) throws SQLException   {
1466        registerOutParameter(findParameterIndex(parameterName), sqlType);
1467    }
1468
1469//#endif JDBC3
1470
1471    /**
1472     * <!-- start generic documentation -->
1473     * Retrieves the value of the designated JDBC <code>DATALINK</code>
1474     * parameter as a <code>java.net.URL</code> object. <p>
1475     * <!-- end generic documentation -->
1476     *
1477     * <!-- start release-specific documentation -->
1478     * <div class="ReleaseSpecificDocumentation">
1479     * <h3>HSQLDB-Specific Information:</h3> <p>
1480     *
1481     * HSQLDB 1.7.2 does not support this feature. <p>
1482     *
1483     * Calling this method always throws an <code>SQLException</code>.
1484     * </div>
1485     * <!-- end release-specific documentation -->
1486     *
1487     * @param parameterIndex the first parameter is 1, the second is 2,...
1488     * @return a <code>java.net.URL</code> object that represents the
1489     *   JDBC <code>DATALINK</code> value used as the designated
1490     *   parameter
1491     * @exception SQLException if a database access error occurs,
1492     *      or if the URL being returned is
1493     *      not a valid URL on the Java platform
1494     * @see #setURL
1495     * @since JDK 1.4, HSQLDB 1.7.0
1496     */
1497//#ifdef JDBC3
1498    public java.net.URL   getURL(int parameterIndex) throws SQLException   {
1499        throw Util.notSupported();
1500    }
1501
1502//#endif JDBC3
1503
1504    /**
1505     * <!-- start generic documentation -->
1506     * Sets the designated parameter to the given <code>java.net.URL</code>
1507     * object.  The driver converts this to an SQL <code>DATALINK</code>
1508     * value when it sends it to the database. <p>
1509     * <!-- end generic documentation -->
1510     *
1511     * <!-- start release-specific documentation -->
1512     * <div class="ReleaseSpecificDocumentation">
1513     * <h3>HSQLDB-Specific Information:</h3> <p>
1514     *
1515     * HSQLDB 1.7.2 does not support this feature. <p>
1516     *
1517     * Calling this method always throws an <code>SQLException</code>.
1518     * </div>
1519     * <!-- end release-specific documentation -->
1520     *
1521     * @param parameterName the name of the parameter
1522     * @param val the parameter value
1523     * @exception SQLException if a database access error occurs,
1524     *      or if a URL is malformed
1525     * @see #getURL
1526     * @since JDK 1.4, HSQLDB 1.7.0
1527     */
1528//#ifdef JDBC3
1529    public void setURL(String   parameterName,
1530                       java.net.URL   val) throws SQLException   {
1531        setURL(findParameterIndex(parameterName), val);
1532    }
1533
1534//#endif JDBC3
1535
1536    /**
1537     * <!-- start generic documentation -->
1538     * Sets the designated parameter to SQL <code>NULL</code>.
1539     *
1540     * <P><B>Note:</B> You must specify the parameter's SQL type. <p>
1541     * <!-- end generic documentation -->
1542     *
1543     * <!-- start release-specific documentation -->
1544     * <div class="ReleaseSpecificDocumentation">
1545     * <h3>HSQLDB-Specific Information:</h3> <p>
1546     *
1547     * Starting with 1.7.2, HSLQDB supports this.
1548     * </div>
1549     * <!-- end release-specific documentation -->
1550     *
1551     * @param parameterName the name of the parameter
1552     * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
1553     * @exception SQLException if a database access error occurs
1554     * @since JDK 1.4, HSQLDB 1.7.0
1555     */
1556//#ifdef JDBC3
1557    public void setNull(String   parameterName,
1558                        int sqlType) throws SQLException   {
1559        setNull(findParameterIndex(parameterName), sqlType);
1560    }
1561
1562//#endif JDBC3
1563
1564    /**
1565     * <!-- start generic documentation -->
1566     * Sets the designated parameter to the given Java <code>boolean</code> value.
1567     * (JDBC4 clarification:) The driver converts this
1568     * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends
1569     * it to the database. <p>
1570     * <!-- end generic documentation -->
1571     *
1572     * <!-- start release-specific documentation -->
1573     * <div class="ReleaseSpecificDocumentation">
1574     * <h3>HSQLDB-Specific Information:</h3> <p>
1575     *
1576     * Starting with 1.7.2, HSLQDB supports this.
1577     * </div>
1578     * <!-- end release-specific documentation -->
1579     *
1580     * @param parameterName the name of the parameter
1581     * @param x the parameter value
1582     * @exception SQLException if a database access error occurs
1583     * @see #getBoolean
1584     * @since JDK 1.4, HSQLDB 1.7.0
1585     */
1586//#ifdef JDBC3
1587    public void setBoolean(String   parameterName,
1588                           boolean x) throws SQLException   {
1589        setBoolean(findParameterIndex(parameterName), x);
1590    }
1591
1592//#endif JDBC3
1593
1594    /**
1595     * <!-- start generic documentation -->
1596     * Sets the designated parameter to the given Java <code>byte</code> value.
1597     * The driver converts this to an SQL <code>TINYINT</code> value when it
1598     * sends it to the database. <p>
1599     * <!-- end generic documentation -->
1600     *
1601     * <!-- start release-specific documentation -->
1602     * <div class="ReleaseSpecificDocumentation">
1603     * <h3>HSQLDB-Specific Information:</h3> <p>
1604     *
1605     * Starting with 1.7.2, HSLQDB supports this.
1606     * </div>
1607     * <!-- end release-specific documentation -->
1608     *
1609     * @param parameterName the name of the parameter
1610     * @param x the parameter value
1611     * @exception SQLException if a database access error occurs
1612     * @see #getByte
1613     * @since JDK 1.4, HSQLDB 1.7.0
1614     */
1615//#ifdef JDBC3
1616    public void setByte(String   parameterName, byte x) throws SQLException   {
1617        setByte(findParameterIndex(parameterName), x);
1618    }
1619
1620//#endif JDBC3
1621
1622    /**
1623     * <!-- start generic documentation -->
1624     * Sets the designated parameter to the given Java <code>short</code> value.
1625     * The driver converts this to an SQL <code>SMALLINT</code> value when
1626     * it sends it to the database. <p>
1627     * <!-- end generic documentation -->
1628     *
1629     * <!-- start release-specific documentation -->
1630     * <div class="ReleaseSpecificDocumentation">
1631     * <h3>HSQLDB-Specific Information:</h3> <p>
1632     *
1633     * Starting with 1.7.2, HSLQDB supports this.
1634     * </div>
1635     * <!-- end release-specific documentation -->
1636     *
1637     * @param parameterName the name of the parameter
1638     * @param x the parameter value
1639     * @exception SQLException if a database access error occurs
1640     * @see #getShort
1641     * @since JDK 1.4, HSQLDB 1.7.0
1642     */
1643//#ifdef JDBC3
1644    public void setShort(String   parameterName, short x) throws SQLException   {
1645        setShort(findParameterIndex(parameterName), x);
1646    }
1647
1648//#endif JDBC3
1649
1650    /**
1651     * <!-- start generic documentation -->
1652     * Sets the designated parameter to the given Java <code>int</code> value.
1653     * The driver converts this to an SQL <code>INTEGER</code> value when it
1654     * sends it to the database. <p>
1655     * <!-- end generic documentation -->
1656     *
1657     * <!-- start release-specific documentation -->
1658     * <div class="ReleaseSpecificDocumentation">
1659     * <h3>HSQLDB-Specific Information:</h3> <p>
1660     *
1661     * Starting with 1.7.2, HSLQDB supports this.
1662     * </div>
1663     * <!-- end release-specific documentation -->
1664     *
1665     * @param parameterName the name of the parameter
1666     * @param x the parameter value
1667     * @exception SQLException if a database access error occurs
1668     * @see #getInt
1669     * @since JDK 1.4, HSQLDB 1.7.0
1670     */
1671//#ifdef JDBC3
1672    public void setInt(String   parameterName, int x) throws SQLException   {
1673        setInt(findParameterIndex(parameterName), x);
1674    }
1675
1676//#endif JDBC3
1677
1678    /**
1679     * <!-- start generic documentation -->
1680     * Sets the designated parameter to the given Java <code>long</code> value.
1681     * The driver converts this to an SQL <code>BIGINT</code> value when it
1682     * sends it to the database. <p>
1683     * <!-- end generic documentation -->
1684     *
1685     * <!-- start release-specific documentation -->
1686     * <div class="ReleaseSpecificDocumentation">
1687     * <h3>HSQLDB-Specific Information:</h3> <p>
1688     *
1689     * Starting with 1.7.2, HSLQDB supports this.
1690     * </div>
1691     * <!-- end release-specific documentation -->
1692     *
1693     * @param parameterName the name of the parameter
1694     * @param x the parameter value
1695     * @exception SQLException if a database access error occurs
1696     * @see #getLong
1697     * @since JDK 1.4, HSQLDB 1.7.0
1698     */
1699//#ifdef JDBC3
1700    public void setLong(String   parameterName, long x) throws SQLException   {
1701        setLong(findParameterIndex(parameterName), x);
1702    }
1703
1704//#endif JDBC3
1705
1706    /**
1707     * <!-- start generic documentation -->
1708     * Sets the designated parameter to the given Java <code>float</code> value.
1709     * The driver converts this to an SQL <code>FLOAT</code> value when it
1710     * sends it to the database. <p>
1711     * <!-- end generic documentation -->
1712     *
1713     * <!-- start release-specific documentation -->
1714     * <div class="ReleaseSpecificDocumentation">
1715     * <h3>HSQLDB-Specific Information:</h3> <p>
1716     *
1717     * Starting with 1.7.2, HSLQDB supports this.
1718     * </div>
1719     * <!-- end release-specific documentation -->
1720     *
1721     * @param parameterName the name of the parameter
1722     * @param x the parameter value
1723     * @exception SQLException if a database access error occurs
1724     * @see #getFloat
1725     * @since JDK 1.4, HSQLDB 1.7.0
1726     */
1727//#ifdef JDBC3
1728    public void setFloat(String   parameterName, float x) throws SQLException   {
1729        setFloat(findParameterIndex(parameterName), x);
1730    }
1731
1732//#endif JDBC3
1733
1734    /**
1735     * <!-- start generic documentation -->
1736     * Sets the designated parameter to the given Java <code>double</code> value.
1737     * The driver converts this to an SQL <code>DOUBLE</code> value when it
1738     * sends it to the database. <p>
1739     * <!-- end generic documentation -->
1740     *
1741     * <!-- start release-specific documentation -->
1742     * <div class="ReleaseSpecificDocumentation">
1743     * <h3>HSQLDB-Specific Information:</h3> <p>
1744     *
1745     * Starting with 1.7.2, HSLQDB supports this.
1746     * </div>
1747     * <!-- end release-specific documentation -->
1748     *
1749     * @param parameterName the name of the parameter
1750     * @param x the parameter value
1751     * @exception SQLException if a database access error occurs
1752     * @see #getDouble
1753     * @since JDK 1.4, HSQLDB 1.7.0
1754     */
1755//#ifdef JDBC3
1756    public void setDouble(String   parameterName,
1757                          double x) throws SQLException   {
1758        setDouble(findParameterIndex(parameterName), x);
1759    }
1760
1761//#endif JDBC3
1762
1763    /**
1764     * <!-- start generic documentation -->
1765     * Sets the designated parameter to the given
1766     * <code>java.math.BigDecimal</code> value.
1767     * The driver converts this to an SQL <code>NUMERIC</code> value when
1768     * it sends it to the database. <p>
1769     * <!-- end generic documentation -->
1770     *
1771     * <!-- start release-specific documentation -->
1772     * <div class="ReleaseSpecificDocumentation">
1773     * <h3>HSQLDB-Specific Information:</h3> <p>
1774     *
1775     * Starting with 1.7.2, HSLQDB supports this.
1776     * </div>
1777     * <!-- end release-specific documentation -->
1778     *
1779     * @param parameterName the name of the parameter
1780     * @param x the parameter value
1781     * @exception SQLException if a database access error occurs
1782     * @see #getBigDecimal
1783     * @since JDK 1.4, HSQLDB 1.7.0
1784     */
1785//#ifdef JDBC3
1786    public void setBigDecimal(String   parameterName,
1787                              BigDecimal   x) throws SQLException   {
1788        setBigDecimal(findParameterIndex(parameterName), x);
1789    }
1790
1791//#endif JDBC3
1792
1793    /**
1794     * <!-- start generic documentation -->
1795     * Sets the designated parameter to the given Java <code>String</code>
1796     * value. The driver converts this to an SQL <code>VARCHAR</code>
1797     * or <code>LONGVARCHAR</code> value (depending on the argument's
1798     * size relative to the driver's limits on <code>VARCHAR</code> values)
1799     * when it sends it to the database. <p>
1800     * <!-- end generic documentation -->
1801     *
1802     * <!-- start release-specific documentation -->
1803     * <div class="ReleaseSpecificDocumentation">
1804     * <h3>HSQLDB-Specific Information:</h3> <p>
1805     *
1806     * Starting with 1.7.2, HSLQDB supports this.
1807     * </div>
1808     * <!-- end release-specific documentation -->
1809     *
1810     * @param parameterName the name of the parameter
1811     * @param x the parameter value
1812     * @exception SQLException if a database access error occurs
1813     * @see #getString
1814     * @since JDK 1.4, HSQLDB 1.7.0
1815     */
1816//#ifdef JDBC3
1817    public void setString(String   parameterName,
1818                          String   x) throws SQLException   {
1819        setString(findParameterIndex(parameterName), x);
1820    }
1821
1822//#endif JDBC3
1823
1824    /**
1825     * <!-- start generic documentation -->
1826     * Sets the designated parameter to the given Java array of bytes.
1827     * The driver converts this to an SQL <code>VARBINARY</code> or
1828     * <code>LONGVARBINARY</code> (depending on the argument's size relative
1829     * to the driver's limits on <code>VARBINARY</code> values) when it sends
1830     * it to the database. <p>
1831     * <!-- end generic documentation -->
1832     *
1833     * <!-- start release-specific documentation -->
1834     * <div class="ReleaseSpecificDocumentation">
1835     * <h3>HSQLDB-Specific Information:</h3> <p>
1836     *
1837     * Starting with 1.7.2, HSLQDB supports this.
1838     * </div>
1839     * <!-- end release-specific documentation -->
1840     *
1841     * @param parameterName the name of the parameter
1842     * @param x the parameter value
1843     * @exception SQLException if a database access error occurs
1844     * @see #getBytes
1845     * @since JDK 1.4, HSQLDB 1.7.0
1846     */
1847//#ifdef JDBC3
1848    public void setBytes(String   parameterName, byte[] x) throws SQLException   {
1849        setBytes(findParameterIndex(parameterName), x);
1850    }
1851
1852//#endif JDBC3
1853
1854    /**
1855     * <!-- start generic documentation -->
1856     * (JDBC4 clarification:) Sets the designated parameter to the given <code>java.sql.Date</code> value
1857     * using the default time zone of the virtual machine that is running
1858     * the application.  The driver converts this to an SQL <code>DATE</code> value
1859     * when it sends it to the database. <p>
1860     * <!-- end generic documentation -->
1861     *
1862     * <!-- start release-specific documentation -->
1863     * <div class="ReleaseSpecificDocumentation">
1864     * <h3>HSQLDB-Specific Information:</h3> <p>
1865     *
1866     * Starting with 1.7.2, HSLQDB supports this.
1867     * </div>
1868     * <!-- end release-specific documentation -->
1869     *
1870     * @param parameterName the name of the parameter
1871     * @param x the parameter value
1872     * @exception SQLException if a database access error occurs
1873     * @see #getDate
1874     * @since JDK 1.4, HSQLDB 1.7.0
1875     */
1876//#ifdef JDBC3
1877    public void setDate(String   parameterName, Date   x) throws SQLException   {
1878        setDate(findParameterIndex(parameterName), x);
1879    }
1880
1881//#endif JDBC3
1882
1883    /**
1884     * <!-- start generic documentation -->
1885     * Sets the designated parameter to the given <code>java.sql.Time</code>
1886     * value.  The driver converts this to an SQL <code>TIME</code> value
1887     * when it sends it to the database. <p>
1888     * <!-- end generic documentation -->
1889     *
1890     * <!-- start release-specific documentation -->
1891     * <div class="ReleaseSpecificDocumentation">
1892     * <h3>HSQLDB-Specific Information:</h3> <p>
1893     *
1894     * Starting with 1.7.2, HSLQDB supports this.
1895     * </div>
1896     * <!-- end release-specific documentation -->
1897     *
1898     * @param parameterName the name of the parameter
1899     * @param x the parameter value
1900     * @exception SQLException if a database access error occurs
1901     * @see #getTime
1902     * @since JDK 1.4, HSQLDB 1.7.0
1903     */
1904//#ifdef JDBC3
1905    public void setTime(String   parameterName, Time   x) throws SQLException   {
1906        setTime(findParameterIndex(parameterName), x);
1907    }
1908
1909//#endif JDBC3
1910
1911    /**
1912     * <!-- start generic documentation -->
1913     * Sets the designated parameter to the given
1914     * <code>java.sql.Timestamp</code> value. The driver
1915     * converts this to an SQL <code>TIMESTAMP</code> value when it
1916     * sends it to the database. <p>
1917     * <!-- end generic documentation -->
1918     *
1919     * <!-- start release-specific documentation -->
1920     * <div class="ReleaseSpecificDocumentation">
1921     * <h3>HSQLDB-Specific Information:</h3> <p>
1922     *
1923     * Starting with 1.7.2, HSLQDB supports this.
1924     * </div>
1925     * <!-- end release-specific documentation -->
1926     *
1927     * @param parameterName the name of the parameter
1928     * @param x the parameter value
1929     * @exception SQLException if a database access error occurs
1930     * @see #getTimestamp
1931     * @since JDK 1.4, HSQLDB 1.7.0
1932     */
1933//#ifdef JDBC3
1934    public void setTimestamp(String   parameterName,
1935                             Timestamp   x) throws SQLException   {
1936        setTimestamp(findParameterIndex(parameterName), x);
1937    }
1938
1939//#endif JDBC3
1940
1941    /**
1942     * <!-- start generic documentation -->
1943     * Sets the designated parameter to the given input stream, which will
1944     * have the specified number of bytes.
1945     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
1946     * parameter, it may be more practical to send it via a
1947     * <code>java.io.InputStream</code>. Data will be read from the stream
1948     * as needed until end-of-file is reached.  The JDBC driver will
1949     * do any necessary conversion from ASCII to the database char format.
1950     *
1951     * <P><B>Note:</B> This stream object can either be a standard
1952     * Java stream object or your own subclass that implements the
1953     * standard interface. <p>
1954     * <!-- end generic documentation -->
1955     *
1956     * <!-- start release-specific documentation -->
1957     * <div class="ReleaseSpecificDocumentation">
1958     * <h3>HSQLDB-Specific Information:</h3> <p>
1959     *
1960     * Starting with 1.7.2, HSLQDB supports this.
1961     * </div>
1962     * <!-- end release-specific documentation -->
1963     *
1964     * @param parameterName the name of the parameter
1965     * @param x the Java input stream that contains the ASCII parameter value
1966     * @param length the number of bytes in the stream
1967     * @exception SQLException if a database access error occurs
1968     * @since JDK 1.4, HSQLDB 1.7.0
1969     */
1970//#ifdef JDBC3
1971    public void setAsciiStream(String   parameterName, java.io.InputStream   x,
1972                               int length) throws SQLException   {
1973        setAsciiStream(findParameterIndex(parameterName), x, length);
1974    }
1975
1976//#endif JDBC3
1977
1978    /**
1979     * <!-- start generic documentation -->
1980     * Sets the designated parameter to the given input stream, which will
1981     * have the specified number of bytes.
1982     * When a very large binary value is input to a <code>LONGVARBINARY</code>
1983     * parameter, it may be more practical to send it via a
1984     * <code>java.io.InputStream</code> object. The data will be read from
1985     * the stream as needed until end-of-file is reached.
1986     *
1987     * <P><B>Note:</B> This stream object can either be a standard
1988     * Java stream object or your own subclass that implements the
1989     * standard interface. <p>
1990     * <!-- end generic documentation -->
1991     *
1992     * <!-- start release-specific documentation -->
1993     * <div class="ReleaseSpecificDocumentation">
1994     * <h3>HSQLDB-Specific Information:</h3> <p>
1995     *
1996     * Starting with 1.7.2, HSLQDB supports this.
1997     * </div>
1998     * <!-- end release-specific documentation -->
1999     *
2000     * @param parameterName the name of the parameter
2001     * @param x the java input stream which contains the binary parameter value
2002     * @param length the number of bytes in the stream
2003     * @exception SQLException if a database access error occurs
2004     * @since JDK 1.4, HSQLDB 1.7.0
2005     */
2006//#ifdef JDBC3
2007    public void setBinaryStream(String   parameterName, java.io.InputStream   x,
2008                                int length) throws SQLException   {
2009        setBinaryStream(findParameterIndex(parameterName), x, length);
2010    }
2011
2012//#endif JDBC3
2013
2014    /**
2015     * <!-- start generic documentation -->
2016     * Sets the value of the designated parameter with the given object.
2017     * The second argument must be an object type; for integral values, the
2018     * <code>java.lang</code> equivalent objects should be used.
2019     *
2020     * <p>The given Java object will be converted to the given targetSqlType
2021     * before being sent to the database.
2022     *
2023     * If the object has a custom mapping (is of a class implementing the
2024     * interface <code>SQLData</code>),
2025     * the JDBC driver should call the method <code>SQLData.writeSQL</code>
2026     * to write it to the SQL data stream.
2027     * If, on the other hand, the object is of a class implementing
2028     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2029     * <code>Struct</code>, or <code>Array</code>, the driver should pass it
2030     * to the database as a value of the corresponding SQL type.
2031     * <P>
2032     * Note that this method may be used to pass datatabase-
2033     * specific abstract data types. <p>
2034     * <!-- end generic documentation -->
2035     *
2036     * <!-- start release-specific documentation -->
2037     * <div class="ReleaseSpecificDocumentation">
2038     * <h3>HSQLDB-Specific Information:</h3> <p>
2039     *
2040     * Starting with 1.7.2, HSLQDB supports this.
2041     * </div>
2042     * <!-- end release-specific documentation -->
2043     *
2044     * @param parameterName the name of the parameter
2045     * @param x the object containing the input parameter value
2046     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
2047     * sent to the database. The scale argument may further qualify this type.
2048     * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
2049     *    this is the number of digits after the decimal point.  For all
2050     *    other types, this value will be ignored.
2051     * @exception SQLException if a database access error occurs
2052     * @see java.sql.Types
2053     * @see #getObject
2054     * @since JDK 1.4, HSQLDB 1.7.0
2055     */
2056//#ifdef JDBC3
2057    public void setObject(String   parameterName, Object   x, int targetSqlType,
2058                          int scale) throws SQLException   {
2059        setObject(findParameterIndex(parameterName), x, targetSqlType, scale);
2060    }
2061
2062//#endif JDBC3
2063
2064    /**
2065     * <!-- start generic documentation -->
2066     * Sets the value of the designated parameter with the given object.
2067     * This method is like the method <code>setObject</code>
2068     * above, except that it assumes a scale of zero. <p>
2069     * <!-- end generic documentation -->
2070     *
2071     * <!-- start release-specific documentation -->
2072     * <div class="ReleaseSpecificDocumentation">
2073     * <h3>HSQLDB-Specific Information:</h3> <p>
2074     *
2075     * Starting with 1.7.2, HSLQDB supports this.
2076     * </div>
2077     * <!-- end release-specific documentation -->
2078     *
2079     * @param parameterName the name of the parameter
2080     * @param x the object containing the input parameter value
2081     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
2082     *                 sent to the database
2083     * @exception SQLException if a database access error occurs
2084     * @see #getObject
2085     * @since JDK 1.4, HSQLDB 1.7.0
2086     */
2087//#ifdef JDBC3
2088    public void setObject(String   parameterName, Object   x,
2089                          int targetSqlType) throws SQLException   {
2090        setObject(findParameterIndex(parameterName), x, targetSqlType);
2091    }
2092
2093//#endif JDBC3
2094
2095    /**
2096     * <!-- start generic documentation -->
2097     * Sets the value of the designated parameter with the given object.
2098     * The second parameter must be of type <code>Object</code>; therefore,
2099     * the <code>java.lang</code> equivalent objects should be used for
2100     * built-in types.
2101     *
2102     * <p>The JDBC specification specifies a standard mapping from
2103     * Java <code>Object</code> types to SQL types.  The given argument
2104     * will be converted to the corresponding SQL type before being
2105     * sent to the database.
2106     *
2107     * <p>Note that this method may be used to pass datatabase-
2108     * specific abstract data types, by using a driver-specific Java
2109     * type.
2110     *
2111     * If the object is of a class implementing the interface
2112     * <code>SQLData</code>, the JDBC driver should call the method
2113     * <code>SQLData.writeSQL</code> to write it to the SQL data stream.
2114     * If, on the other hand, the object is of a class implementing
2115     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2116     * <code>Struct</code>, or <code>Array</code>, the driver should pass it
2117     * to the database as a value of the corresponding SQL type.
2118     * <P>
2119     * This method throws an exception if there is an ambiguity, for example,
2120     * if the object is of a class implementing more than one of the
2121     * interfaces named above. <p>
2122     * <!-- end generic documentation -->
2123     *
2124     * <!-- start release-specific documentation -->
2125     * <div class="ReleaseSpecificDocumentation">
2126     * <h3>HSQLDB-Specific Information:</h3> <p>
2127     *
2128     * Starting with 1.7.2, HSLQDB supports this.
2129     * </div>
2130     * <!-- end release-specific documentation -->
2131     *
2132     * @param parameterName the name of the parameter
2133     * @param x the object containing the input parameter value
2134     * @exception SQLException if a database access error occurs or if the given
2135     *      <code>Object</code> parameter is ambiguous
2136     * @see #getObject
2137     * @since JDK 1.4, HSQLDB 1.7.0
2138     */
2139//#ifdef JDBC3
2140    public void setObject(String   parameterName,
2141                          Object   x) throws SQLException   {
2142        setObject(findParameterIndex(parameterName), x);
2143    }
2144
2145//#endif JDBC3
2146
2147    /**
2148     * <!-- start generic documentation -->
2149     * Sets the designated parameter to the given <code>Reader</code>
2150     * object, which is the given number of characters long.
2151     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
2152     * parameter, it may be more practical to send it via a
2153     * <code>java.io.Reader</code> object. The data will be read from the
2154     * stream as needed until end-of-file is reached.  The JDBC driver will
2155     * do any necessary conversion from UNICODE to the database char format.
2156     *
2157     * <P><B>Note:</B> This stream object can either be a standard
2158     * Java stream object or your own subclass that implements the
2159     * standard interface. <p>
2160     * <!-- end generic documentation -->
2161     *
2162     * <!-- start release-specific documentation -->
2163     * <div class="ReleaseSpecificDocumentation">
2164     * <h3>HSQLDB-Specific Information:</h3> <p>
2165     *
2166     * Starting with 1.7.2, HSLQDB supports this.
2167     * </div>
2168     * <!-- end release-specific documentation -->
2169     *
2170     * @param parameterName the name of the parameter
2171     * @param reader the <code>java.io.Reader</code> object that
2172     *  contains the UNICODE data used as the designated parameter
2173     * @param length the number of characters in the stream
2174     * @exception SQLException if a database access error occurs
2175     * @since JDK 1.4, HSQLDB 1.7.0
2176     */
2177//#ifdef JDBC3
2178    public void setCharacterStream(String   parameterName,
2179                                   java.io.Reader   reader,
2180                                   int length) throws SQLException   {
2181        setCharacterStream(findParameterIndex(parameterName), reader, length);
2182    }
2183
2184//#endif JDBC3
2185
2186    /**
2187     * <!-- start generic documentation -->
2188     * Sets the designated parameter to the given <code>java.sql.Date</code>
2189     * value, using the given <code>Calendar</code> object.  The driver uses
2190     * the <code>Calendar</code> object to construct an SQL <code>DATE</code>
2191     * value, which the driver then sends to the database.  With a
2192     * a <code>Calendar</code> object, the driver can calculate the date
2193     * taking into account a custom timezone.  If no
2194     * <code>Calendar</code> object is specified, the driver uses the default
2195     * timezone, which is that of the virtual machine running the
2196     * application. <p>
2197     * <!-- end generic documentation -->
2198     *
2199     * <!-- start release-specific documentation -->
2200     * <div class="ReleaseSpecificDocumentation">
2201     * <h3>HSQLDB-Specific Information:</h3> <p>
2202     *
2203     * Starting with 1.7.2, HSLQDB supports this.
2204     * </div>
2205     * <!-- end release-specific documentation -->
2206     *
2207     * @param parameterName the name of the parameter
2208     * @param x the parameter value
2209     * @param cal the <code>Calendar</code> object the driver will use
2210     *      to construct the date
2211     * @exception SQLException if a database access error occurs
2212     * @see #getDate
2213     * @since JDK 1.4, HSQLDB 1.7.0
2214     */
2215//#ifdef JDBC3
2216    public void setDate(String   parameterName, Date   x,
2217                        Calendar   cal) throws SQLException   {
2218        setDate(findParameterIndex(parameterName), x, cal);
2219    }
2220
2221//#endif JDBC3
2222
2223    /**
2224     * <!-- start generic documentation -->
2225     * Sets the designated parameter to the given <code>java.sql.Time</code>
2226     * value, using the given <code>Calendar</code> object.  The driver uses
2227     * the <code>Calendar</code> object to construct an SQL <code>TIME</code>
2228     * value, which the driver then sends to the database.  With a
2229     * a <code>Calendar</code> object, the driver can calculate the time
2230     * taking into account a custom timezone.  If no
2231     * <code>Calendar</code> object is specified, the driver uses the default
2232     * timezone, which is that of the virtual machine running the
2233     * application. <p>
2234     * <!-- end generic documentation -->
2235     *
2236     * <!-- start release-specific documentation -->
2237     * <div class="ReleaseSpecificDocumentation">
2238     * <h3>HSQLDB-Specific Information:</h3> <p>
2239     *
2240     * Starting with 1.7.2, HSLQDB supports this.
2241     * </div>
2242     * <!-- end release-specific documentation -->
2243     *
2244     * @param parameterName the name of the parameter
2245     * @param x the parameter value
2246     * @param cal the <code>Calendar</code> object the driver will use
2247     *      to construct the time
2248     * @exception SQLException if a database access error occurs
2249     * @see #getTime
2250     * @since JDK 1.4, HSQLDB 1.7.0
2251     */
2252//#ifdef JDBC3
2253    public void setTime(String   parameterName, Time   x,
2254                        Calendar   cal) throws SQLException   {
2255        setTime(findParameterIndex(parameterName), x, cal);
2256    }
2257
2258//#endif JDBC3
2259
2260    /**
2261     * <!-- start generic documentation -->
2262     * Sets the designated parameter to the given
2263     * <code>java.sql.Timestamp</code> value, using the given
2264     * <code>Calendar</code> object.  The driver uses the
2265     * <code>Calendar</code> object to construct an SQL
2266     * <code>TIMESTAMP</code> value, which the driver then sends to the
2267     * database.  With a <code>Calendar</code> object, the driver can
2268     * calculate the timestamp taking into account a custom timezone.  If no
2269     * <code>Calendar</code> object is specified, the driver uses the default
2270     * timezone, which is that of the virtual machine running the
2271     * application. <p>
2272     * <!-- end generic documentation -->
2273     *
2274     * <!-- start release-specific documentation -->
2275     * <div class="ReleaseSpecificDocumentation">
2276     * <h3>HSQLDB-Specific Information:</h3> <p>
2277     *
2278     * Starting with 1.7.2, HSLQDB supports this.
2279     * </div>
2280     * <!-- end release-specific documentation -->
2281     *
2282     * @param parameterName the name of the parameter
2283     * @param x the parameter value
2284     * @param cal the <code>Calendar</code> object the driver will use
2285     *      to construct the timestamp
2286     * @exception SQLException if a database access error occurs
2287     * @see #getTimestamp
2288     * @since JDK 1.4, HSQLDB 1.7.0
2289     */
2290//#ifdef JDBC3
2291    public void setTimestamp(String   parameterName, Timestamp   x,
2292                             Calendar   cal) throws SQLException   {
2293        setTimestamp(findParameterIndex(parameterName), x, cal);
2294    }
2295
2296//#endif JDBC3
2297
2298    /**
2299     * <!-- start generic documentation -->
2300     * Sets the designated parameter to SQL <code>NULL</code>.
2301     * This version of the method <code>setNull</code> should
2302     * be used for user-defined types and <code>REF</code> type parameters.
2303     * Examples of user-defined types include: <code>STRUCT</code>,
2304     * <code>DISTINCT</code>, <code>JAVA_OBJECT</code>, and
2305     * named array types.
2306     *
2307     * <P><B>Note:</B> To be portable, applications must give the
2308     * SQL type code and the fully-qualified SQL type name when specifying
2309     * a <code>NULL</code> user-defined or <code>REF</code> parameter.
2310     * In the case of a user-defined type the name is the type name of the
2311     * parameter itself.  For a <code>REF</code> parameter, the name is the
2312     * type name of the referenced type.  If a JDBC driver does not need
2313     * the type code or type name information, it may ignore it.
2314     *
2315     * Although it is intended for user-defined and <code>Ref</code>
2316     * parameters, this method may be used to set a null parameter of
2317     * any JDBC type. If the parameter does not have a user-defined or
2318     * <code>REF</code> type, the given <code>typeName</code> is ignored. <p>
2319     * <!-- end generic documentation -->
2320     *
2321     * <!-- start release-specific documentation -->
2322     * <div class="ReleaseSpecificDocumentation">
2323     * <h3>HSQLDB-Specific Information:</h3> <p>
2324     *
2325     * Starting with 1.7.2, HSLQDB supports this.
2326     * </div>
2327     * <!-- end release-specific documentation -->
2328     *
2329     * @param parameterName the name of the parameter
2330     * @param sqlType a value from <code>java.sql.Types</code>
2331     * @param typeName the fully-qualified name of an SQL user-defined type;
2332     *  ignored if the parameter is not a user-defined type or
2333     *  SQL <code>REF</code> value
2334     * @exception SQLException if a database access error occurs
2335     * @since JDK 1.4, HSQLDB 1.7.0
2336     */
2337//#ifdef JDBC3
2338    public void setNull(String   parameterName, int sqlType,
2339                        String   typeName) throws SQLException   {
2340        setNull(findParameterIndex(parameterName), sqlType, typeName);
2341    }
2342
2343//#endif JDBC3
2344
2345    /**
2346     * <!-- start generic documentation -->
2347     * Retrieves the value of a JDBC <code>CHAR</code>, <code>VARCHAR</code>,
2348     * or <code>LONGVARCHAR</code> parameter as a <code>String</code> in
2349     * the Java programming language.
2350     * <p>
2351     * For the fixed-length type JDBC <code>CHAR</code>,
2352     * the <code>String</code> object
2353     * returned has exactly the same value the (JDBC4 clarification:) SQL
2354     * <code>CHAR</code> value had in the
2355     * database, including any padding added by the database. <p>
2356     * <!-- end generic documentation -->
2357     *
2358     * <!-- start release-specific documentation -->
2359     * <div class="ReleaseSpecificDocumentation">
2360     * <h3>HSQLDB-Specific Information:</h3> <p>
2361     *
2362     * HSQLDB 1.7.2 does not support this feature. <p>
2363     *
2364     * Calling this method always throws an <code>SQLException</code>.
2365     * </div>
2366     * <!-- end release-specific documentation -->
2367     *
2368     * @param parameterName the name of the parameter
2369     * @return the parameter value. If the value is SQL <code>NULL</code>,
2370     * the result is <code>null</code>.
2371     * @exception SQLException if a database access error occurs
2372     * @see #setString
2373     * @since JDK 1.4, HSQLDB 1.7.0
2374     */
2375//#ifdef JDBC3
2376    public String   getString(String   parameterName) throws SQLException   {
2377        return getString(findParameterIndex(parameterName));
2378    }
2379
2380//#endif JDBC3
2381
2382    /**
2383     * <!-- start generic documentation -->
2384     * (JDBC4 modified:) Retrieves the value of a JDBC <code>BIT</code> or <code>BOOLEAN</code>
2385     * parameter as a
2386     * <code>boolean</code> in the Java programming language. <p>
2387     * <!-- end generic documentation -->
2388     *
2389     * <!-- start release-specific documentation -->
2390     * <div class="ReleaseSpecificDocumentation">
2391     * <h3>HSQLDB-Specific Information:</h3> <p>
2392     *
2393     * HSQLDB 1.7.2 does not support this feature. <p>
2394     *
2395     * Calling this method always throws an <code>SQLException</code>.
2396     * </div>
2397     * <!-- end release-specific documentation -->
2398     *
2399     * @param parameterName the name of the parameter
2400     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2401     * the result is <code>false</code>.
2402     * @exception SQLException if a database access error occurs
2403     * @see #setBoolean
2404     * @since JDK 1.4, HSQLDB 1.7.0
2405     */
2406//#ifdef JDBC3
2407    public boolean getBoolean(String   parameterName) throws SQLException   {
2408        return getBoolean(findParameterIndex(parameterName));
2409    }
2410
2411//#endif JDBC3
2412
2413    /**
2414     * <!-- start generic documentation -->
2415     * Retrieves the value of a JDBC <code>TINYINT</code> parameter as a
2416     * <code>byte</code> in the Java programming language. <p>
2417     * <!-- end generic documentation -->
2418     *
2419     * <!-- start release-specific documentation -->
2420     * <div class="ReleaseSpecificDocumentation">
2421     * <h3>HSQLDB-Specific Information:</h3> <p>
2422     *
2423     * HSQLDB 1.7.2 does not support this feature. <p>
2424     *
2425     * Calling this method always throws an <code>SQLException</code>.
2426     * </div>
2427     * <!-- end release-specific documentation -->
2428     *
2429     * @param parameterName the name of the parameter
2430     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2431     * the result is <code>0</code>.
2432     * @exception SQLException if a database access error occurs
2433     * @see #setByte
2434     * @since JDK 1.4, HSQLDB 1.7.0
2435     */
2436//#ifdef JDBC3
2437    public byte getByte(String   parameterName) throws SQLException   {
2438        return getByte(findParameterIndex(parameterName));
2439    }
2440
2441//#endif JDBC3
2442
2443    /**
2444     * <!-- start generic documentation -->
2445     * Retrieves the value of a JDBC <code>SMALLINT</code> parameter as
2446     * a <code>short</code> in the Java programming language. <p>
2447     * <!-- end generic documentation -->
2448     *
2449     * <!-- start release-specific documentation -->
2450     * <div class="ReleaseSpecificDocumentation">
2451     * <h3>HSQLDB-Specific Information:</h3> <p>
2452     *
2453     * HSQLDB 1.7.2 does not support this feature. <p>
2454     *
2455     * Calling this method always throws an <code>SQLException</code>.
2456     * </div>
2457     * <!-- end release-specific documentation -->
2458     *
2459     * @param parameterName the name of the parameter
2460     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2461     * the result is <code>0</code>.
2462     * @exception SQLException if a database access error occurs
2463     * @see #setShort
2464     * @since JDK 1.4, HSQLDB 1.7.0
2465     */
2466//#ifdef JDBC3
2467    public short getShort(String   parameterName) throws SQLException   {
2468        return getShort(findParameterIndex(parameterName));
2469    }
2470
2471//#endif JDBC3
2472
2473    /**
2474     * <!-- start generic documentation -->
2475     * Retrieves the value of a JDBC <code>INTEGER</code> parameter as
2476     * an <code>int</code> in the Java programming language. <p>
2477     * <!-- end generic documentation -->
2478     *
2479     * <!-- start release-specific documentation -->
2480     * <div class="ReleaseSpecificDocumentation">
2481     * <h3>HSQLDB-Specific Information:</h3> <p>
2482     *
2483     * HSQLDB 1.7.2 does not support this feature. <p>
2484     *
2485     * Calling this method always throws an <code>SQLException</code>.
2486     * </div>
2487     * <!-- end release-specific documentation -->
2488     *
2489     * @param parameterName the name of the parameter
2490     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2491     *   the result is <code>0</code>.
2492     * @exception SQLException if a database access error occurs
2493     * @see #setInt
2494     * @since JDK 1.4, HSQLDB 1.7.0
2495     */
2496//#ifdef JDBC3
2497    public int getInt(String   parameterName) throws SQLException   {
2498        return getInt(findParameterIndex(parameterName));
2499    }
2500
2501//#endif JDBC3
2502
2503    /**
2504     * <!-- start generic documentation -->
2505     * Retrieves the value of a JDBC <code>BIGINT</code> parameter as
2506     * a <code>long</code> in the Java programming language. <p>
2507     * <!-- end generic documentation -->
2508     *
2509     * <!-- start release-specific documentation -->
2510     * <div class="ReleaseSpecificDocumentation">
2511     * <h3>HSQLDB-Specific Information:</h3> <p>
2512     *
2513     * HSQLDB 1.7.2 does not support this feature. <p>
2514     *
2515     * Calling this method always throws an <code>SQLException</code>.
2516     * </div>
2517     * <!-- end release-specific documentation -->
2518     *
2519     * @param parameterName the name of the parameter
2520     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2521     *   the result is <code>0</code>.
2522     * @exception SQLException if a database access error occurs
2523     * @see #setLong
2524     * @since JDK 1.4, HSQLDB 1.7.0
2525     */
2526//#ifdef JDBC3
2527    public long getLong(String   parameterName) throws SQLException   {
2528        return getLong(findParameterIndex(parameterName));
2529    }
2530
2531//#endif JDBC3
2532
2533    /**
2534     * <!-- start generic documentation -->
2535     * Retrieves the value of a JDBC <code>FLOAT</code> parameter as
2536     * a <code>float</code> in the Java programming language. <p>
2537     * <!-- end generic documentation -->
2538     *
2539     * <!-- start release-specific documentation -->
2540     * <div class="ReleaseSpecificDocumentation">
2541     * <h3>HSQLDB-Specific Information:</h3> <p>
2542     *
2543     * HSQLDB 1.7.2 does not support this feature. <p>
2544     *
2545     * Calling this method always throws an <code>SQLException</code>.
2546     * </div>
2547     * <!-- end release-specific documentation -->
2548     *
2549     * @param parameterName the name of the parameter
2550     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2551     *   the result is <code>0</code>.
2552     * @exception SQLException if a database access error occurs
2553     * @see #setFloat
2554     * @since JDK 1.4, HSQLDB 1.7.0
2555     */
2556//#ifdef JDBC3
2557    public float getFloat(String   parameterName) throws SQLException   {
2558        return getFloat(findParameterIndex(parameterName));
2559    }
2560
2561//#endif JDBC3
2562
2563    /**
2564     * <!-- start generic documentation -->
2565     * Retrieves the value of a JDBC <code>DOUBLE</code> parameter as
2566     * a <code>double</code> in the Java programming language. <p>
2567     * <!-- end generic documentation -->
2568     *
2569     * <!-- start release-specific documentation -->
2570     * <div class="ReleaseSpecificDocumentation">
2571     * <h3>HSQLDB-Specific Information:</h3> <p>
2572     *
2573     * HSQLDB 1.7.2 does not support this feature. <p>
2574     *
2575     * Calling this method always throws an <code>SQLException</code>.
2576     * </div>
2577     * <!-- end release-specific documentation -->
2578     *
2579     * @param parameterName the name of the parameter
2580     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2581     *   the result is <code>0</code>.
2582     * @exception SQLException if a database access error occurs
2583     * @see #setDouble
2584     * @since JDK 1.4, HSQLDB 1.7.0
2585     */
2586//#ifdef JDBC3
2587    public double getDouble(String   parameterName) throws SQLException   {
2588        return getDouble(findParameterIndex(parameterName));
2589    }
2590
2591//#endif JDBC3
2592
2593    /**
2594     * <!-- start generic documentation -->
2595     * Retrieves the value of a JDBC <code>BINARY</code> or
2596     * <code>VARBINARY</code> parameter as an array of <code>byte</code>
2597     * values in the Java programming language. <p>
2598     * <!-- end generic documentation -->
2599     *
2600     * <!-- start release-specific documentation -->
2601     * <div class="ReleaseSpecificDocumentation">
2602     * <h3>HSQLDB-Specific Information:</h3> <p>
2603     *
2604     * HSQLDB 1.7.2 does not support this feature. <p>
2605     *
2606     * Calling this method always throws an <code>SQLException</code>.
2607     * </div>
2608     * <!-- end release-specific documentation -->
2609     *
2610     * @param parameterName the name of the parameter
2611     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2612     *      the result is <code>null</code>.
2613     * @exception SQLException if a database access error occurs
2614     * @see #setBytes
2615     * @since JDK 1.4, HSQLDB 1.7.0
2616     */
2617//#ifdef JDBC3
2618    public byte[] getBytes(String   parameterName) throws SQLException   {
2619        return getBytes(findParameterIndex(parameterName));
2620    }
2621
2622//#endif JDBC3
2623
2624    /**
2625     * <!-- start generic documentation -->
2626     * Retrieves the value of a JDBC <code>DATE</code> parameter as a
2627     * <code>java.sql.Date</code> object. <p>
2628     * <!-- end generic documentation -->
2629     *
2630     * <!-- start release-specific documentation -->
2631     * <div class="ReleaseSpecificDocumentation">
2632     * <h3>HSQLDB-Specific Information:</h3> <p>
2633     *
2634     * HSQLDB 1.7.2 does not support this feature. <p>
2635     *
2636     * Calling this method always throws an <code>SQLException</code>.
2637     * </div>
2638     * <!-- end release-specific documentation -->
2639     *
2640     * @param parameterName the name of the parameter
2641     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2642     *      the result is <code>null</code>.
2643     * @exception SQLException if a database access error occurs
2644     * @see #setDate
2645     * @since JDK 1.4, HSQLDB 1.7.0
2646     */
2647//#ifdef JDBC3
2648    public Date   getDate(String   parameterName) throws SQLException   {
2649        return getDate(findParameterIndex(parameterName));
2650    }
2651
2652//#endif JDBC3
2653
2654    /**
2655     * <!-- start generic documentation -->
2656     * Retrieves the value of a JDBC <code>TIME</code> parameter as a
2657     * <code>java.sql.Time</code> object. <p>
2658     * <!-- end generic documentation -->
2659     *
2660     * <!-- start release-specific documentation -->
2661     * <div class="ReleaseSpecificDocumentation">
2662     * <h3>HSQLDB-Specific Information:</h3> <p>
2663     *
2664     * HSQLDB 1.7.2 does not support this feature. <p>
2665     *
2666     * Calling this method always throws an <code>SQLException</code>.
2667     * </div>
2668     * <!-- end release-specific documentation -->
2669     *
2670     * @param parameterName the name of the parameter
2671     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2672     *      the result is <code>null</code>.
2673     * @exception SQLException if a database access error occurs
2674     * @see #setTime
2675     * @since JDK 1.4, HSQLDB 1.7.0
2676     */
2677//#ifdef JDBC3
2678    public Time   getTime(String   parameterName) throws SQLException   {
2679        return getTime(findParameterIndex(parameterName));
2680    }
2681
2682//#endif JDBC3
2683
2684    /**
2685     * <!-- start generic documentation -->
2686     * Retrieves the value of a JDBC <code>TIMESTAMP</code> parameter as a
2687     * <code>java.sql.Timestamp</code> object. <p>
2688     * <!-- end generic documentation -->
2689     *
2690     * <!-- start release-specific documentation -->
2691     * <div class="ReleaseSpecificDocumentation">
2692     * <h3>HSQLDB-Specific Information:</h3> <p>
2693     *
2694     * HSQLDB 1.7.2 does not support this feature. <p>
2695     *
2696     * Calling this method always throws an <code>SQLException</code>.
2697     * </div>
2698     * <!-- end release-specific documentation -->
2699     *
2700     * @param parameterName the name of the parameter
2701     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2702     *      the result is <code>null</code>.
2703     * @exception SQLException if a database access error occurs
2704     * @see #setTimestamp
2705     * @since JDK 1.4, HSQLDB 1.7.0
2706     */
2707//#ifdef JDBC3
2708    public Timestamp   getTimestamp(String   parameterName) throws SQLException   {
2709        return getTimestamp(findParameterIndex(parameterName));
2710    }
2711
2712//#endif JDBC3
2713
2714    /**
2715     * <!-- start generic documentation -->
2716     * Retrieves the value of a parameter as an <code>Object</code> in the Java
2717     * programming language. If the value is an SQL <code>NULL</code>, the
2718     * driver returns a Java <code>null</code>.
2719     * <p>
2720     * This method returns a Java object whose type corresponds to the JDBC
2721     * type that was registered for this parameter using the method
2722     * <code>registerOutParameter</code>.  By registering the target JDBC
2723     * type as <code>java.sql.Types.OTHER</code>, this method can be used
2724     * to read database-specific abstract data types. <p>
2725     * <!-- end generic documentation -->
2726     *
2727     * <!-- start release-specific documentation -->
2728     * <div class="ReleaseSpecificDocumentation">
2729     * <h3>HSQLDB-Specific Information:</h3> <p>
2730     *
2731     * HSQLDB 1.7.2 does not support this feature. <p>
2732     *
2733     * Calling this method always throws an <code>SQLException</code>.
2734     * </div>
2735     * <!-- end release-specific documentation -->
2736     *
2737     * @param parameterName the name of the parameter
2738     * @return A <code>java.lang.Object</code> holding the OUT parameter value.
2739     * @exception SQLException if a database access error occurs
2740     * @see java.sql.Types
2741     * @see #setObject
2742     * @since JDK 1.4, HSQLDB 1.7.0
2743     */
2744//#ifdef JDBC3
2745    public Object   getObject(String   parameterName) throws SQLException   {
2746        return getObject(findParameterIndex(parameterName));
2747    }
2748
2749//#endif JDBC3
2750
2751    /**
2752     * <!-- start generic documentation -->
2753     * Retrieves the value of a JDBC <code>NUMERIC</code> parameter as a
2754     * <code>java.math.BigDecimal</code> object with as many digits to the
2755     * right of the decimal point as the value contains. <p>
2756     * <!-- end generic documentation -->
2757     *
2758     * <!-- start release-specific documentation -->
2759     * <div class="ReleaseSpecificDocumentation">
2760     * <h3>HSQLDB-Specific Information:</h3> <p>
2761     *
2762     * HSQLDB 1.7.2 does not support this feature. <p>
2763     *
2764     * Calling this method always throws an <code>SQLException</code>.
2765     * </div>
2766     * <!-- end release-specific documentation -->
2767     *
2768     * @param parameterName the name of the parameter
2769     * @return the parameter value in full precision.  If the value is
2770     * SQL <code>NULL</code>, the result is <code>null</code>.
2771     * @exception SQLException if a database access error occurs
2772     * @see #setBigDecimal
2773     * @since JDK 1.4, HSQLDB 1.7.0
2774     */
2775//#ifdef JDBC3
2776    public BigDecimal   getBigDecimal(String   parameterName)
2777    throws SQLException   {
2778        return getBigDecimal(findParameterIndex(parameterName));
2779    }
2780
2781//#endif JDBC3
2782
2783    /**
2784     * <!-- start generic documentation -->
2785     * Returns an object representing the value of OUT parameter
2786     * <code>parameterName</code> and uses <code>map</code> for the custom
2787     * mapping of the parameter value.
2788     * <p>
2789     * This method returns a Java object whose type corresponds to the
2790     * JDBC type that was registered for this parameter using the method
2791     * <code>registerOutParameter</code>.  By registering the target
2792     * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
2793     * be used to read database-specific abstract data types. <p>
2794     * <!-- end generic documentation -->
2795     *
2796     * <!-- start release-specific documentation -->
2797     * <div class="ReleaseSpecificDocumentation">
2798     * <h3>HSQLDB-Specific Information:</h3> <p>
2799     *
2800     * HSQLDB 1.7.2 does not support this feature. <p>
2801     *
2802     * Calling this method always throws an <code>SQLException</code>.
2803     * </div>
2804     * <!-- end release-specific documentation -->
2805     *
2806     * @param parameterName the name of the parameter
2807     * @param map the mapping from SQL type names to Java classes
2808     * @return a <code>java.lang.Object</code> holding the OUT parameter value
2809     * @exception SQLException if a database access error occurs
2810     * @see #setObject
2811     * @since JDK 1.4, HSQLDB 1.7.0
2812     */
2813//#ifdef JDBC3
2814    public Object   getObject(String   parameterName,
2815                            Map   map) throws SQLException   {
2816        return getObject(findParameterIndex(parameterName), map);
2817    }
2818
2819//#endif JDBC3
2820
2821    /**
2822     * <!-- start generic documentation -->
2823     * Retrieves the value of a JDBC <code>REF(&lt;structured-type&gt;)</code>
2824     * parameter as a {@link Ref} object in the Java programming language. <p>
2825     * <!-- end generic documentation -->
2826     *
2827     * <!-- start release-specific documentation -->
2828     * <div class="ReleaseSpecificDocumentation">
2829     * <h3>HSQLDB-Specific Information:</h3> <p>
2830     *
2831     * HSQLDB 1.7.2 does not support this feature. <p>
2832     *
2833     * Calling this method always throws an <code>SQLException</code>.
2834     * </div>
2835     * <!-- end release-specific documentation -->
2836     *
2837     * @param parameterName the name of the parameter
2838     * @return the parameter value as a <code>Ref</code> object in the
2839     *    Java programming language.  If the value was SQL <code>NULL</code>,
2840     *    the value <code>null</code> is returned.
2841     * @exception SQLException if a database access error occurs
2842     * @since JDK 1.4, HSQLDB 1.7.0
2843     */
2844//#ifdef JDBC3
2845    public Ref   getRef(String   parameterName) throws SQLException   {
2846        return getRef(findParameterIndex(parameterName));
2847    }
2848
2849//#endif JDBC3
2850
2851    /**
2852     * <!-- start generic documentation -->
2853     * Retrieves the value of a JDBC <code>BLOB</code> parameter as a
2854     * {@link java.sql.Blob} object in the Java programming language. <p>
2855     * <!-- end generic documentation -->
2856     *
2857     * <!-- start release-specific documentation -->
2858     * <div class="ReleaseSpecificDocumentation">
2859     * <h3>HSQLDB-Specific Information:</h3> <p>
2860     *
2861     * HSQLDB 1.7.2 does not support this feature. <p>
2862     *
2863     * Calling this method always throws an <code>SQLException</code>.
2864     * </div>
2865     * <!-- end release-specific documentation -->
2866     *
2867     * @param parameterName the name of the parameter
2868     * @return the parameter value as a <code>Blob</code> object in the
2869     *    Java programming language.  If the value was SQL <code>NULL</code>,
2870     *    the value <code>null</code> is returned.
2871     * @exception SQLException if a database access error occurs
2872     * @since JDK 1.4, HSQLDB 1.7.0
2873     */
2874//#ifdef JDBC3
2875    public Blob   getBlob(String   parameterName) throws SQLException   {
2876        return getBlob(findParameterIndex(parameterName));
2877    }
2878
2879//#endif JDBC3
2880
2881    /**
2882     * <!-- start generic documentation -->
2883     * Retrieves the value of a JDBC <code>CLOB</code> parameter as a
2884     * {@link java.sql.Clob} object in the Java programming language. <p>
2885     * <!-- end generic documentation -->
2886     *
2887     * <!-- start release-specific documentation -->
2888     * <div class="ReleaseSpecificDocumentation">
2889     * <h3>HSQLDB-Specific Information:</h3> <p>
2890     *
2891     * HSQLDB 1.7.2 does not support this feature. <p>
2892     *
2893     * Calling this method always throws an <code>SQLException</code>.
2894     * </div>
2895     * <!-- end release-specific documentation -->
2896     *
2897     * @param parameterName the name of the parameter
2898     * @return the parameter value as a <code>Clob</code> object in the
2899     *    Java programming language.  If the value was SQL <code>NULL</code>,
2900     *    the value <code>null</code> is returned.
2901     * @exception SQLException if a database access error occurs
2902     * @since JDK 1.4, HSQLDB 1.7.0
2903     */
2904//#ifdef JDBC3
2905    public Clob   getClob(String   parameterName) throws SQLException   {
2906        return getClob(findParameterIndex(parameterName));
2907    }
2908
2909//#endif JDBC3
2910
2911    /**
2912     * <!-- start generic documentation -->
2913     * Retrieves the value of a JDBC <code>ARRAY</code> parameter as an
2914     * {@link Array} object in the Java programming language. <p>
2915     * <!-- end generic documentation -->
2916     *
2917     * <!-- start release-specific documentation -->
2918     * <div class="ReleaseSpecificDocumentation">
2919     * <h3>HSQLDB-Specific Information:</h3> <p>
2920     *
2921     * HSQLDB 1.7.2 does not support this feature. <p>
2922     *
2923     * Calling this method always throws an <code>SQLException</code>.
2924     * </div>
2925     * <!-- end release-specific documentation -->
2926     *
2927     * @param parameterName the name of the parameter
2928     * @return the parameter value as an <code>Array</code> object in
2929     *    Java programming language.  If the value was SQL <code>NULL</code>,
2930     *    the value <code>null</code> is returned.
2931     * @exception SQLException if a database access error occurs
2932     * @since JDK 1.4, HSQLDB 1.7.0
2933     */
2934//#ifdef JDBC3
2935    public Array   getArray(String   parameterName) throws SQLException   {
2936        return getArray(findParameterIndex(parameterName));
2937    }
2938
2939//#endif JDBC3
2940
2941    /**
2942     * <!-- start generic documentation -->
2943     * Retrieves the value of a JDBC <code>DATE</code> parameter as a
2944     * <code>java.sql.Date</code> object, using
2945     * the given <code>Calendar</code> object
2946     * to construct the date.
2947     * With a <code>Calendar</code> object, the driver
2948     * can calculate the date taking into account a custom timezone and
2949     * locale.  If no <code>Calendar</code> object is specified, the d
2950     * river uses the default timezone and locale. <p>
2951     * <!-- end generic documentation -->
2952     *
2953     * <!-- start release-specific documentation -->
2954     * <div class="ReleaseSpecificDocumentation">
2955     * <h3>HSQLDB-Specific Information:</h3> <p>
2956     *
2957     * HSQLDB 1.7.2 does not support this feature. <p>
2958     *
2959     * Calling this method always throws an <code>SQLException</code>.
2960     * </div>
2961     * <!-- end release-specific documentation -->
2962     *
2963     * @param parameterName the name of the parameter
2964     * @param cal the <code>Calendar</code> object the driver will use
2965     *      to construct the date
2966     * @return the parameter value.  If the value is SQL <code>NULL</code>,
2967     * the result is <code>null</code>.
2968     * @exception SQLException if a database access error occurs
2969     * @see #setDate
2970     * @since JDK 1.4, HSQLDB 1.7.0
2971     */
2972//#ifdef JDBC3
2973    public Date   getDate(String   parameterName,
2974                        Calendar   cal) throws SQLException   {
2975        return getDate(findParameterIndex(parameterName), cal);
2976    }
2977
2978//#endif JDBC3
2979
2980    /**
2981     * <!-- start generic documentation -->
2982     * Retrieves the value of a JDBC <code>TIME</code> parameter as a
2983     * <code>java.sql.Time</code> object, using
2984     * the given <code>Calendar</code> object
2985     * to construct the time.
2986     * With a <code>Calendar</code> object, the driver
2987     * can calculate the time taking into account a custom timezone and
2988     * locale. If no <code>Calendar</code> object is specified, the driver
2989     * uses the default timezone and locale. <p>
2990     * <!-- end generic documentation -->
2991     *
2992     * <!-- start release-specific documentation -->
2993     * <div class="ReleaseSpecificDocumentation">
2994     * <h3>HSQLDB-Specific Information:</h3> <p>
2995     *
2996     * HSQLDB 1.7.2 does not support this feature. <p>
2997     *
2998     * Calling this method always throws an <code>SQLException</code>.
2999     * </div>
3000     * <!-- end release-specific documentation -->
3001     *
3002     * @param parameterName the name of the parameter
3003     * @param cal the <code>Calendar</code> object the driver will use
3004     *      to construct the time
3005     * @return the parameter value; if the value is SQL <code>NULL</code>,
3006     *      the result is <code>null</code>.
3007     * @exception SQLException if a database access error occurs
3008     * @see #setTime
3009     * @since JDK 1.4, HSQLDB 1.7.0
3010     */
3011//#ifdef JDBC3
3012    public Time   getTime(String   parameterName,
3013                        Calendar   cal) throws SQLException   {
3014        return getTime(findParameterIndex(parameterName), cal);
3015    }
3016
3017//#endif JDBC3
3018
3019    /**
3020     * <!-- start generic documentation -->
3021     * Retrieves the value of a JDBC <code>TIMESTAMP</code> parameter as a
3022     * <code>java.sql.Timestamp</code> object, using
3023     * the given <code>Calendar</code> object to construct
3024     * the <code>Timestamp</code> object.
3025     * With a <code>Calendar</code> object, the driver
3026     * can calculate the timestamp taking into account a custom timezone
3027     * and locale.  If no <code>Calendar</code> object is specified, the
3028     * driver uses the default timezone and locale. <p>
3029     * <!-- end generic documentation -->
3030     *
3031     * <!-- start release-specific documentation -->
3032     * <div class="ReleaseSpecificDocumentation">
3033     * <h3>HSQLDB-Specific Information:</h3> <p>
3034     *
3035     * HSQLDB 1.7.2 does not support this feature. <p>
3036     *
3037     * Calling this method always throws an <code>SQLException</code>.
3038     * </div>
3039     * <!-- end release-specific documentation -->
3040     *
3041     *
3042     * @param parameterName the name of the parameter
3043     * @param cal the <code>Calendar</code> object the driver will use
3044     *      to construct the timestamp
3045     * @return the parameter value.  If the value is SQL <code>NULL</code>,
3046     *      the result is <code>null</code>.
3047     * @exception SQLException if a database access error occurs
3048     * @see #setTimestamp
3049     * @since JDK 1.4, HSQLDB 1.7.0
3050     */
3051//#ifdef JDBC3
3052    public Timestamp   getTimestamp(String   parameterName,
3053                                  Calendar   cal) throws SQLException   {
3054        return getTimestamp(findParameterIndex(parameterName), cal);
3055    }
3056
3057//#endif JDBC3
3058
3059    /**
3060     * <!-- start generic documentation -->
3061     * Retrieves the value of a JDBC <code>DATALINK</code> parameter as a
3062     * <code>java.net.URL</code> object. <p>
3063     * <!-- end generic documentation -->
3064     *
3065     * <!-- start release-specific documentation -->
3066     * <div class="ReleaseSpecificDocumentation">
3067     * <h3>HSQLDB-Specific Information:</h3> <p>
3068     *
3069     * HSQLDB 1.7.2 does not support this feature. <p>
3070     *
3071     * Calling this method always throws an <code>SQLException</code>.
3072     * </div>
3073     * <!-- end release-specific documentation -->
3074     *
3075     * @param parameterName the name of the parameter
3076     * @return the parameter value as a <code>java.net.URL</code> object in the
3077     *      Java programming language.  If the value was SQL
3078     *      <code>NULL</code>, the value <code>null</code> is returned.
3079     * @exception SQLException if a database access error occurs,
3080     *      or if there is a problem with the URL
3081     * @see #setURL
3082     * @since JDK 1.4, HSQLDB 1.7.0
3083     */
3084//#ifdef JDBC3
3085    public java.net.URL   getURL(String   parameterName) throws SQLException   {
3086        return getURL(findParameterIndex(parameterName));
3087    }
3088
3089//#endif JDBC3
3090}
3091
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags