/*
 * Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package javax.sql;

import java.sql.*;
import java.io.*;
import java.math.*;
import java.util.*;

/**
 * The interface that adds support to the JDBC API for the
 * JavaBeans component model.
 * A rowset, which can be used as a JavaBeans component in
 * a visual Bean development environment, can be created and
 * configured at design time and executed at run time.
 * <P>
 * The {@code RowSet}
 * interface provides a set of JavaBeans properties that allow a {@code RowSet}
 * instance to be configured to connect to a JDBC data source and read
 * some data from the data source.  A group of setter methods ({@code setInt},
 * {@code setBytes}, {@code setString}, and so on)
 * provide a way to pass input parameters to a rowset's command property.
 * This command is the SQL query the rowset uses when it gets its data from
 * a relational database, which is generally the case.
 * <P>
 * The {@code RowSet}
 * interface supports JavaBeans events, allowing other components in an
 * application to be notified when an event occurs on a rowset,
 * such as a change in its value.
 *
 * <P>The {@code RowSet} interface is unique in that it is intended to be
 * implemented using the rest of the JDBC API.  In other words, a
 * {@code RowSet} implementation is a layer of software that executes "on top"
 * of a JDBC driver.  Implementations of the {@code RowSet} interface can
 * be provided by anyone, including JDBC driver vendors who want to
 * provide a {@code RowSet} implementation as part of their JDBC products.
 * <P>
 * A {@code RowSet} object may make a connection with a data source and
 * maintain that connection throughout its life cycle, in which case it is
 * called a <i>connected</i> rowset.  A rowset may also make a connection with
 * a data source, get data from it, and then close the connection. Such a rowset
 * is called a <i>disconnected</i> rowset.  A disconnected rowset may make
 * changes to its data while it is disconnected and then send the changes back
 * to the original source of the data, but it must reestablish a connection to do so.
 * <P>
 * A disconnected rowset may have a {@code Reader} (a {@code RowSetReader} object)
 * and a writer (a {@code RowSetWriter} object) associated with it.
 * The {@code Reader} may be implemented in many different ways to populate a rowset
 * with data, including getting data from a non-relational data source. The
 * writer can also be implemented in many different ways to propagate changes
 * made to the rowset's data back to the underlying data source.
 * <P>
 * Rowsets are easy to use.  The {@code RowSet} interface extends the standard
 * {@code java.sql.ResultSet} interface.  The {@code RowSetMetaData}
 * interface extends the {@code java.sql.ResultSetMetaData} interface.
 * Thus, developers familiar
 * with the JDBC API will have to learn a minimal number of new APIs to
 * use rowsets.  In addition, third-party software tools that work with
 * JDBC {@code ResultSet} objects will also easily be made to work with rowsets.
 *
 * @since 1.4
 */

public interface RowSet extends ResultSet {

  //-----------------------------------------------------------------------
  // Properties
  //-----------------------------------------------------------------------

  //-----------------------------------------------------------------------
  // The following properties may be used to create a Connection.
  //-----------------------------------------------------------------------

  /**
   * Retrieves the url property this {@code RowSet} object will use to
   * create a connection if it uses the {@code DriverManager}
   * instead of a {@code DataSource} object to establish the connection.
   * The default value is {@code null}.
   *
   * @return a string url
   * @throws SQLException if a database access error occurs
   * @see #setUrl
   */
  String getUrl() throws SQLException;

  /**
   * Sets the URL this {@code RowSet} object will use when it uses the
   * {@code DriverManager} to create a connection.
   *
   * Setting this property is optional.  If a URL is used, a JDBC driver
   * that accepts the URL must be loaded before the
   * rowset is used to connect to a database.  The rowset will use the URL
* toadatabase when or 
   * data.  Either a URL or a data source name is used to create a
   * connection, whichever was set to non null value most recently.
   *
   * @param url a string value; may be {@code null}
   * @throws SQLException if a database access error occurs
   * @see #getUrl
   */
  void setUrl(String url) throws SQLException;

  /**
   * Retrieves the logical  version 2 for more details (a copy is included in the LICENSE file that
   * {@code RowSet}  2along this  not  to the  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   *
   * @return a data source name
   *@see #etDataSourceName
   * @see #setUrl
   */
  String getDataSourceName();

  /**
   *Sets the data source name property for this {@code RowSet} object to the
   * given {@code String}.
   * <P>
   *  valueof  data source name property can used to do a lookup of
   * a {@code DataSource} object that has been registered with a naming
   * service.  After being retrieved, the {@code DataSource} object can be
.
   *
   * @param name the logical name of the data source for this {@code RowSet}
   *        object; may be {@code null}
    tSQLExceptionif   access error
   * @see #getDataSourceName
   */
  void setDataSourceName(*arelational database,which is generallythe .

  /**
   *the usedto a  for this
   * {@code RowSet} object.
   * The username property is set at run time before calling the method
*@ .  
   * not usually part of the serialized state of a {@code RowSet} object.
   *
   * @return the username*implemented theoftheJDBC .In words java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
   * @see #setUsername
   */
  String getUsername();

  
   * Sets the username property for this {@code  * provide a {@code RowSet} implementation as part of productsjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   * given {@code String}.
   *
   * @param name a user name
    @throws SQLException if a database access error occurs
    @ee #getUsername
   */
  void setUsername(String name) throws SQLException;

  /**
   * Retrieves the password used to create a database connection.
   * The password property is set at run time before calling the method
   * {@code execute}.  It is not usually part of the serialized state
   * of a {@code RowSet} object.
   *
   * @return the password for making a database connection
   * @see #setPassword
   */
  String getPassword();

  /**
   * Sets the database password for this {@code   The {codeReader} may be implemented in many different ways to populate a rowset
   * the given {@code String}.
   *
   * @param   easy    {code }interface 
   * @throws SQLException if a database access error occurs
   * @see #getPassword
   */
  void setPassword(String password) throws SQLException;

  /**
   * Retrieves the transaction isolation level set for this
   * {@code RowSet} object.
   *
   * @return the transaction isolation level; one of
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *      {@code Connection.  //--------------------------------------------------
   *      {@code Connection.TRANSACTION_REPEATABLE_READ}, or
   *      {@code Connection.TRANSACTION_SERIALIZABLE}
*see #etTransactionIsolation
   */
  int getTransactionIsolation();

  
   * Sets the * @throws SQLExceptionif  database access occurs
   *
       Sets  URLURL{codeRowSet}objectwill itusesjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 }
   *      {@code Connection.java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 51
   *      *java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 74
   *      {@code Connection.TRANSACTION_SERIALIZABLE}
   * @throws ly tocreatea  whenreading writing
   * @see #getTransactionIsolation
   */
  void   java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 67

  /**
    @urlstring value; may be {@code null}
   * {@code RowSet} object, which specifies the custom mapping
   * of SQL user-defined types, if any.  The default is for the
   * type map to be empty. seesetUrl
  
   * @return a {@code java.util.Map} object containing the names of
   *         SQL user-defined types and roperty can  used do lookup  of
   *         to be mapped
   *
   * @throws SQLException if a database access error occurs
   * @see #setTypeMap
   */
   java.util.Map<String,Class<?>> getTypeMap() throws SQLException;

  /**
   * Installs the given {@code    * Installs the given {@code javaaccess error occurs
   * type map for this {@code RowSet} objectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 68
   *
   * @param map  a {@code java.util.Map} object containing the names of
            SQL user-defined types  theJava  towhich  are
      
    @hrows  if  database accesserror occurs
   * @see #getTypeMap
   */
   void setTypeMap(java.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5

  //-----------------------------------------------------------------------
  // The following properties may be used to create a Statement.
  //-----------------------------------------------------------------------*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 28

  /**
   * Retrieves this {@code RowSet} object's command property.
   *
   * The command property contains a command string, which must be an SQL
   * query, that can be executed to fill the rowset with data.
   * The default value is    of{ java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 32
   *
   * @return the command string; may be {@code null}
   * @see #setCommand
   */
  String getCommand();

  /**
   * Sets this {@code RowSet} object's command property 
   * SQL query.
   *
   * This property   void setPassword(St password)throws ;
   * when a rowset gets its data from a data source that does not support
   * commands, such as a spreadsheet.
   *
   * @{java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 53
 {code }  be@ null
   * @throws SQLException if a database access error occurs
    see getCommand
   */
  void setCommand(String cmd) throws SQLException;

  /**
   * Retrieveswhetherthis @code  is only.
   * If updates are possible, the default is for a rowset to be
   * updatable.
   * <P>
   * Attempts to update a read-only rowset  *@SQLException a databaseaccesserroroccurs
   *  *Retrieves {code Map}  with 
   *
   * @return {@code true} if this {@code RowSet} object is
   *         read-   * type mapbe .
   * @see #setReadOnly
   */
  boolean isReadOnly();

  /**
*Sets this{@odeRowSet} is -to 
   * given {@code boolean}.
   *
   * @param value             be
   *        updatable
   * @throws SQLException if a database access error occurs
   * @see #isReadOnly
   */
  void setReadOnly(boolean value)

  /**
   * Retrieves the maximum number of bytes that may be       this@}object    
   * for certain column values.
   * This limit applies only to {@code BINARY},
@ {java.lang.StringIndexOutOfBoundsException: Range [53, 50) out of bounds for length 66
   * {@code VARCHAR}, {@code LONGVARCHAR}, {@code NCHAR}
   * {@odeNVARCHAR}.
   *   /The  properties may be used to create a Statement.
   *
   * @return the current maximum column size limit; zero means that there
   *          is no limit
   * @throws SQLException if a database access error occurs
   * @see #setMaxFieldSize
   */
  getMaxFieldSize  SQLException;

  /**
   * Sets the maximum number of bytes that can be returned for a column
   * value to the given number of bytes.
  @BINARY}
   * {@code VARBINARY}, {@code LONGVARBINARYBINARY}, {@code CHAR},
   * {@code VARCHAR}, {@code LONGVARCHAR}, {@code NCHAR}
   * and {@code NVARCHAR} columns.
   * If the limit is exceeded, the excess data is silently discarded.
ortability, use values greater than 256.
   *
   * @param max limit   
   * @throws SQLException if a database access error occurs
   * @see #getMaxFieldSize
   */
  void setMaxFieldSize(int   void setCommand(

  /**
*Retrievesmaximum  ofrows*NOT COPYRIGHT NOTICES THISHEADERjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    object cancontain.
     *FITNESS  A PURPOSE.See GNU General PublicLicense
   *
*  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 72
    unlimited
*@SQLException  java.lang.StringIndexOutOfBoundsException: Range [46, 39) out of bounds for length 59
*@ 
   */
intgetMaxRows  * JavaBeans component A, be  ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  **
   * Sets *configuredatdesign time  executedatrun .
   * object can contain to the specified number.
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 21
   *
     interfaceaset    p @code}ifreadonly;{codefalse}if
   * @throws SQLException if a database access error occurs
   * @see   data fromdata source.  groupof setter   throws if database java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 59
   */
  void setMaxRows(int   setReadOnly  SQLException

  /**
    processing  enabled this

* * {@codeVARBINARY o }{code },
   *  Thiscommand is the SQL query e  java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 69
   *
    return @ode }   * application to be notified whenan occurs ona rowsetjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   *         {@code false} if it is disabled
   * @throws SQLException if a database access error occurs
*#
   */
  boolean getEscapeProcessing() throws SQLException;

  /**
   * Sets escape processing for this {@code RowSet} object on or
   * off. If escape scanning is on (the default), the driver will do
   * escape substitution before sending an SQL statement to the database.
   *
   *   
           code  disableit
   *@SQLException    access error occurs
   * @see #getEscapeProcessing
   */
  void setEscapeProcessing(boolean enable) throws SQLException;

  /**
 seconds  willwait 

   * If this limit is exceeded, an {@code SQLException} is thrown.
    seesetMaxRows
   *@java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
   *          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ifa  access error 
   * @see # object can containspecified ustjava.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 85
   */
  int getQueryTimeout() throws SQLException;

  /**
   * Sets    
   * a statement to execute to the given number of seconds.
    int   java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
   *
   *@ secondsthe   timeout  in seconds; means
   *        that there is no limit
   * @throws SQLException if a database access error occurs
   * @see #getQueryTimeout
   */
       to{codejava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 78

  /**
   java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    is usedto change typeof rowset,  by
   * default read-only and non-scrollable.
   *
   * @param java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4
   *        {@code ResultSet.TYPE_FORWARD_ONLY},
   *        {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or
   {@ResultSet.TYPE_SCROLL_SENSITIVE}
   * @throws SQLException if a database access error occurs
   #getType
   */
  void setType(int type) JDBC {code }objectswill alsoeasily bemade to work with rowsets.

  /**
   Setstheconcurrency  this{@odeRowSet} objecttogiven
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * of   @   seconds;zeromeans
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * @param java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 :@.}
   *        {@code * Sets the maximum time the java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
   * @throws SQLException if a database access error occurs
   * @see ResultSet#getConcurrency
   */
  void setConcurrency(int concurrency) throws   */

/--------------------------------------------------
  // Parameters
  --------------------------------

  /**
   * The {@code RowSet} setter methods are used to set any input parameters
   * needed by the {@code RowSet} object's command.
   * Parameters are set     used to   Thewill use     java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 59
   */

  /**
  * the   this{code java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 70
   * command to SQL    connection,whichever set  non null value most .
   *
   * <P><B>Note:<    @hrows  ifa   error occurs
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param sqlType a SQL type code defined by {@code java.sql.Typesjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 36
   * @throws SQLException if a database * concurrency level. This method is usedconcurrency
   */
  void setNull(int parameterIndex, int sqlType) throws*

  /**
*Sets to SQL {@code NULL}.
     *
     *<        {@ode ResultSet.ONCUR_UPDATABLE}
     *
     * @param parameterName the name of the parameter
     *   ----------------------------
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * this username aconnection 
SQLFeatureNotSupportedException   does support
     * this method
      since14
     */
     String  )java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 72

  /**
*Sets designatedparameter this @ode }objectsSQL
     SQL@code }.version  ofmethod @setNull}
   should  used SQL -  UDTs) @  type
   * parameters.  Examples of UDTs include
   *     @ee 
*
   * <P><Bjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 6
 typeandthe    *iven {odejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    a NULL UDTor{code parameter.In   of UDT,
   * the name is the type name of the parameter itself.  For a {@code REF}
   *  *Thepasswordproperty java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 71
   * a JDBC driver    * command to SQL {@cNULL}   method @ setNull}
   * it may ignore it.
   *
   * Although it is intended for UDT and {@code REF} parameters,     { object.
 this method may used    null parameter of any JDBC type.
   * If the parameter *@g
 typeName parameter is ignored.
*
*
*@ parameteris1   rthejava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 52
   * @param          {code .TRANSACTION_READ_COMMITTED
    *@Connection}
   *        name of the SQL structured type   /
   *        type; ignored if the parameter is not a UDT or {@code REF} type
* java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 59
   */
  void setNull (int          @ java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 56
 

  /**
     * Sets*      { java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
*This  of  method {code setNull}should
     * be used   void setTransactionIsolation(int level) throws SQLException;
     * of    *
      array types.
*
     * <P><B>* @param typeName  ofanSQL type
     * SQL type code and the fully-qualified SQL type name when specifying
      a user-defined  REFparameter. In the of a defined 
*java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 25
     * parameter, the name is the
       driverdoesnot the  code typename
     * it may ignore it.
     *
*it intended userdefined  parameters,
     * this method may be used to set a null parameter of any JDBC type.
     * If the parameter does not have a     
     * typeName is              andtheJava which they 
*
     *
     * @param parameterName the name of the parameter
  
     *@ typeNamethe -qualified  an definedjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
     *        ignored if the parameter is not a user-defined type or
     *        SQL {@code REF} value
*@hrowsjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 64
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
*this
    * sjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 17
     */
     (java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 69
        throws SQLException;

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * to        @  ajava.lang.StringIndexOutOfBoundsException: Range [48, 41) out of bounds for length 64
.
   *
   * @param parameterIndex the first parameter is 1, the second is  * SQLException   accessjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 59
   *   *Ifare the  for rowset be
   * @throws SQLException if a database access    *  a  java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
   */
  void*

  /***read-    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
     *    ()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
     * The driver converts this
     * to an SQL {@code BIT} or {@code BOOLEAN}     java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59
     *
     * @param parameterName the name    *t   java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 59
     * @param   *
     * @throws SQLException if a *  only   
}
     * @see #getBoolean
        *           limit
     * this s 
     * @
     */
voidjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 73

  /**
   * Sets the designated parameter in this {@code java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 47
* the given      hrows  if  JDBC driver   support
an @  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 68
  
   * @param parameterIndex    to  {java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 70
*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 33
    thejava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 69
   */
  (   x throwsjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63

  /**
     * Sets the designated    @SQLExceptiondatabase erroroccurs
     * The driver converts this
     * to an SQL {@code TINYINT} value when it sends it to the database.
     *
     * @param parameterName the name of the parameter
      value
     *@throws SQLException if a database  access error      * this method is called on a closed {@code CallableStatemenmethod called ona  @codeCallableStatementjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
     * this method is called on a closed
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
  int getMaxRows()throws SQLException;
      @see#getByte
     * @since 1.4
     */
    void setByte(String * If the limit is exceeded, the excess 

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   * Sets the designated parameter in this {@code RowSet} object's command
      Java{ short}. The   thisto
   * an SQL {@code SMALLINT} value before sending it to  database.
   *
   * @param parameterIndex the first parameter is 1, thesecond  2,..
   * @param x the     @aram  the parameter value
   * @throws SQLException if a database access error     @hrows SQLException 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
voidiparameterIndex)throwsSQLException;

  /**
     *Setsdesignated java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 75
     * The driver converts this
      toan @ }  when  sendsit the database.
     *
     * @param parameterName the name of      
     * @param x the parameter value
     * @throws SQLException if a database     @ SQLException adatabase access error occurs
     * this method is      @hrows    processingforthis {code RowSet}object on or
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see    *thejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 74
     * @since 1.4
     */
    void setShort(String parameterName, short x) throws SQLException;

  **
 {@RowSet s command
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   *
   * @param   *
   * *@java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 73
   *java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 66
   */
  void setInt(int parameterIndex, int x) throws SQLException;

  /**
ameterthegiven Java  {@ode value.
     driver converts this
     * to an SQL {@code INTEGER} value when it sends it to the database   *see#etQueryTimeout
     *
     * @param parameterName the name of the parameter
     * @param x the parameter value
     * @throws SQLException      *
     * this method is called on    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see #getInt
     * @since 1.4
     */
   String   SQLException

  /**
   * */
      java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 68
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *
exthefirst parameter1, the   2 .
   * @param x the parameter value
   * @throws SQLException if a database access error occurs
   */
  void setLong(int parameterIndex, long x) throws SQLException;

  /**
     * Sets the designated parameter to the given Java {@   *{code .error
        *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * to   **
     
     *@  parameterName the name the 
     * @param x the parameter value
 t SQLException if a database access error occurs or
     * this     @throwsSQLException if a database access error occurs
     * -//-----------------------------------------------------------------------java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 66
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      @ee      * @throws SQLFeiftheJDBCdriver does support
        {code }objectscommand.
     */
    void setLong(String parameterName, long x)throws SQLException

  /**
   * Sets the designated parameter in  /**
   * to the given Java {@code float} value. The driver converts this to
   * an SQL {@code REAL} value before sending it to the database.
*
   * @param parameterIndex*@aram thevalue
   * @   * @throw  if database accesserror occurs
   *@ SQLException if a database access error occurs
   */
  void setFloat(int parameterIndex, float x) throws SQLException;

  /**
     * Sets the java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
     * The driver converts this
      toanSQL {code FLOAT}}value  it     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     *
     * @param parameterName the name of the parameter
     * @param x the parameter value
     * @throws SQLException      *this
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if  
     * this method
     * @see #getFloat      @hrows SQLFeatureNotSupportedException if the JDBC driver does not support
     * @since 1.4
     */
    ( parameterNamefloatx)throws SQLException;

  /**
   * Sets theiven {@ double  java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 72
*to  given  @code } .The driver converts this to
    an SQL @code }valuebefore  it  the .
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the parameter value
   * @throws SQLException if a*java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 31
   */
  void setDouble(int parameterIndex, double x) throws   * SQLtype codeand thefully   namewhenspecifying

  /**
     *Setsthedesignated parameter  the  Java {@code double} value.
     * The driver converts this
     * to an SQL {   *the  the type name  parameter itself  Fora{c REF
     *
     
   @aram x value
 or
     * this method is   *to   @odejavamath.BigDecimal} value.
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
*method
* @java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
      @14
     */
    void setDouble(String parameterName, double x) throws SQLException;

  /**
   * *it itto database
   * to the given {@code java.* @param parameterName the name
   * The driver converts this to
  *   @code NUMERIC}value before sending it to the database.
   
   * @param parameterIndexthefirst  , thesecond is2 .java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   
   
   */
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

  /**
     * Sets the designated parameter to the given
     * {@code java.math.BigDecimal} value.
     * The driver converts this to an SQL {@code NUMERIC} value when
     * it sends it to the database.
     *
     * @param parameterName the name *
     * @param x the parameter value
     * @throws SQLException if a database access error occurs or
this method is on  closedc}
     * @throws 
     * this method
     * @see #getBigDecimal
      @1.4
     */
    void setBigDecimal(String parameterName, BigDecimal x) throws SQLException;

/**
   * Sets      whenit  it  database.
*  java.lang.StringIndexOutOfBoundsException: Range [20, 1) out of bounds for length 53
        * it  for - and Refparameters,
   {     * thismethodiscalledon aclosed @codeCallableStatement}
   } valuesjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   *
   * @throws SQLException if a database access        * @param@ parameterNamethe of theparameter
   */
  void setString(int parameterIndex, String x) throws SQLException;

  /**
* @typeName qualified of SQLSQL ;
driver  
     * to an SQL {@code VARCHAR} or {@code LONGVARCHAR}              {REFvalue
     * (depending on the argument's
      * @ java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 82
     * when it sends it to the database.
     *
     * @param parameterName the name of the parameter
     * @param x    * to the given J{cboolean}value.Thedriverconverts this to
     * @throws SQLException if a       sjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 72
     * this method is called on a closed {@code CallableStatement}
* java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
     * this method
     *   *   
     @ince 1.4
     */
    void setString(String parameterName*java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5

  /**
   * Sets the designated parameter    an @ before itdatabase 
   * to  *@  parameter java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     convertsto  {@ } 
   *   java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 74
   * to the  * throwsSQLFeatureNotSupportedExceptionifthe  driverdoessupport
   *
   * @   * an SQL*  @ }to void setBoolean(String parameterName, boolean x) throws
   * @param x the parameter value
    paramthefirstparameter is 1,the second is 2 .java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   */
  void setBytes(int parameterIndex, byte x[]) throws   * an  @ode   sendingittothe .

  /**
     * Sets the designated parameter to the given Java*Sets java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 74
     * The driver converts this to    /
     * {@code LONGVARBINARY} (depending       thebeforeit  ,java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80
     * to the driver's limits on {@code VARBINARY}     paramparameterIndexfirstparameter is 1, the second is 2, ...
     * it to the database.
     *
     * @param parameterName ona java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 66
     * @param xthisto an { TIMESTAMP when   java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
     *     (parameterName x throws ;
     * this    Sets thedesignated parameter inthis{@ode RowSet}objects command
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see #getBytes
     * @since 1.4
     */
    void setBytes(String parameterName, byte x[]) throws SQLException;

  /**
*Sets  designatedparameter in this {   * Sets the designated parameter in this {@code RowSet
   * to the given {@code java.sql.Date} value. The driver converts this to
   * an SQL {@code DATE} value before sending it to the java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 59
   * default   **
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the parameter value
   
   */
. java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

  /**
   * Sets the    the parameter {code  ' 
   * to   voidsetAsciiStreamintparameterIndex .io.x, )
   * an SQL {@code TIME} value before sending it to the database, using      * Sets the designated parameter to the given input stream, which will 
   * default {@code java.util.Calendar} to calculate it.
   *
   @ first 1 the   ,.
   * @param x the parameter value
   * @throws SQLException if a database access error occurs
   */
mex java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 72

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * to the given {@code java.sql.Timestamp} value. The driver converts this to
   * an SQL      @  java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 18
   * default {@code java.util.Calendar}  x)throwsSQLException
   *
*pjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 18
   * @param x the parameter value
   * throws if  access error occurs
   */
  void setTimestamp(int     designated thisjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 74
    throws SQLException;

  /**
*thejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 83
     * The driver
     * converts this to an SQL {@   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * database.
     *
     * @param parameterName the name of the parameter
     * @param      *  {codeBIGINT valuewhen sends to database.
     * @throws SQLException if a database access error occurs or
 { 
     throws   theJDBCdriver not 
    Java  your subclass implements
     @see #
 .
     */
    void setTimestamp(String parameterName, java.sql.Timestamp x)
             setLong( ,long)throwsSQLException

  /**
* thedesignated inthis @RowSet 
   * to the given   void setBinaryStream(int parameterIndex, java.io.InputStream x,
   * It may be more practical to send a very large ASCII value which  
   * {@code * @param x the parameter 
   * parameter. The driver will read the data from the stream
   * asjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *
   * <P><B>java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6
   *     * SQL @java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 70
   * standard interface.
   *
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26
   * @param x the Java input stream that contains      *@aram the of parameter
   * @param length the number of bytes in the stream
tion ifa  access 
   */
  void setAsciiStream(int parameterIndex, java.io.InputStream x, int length)
    throws SQLException;

  /**
     * Sets the designated parameter to the given input       since1 /**
*the java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 37
*a large   is toa{@ LONGVARCHAR
     * parameter, it may be more practical to send it via     may     avery java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 70
*odejavaI}    java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 69
     * as needed until end-of-file is reached.  The JDBC driver will
     * do any necessary conversion from ASCII to thevoidsetDouble(intparameterIndex,double ) java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 64
     *
* <<Note:B     toSQL{DOUBLE}itsendsthejava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
     *@param the value
      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26
     *
     * @param parameterName the name of the parameter
     * @param x the Java input stream    throwsjava.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 59
     * @param length the number of bytes in the stream
*  a   error java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
     * this method is called      setDouble(String parameterName, double x)   /**
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this      * java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 59
     * @since 1.4
     */
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 80
        throws SQLException;

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 object     dojava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 76
   * to the given {@code java.io.InputStream} value.
   * It may be more practical to send a very large binary value via a
   * {@code java.io.InputStream} rather than as a {@code LONGVARBINARY}
   * parameter. The driver will read the data from the stream
* neededuntil   endoffile.
   *
   * <P><B>Note:</B> This stream object can either be a standard
   * Java stream object or your own subclass that implements     *{codejava.math      aparameterName nameof parameter
   * standard interface.
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the java input stream which contains the binary parameter value
   * @param length the      * @param parameterName theof  parameter*containsthe  datausedthe 
   * @throws SQLException if a database access error occurs
   */
ryStreamnt parameterIndexjava..InputStreamjava.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
                       int length) throws SQLException;

/**
     * Sets the designated parameter to the given input      *this 
     * the specified number of bytes.
*a  to/*
       the Java@String}value.int ) ;
     * {@code java.io.InputStream} object. The  /**
     * as needed until end-of-file is reached.
     *
     voidint  x ;
*Javastreamobject or your own subclass that implements the
     * standard rconvertsthis
     
     * @param parameterName the name of the parameter
     * @param x the java input stream which contains the binary parameter value
     * @param length the number of bytes    <>Note:/>streamcanbe 
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @since 1.4
     */
    void setBinaryStream(String parameterName, java.io.InputStream
                         )throws

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * to the given {@code java.io.Reader} value.
   * It may be more java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 6
   * {@code java.io.Reader} rather than as a {@code LONGVARCHAR}
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 61
   * as needed until it reaches end-of-file.
*
   * 
   * Java stream object or your own subclass that implements the
 
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @     * {@code  on  arguments relative
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
   * @param length the number of characters      *  conversion  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 74
   * @throws SQLException if a database access error occurs
   */
  void setCharacterStream(int parameterIndex,
                          Reader reader,
int java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 26

  /**
     * Sets the designated parameter to the given {@code Reader}
     *      *@     * {@code   
     * When a very large UNICODE value is input to a {@code LONGVARCHAR}
     * parameter, it may be more practical to send it via a
     * {@code java.io.Reader} object. The data will be read from the stream
     * as needed until end-of-* paramparameterIndex first parameter is 1 the is2 .
*   UNICODEto database java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 76
     *
*P<BN<B stream caneither  a 
*objectorown that java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 66
     * standard interface.
     *
     * @param parameterName the name of the parameter
     * @param reader the {@code java.io.Reader} object that
     *        contains the UNICODE data used as the designated parameter
     * @param length the number of characters in the stream
     * @throws *<B:</>Consult JDBC determine if
        *@ java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59
     * @throws*
*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 18
     * @since 1.4
     */
    void( parameterName
                            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 64
                            int length   *throws java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 93

*
   * Sets the*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   the  inputstreamjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   * When                        SQLExceptionjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
*maymore to  
   *      the designated parameter to the given input stream.
* -of   to a {@code LONGVARBINARY
    throwsSQLException
   *
   * ><B<B Thisstream object can be a
   * Java stream object or your own subclass that implements the
   * standard interface.
iverdocumentationtodetermine 
   * it might be more efficient to use a version of
   * {@code     *Thedriver
   *
   * @param parameterIndex the first parameter is 1,    * @param parameterIndex the first parameter is 1, theitthe
he stream that contains the ASCII parameter value
   * @throws SQLException if a database access error occurs or
   * this method is called on a closed {@code PreparedStatement}
   * @throws     *@param xtheparameter java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   * @since 1.6
   */
  void setAsciiStream(int parameterIndex*thismethodiscalled aclosed{@CallableStatement
                      throws SQLException;

   /**
     * Sets the designated parameter to the given input stream.
     * When a very large ASCII value is input to a {@code LONGVARCHAR}
     * parameter, it may be more practical to send it via a
     * {@code java.io.InputStream}. Data will be read from     *it might  efficientusea  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
* until end-fileis   or
to the database char format.
     *
     * <P><B>Note:</B> This stream object can either be a standard
     * Java stream java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
     * standard interface.
         Java  object oryour ownsubclassthatimplements java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
     * it might be more efficient to use a version of
*java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 61
     *
     *@param nameof  parameter
     * @param x the Java input stream that contains the ASCII parameter value
     * @  void setAsciiStreamint parameterIndex, java..InputStream x int length)
     * this method is  
     * @    doany  conversionUNICODEthedatabase charformat.
       * @since 1.6
    */
    void setAsciiStream(String parameterName, java.io.InputStream x)
            throws SQLException;

  
   * Sets the designated parameter in    standard      * as needed untilend--ile  reached.The  
   * to the given input stream.
   * When a very large binary value is input to a {@code LONGVARBINARY}
   * parameter, it may be more practical to send it via a
avaI . will
   * stream as needed until end-of-file is reached.

   * <      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 64
   java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 15
   * standard interface.
*P<Note:<>ConsultJDBCto if
  it might  efficient usea  of
   * {@code * Sets the designated parametergiven{codeReader}}
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the java input stream which contains the binary parameter value
   * @throws SQLException if a database access error occurs or
   * this method is called on a closed {@code PreparedStatement}
   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
   * @since 1.6
   */
  void setBinaryStream(int parameterIndex, java.io.InputStream x)
                       throws SQLException*

  /**
     * Sets the designated parameter to the given input stream.
     * When a very large binary value is input to a {@code LONGVARBINARY}
     * parameter, it may be more practical to send it via a
     * {@code java.io.InputStream} object. The data will be read from the
     * stream as needed until end-of-file   *@aram  the java input  which contains thebinary 
     
     * <P><B>Note:</B> This stream object can either be a standard
     * Java stream object or your own subclass that implements the
     * standard interface.
     *    (String parameterName,
     itmight more efficient to use a version of
     * {@code setBinaryStream} which takes a length parameter.
     *
     * @param parameterName the name of the parameter
     * @param x the java input * {@code Reader} reads the data till-of- isreached.
     * @throws SQLException if a database access error occurs or
     *
     * @throws * <P><B>Note:</B> This stream object canbe standard
     * @since 1.6
     */
    void       @parameterName of 
    throws SQLException;

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * to the given {@code Reader}
   *object.
   * When a very large UNICODE value is input to a {@code LONGVARCHAR}
   * parameter* @aram  
   * {@code java.    @  if thedriverdoes not support national
   * as int   ;
   * do any necessary conversion from UNICODE to the database char format.
   *
   * <P><B>Note   *It  bemore practicaltoaveryvalue a
* object or own subclass that  the
   * standard interface.
    to determine if
   * it might be more    * as needed  itreaches end-of-file.
   * {@code setCharacterStream} which takes a length parameter.
   *
   *withthejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 66
   * @param reader the {@code java.io.Reader} object that contains the
    
   * @throws SQLException if a database access error occurs or
      *
** @param reader c java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 75
   since 1java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   */
  void setCharacterStream(int parameterIndex,
javaio.eaderreader)throwsSQLException

/
     *                            
     * object.
     istoa{java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 72
     * parameter, it may be more practical to send it via a
     * {@code java.io.Reader} object. The data will be read from the stream
     * as needed until end-of-file is    * by scaleOrLength. If these conditionstruedriverwill generatea
     * do any necessary conversion from UNICODE to the database char format.
     *
     * <P><B>Note:</B> This stream object can either be   
        object your ownsubclass thatimplements 
     * standard interface.
     * <P><B>Note:</B> Consult your JDBC java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 39
*itjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 53
@ java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 65
     *
     * @param parameterName the name of the parameter
     * @param reader the {@code java.io.Reader} object that contains the
     *        Unicode data
     *@SQLExceptionifa databaseaccess erroroccursjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
      s1
     */
    ,
                          java.io.Reader reader) throws SQLException;

 
   * Sets the designated parameter in this {@code RowSet} object's command
   * to a {@   * or {@code} thejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 69
   * {@code Reader} reads the data till end-of-file is reached. The
    necessary from   java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   * the national character set in the database.

   * <P><B>Note:</B> This stream object can either be a standard
        setCharacterStream(String parameterName,
   * standard interface.
   * <P><B>Note:</B> Consult    *type.
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 51
   * {@code setNCharacterStream} which takes a length parameter.
             java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 71
   * @param parameterIndex of the first parameter is 1, the second is 2, ...
   **of data the or{Reader}   other
   * @throws SQLException if the driver does not support national
   *         character sets;  if the driver can detect that a data conversion
   *  error could occur ; if a database access error occurs; or
   * this method is called on a closed {@code PreparedStatement}
*tifthe  not java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 93
   * @since 1.6
   */
   void setNCharacterStream(int parameterIndex, Reader value) throws    * @param parameterIndex the first parameter is 1, the second is 2, ..



  /**
 command
   * with the given Java {@code Object}.  For integral values, the
   **@ince1
   * an instance of the class {@code Integer} for an {@code int}).void (int,java..InputStream )
   *
   * If the second argument is an {@code InputStream} then the stream must contain
*    specifiedscaleOrLength.If argumentis a
   * {@code Reader} then the {@code Reader} must contain the number of characters specified
   * by scaleOrLength. If these conditions are not true the driver will       doany fromASCIItothe java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 10
   * {@code SQLException} when the prepared statement is executed.
*
   * <p>The given Java object will be converted to the targetSqlType
   * before being sent to the database.
   * <P>
* If objectis  implementing {java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 62
   * therowset should call the method {@code SQLData.writeSQL}
*write java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 6
   * If, on the other hand, the object is of a      *@throwsSQLFeatureNotSupportedException @  
   * {@code Ref}, {@code Blob}, {@code Clob},  {@code NClob},
   Struct}{ode .}
   * or {@code Array}, the driver should pass it to the database as a
   * value of the corresponding SQL type.
   *
   *
   * *or{code  and  support
   * abstract data types.
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
*@   */
*@aram SQL  (defined in @ .}
   *        to be sent to the database. The scale argument may further qualify this
   *        type.
   * @param scaleOrLength for {@code java.sql     aJava @Object}  For ,the
*or {code java.sql..NUMERIC },
   *          this is the number of digits after the decimal point. For
   *          Java Object types {@code InputStream} and {@code Reader},
   *          this is the length
   *          of the data in the stream or {@code Reader}.  For all other types,
   *          this value will be ignored.
 occurs
   * @see java.sql.Types
   */
  void setObject(int parameterIndex, Object x, int targetSqlType, int   *@throwsSQLFeatureNotSupportedException   the JDBC driverdoes not support this method
            throws SQLException;

  /**
     * Sets the value of the designated parameter with the given object. The second
     * argument must be an object type; for integral values, the
     * {@code java.lang} equivalent objects should be used.
     *
     * <p>The given Java object will be converted      * Setsthe   thedesignated parameter with the given object.
     * before being sent to the database.
     *
     * If the object has a custom mapping (is of a class implementing the
     * interface {@code SQLData}),
     * the JDBC driver should call the      * Java stream object or your own subclassjava.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
     * to      *P>B>Note</B>Consult  JDBC  documentation determinejava.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
     * If, on the other hand, the object is of a class implementing
*c }codeBlob @code }  @NClob}java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
*java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 79
     * or {@code Array}, the * {@code DATALINK}, {@code JAVA_OBJECT@NCHAR,
     * value of the corresponding SQL type.
     * <P>
     *      * throws SQLFeatureNotSupportedExceptioniftheJDBC driver does not support this method
     * specific abstract data types.
     *
     * @param java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
     * @param x the object containing the input      *
     * @param targetSqlType the    to given @code }
* sent  database.The  argument further qualify this type.
     * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
     *          this     *{code javalang objects be  forbuiltin
*          types,this valuewill  ignored.
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if {@code targetSqlType} is
     * a {@code ARRAY}, {@code BLOB}, {@code CLOB},
  ,{@odeJAVA_OBJECT}{code ,
     * {@code NCLOB}, {@code NVARCHAR}, {@code LONGNVARCHAR},
     *  {@code REF}, {@code ROWID}, {@code SQLXML}
     * or  {@code STRUCT} data type and the JDBC driver does not support
     * this data  *
     *@seejava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
     * @see #getObject
     * @since 1.4
     */
           
        throws SQLException; @hrowsSQLException ifa access error occursor

  /**
     thedesignated parameter in this {@code RowSet} object's command
   * with a Java {@code Object}.  For integral values, the
   * {@code java.lang} equivalent objects should be used.
   * This method is like   void setCharacterStream(int parameterIndex,
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*valuesthe scalepresent inthe .
   * <P>
   * Even though it is supported, it is not recommended that this method
   * be called with floating point input values.
   *
   * @param      * {@code java.ioReader}object.  from
   * @param x the object       this
   * @param targetSqlType the SQL type (as defined in     *do necessaryconversionfromUNICODE   char
*sentto  
   * @throws SQLException if a database access error occurs
   */
      *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26
                 int targetSqlType) throws java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 4

  /**
     * Sets the value of the designated parameter with the given object.
hodlike method {codesetObject
*above   assumes aof
     *
     * @param parameterName the name of the 
 the java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 63
     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
todatabase
     * @throws SQLException if a database access error occurs or
    method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if {@code java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
     * a   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * {@code DATALINK}, {@code JAVA_OBJECT}, {@code NCHAR},
     * {@code NCLOB}, {@code NVARCHAR}, {@code LONGNVARCHAR},
     *  {@code REF}, {@code ROWID}, {@code SQLXML}
        {STRUCT}datatype  theJDBC driverdoes not support
     * this data type
     * @see #getObject
     * @since 1.4
     */
    void setObject(String parameterName, Object x, int    @hrows 
        throwsSQLException;

   /**
     * Sets the value of the designated parameter with the given objectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * The second parameter must be of type {@code Object}; therefore, the
      used for built-intypes.
     *
     * <p>The JDBC specification specifies a standard mapping from
     * Java {@code Object} types to SQL types.  The given argument
     * will   *@throws SQLFeatureNotSupportedException  if JDBC driver does not support this method
     * sent to the database.
     *
     * <p>Note that this method may be used to pass database-
     *specific data types, by using a driver-specific Java
     * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
     *
     * If the object is of a class implementing the interface {@code SQLData},
     * the JDBC driver should call the method {@code SQLData.writeSQL}
     * to write it to the SQL data stream.
    If,     cjava. equivalent objects should be used fexample
     * {@code Ref}, {@code Blob}, {@code Clob},  {@code NClob},
     *  {@* to the {@code BLOB} value that the {@code Blob} object
      itto database  a
     *
     * <P>
     * This method throws an exception if there is an ambiguity, for example, if    the number  bytesspecified a BLOB
      object  ofaclass implementing more than one of the interfaces named above.
     *
     * @param parameterName the name of the parameter
     * @param x the object containing the input parameter value
     * @throws SQLException if a database access error occurs,
      this  is called on a closed @CallableStatement} or if the given
     *            {@code Object} parameter is ambiguous
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see #getObject
     * @since 1.4
     */
    oid( java.lang.StringIndexOutOfBoundsException: Range [83, 35) out of bounds for length 83

  /**
   * sent    *If on the other hand, the object is of a class implementing
   * with a Java {@code Object}.  For integral values, the
   * {@code java.lang} equivalent objects should be used    or {@odeArray} the should pass it the database as a
   *
   * <p>The JDBC specification provides a standard mapping from
   <>Note that this method may be used to pass database-specific
   * given Java object to its standard SQL mapping before sending it
   * to the database.
   *
   * <p>Note that this method may be used to pass database-specific
   * abstract data types by using a driver-specific Java type.
   *
   * If the object is of a class implementing {@code SQLData},
   * the rowset should call the method {@code SQLData.writeSQL}
   * to write the object to an {@code SQLOutput} data stream.
   * If, on the other hand, the object is of a class implementing
   * {@code Ref}, {@code Blob}, {@code Clob},  {@code NClob},
   *  {@code Struct}, {@code java.net.URL},
   * or {@code Array}, the driver should pass it to the database as a
   * value of the corresponding SQL type.
   *
   * <P>
   *     */
   * object is of a class implementing more than one of these interfaces.
   *
   * @param parameterIndex The first parameter is 1, the second is 2, ...
   * @param x The object containing the input parameter value
   * @throws SQLException if a database access error occurs
   */
  void setObject(int parameterIndex, Object x) throws    */


  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * with the given  {@code Ref} value.  The driver will convert this
   * to the appropriate {@code REF(<structured-type>)} value.
   *
   **@aram i the first parameter is 1, the second is 2, ...
   * @param x an object representing data of an SQL {@code REF  @java.lang} equivalent objects should be usedjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   *@throws SQLException if a database access error occurs
   */
  void setRef (int i, Ref x) throws SQLException;

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
* the driver   the  {codeSQLData.  write 
   * to the {@code BLOB} value that the {@code Blob} object
   * represents before sending it to the database.
   *
   * @param i the first parameter is 1, the second is 2, ...
    px object representing a BLOB
   * @throws SQLException if a database access error occurs
   */
  void setBlob (int i, Blob x) throws SQLException;

  /**
      Sets java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 69
     * Therows SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     * of characters specified by length otherwise a {@code SQLException} will be
     * generated when the {@code PreparedStatement} is executed.
     * This method differs from the {@code setBinaryStream (int, InputStream, int)}
     * method because it informs the driver that the parameter value should be
     * sent to the server as a {@code BLOB}.  When the {@code setBinaryStream} method is used,
     * the driver may have to do extra work to determine whether the parameter
     * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB}
     * @param parameterIndex index of      *of characters specified by length, otherwise a {@code SQLException} will be
     * the second is 2, ...
     * @param inputStream An object that contains the data to set the parameter
       tojava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
     *@param length the number of bytes in the parameter data.
     * @throws SQLException if a database access error occurs,
     * this method is called on a closed {@code PreparedStatement},
     * if parameterIndex does not correspond
     * to a parameter marker in the  * {code DATALINK}, {@code JAVA_OBJECT}, {@code NCHAR},
     * is less than zero or if the number of bytes in the {@code InputStream} does not match
     the specified 
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     *
     * @since 1.6
     */
     void setBlob(int parameterIndex, InputStream inputStream, long length)
        throws SQLException;

  /**
     * Sets the designated parameter to a {@code InputStream} object.
     * This method differs from the {@code setBinaryStream (int, InputStream)}
     * method because it informs the driver that the parameter value should be
     * sent to the server as a {@code BLOB}.  When the {@code setBinaryStream} method is used,
     * the driver may have to do extra work to determine whether the parameter
     * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB}
     *
     * <P><B>Note:</B> Consult your JDBC driver documentation      *thespecified length; if a database access error occurs or
     * it might be more efficient to use a version of
     * {@code setBlob} which takes a length parameter.
     *
    values have the scale present in the literal.
     * the second is 2, ...
     *   *<>
     * value to.
     * @throws SQLException if    * Even though it is supported  notrecommended that method
     * this method is called on a closed {@code PreparedStatement} or
     * if parameterIndex does not correspond
      to aparameter inthe statement{code .l .
     river does not thismethod
     *
        * @targetSqlType  SQL *sendsit  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 32
     */
     void setBlob(int parameterIndex, InputStream inputStream)
        throws SQLException;

  /**
     * Sets the designated parameter to  void setObject(nt parameterIndex,Object xjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
     * The {@code InputStream} must contain  the number
     * of characters specified by length, otherwise a {@code SQLException} will be
     * generated when the {@code CallableStatement} is executed.
     * This method differs from the {@code setBinaryStream (int, InputStream, int)}
      parameter value should be
     * sent to the server as a {@code BLOB}.  When the {@code setBinaryStream} method is used,
     thejava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 78
     * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB}
     *
     * @param parameterName the name of the parameter to be set
     * the second is 2, ...
     * the driver may have to extrawork to java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 78
     paraminputStream Anobject that contains the data to set the parameter
     * value to.
     * @param length the number of bytes in the parameter data.
     * @throws SQLException  if parameterIndex does not correspond
      to aparameter in  SQLstatement,  or  thelength 
     * is less than zero; if the number of bytes in the {@code InputStream} does not match
     * the * {@code setBlob which takes a length parameter.
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     *
     * @since 1.6
     */
     void setBlob(String parameterName, InputStream inputStream, long length)
        throws SQLException;

  /**
     * Sets the designated parameter to the given {@code java.sql.Blob} object.
     * The driver converts this to an SQL {@code BLOB} value when it
     * sends it to the database.
     *
      @aram parameterName the name of the parameter
     * @param x a {@code Blob} object that maps an SQL {@code BLOB} value
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * java.lang.StringIndexOutOfBoundsException: Range [16, 11) out of bounds for length 42
     * @since 1.6
     */
    void setBlob*param i the first ,..

  /**
     * Sets the designated parameter to a {@code InputStream} object.
     * This method differs from the {@code setBinaryStream (int, InputStream)}
      value should 
     * sent to the server as a {@code BLOB}.  When the {@code setBinaryStream} method is used,
     * the driver may have      * generated when the {@code generated the {codePreparedStatement  executed.
     * data should be send to the server as a {@code LONGVARBINARY} or a {@code BLOB}
     *
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
     * it might be more efficient to use a version of
     * {@code setBlob} which takes a length parameter.
     
     * @param parameterName the name of the parameter
 the  to  the 
     *value 
     *tjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 64
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     *
     * @since 1.6
     */
     void setBlob(String parameterName, InputStream inputStream)
      aclosed @PreparedStatement, if parameterIndex doesnotcorrespond to parameter

  /**
   * Sets the designated parameter in this {@code RowSet} object's command
   * with the given  {@code Clob} value.  The driver will convert this
   * to the {@code CLOB} value that the {@code Clob} object
   * represents before sending it to the database.
   
   * @aram i first parameter is , the   ,..
   * @param x an object representing a CLOB
   * @throws SQLException if a database access error occurs
   */
  void setClob (int i, Clob x) throws SQLException;

  /**
     * Sets the designated parameter to a {@code Reader} object.
     * The {@code Reader} must contain  the number
     * of characters* An is java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 73
      whenthe  @code        besent thejava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 83
    This  differsfrom the @setCharacterStream (int, Reader, int)} method
     * because it*
       @ode CLOB}   the{csetCharacterStream is , the
     * driver may have to do extra work to determine whether the parameter
 to the as {code LONGVARCHAR}r  @CLOB}
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
     * @param reader An object that contains the data to set the parameter value to.
     * @param     
     * @throws SQLException if a * @throws SQLFeatureNotSupportedExceptionif the JDBC driver does supportthis 
     * a closed {@code PreparedStatement}, if parameterIndex does not correspond to a parameter
   
     
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     * @since 1.6
     */
     void setClob(int parameterIndex, Reader reader, long length   *@throwsSQLExceptionifadatabase access error 
       throws SQLException;

  /**
     * Sets the designated parameter to a {@code Reader} object.
     * This method differs from the {@code setCharacterStream (int, Reader)} method
     * because it informs the driver that the parameter value should be sent to
     * the server as a {@code CLOB}.  When the {@code setCharacterStream} method is used, the
    mayhave to do extra work to whetherthe 
     * data should be sent to the server as a {@code LONGVARCHAR} or a {@code CLOB}
     *
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
     * it might be more efficient to use a version of
     * {@code setClob} which takes a length parameter.
     *this methodis on  closed{code }
*@index   parameter is 1, the second is 2, ...
     * @param reader An object that contains the data to set the parameter value to.
     * @throws SQLException if a database access error occurs, this method is called on
     * a closed {@code PreparedStatement}or if parameterIndex does not correspond to a parameter
     * marker in the SQL statement
     *
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     * @since 1.6
     */
     void setClob(int parameterIndex, Reader reader)
       throws SQLException;

  /**
     * Sets the designated parameter to a {@code Reader}      *
     * {@code java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 16
     @hrows SQLExceptionif databaseaccess error occurs java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
     * generated when the on a closed @code PreparedStatement},
     * This method differs from the {@code setCharacterStream (int, Reader, int)} method
*because itinforms the driver thatthe value shouldbesent java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
     * the server as a {@code CLOB}.  When the {@code setCharacterStream} method is used, the
     * driver may have to do extra work to determine whether the parameter
     * data should be send to the server as a {@code LONGVARCHAR} or a {@code CLOB}
      java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
     * @param reader An object that contains the data to set the parameter value to.
     * @param length the number {java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 78
     * @throws SQLException if parameterIndex does not correspond to a parameter
     * marker in the SQL statement; if the length specified is less than zero;
     * a database access error occurs or
     * this*data be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB}
     throws *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 53
     * this method
     *
     * @since 1.6
     */
     void setClob(String java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 6
       throws SQLException;

   /**
     * Sets the designated parameter to the given {@code java * value to.
      driver this an {cCLOB}value when it
     * sends it to the database.

     * @param parameterName the name of the parameter
     that maps an SQL {@code CLOB} value
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code  /**
     * throws SQLFeatureNotSupportedException if  driver does not support
     * this method
     * @since 1.6
     */
    void setClob (String parameterName, Clob x) throws SQLException;

  /**
     * Sets the designated parameter to a {@code Reader} object.
     * This method differs from the {@code setCharacterStream (int, Reader)} method
     * because it informs the driver that the parameter value should be sent to
     * the server as a {@code CLOB}.  When the {@code setCharacterStream *when {@codeCallableStatement}
     * driver may have to do extra work to determine whether the parameter
     * data should be send to the server as a {@  
     *
     * <P<>ote:/>  JDBC documentation theparameter
     *it bemore efficient to  a version of
     * {@code setClob} which takes a length parameter.
     *
     * @param parameterName the name of the parameter
     * @param reader An object that contains the data to set the parameter value to.
     * @throws SQLException if a database access error occurs or*@aram inputStreamAnobject containsthe to  
     * a closed {@code CallableStatement}
     *
     * @void setDateint parameterIndex, javasDx  )
     * @since 1.6
     */
     void setClob(String parameterName, Reader reader)
       throws SQLException;

  /**
   * Sets the designated parameter in this       @hrowsSQLFeatureNotSupportedException application
*method
   * to the      *
   * represents before sending it to the database.
   *
   * @param i the first parameter is 1, the second is 2, ...
   * @param x an object representing an SQL array
   * @throws SQLException if a database access error occurs
   */
  void setArray (int i, Array x) throws SQLException;

/**
   * Sets the designated parameter in this {@code RowSet} object's command
   * with the given  {@code java.sql.Date} value.  The driver*@ince 14
   * to an SQL {@code DATE}      */
   * object to calculate the date.
   *
        SQLException;
   * @param x the parameter value
   * @param cal the {@code java.util.Calendar} object to use for calculating the date
*throwsif   error occurs
   */
  void setDate(int parameterIndex, java.sql.Date x, Calendar cal)
    throws SQLException;

  /**
     * Sets the designated parameter to the given {@code java.sql.Date} value
     * using the default time zone of the virtual machine that is running
     * the      * This methoddiffers from {csetBinaryStreamthe date
     * The driver converts this
     * to an SQL {@code DATE} value when it sends it to the database.
     *
     * @param parameterName the name of the parameter
     * @param x the parameter value
     * @throws SQLException if a database access error      *
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
      this method
     * @see #getDate
     * @since 1.4
     *java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
tDate(tring parameterName,java.Date x)
        throws SQLException;

  /**
 tothe {code java.sql.Date} value,
     * using the given     *
      the {@ode } object to construct an SQL {@ode }value,*throwsSQLFeatureNotSupportedExceptionthe driverdoes not thismethod
     * which the driver then sends to the database.  With a
     * a {@code Calendar} object, the driver can calculate the date
     * taking into account a custom timezone.  If no
     * {@code Calendar} object is specified, the driver uses the default
     * timezone, which is that of the virtual machine running the application.
     *
     * @param parameterName the name of the parameter
     *@aram x the parameter value
     * @param cal the {@code Calendar} object the driver will use
     *            to construct the date
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
     *   *@param xthe parameter value
     * this method
     * @see #getDate
     * @since 1.4
     */
    setDate(tring parameterName,java.Date , Calendar cal
              Sets the designated parameter to a {code }object.

  **
   * Sets the designated parameter in this {       characters  throws java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
*with  given  {@code java.sql.Time} value.The  will convert this
   * to an SQL {@code TIME} value, using the given {@code java.util.Calendar}
   * object to calculate it, before sending it to the database.
        *data be to   {code LONGVARCHAR}a @ CLOB}
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the parameter value
   * @param cal the {@code java.util.Calendar} object to use for calculating the time
    error occurs
   */
  void( parameterIndex javasql.ime,Calendar cal)
    throws SQLException;

  /**
     * Sets the designated parameter to the given {@code java.sql.Time} value.
     * The driver converts this
     * to an SQL {@code TIME} value      /
     *
     * @param parameterName the name of the parameter
     * @param x the parameter value
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     *this 
     * @see #getTime
     * @since 1.4
     */
    void setTime(String parameterName, java.sql.Time x)
        throws SQLException;

  /**
     * Sets the designated parameter to the given {@code java.sql.Time} value,
     * using the given {@code Calendar} object.  The driver uses
L{cTIME}value
     * which the driver then sends to the database.  With a
     * a {@code Calendar} object, the driver can calculate the time
     * taking into account a custom timezone.  If no
     * {@code Calendar} object is specified, the driver uses the default
     timezone,which is that the  machine running application.
     *
     * @param parameterName      * @throws SQLException if ajava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 64
     * @param x the parameter value
     * @param cal the {@code Calendar} object the driver will use
     to the 
     * @throws SQLException if a database       marker in the SQL statement
     * this method is called on a closed { /
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see #getTime
      s .java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     */
    void setTime(String parameterName, java.sql.Time x, Calendar cal)
        throws SQLException;

  /**
    Setsthe designated parameter in this {code RowSet}objectscommand
   * the   {code java.sql.imestamp} value.  Thedriver 
   * convert this to an SQL {@code TIMESTAMP} value, using the given
   * {@code java.util.Calendar} java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 14
   *    * @param pjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 73
   *
   * @param parameterIndex the first parameter is 1, the second is 2, ...
   * @param x the parameter value
*@cal {code .til.} object to  for calculating the
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 21
*@hrows if  database access error occurs
   */
  void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal)
    throws SQLException;

  /**
     to  given {@codejava..Timestamp}value
     * using the given {     *usingthe {c   The driver uses
     * the {@code Calendar} object to construct an SQL {@code TIMESTAMP} value,
     * which the driver then sends to the database.  With a
Calendar} object, the driver can calculate the timestamp
     * taking into account a custom java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 40
     * {@code Calendar} object is specified, the driver uses the default
     * timezone, which is that of the virtual machine running the application.
     *
     * @param parameterName java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 6
     * @param x     *
      {code Calendar} object the driver will use
     *            to construct the timestamp
     
     * this method is called on a closed {@code CallableStatement}
     * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see #getTimestamp
     *@since 1.4
     */
    void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
        throws SQLException;

  /**
   * Clears the parameters set for 
   * <P>In general, parameter* @14
   * {@code RowSet} object. Setting a parameter value automatically voidsetClob (parameterName,Clob )throws ;
   * previous value.  However, in some cases it is useful to immediately
   * release the resources used by the current parameter values, which can
   * be done by calling the method {@code clearParameters}.
   *
   * @throws SQLException if a database access error occurs
   */
  void clearParameters() throws SQLException;

  //---------------------------------------------------------------------
  // Reading and writing data
  -------------------

  /**
   * Fills this {@code RowSet} object with data.
   * <P>
   * The {@code execute} method may use the following properties
   * to create a connection for reading data:       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   * user name, password,      
   *
   * The {@code execute} method  may use the following properties
   *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 48
*,read only fieldsize,
   * maximum rows, escape processing, and query timeout.
   * <P>
   * If the required properties have java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   * thrown.  If this method is successful, the current contents of the     Fills6
   * discarded and the rowset's metadata is also (re)set.  If there are
   * outstanding updates, they are ignored.
   *        SQLException;
   * If this {@code RowSet} object does not maintain a continuous connection
   * with its source of data, it may use a {@code Reader} (a {@code RowSetReader}
   * object) to fill itself with data.  In this case, a {@code Reader} will have been
    {code  ,andthe 
  the{code' @ode }
   * method as part of its implementation.
   *
    tifadatabase access error occurs or any of the
   *         properties necessary for making a connection and creating
   *         a statement have not been set
   */
  void     thrown  this methodis successful,current contents of are

  //--------------------------------------------------------------------   *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 71
  // Events
  //--------------------------------------------------------------------

  /**
   *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 71
*that java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 46
   *
   * @param listener a component that has implemented the {@code RowSetListener}
*        benotifiedwhen eventsoccur on this
   *        {@code RowSet} object
   * @see #removeRowSetListener
   */
  void addRowSetListener(RowSetListener listener);

  /**
   * Removes the specified listener from the list of components that will be
   * notified when an event occurs on this {@code RowSet} object.
   *
   * @param listener a component that has been registered as a listener for this
   *        {@code RowSet} object
   * @see #addRowSetListener
   */
  void removeRowSetListener(RowSetListener listener);

    /**
      * Sets the designated parameter to the given {@code java.sql.SQLXML} object. The driver converts this to an
      * SQL {@code XML} value when it sends it to the database.
      * @param parameterIndex index of the first parameter is 1, the java.lang.StringIndexOutOfBoundsException: Range [0, 75) out of bounds for length 0
      * @param xmlObject a {@code SQLXML} object that maps an SQL {@code XML} value
      * @throws SQLException if a database access error occurs, this method
      *  is called on a closed result set,
      * the {@code java.xml.transform.Result},
      *his method
      * for the {      see getDate
      *  if there is an error processing the XML value.  The {@code getCause} method
      *  of the exception may provide a more detailed exception, for example, if the
  .
      * @since 1.6
      */
     void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException;

    /**
     * Sets the designated parameter to the given {@code java.sql.SQLXML} object. The driver converts this to an
     * {@code SQL XML} value when it sends it to the database.
     * @param parameterName the name of the parameter
     * @param xmlObject a {@code SQLXML} object that maps an {@code SQL XML} value
     * @throws SQLException if a database access error occurs, this method
     *  is called on a closed result set,
     * the {@code java.xml.transform.Result},
     *  {@code Writer} or {@code OutputStream} has not been closed
     * for the {@code SQLXML} object  or
     *  if there is an error processing the XML value.  The {@code getCause} method
     *  of the exception may provide a more detailed exception, for example, if the
     *  stream       * @param parameterIndex index  thefirst parameter is , secondis2 .
*@since 1.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     */
    void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException;

    /**
     * Sets the designated parameter to the given {@code java.sql.RowId} object. The
     * driver converts this to a     * see getDate
     * to the database
     *
             voidSjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 69
     * @param x the parameter value
     * @throws SQLException if a database access java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 43
     *
     * @since 1.6
     */
    void setRowIdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /**
    * Sets the designated parameter to the given {@code java.sql.RowId} object. The
    * driver converts this , before  sending it to the database.
    * database.
*
    * @aram parameterName the name of the parameter
    * @param x the parameter value
 *@throws java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 60
    * @since 1.6
    */
   void      *@hrows SQLExceptionif a access error occurs,this 

      void setTime(int parameterIndex, java.sql.Time x, Calendar cal) setTime(nt parameterIndex, java.sql.Time x, Calendar cal)
     * Sets the designated parameter to the given {@code String} object.
     * The driver converts this to a SQL {@code NCHAR} or
     * {@code NVARCHAR} or {@code LONGNVARCHAR} value
     * (depending on the argument's
     * size relative to the driver's limits on {@code NVARCHAR} values)
sends to 
     *
      @aram parameterIndex of the first parameter is 1, the second is 2, ...
     * @param value the parameter value
     * @throws * @param x the parameter value
     *         java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     *  error could occur ; or if a database access error occurs
     * @since 1.6
     */
     void setNString(int parameterIndex, String value) throws SQLException;

    **
     * Sets the designated parameter to the given {@code String} object.
*Thedriver converts this java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 7
     *@ }  @LONGNVARCHAR}
     * @param parameterName the name of the column to be set
     * @param value the parameter value
     * @throws SQLException if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
     *  error could occur; or if a database access error occurs
     * @since 1.6
     */
    public void setNString(String parameterName, String value)
            throws SQLException;

    /**
     * Sets the designated      * a {@code Calendar} object,the driver  can calculate the time
*@ode  the  till end-of-file is . The
     * driver does the necessary conversion from Java character format to
      thenational character set in the database.
     * @param parameterIndex of the first parameter is 1, the second is 2, ...
     * @param value the parameter value
     * @param length the number of characters in the parameter data.
     * @throws SQLException if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
      database access error occurs
     * @since 1.6
     */
     void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException;

    /**
     * Sets the designated parameter to a {@code Reader} object. The
     * {@code Reader} reads the data till end-of-file is reached. The
     * driver does the necessary conversion from Java character format to
     * the national character set in the database.
     * @param parameterName the name of the     * s1.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
*pjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 39
     * @param length the number of characters in the parameter data.
     * @throws SQLException if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
     *  error could occur; or if a database access error occurs
     * @since 1.6
     */
    public void setNCharacterStream(String parameterName, Reader value, long length)
            throws SQLException;

    /**
     * Sets the designated parameter to a {@code Reader} object. The
     * {@code Reader} reads the data till end-of-file is reached. The
     *  *
     * the national character set in the database.

     * <P><B>Note:</B> This stream object can either be a standard
     * Java stream object or your own subclass that implements the
     * standard interface.
      determine if
*mightefficientto a version java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
     * {@code setNCharacterStream} which takes a length parameter.
     *
     * @param parameterName the name of the parameter
     * @param value the parameter value
     * @throws SQLException if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
     *  error could occur ; if a database access error occurs; or
     * this method is called on a closed {@code CallableStatement}
      @  if JDBC*@ince1.
     * @since 1.6
     */
     void setNCharacterStream(String parameterName, Reader value) throws SQLException;

    /**
    * Sets the designated parameter to a {@code java      Sets designated   aa @Reader}object.The
    * implements the {@code java.sql.NClob} interface. This {@code NClob}
    * object maps to a SQL {@code NCLOB}.
     the name the java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
*@aram  parameter value
    * @throws SQLException if the driver does not support national
    *         character sets;  if the driver can detect that a data conversion
    *  error could occur; or *            to construct the
    * @since 1.6
    */
void(  value SQLExceptionjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

    /**
     * Sets the designated parameter to a {@code Reader} object.
     * The {@code Reader} must contain  the number
     * of characters specified by length otherwise a {@code SQLException} will be
        the @code CallableStatement}is executed.
     * This method differs from the {@code setCharacterStream (int, Reader, int)} method
     * because it informs the driver that the parameter value should be sent to
*the server as a {@ NCLOB}.  When the @setCharacterStream}method   
     * driver may have to do extra work to determine whether the parameter
*data should sendto the as  @LONGNVARCHAR}ora @ NCLOB}
     *
 thenameof   to    previous Hin cases  isuseful
     paramreader  objectthat contains data toset parameter  .
     * @param length the number of characters in the parameter data.
     * @throws SQLException if parameterIndex does not correspond to a parameter
     * marker in the SQL statement; if the     @throws  if a database erroroccurs
     * if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
     *  error could occur; if a database access error occurs or
     * this method is called on a closed {@code CallableStatement}
      tSQLFeatureNotSupportedException 
     * this method
     * @since 1.6
     */
     StringparameterName Readerreader,lengthjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
       throws SQLException;

    /**
     * Sets the designated parameter to a {@code Reader} object.
     * This method differs from the {@code setCharacterStream (int, Reader)} method
     * because it informs the driver that the parameter value should be sent to
     * the server as a {@code NCLOB}.  When the {@code setCharacterStream} method is used, the
     * driver may have to do extra work to determine whether the parameter
     * data should be send to the server as a {@code LONGNVARCHAR} or a {@code NCLOB}
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
     * it might be more efficient to use a version of
     * {@code setNClob} which takes a length parameter.
     *
     * @param parameterName the name of the parameter
     * @param reader An object that contains the data to set the parameter     *         character sets; the  can*<P
     * @throws SQLException if the driver does not support national character sets;
        driver   *this is calledon closed@ode }
     *  occur;  aa access occurs 
     methodis  ona  @CallableStatementjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     *
     * @since 1.6
     */
voidString parameterName, readerjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
       throws   *@hrows ifa database accesserror occurs or   the

    /**
     * Sets the designated parameter to a {@code Reader} object.
     * The {@code Reader} must contain  the number
     * of characters specified by length otherwise a {@code SQLException} will be
     * generated when the {@code PreparedStatement} is executed.
     * This method differs from the {@code setCharacterStream (int, Reader, int)} method
     * because it informs the driver that the parameter value should be sent to/**
     * the server as a {@java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 6
     * driver may have to do extra work to determine whether the parameter
     * data should be sent to the server as a {@code LONGNVARCHAR} or a {@code NCLOB}
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
     * @param reader An object that contains the data to set the parameter value to.
     * @param length the number of characters in the parameter data.
     * @throws SQLException if parameterIndex does not correspond to a parameter
     * marker in the SQL statement; if the length specified is less than zero;
     * if the driver      because informs driver the parameter value be  java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
     * if the driver can detect that a data conversion
*error occur; if  database  error  or
     * this method is called on a closed {@code PreparedStatement}
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     *
     * @since 1.6
     */
     void setNClob(int parameterIndex, Reader reader, long length)
       throws SQLException;

    
*Setsthe parameter a{code .N  driverconverts this to a
     * SQL {@code NCLOB} value when it sends it to the database.
     * @param parameterIndex of the first parameter is 1, the second is 2, ...
     * @param value the parameter value
     @hrows SQLException if the driver does not support national
     *         character sets;  if the driver can detect that a data conversion
     *  error could occur ; or if a database access error occurs
     @ince 1.6
     */
     void setNClob(int parameterIndex, NClob value) throws SQLException;

    /**
     * Sets the designated parameter to a {@code Reader} object.
      This  differs fromthe{@ode setCharacterStream (int, Reader)} method
     * because it informs the driver that the parameter value should be sent to
     * the server as a {@code NCLOB}.  When the {@code setCharacterStream} method is used, the
     *     void setSQLXML(nt java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 7
     * data should be sent to the server as a {@code LONGNVARCHAR} or java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 0
*<<>Note<B  your JDBC  documentation to determine if
     * it might be more efficient to use a version of
     * {@code setNClob} which takes a length parameter.
     *
     * @param      *@param parameterName the nameof  parameter java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 94
     * @param reader An object that contains the data to set the parameter value to.
     * @throws SQLException if parameterIndex does not correspond to a parameter
     * marker in the SQL statement;
     * if the driver does not support national character sets;
     * if the driver can detect that a data conversion
     *  error could occur;  if a database access error occurs or
     * this method is called on a closed {@code PreparedStatement}
      throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
     *
     * @since 1.6
     */
     void setNClob*stream does notcontainvalid XML.
       throws SQLException;

    /**
     * Sets     * if the */
     *    voidsetSQLXMLString parameterName, SQLXML xmlObject) throws SQLException;
     * when it sends it to the database.
     *
     * @param parameterIndex the first parameter is 1, the second is 2, ...
     * @param x the {@code java.net.URL} object to be set
     * @throws SQLException if a database access error occurs or
     * this method is called on a closed {@code PreparedStatement}
     * @throws SQLFeatureNotSupportedException  if the JDBC driver           setNClob(String , Reader )
     * @since 1.4
     */
    void setURL(int parameterIndex, java.net.URL x) throws java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 7



}