1 /*

     2  * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.sql;

    27 

    28 import java.math.BigDecimal;

    29 import java.util.Calendar;

    30 import java.io.Reader;

    31 import java.io.InputStream;

    32 

    33 /**

    34  * The interface used to execute SQL stored procedures.  The JDBC API

    35  * provides a stored procedure SQL escape syntax that allows stored procedures

    36  * to be called in a standard way for all RDBMSs. This escape syntax has one

    37  * form that includes a result parameter and one that does not. If used, the result

    38  * parameter must be registered as an OUT parameter. The other parameters

    39  * can be used for input, output or both. Parameters are referred to

    40  * sequentially, by number, with the first parameter being 1.

    41  * <PRE>

    42  *   {?= call <procedure-name>[(<arg1>,<arg2>, ...)]}

    43  *   {call <procedure-name>[(<arg1>,<arg2>, ...)]}

    44  * </PRE>

    45  * <P>

    46  * IN parameter values are set using the <code>set</code> methods inherited from

    47  * {@link PreparedStatement}.  The type of all OUT parameters must be

    48  * registered prior to executing the stored procedure; their values

    49  * are retrieved after execution via the <code>get</code> methods provided here.

    50  * <P>

    51  * A <code>CallableStatement</code> can return one {@link ResultSet} object or

    52  * multiple <code>ResultSet</code> objects.  Multiple

    53  * <code>ResultSet</code> objects are handled using operations

    54  * inherited from {@link Statement}.

    55  * <P>

    56  * For maximum portability, a call's <code>ResultSet</code> objects and

    57  * update counts should be processed prior to getting the values of output

    58  * parameters.

    59  *

    60  *

    61  * @see Connection#prepareCall

    62  * @see ResultSet

    63  * @since 1.1

    64  */

    65 

    66 public interface CallableStatement extends PreparedStatement {

    67 

    68     /**

    69      * Registers the OUT parameter in ordinal position

    70      * <code>parameterIndex</code> to the JDBC type

    71      * <code>sqlType</code>.  All OUT parameters must be registered

    72      * before a stored procedure is executed.

    73      * <p>

    74      * The JDBC type specified by <code>sqlType</code> for an OUT

    75      * parameter determines the Java type that must be used

    76      * in the <code>get</code> method to read the value of that parameter.

    77      * <p>

    78      * If the JDBC type expected to be returned to this output parameter

    79      * is specific to this particular database, <code>sqlType</code>

    80      * should be <code>java.sql.Types.OTHER</code>.  The method

    81      * {@link #getObject} retrieves the value.

    82      *

    83      * @param parameterIndex the first parameter is 1, the second is 2,

    84      *        and so on

    85      * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.

    86      *        If the parameter is of JDBC type <code>NUMERIC</code>

    87      *        or <code>DECIMAL</code>, the version of

    88      *        <code>registerOutParameter</code> that accepts a scale value

    89      *        should be used.

    90      *

    91      * @exception SQLException if the parameterIndex is not valid;

    92      * if a database access error occurs or

    93      * this method is called on a closed <code>CallableStatement</code>

    94      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

    95      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

    96      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

    97      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

    98      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

    99      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   100      * this data type

   101      * @see Types

   102      */

   103     void registerOutParameter(int parameterIndex, int sqlType)

   104         throws SQLException;

   105 

   106     /**

   107      * Registers the parameter in ordinal position

   108      * <code>parameterIndex</code> to be of JDBC type

   109      * <code>sqlType</code>. All OUT parameters must be registered

   110      * before a stored procedure is executed.

   111      * <p>

   112      * The JDBC type specified by <code>sqlType</code> for an OUT

   113      * parameter determines the Java type that must be used

   114      * in the <code>get</code> method to read the value of that parameter.

   115      * <p>

   116      * This version of <code>registerOutParameter</code> should be

   117      * used when the parameter is of JDBC type <code>NUMERIC</code>

   118      * or <code>DECIMAL</code>.

   119      *

   120      * @param parameterIndex the first parameter is 1, the second is 2,

   121      * and so on

   122      * @param sqlType the SQL type code defined by <code>java.sql.Types</code>.

   123      * @param scale the desired number of digits to the right of the

   124      * decimal point.  It must be greater than or equal to zero.

   125      * @exception SQLException if the parameterIndex is not valid;

   126      * if a database access error occurs or

   127      * this method is called on a closed <code>CallableStatement</code>

   128      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

   129      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

   130      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

   131      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

   132      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

   133      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   134      * this data type

   135      * @see Types

   136      */

   137     void registerOutParameter(int parameterIndex, int sqlType, int scale)

   138         throws SQLException;

   139 

   140     /**

   141      * Retrieves whether the last OUT parameter read had the value of

   142      * SQL <code>NULL</code>.  Note that this method should be called only after

   143      * calling a getter method; otherwise, there is no value to use in

   144      * determining whether it is <code>null</code> or not.

   145      *

   146      * @return <code>true</code> if the last parameter read was SQL

   147      * <code>NULL</code>; <code>false</code> otherwise

   148      * @exception SQLException if a database access error occurs or

   149      * this method is called on a closed <code>CallableStatement</code>

   150      */

   151     boolean wasNull() throws SQLException;

   152 

   153     /**

   154      * Retrieves the value of the designated JDBC <code>CHAR</code>,

   155      * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> parameter as a

   156      * <code>String</code> in the Java programming language.

   157      * <p>

   158      * For the fixed-length type JDBC <code>CHAR</code>,

   159      * the <code>String</code> object

   160      * returned has exactly the same value the SQL

   161      * <code>CHAR</code> value had in the

   162      * database, including any padding added by the database.

   163      *

   164      * @param parameterIndex the first parameter is 1, the second is 2,

   165      * and so on

   166      * @return the parameter value. If the value is SQL <code>NULL</code>,

   167      *         the result

   168      *         is <code>null</code>.

   169      * @exception SQLException if the parameterIndex is not valid;

   170      * if a database access error occurs or

   171      * this method is called on a closed <code>CallableStatement</code>

   172      * @see #setString

   173      */

   174     String getString(int parameterIndex) throws SQLException;

   175 

   176     /**

   177      * Retrieves the value of the designated JDBC <code>BIT</code>

   178      * or <code>BOOLEAN</code> parameter as a

   179      * <code>boolean</code> in the Java programming language.

   180      *

   181      * @param parameterIndex the first parameter is 1, the second is 2,

   182      *        and so on

   183      * @return the parameter value.  If the value is SQL <code>NULL</code>,

   184      *         the result is <code>false</code>.

   185      * @exception SQLException if the parameterIndex is not valid;

   186      * if a database access error occurs or

   187      * this method is called on a closed <code>CallableStatement</code>

   188      * @see #setBoolean

   189      */

   190     boolean getBoolean(int parameterIndex) throws SQLException;

   191 

   192     /**

   193      * Retrieves the value of the designated JDBC <code>TINYINT</code> parameter

   194      * as a <code>byte</code> in the Java programming language.

   195      *

   196      * @param parameterIndex the first parameter is 1, the second is 2,

   197      * and so on

   198      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   199      * is <code>0</code>.

   200      * @exception SQLException if the parameterIndex is not valid;

   201      * if a database access error occurs or

   202      * this method is called on a closed <code>CallableStatement</code>

   203      * @see #setByte

   204      */

   205     byte getByte(int parameterIndex) throws SQLException;

   206 

   207     /**

   208      * Retrieves the value of the designated JDBC <code>SMALLINT</code> parameter

   209      * as a <code>short</code> in the Java programming language.

   210      *

   211      * @param parameterIndex the first parameter is 1, the second is 2,

   212      * and so on

   213      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   214      * is <code>0</code>.

   215      * @exception SQLException if the parameterIndex is not valid;

   216      * if a database access error occurs or

   217      * this method is called on a closed <code>CallableStatement</code>

   218      * @see #setShort

   219      */

   220     short getShort(int parameterIndex) throws SQLException;

   221 

   222     /**

   223      * Retrieves the value of the designated JDBC <code>INTEGER</code> parameter

   224      * as an <code>int</code> in the Java programming language.

   225      *

   226      * @param parameterIndex the first parameter is 1, the second is 2,

   227      * and so on

   228      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   229      * is <code>0</code>.

   230      * @exception SQLException if the parameterIndex is not valid;

   231      * if a database access error occurs or

   232      * this method is called on a closed <code>CallableStatement</code>

   233      * @see #setInt

   234      */

   235     int getInt(int parameterIndex) throws SQLException;

   236 

   237     /**

   238      * Retrieves the value of the designated JDBC <code>BIGINT</code> parameter

   239      * as a <code>long</code> in the Java programming language.

   240      *

   241      * @param parameterIndex the first parameter is 1, the second is 2,

   242      * and so on

   243      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   244      * is <code>0</code>.

   245      * @exception SQLException if the parameterIndex is not valid;

   246      * if a database access error occurs or

   247      * this method is called on a closed <code>CallableStatement</code>

   248      * @see #setLong

   249      */

   250     long getLong(int parameterIndex) throws SQLException;

   251 

   252     /**

   253      * Retrieves the value of the designated JDBC <code>FLOAT</code> parameter

   254      * as a <code>float</code> in the Java programming language.

   255      *

   256      * @param parameterIndex the first parameter is 1, the second is 2,

   257      *        and so on

   258      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   259      *         is <code>0</code>.

   260      * @exception SQLException if the parameterIndex is not valid;

   261      * if a database access error occurs or

   262      * this method is called on a closed <code>CallableStatement</code>

   263      * @see #setFloat

   264      */

   265     float getFloat(int parameterIndex) throws SQLException;

   266 

   267     /**

   268      * Retrieves the value of the designated JDBC <code>DOUBLE</code> parameter as a <code>double</code>

   269      * in the Java programming language.

   270      * @param parameterIndex the first parameter is 1, the second is 2,

   271      *        and so on

   272      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   273      *         is <code>0</code>.

   274      * @exception SQLException if the parameterIndex is not valid;

   275      * if a database access error occurs or

   276      * this method is called on a closed <code>CallableStatement</code>

   277      * @see #setDouble

   278      */

   279     double getDouble(int parameterIndex) throws SQLException;

   280 

   281     /**

   282      * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a

   283      * <code>java.math.BigDecimal</code> object with <i>scale</i> digits to

   284      * the right of the decimal point.

   285      * @param parameterIndex the first parameter is 1, the second is 2,

   286      *        and so on

   287      * @param scale the number of digits to the right of the decimal point

   288      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   289      *         is <code>null</code>.

   290      * @exception SQLException if the parameterIndex is not valid;

   291      * if a database access error occurs or

   292      * this method is called on a closed <code>CallableStatement</code>

   293      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   294      * this method

   295      * @deprecated use <code>getBigDecimal(int parameterIndex)</code>

   296      *             or <code>getBigDecimal(String parameterName)</code>

   297      * @see #setBigDecimal

   298      */

   299     @Deprecated(since="1.2")

   300     BigDecimal getBigDecimal(int parameterIndex, int scale)

   301         throws SQLException;

   302 

   303     /**

   304      * Retrieves the value of the designated JDBC <code>BINARY</code> or

   305      * <code>VARBINARY</code> parameter as an array of <code>byte</code>

   306      * values in the Java programming language.

   307      * @param parameterIndex the first parameter is 1, the second is 2,

   308      *        and so on

   309      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   310      *         is <code>null</code>.

   311      * @exception SQLException if the parameterIndex is not valid;

   312      * if a database access error occurs or

   313      * this method is called on a closed <code>CallableStatement</code>

   314      * @see #setBytes

   315      */

   316     byte[] getBytes(int parameterIndex) throws SQLException;

   317 

   318     /**

   319      * Retrieves the value of the designated JDBC <code>DATE</code> parameter as a

   320      * <code>java.sql.Date</code> object.

   321      * @param parameterIndex the first parameter is 1, the second is 2,

   322      *        and so on

   323      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   324      *         is <code>null</code>.

   325      * @exception SQLException if the parameterIndex is not valid;

   326      * if a database access error occurs or

   327      * this method is called on a closed <code>CallableStatement</code>

   328      * @see #setDate

   329      */

   330     java.sql.Date getDate(int parameterIndex) throws SQLException;

   331 

   332     /**

   333      * Retrieves the value of the designated JDBC <code>TIME</code> parameter as a

   334      * <code>java.sql.Time</code> object.

   335      *

   336      * @param parameterIndex the first parameter is 1, the second is 2,

   337      *        and so on

   338      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   339      *         is <code>null</code>.

   340      * @exception SQLException if the parameterIndex is not valid;

   341      * if a database access error occurs or

   342      * this method is called on a closed <code>CallableStatement</code>

   343      * @see #setTime

   344      */

   345     java.sql.Time getTime(int parameterIndex) throws SQLException;

   346 

   347     /**

   348      * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a

   349      * <code>java.sql.Timestamp</code> object.

   350      *

   351      * @param parameterIndex the first parameter is 1, the second is 2,

   352      *        and so on

   353      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   354      *         is <code>null</code>.

   355      * @exception SQLException if the parameterIndex is not valid;

   356      * if a database access error occurs or

   357      * this method is called on a closed <code>CallableStatement</code>

   358      * @see #setTimestamp

   359      */

   360     java.sql.Timestamp getTimestamp(int parameterIndex)

   361         throws SQLException;

   362 

   363     //----------------------------------------------------------------------

   364     // Advanced features:

   365 

   366 

   367     /**

   368      * Retrieves the value of the designated parameter as an <code>Object</code>

   369      * in the Java programming language. If the value is an SQL <code>NULL</code>,

   370      * the driver returns a Java <code>null</code>.

   371      * <p>

   372      * This method returns a Java object whose type corresponds to the JDBC

   373      * type that was registered for this parameter using the method

   374      * <code>registerOutParameter</code>.  By registering the target JDBC

   375      * type as <code>java.sql.Types.OTHER</code>, this method can be used

   376      * to read database-specific abstract data types.

   377      *

   378      * @param parameterIndex the first parameter is 1, the second is 2,

   379      *        and so on

   380      * @return A <code>java.lang.Object</code> holding the OUT parameter value

   381      * @exception SQLException if the parameterIndex is not valid;

   382      * if a database access error occurs or

   383      * this method is called on a closed <code>CallableStatement</code>

   384      * @see Types

   385      * @see #setObject

   386      */

   387     Object getObject(int parameterIndex) throws SQLException;

   388 

   389 

   390     //--------------------------JDBC 2.0-----------------------------

   391 

   392     /**

   393      * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a

   394      * <code>java.math.BigDecimal</code> object with as many digits to the

   395      * right of the decimal point as the value contains.

   396      * @param parameterIndex the first parameter is 1, the second is 2,

   397      * and so on

   398      * @return the parameter value in full precision.  If the value is

   399      * SQL <code>NULL</code>, the result is <code>null</code>.

   400      * @exception SQLException if the parameterIndex is not valid;

   401      * if a database access error occurs or

   402      * this method is called on a closed <code>CallableStatement</code>

   403      * @see #setBigDecimal

   404      * @since 1.2

   405      */

   406     BigDecimal getBigDecimal(int parameterIndex) throws SQLException;

   407 

   408     /**

   409      * Returns an object representing the value of OUT parameter

   410      * <code>parameterIndex</code> and uses <code>map</code> for the custom

   411      * mapping of the parameter value.

   412      * <p>

   413      * This method returns a Java object whose type corresponds to the

   414      * JDBC type that was registered for this parameter using the method

   415      * <code>registerOutParameter</code>.  By registering the target

   416      * JDBC type as <code>java.sql.Types.OTHER</code>, this method can

   417      * be used to read database-specific abstract data types.

   418      * @param parameterIndex the first parameter is 1, the second is 2, and so on

   419      * @param map the mapping from SQL type names to Java classes

   420      * @return a <code>java.lang.Object</code> holding the OUT parameter value

   421      * @exception SQLException if the parameterIndex is not valid;

   422      * if a database access error occurs or

   423      * this method is called on a closed <code>CallableStatement</code>

   424      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   425      * this method

   426      * @see #setObject

   427      * @since 1.2

   428      */

   429     Object getObject(int parameterIndex, java.util.Map<String,Class<?>> map)

   430         throws SQLException;

   431 

   432     /**

   433      * Retrieves the value of the designated JDBC <code>REF(&lt;structured-type&gt;)</code>

   434      * parameter as a {@link java.sql.Ref} object in the Java programming language.

   435      * @param parameterIndex the first parameter is 1, the second is 2,

   436      * and so on

   437      * @return the parameter value as a <code>Ref</code> object in the

   438      * Java programming language.  If the value was SQL <code>NULL</code>, the value

   439      * <code>null</code> is returned.

   440      * @exception SQLException if the parameterIndex is not valid;

   441      * if a database access error occurs or

   442      * this method is called on a closed <code>CallableStatement</code>

   443      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   444      * this method

   445      * @since 1.2

   446      */

   447     Ref getRef (int parameterIndex) throws SQLException;

   448 

   449     /**

   450      * Retrieves the value of the designated JDBC <code>BLOB</code> parameter as a

   451      * {@link java.sql.Blob} object in the Java programming language.

   452      * @param parameterIndex the first parameter is 1, the second is 2, and so on

   453      * @return the parameter value as a <code>Blob</code> object in the

   454      * Java programming language.  If the value was SQL <code>NULL</code>, the value

   455      * <code>null</code> is returned.

   456      * @exception SQLException if the parameterIndex is not valid;

   457      * if a database access error occurs or

   458      * this method is called on a closed <code>CallableStatement</code>

   459      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   460      * this method

   461      * @since 1.2

   462      */

   463     Blob getBlob (int parameterIndex) throws SQLException;

   464 

   465     /**

   466      * Retrieves the value of the designated JDBC <code>CLOB</code> parameter as a

   467      * <code>java.sql.Clob</code> object in the Java programming language.

   468      * @param parameterIndex the first parameter is 1, the second is 2, and

   469      * so on

   470      * @return the parameter value as a <code>Clob</code> object in the

   471      * Java programming language.  If the value was SQL <code>NULL</code>, the

   472      * value <code>null</code> is returned.

   473      * @exception SQLException if the parameterIndex is not valid;

   474      * if a database access error occurs or

   475      * this method is called on a closed <code>CallableStatement</code>

   476      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   477      * this method

   478      * @since 1.2

   479      */

   480     Clob getClob (int parameterIndex) throws SQLException;

   481 

   482     /**

   483      *

   484      * Retrieves the value of the designated JDBC <code>ARRAY</code> parameter as an

   485      * {@link java.sql.Array} object in the Java programming language.

   486      * @param parameterIndex the first parameter is 1, the second is 2, and

   487      * so on

   488      * @return the parameter value as an <code>Array</code> object in

   489      * the Java programming language.  If the value was SQL <code>NULL</code>, the

   490      * value <code>null</code> is returned.

   491      * @exception SQLException if the parameterIndex is not valid;

   492      * if a database access error occurs or

   493      * this method is called on a closed <code>CallableStatement</code>

   494      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   495      * this method

   496      * @since 1.2

   497      */

   498     Array getArray (int parameterIndex) throws SQLException;

   499 

   500     /**

   501      * Retrieves the value of the designated JDBC <code>DATE</code> parameter as a

   502      * <code>java.sql.Date</code> object, using

   503      * the given <code>Calendar</code> object

   504      * to construct the date.

   505      * With a <code>Calendar</code> object, the driver

   506      * can calculate the date taking into account a custom timezone and locale.

   507      * If no <code>Calendar</code> object is specified, the driver uses the

   508      * default timezone and locale.

   509      *

   510      * @param parameterIndex the first parameter is 1, the second is 2,

   511      * and so on

   512      * @param cal the <code>Calendar</code> object the driver will use

   513      *            to construct the date

   514      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   515      *         is <code>null</code>.

   516      * @exception SQLException if the parameterIndex is not valid;

   517      * if a database access error occurs or

   518      * this method is called on a closed <code>CallableStatement</code>

   519      * @see #setDate

   520      * @since 1.2

   521      */

   522     java.sql.Date getDate(int parameterIndex, Calendar cal)

   523         throws SQLException;

   524 

   525     /**

   526      * Retrieves the value of the designated JDBC <code>TIME</code> parameter as a

   527      * <code>java.sql.Time</code> object, using

   528      * the given <code>Calendar</code> object

   529      * to construct the time.

   530      * With a <code>Calendar</code> object, the driver

   531      * can calculate the time taking into account a custom timezone and locale.

   532      * If no <code>Calendar</code> object is specified, the driver uses the

   533      * default timezone and locale.

   534      *

   535      * @param parameterIndex the first parameter is 1, the second is 2,

   536      * and so on

   537      * @param cal the <code>Calendar</code> object the driver will use

   538      *            to construct the time

   539      * @return the parameter value; if the value is SQL <code>NULL</code>, the result

   540      *         is <code>null</code>.

   541      * @exception SQLException if the parameterIndex is not valid;

   542      * if a database access error occurs or

   543      * this method is called on a closed <code>CallableStatement</code>

   544      * @see #setTime

   545      * @since 1.2

   546      */

   547     java.sql.Time getTime(int parameterIndex, Calendar cal)

   548         throws SQLException;

   549 

   550     /**

   551      * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a

   552      * <code>java.sql.Timestamp</code> object, using

   553      * the given <code>Calendar</code> object to construct

   554      * the <code>Timestamp</code> object.

   555      * With a <code>Calendar</code> object, the driver

   556      * can calculate the timestamp taking into account a custom timezone and locale.

   557      * If no <code>Calendar</code> object is specified, the driver uses the

   558      * default timezone and locale.

   559      *

   560      *

   561      * @param parameterIndex the first parameter is 1, the second is 2,

   562      * and so on

   563      * @param cal the <code>Calendar</code> object the driver will use

   564      *            to construct the timestamp

   565      * @return the parameter value.  If the value is SQL <code>NULL</code>, the result

   566      *         is <code>null</code>.

   567      * @exception SQLException if the parameterIndex is not valid;

   568      * if a database access error occurs or

   569      * this method is called on a closed <code>CallableStatement</code>

   570      * @see #setTimestamp

   571      * @since 1.2

   572      */

   573     java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal)

   574         throws SQLException;

   575 

   576 

   577     /**

   578      * Registers the designated output parameter.

   579      * This version of

   580      * the method <code>registerOutParameter</code>

   581      * should be used for a user-defined or <code>REF</code> output parameter.  Examples

   582      * of user-defined types include: <code>STRUCT</code>, <code>DISTINCT</code>,

   583      * <code>JAVA_OBJECT</code>, and named array types.

   584      *<p>

   585      * All OUT parameters must be registered

   586      * before a stored procedure is executed.

   587      * <p>  For a user-defined parameter, the fully-qualified SQL

   588      * type name of the parameter should also be given, while a <code>REF</code>

   589      * parameter requires that the fully-qualified type name of the

   590      * referenced type be given.  A JDBC driver that does not need the

   591      * type code and type name information may ignore it.   To be portable,

   592      * however, applications should always provide these values for

   593      * user-defined and <code>REF</code> parameters.

   594      *

   595      * Although it is intended for user-defined and <code>REF</code> parameters,

   596      * this method may be used to register a parameter of any JDBC type.

   597      * If the parameter does not have a user-defined or <code>REF</code> type, the

   598      * <i>typeName</i> parameter is ignored.

   599      *

   600      * <P><B>Note:</B> When reading the value of an out parameter, you

   601      * must use the getter method whose Java type corresponds to the

   602      * parameter's registered SQL type.

   603      *

   604      * @param parameterIndex the first parameter is 1, the second is 2,...

   605      * @param sqlType a value from {@link java.sql.Types}

   606      * @param typeName the fully-qualified name of an SQL structured type

   607      * @exception SQLException if the parameterIndex is not valid;

   608      * if a database access error occurs or

   609      * this method is called on a closed <code>CallableStatement</code>

   610      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

   611      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

   612      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

   613      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

   614      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

   615      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   616      * this data type

   617      * @see Types

   618      * @since 1.2

   619      */

   620     void registerOutParameter (int parameterIndex, int sqlType, String typeName)

   621         throws SQLException;

   622 

   623   //--------------------------JDBC 3.0-----------------------------

   624 

   625     /**

   626      * Registers the OUT parameter named

   627      * <code>parameterName</code> to the JDBC type

   628      * <code>sqlType</code>.  All OUT parameters must be registered

   629      * before a stored procedure is executed.

   630      * <p>

   631      * The JDBC type specified by <code>sqlType</code> for an OUT

   632      * parameter determines the Java type that must be used

   633      * in the <code>get</code> method to read the value of that parameter.

   634      * <p>

   635      * If the JDBC type expected to be returned to this output parameter

   636      * is specific to this particular database, <code>sqlType</code>

   637      * should be <code>java.sql.Types.OTHER</code>.  The method

   638      * {@link #getObject} retrieves the value.

   639      * @param parameterName the name of the parameter

   640      * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.

   641      * If the parameter is of JDBC type <code>NUMERIC</code>

   642      * or <code>DECIMAL</code>, the version of

   643      * <code>registerOutParameter</code> that accepts a scale value

   644      * should be used.

   645      * @exception SQLException if parameterName does not correspond to a named

   646      * parameter; if a database access error occurs or

   647      * this method is called on a closed <code>CallableStatement</code>

   648      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

   649      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

   650      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

   651      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

   652      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

   653      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   654      * this data type or if the JDBC driver does not support

   655      * this method

   656      * @since 1.4

   657      * @see Types

   658      */

   659     void registerOutParameter(String parameterName, int sqlType)

   660         throws SQLException;

   661 

   662     /**

   663      * Registers the parameter named

   664      * <code>parameterName</code> to be of JDBC type

   665      * <code>sqlType</code>.  All OUT parameters must be registered

   666      * before a stored procedure is executed.

   667      * <p>

   668      * The JDBC type specified by <code>sqlType</code> for an OUT

   669      * parameter determines the Java type that must be used

   670      * in the <code>get</code> method to read the value of that parameter.

   671      * <p>

   672      * This version of <code>registerOutParameter</code> should be

   673      * used when the parameter is of JDBC type <code>NUMERIC</code>

   674      * or <code>DECIMAL</code>.

   675      *

   676      * @param parameterName the name of the parameter

   677      * @param sqlType SQL type code defined by <code>java.sql.Types</code>.

   678      * @param scale the desired number of digits to the right of the

   679      * decimal point.  It must be greater than or equal to zero.

   680      * @exception SQLException if parameterName does not correspond to a named

   681      * parameter; if a database access error occurs or

   682      * this method is called on a closed <code>CallableStatement</code>

   683      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

   684      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

   685      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

   686      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

   687      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

   688      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   689      * this data type or if the JDBC driver does not support

   690      * this method

   691      * @since 1.4

   692      * @see Types

   693      */

   694     void registerOutParameter(String parameterName, int sqlType, int scale)

   695         throws SQLException;

   696 

   697     /**

   698      * Registers the designated output parameter.  This version of

   699      * the method <code>registerOutParameter</code>

   700      * should be used for a user-named or REF output parameter.  Examples

   701      * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and

   702      * named array types.

   703      *<p>

   704      * All OUT parameters must be registered

   705      * before a stored procedure is executed.

   706      * <p>

   707      * For a user-named parameter the fully-qualified SQL

   708      * type name of the parameter should also be given, while a REF

   709      * parameter requires that the fully-qualified type name of the

   710      * referenced type be given.  A JDBC driver that does not need the

   711      * type code and type name information may ignore it.   To be portable,

   712      * however, applications should always provide these values for

   713      * user-named and REF parameters.

   714      *

   715      * Although it is intended for user-named and REF parameters,

   716      * this method may be used to register a parameter of any JDBC type.

   717      * If the parameter does not have a user-named or REF type, the

   718      * typeName parameter is ignored.

   719      *

   720      * <P><B>Note:</B> When reading the value of an out parameter, you

   721      * must use the <code>getXXX</code> method whose Java type XXX corresponds to the

   722      * parameter's registered SQL type.

   723      *

   724      * @param parameterName the name of the parameter

   725      * @param sqlType a value from {@link java.sql.Types}

   726      * @param typeName the fully-qualified name of an SQL structured type

   727      * @exception SQLException if parameterName does not correspond to a named

   728      * parameter; if a database access error occurs or

   729      * this method is called on a closed <code>CallableStatement</code>

   730      * @exception SQLFeatureNotSupportedException if <code>sqlType</code> is

   731      * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,

   732      * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,

   733      * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,

   734      *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>

   735      * or  <code>STRUCT</code> data type and the JDBC driver does not support

   736      * this data type or if the JDBC driver does not support

   737      * this method

   738      * @see Types

   739      * @since 1.4

   740      */

   741     void registerOutParameter (String parameterName, int sqlType, String typeName)

   742         throws SQLException;

   743 

   744     /**

   745      * Retrieves the value of the designated JDBC <code>DATALINK</code> parameter as a

   746      * <code>java.net.URL</code> object.

   747      *

   748      * @param parameterIndex the first parameter is 1, the second is 2,...

   749      * @return a <code>java.net.URL</code> object that represents the

   750      *         JDBC <code>DATALINK</code> value used as the designated

   751      *         parameter

   752      * @exception SQLException if the parameterIndex is not valid;

   753      * if a database access error occurs,

   754      * this method is called on a closed <code>CallableStatement</code>,

   755      *            or if the URL being returned is

   756      *            not a valid URL on the Java platform

   757      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   758      * this method

   759      * @see #setURL

   760      * @since 1.4

   761      */

   762     java.net.URL getURL(int parameterIndex) throws SQLException;

   763 

   764     /**

   765      * Sets the designated parameter to the given <code>java.net.URL</code> object.

   766      * The driver converts this to an SQL <code>DATALINK</code> value when

   767      * it sends it to the database.

   768      *

   769      * @param parameterName the name of the parameter

   770      * @param val the parameter value

   771      * @exception SQLException if parameterName does not correspond to a named

   772      * parameter; if a database access error occurs;

   773      * this method is called on a closed <code>CallableStatement</code>

   774      *            or if a URL is malformed

   775      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   776      * this method

   777      * @see #getURL

   778      * @since 1.4

   779      */

   780     void setURL(String parameterName, java.net.URL val) throws SQLException;

   781 

   782     /**

   783      * Sets the designated parameter to SQL <code>NULL</code>.

   784      *

   785      * <P><B>Note:</B> You must specify the parameter's SQL type.

   786      *

   787      * @param parameterName the name of the parameter

   788      * @param sqlType the SQL type code defined in <code>java.sql.Types</code>

   789      * @exception SQLException if parameterName does not correspond to a named

   790      * parameter; if a database access error occurs or

   791      * this method is called on a closed <code>CallableStatement</code>

   792      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   793      * this method

   794      * @since 1.4

   795      */

   796     void setNull(String parameterName, int sqlType) throws SQLException;

   797 

   798     /**

   799      * Sets the designated parameter to the given Java <code>boolean</code> value.

   800      * The driver converts this

   801      * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.

   802      *

   803      * @param parameterName the name of the parameter

   804      * @param x the parameter value

   805      * @exception SQLException if parameterName does not correspond to a named

   806      * parameter; if a database access error occurs or

   807      * this method is called on a closed <code>CallableStatement</code>

   808      * @see #getBoolean

   809      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   810      * this method

   811      * @since 1.4

   812      */

   813     void setBoolean(String parameterName, boolean x) throws SQLException;

   814 

   815     /**

   816      * Sets the designated parameter to the given Java <code>byte</code> value.

   817      * The driver converts this

   818      * to an SQL <code>TINYINT</code> value when it sends it to the database.

   819      *

   820      * @param parameterName the name of the parameter

   821      * @param x the parameter value

   822      * @exception SQLException if parameterName does not correspond to a named

   823      * parameter; if a database access error occurs or

   824      * this method is called on a closed <code>CallableStatement</code>

   825      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   826      * this method

   827      * @see #getByte

   828      * @since 1.4

   829      */

   830     void setByte(String parameterName, byte x) throws SQLException;

   831 

   832     /**

   833      * Sets the designated parameter to the given Java <code>short</code> value.

   834      * The driver converts this

   835      * to an SQL <code>SMALLINT</code> value when it sends it to the database.

   836      *

   837      * @param parameterName the name of the parameter

   838      * @param x the parameter value

   839      * @exception SQLException if parameterName does not correspond to a named

   840      * parameter; if a database access error occurs or

   841      * this method is called on a closed <code>CallableStatement</code>

   842      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   843      * this method

   844      * @see #getShort

   845      * @since 1.4

   846      */

   847     void setShort(String parameterName, short x) throws SQLException;

   848 

   849     /**

   850      * Sets the designated parameter to the given Java <code>int</code> value.

   851      * The driver converts this

   852      * to an SQL <code>INTEGER</code> value when it sends it to the database.

   853      *

   854      * @param parameterName the name of the parameter

   855      * @param x the parameter value

   856      * @exception SQLException if parameterName does not correspond to a named

   857      * parameter; if a database access error occurs or

   858      * this method is called on a closed <code>CallableStatement</code>

   859      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   860      * this method

   861      * @see #getInt

   862      * @since 1.4

   863      */

   864     void setInt(String parameterName, int x) throws SQLException;

   865 

   866     /**

   867      * Sets the designated parameter to the given Java <code>long</code> value.

   868      * The driver converts this

   869      * to an SQL <code>BIGINT</code> value when it sends it to the database.

   870      *

   871      * @param parameterName the name of the parameter

   872      * @param x the parameter value

   873      * @exception SQLException if parameterName does not correspond to a named

   874      * parameter; if a database access error occurs or

   875      * this method is called on a closed <code>CallableStatement</code>

   876      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   877      * this method

   878      * @see #getLong

   879      * @since 1.4

   880      */

   881     void setLong(String parameterName, long x) throws SQLException;

   882 

   883     /**

   884      * Sets the designated parameter to the given Java <code>float</code> value.

   885      * The driver converts this

   886      * to an SQL <code>FLOAT</code> value when it sends it to the database.

   887      *

   888      * @param parameterName the name of the parameter

   889      * @param x the parameter value

   890      * @exception SQLException if parameterName does not correspond to a named

   891      * parameter; if a database access error occurs or

   892      * this method is called on a closed <code>CallableStatement</code>

   893      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   894      * this method

   895      * @see #getFloat

   896      * @since 1.4

   897      */

   898     void setFloat(String parameterName, float x) throws SQLException;

   899 

   900     /**

   901      * Sets the designated parameter to the given Java <code>double</code> value.

   902      * The driver converts this

   903      * to an SQL <code>DOUBLE</code> value when it sends it to the database.

   904      *

   905      * @param parameterName the name of the parameter

   906      * @param x the parameter value

   907      * @exception SQLException if parameterName does not correspond to a named

   908      * parameter; if a database access error occurs or

   909      * this method is called on a closed <code>CallableStatement</code>

   910      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   911      * this method

   912      * @see #getDouble

   913      * @since 1.4

   914      */

   915     void setDouble(String parameterName, double x) throws SQLException;

   916 

   917     /**

   918      * Sets the designated parameter to the given

   919      * <code>java.math.BigDecimal</code> value.

   920      * The driver converts this to an SQL <code>NUMERIC</code> value when

   921      * it sends it to the database.

   922      *

   923      * @param parameterName the name of the parameter

   924      * @param x the parameter value

   925      * @exception SQLException if parameterName does not correspond to a named

   926      * parameter; if a database access error occurs or

   927      * this method is called on a closed <code>CallableStatement</code>

   928      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   929      * this method

   930      * @see #getBigDecimal

   931      * @since 1.4

   932      */

   933     void setBigDecimal(String parameterName, BigDecimal x) throws SQLException;

   934 

   935     /**

   936      * Sets the designated parameter to the given Java <code>String</code> value.

   937      * The driver converts this

   938      * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value

   939      * (depending on the argument's

   940      * size relative to the driver's limits on <code>VARCHAR</code> values)

   941      * when it sends it to the database.

   942      *

   943      * @param parameterName the name of the parameter

   944      * @param x the parameter value

   945      * @exception SQLException if parameterName does not correspond to a named

   946      * parameter; if a database access error occurs or

   947      * this method is called on a closed <code>CallableStatement</code>

   948      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   949      * this method

   950      * @see #getString

   951      * @since 1.4

   952      */

   953     void setString(String parameterName, String x) throws SQLException;

   954 

   955     /**

   956      * Sets the designated parameter to the given Java array of bytes.

   957      * The driver converts this to an SQL <code>VARBINARY</code> or

   958      * <code>LONGVARBINARY</code> (depending on the argument's size relative

   959      * to the driver's limits on <code>VARBINARY</code> values) when it sends

   960      * it to the database.

   961      *

   962      * @param parameterName the name of the parameter

   963      * @param x the parameter value

   964      * @exception SQLException if parameterName does not correspond to a named

   965      * parameter; if a database access error occurs or

   966      * this method is called on a closed <code>CallableStatement</code>

   967      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   968      * this method

   969      * @see #getBytes

   970      * @since 1.4

   971      */

   972     void setBytes(String parameterName, byte x[]) throws SQLException;

   973 

   974     /**

   975      * Sets the designated parameter to the given <code>java.sql.Date</code> value

   976      * using the default time zone of the virtual machine that is running

   977      * the application.

   978      * The driver converts this

   979      * to an SQL <code>DATE</code> value when it sends it to the database.

   980      *

   981      * @param parameterName the name of the parameter

   982      * @param x the parameter value

   983      * @exception SQLException if parameterName does not correspond to a named

   984      * parameter; if a database access error occurs or

   985      * this method is called on a closed <code>CallableStatement</code>

   986      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

   987      * this method

   988      * @see #getDate

   989      * @since 1.4

   990      */

   991     void setDate(String parameterName, java.sql.Date x)

   992         throws SQLException;

   993 

   994     /**

   995      * Sets the designated parameter to the given <code>java.sql.Time</code> value.

   996      * The driver converts this

   997      * to an SQL <code>TIME</code> value when it sends it to the database.

   998      *

   999      * @param parameterName the name of the parameter

  1000      * @param x the parameter value

  1001      * @exception SQLException if parameterName does not correspond to a named

  1002      * parameter; if a database access error occurs or

  1003      * this method is called on a closed <code>CallableStatement</code>

  1004      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

  1005      * this method

  1006      * @see #getTime

  1007      * @since 1.4

  1008      */

  1009     void setTime(String parameterName, java.sql.Time x)

  1010         throws SQLException;

  1011 

  1012     /**

  1013      * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.

  1014      * The driver

  1015      * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the

  1016      * database.

  1017      *

  1018      * @param parameterName the name of the parameter

  1019      * @param x the parameter value

  1020      * @exception SQLException if parameterName does not correspond to a named

  1021      * parameter; if a database access error occurs or

  1022      * this method is called on a closed <code>CallableStatement</code>

  1023      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

  1024      * this method

  1025      * @see #getTimestamp

  1026      * @since 1.4

  1027      */

  1028     void setTimestamp(String parameterName, java.sql.Timestamp x)

  1029         throws SQLException;

  1030 

  1031     /**

  1032      * Sets the designated parameter to the given input stream, which will have

  1033      * the specified number of bytes.

  1034      * When a very large ASCII value is input to a <code>LONGVARCHAR</code>

  1035      * parameter, it may be more practical to send it via a

  1036      * <code>java.io.InputStream</code>. Data will be read from the stream

  1037      * as needed until end-of-file is reached.  The JDBC driver will

  1038      * do any necessary conversion from ASCII to the database char format.

  1039      *

  1040      * <P><B>Note:</B> This stream object can either be a standard

  1041      * Java stream object or your own subclass that implements the

  1042      * standard interface.

  1043      *

  1044      * @param parameterName the name of the parameter

  1045      * @param x the Java input stream that contains the ASCII parameter value

  1046      * @param length the number of bytes in the stream

  1047      * @exception SQLException if parameterName does not correspond to a named

  1048      * parameter; if a database access error occurs or

  1049      * this method is called on a closed <code>CallableStatement</code>

  1050      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

  1051      * this method

  1052      * @since 1.4

  1053      */

  1054     void setAsciiStream(String parameterName, java.io.InputStream x, int length)

  1055         throws SQLException;

  1056 

  1057     /**

  1058      * Sets the designated parameter to the given input stream, which will have

  1059      * the specified number of bytes.

  1060      * When a very large binary value is input to a <code>LONGVARBINARY</code>

  1061      * parameter, it may be more practical to send it via a

  1062      * <code>java.io.InputStream</code> object. The data will be read from the stream

  1063      * as needed until end-of-file is reached.

  1064      *

  1065      * <P><B>Note:</B> This stream object can either be a standard

  1066      * Java stream object or your own subclass that implements the

  1067      * standard interface.

  1068      *

  1069      * @param parameterName the name of the parameter

  1070      * @param x the java input stream which contains the binary parameter value

  1071      * @param length the number of bytes in the stream

  1072      * @exception SQLException if parameterName does not correspond to a named

  1073      * parameter; if a database access error occurs or

  1074      * this method is called on a closed <code>CallableStatement</code>

  1075      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support

  1076      * this method

  1077      * @since 1.4

  1078      */

  1079     void setBinaryStream(String parameterName, java.io.InputStream x,

  1080                          int length) throws SQLException;

  1081 

  1082     /**

  1083      * Sets the value of the designated parameter with the given object.

  1084      *

  1085      * <p>The given Java object will be converted to the given targetSqlType

  1086      * before being sent to the database.

  1087      *

  1088      * If the object has a custom mapping (is of a class implementing the

  1089      * interface <code>SQLData</code>),

  1090      * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it

  1091      * to the SQL data stream.

  1092      * If, on the other hand, the object is of a class implementing

  1093      * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,

  1094      *  <code>Struct</code>, <code>java.net.URL</code>,

  1095      * or <code>Array</code>, the driver should pass it to the database as a

  1096      * value of the corresponding SQL type.

  1097      * <P>

  1098      * Note that this method may be used to pass datatabase-

  1099      * specific abstract data types.

  1100      *

  1101      * @param parameterName the name of the parameter

  1102      * @param x the object containing the input parameter value

  1103      * @param targetSqlType the SQL type (as defined in java.sql.Types) to be

  1104      * sent to the database. The scale argument may further qualify this type.

  1105      * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,

  1106      *          this is the number of digits after the decimal point.  For all other

  1107      *          types, this value will be ignored.

  1108      * @exception SQLException if parameterName does not correspond to a named

  1109      * parameter; if a database access error occurs or

  1110      * this method is called on a closed <code>CallableStatement</code>

  1111      * @exception SQLFeatureNotSupportedException if

  1112      * the JDBC driver does not support the specified targetSqlType

  1113      * @see Types

  1114      * @see #getObject

  1115      * @since 1.4

  1116      */

  1117     void setObject(String parameterName, Object x, int targetSqlType, int scale)

  1118         throws SQLException;

  1119 

  1120     /**

  1121      * Sets the value of the designated parameter with the given object.

  1122      *

  1123      * This method is similar to {@link #setObject(String parameterName,

  1124      * Object x, int targetSqlType, int scaleOrLength)},

  1125      * except that it assumes a scale of zero.

  1126      *

  1127      * @param parameterName the name of the parameter

  1128      * @param x the object containing the input parameter value

  1129      * @param targetSqlType the SQL type (as defined in java.sql.Types) to be

  1130      *                      sent to the database

  1131      * @exception SQLException if parameterName does not correspond to a named

  1132      * parameter; if a database access error occurs or

  1133      * this method is called on a closed <code>CallableStatement</code>

  1134      * @exception SQLFeatureNotSupportedException if

  1135      * the JDBC driver does not support the specified targetSqlType