1 /*
   2  * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javax.sql.rowset;
  27 
  28 import java.sql.*;
  29 import javax.sql.*;
  30 import java.util.*;
  31 import java.io.*;
  32 import java.math.*;
  33 import java.io.Serializable;
  34 
  35 import javax.sql.rowset.serial.*;
  36 
  37 /**
  38  * An abstract class providing a <code>RowSet</code> object with its basic functionality.
  39  * The basic functions include having properties and sending event notifications,
  40  * which all JavaBeans&trade; components must implement.
  41  *
  42  * <h3>1.0 Overview</h3>
  43  * The <code>BaseRowSet</code> class provides the core functionality
  44  * for all <code>RowSet</code> implementations,
  45  * and all standard implementations <b>may</b> use this class in combination with
  46  * one or more <code>RowSet</code> interfaces in order to provide a standard
  47  * vendor-specific implementation.  To clarify, all implementations must implement
  48  * at least one of the <code>RowSet</code> interfaces (<code>JdbcRowSet</code>,
  49  * <code>CachedRowSet</code>, <code>JoinRowSet</code>, <code>FilteredRowSet</code>,
  50  * or <code>WebRowSet</code>). This means that any implementation that extends
  51  * the <code>BaseRowSet</code> class must also implement one of the <code>RowSet</code>
  52  * interfaces.
  53  * <p>
  54  * The <code>BaseRowSet</code> class provides the following:
  55  *
  56  * <UL>
  57  * <LI><b>Properties</b>
  58  *     <ul>
  59  *     <li>Fields for storing current properties
  60  *     <li>Methods for getting and setting properties
  61  *     </ul>
  62  *
  63  * <LI><b>Event notification</b>
  64  *
  65  * <LI><b>A complete set of setter methods</b> for setting the parameters in a
  66  *      <code>RowSet</code> object's command
  67  *
  68  * <LI> <b>Streams</b>
  69  *  <ul>
  70  *  <li>Fields for storing stream instances
  71  *  <li>Constants for indicating the type of a stream
  72  *  </ul>
  73  * </UL>
  74  *
  75  * <h3>2.0 Setting Properties</h3>
  76  * All rowsets maintain a set of properties, which will usually be set using
  77  * a tool.  The number and kinds of properties a rowset has will vary,
  78  * depending on what the <code>RowSet</code> implementation does and how it gets
  79  * its data.  For example,
  80  * rowsets that get their data from a <code>ResultSet</code> object need to
  81  * set the properties that are required for making a database connection.
  82  * If a <code>RowSet</code> object uses the <code>DriverManager</code> facility to make a
  83  * connection, it needs to set a property for the JDBC URL that identifies the
  84  * appropriate driver, and it needs to set the properties that give the
  85  * user name and password.
  86  * If, on the other hand, the rowset uses a <code>DataSource</code> object
  87  * to make the connection, which is the preferred method, it does not need to
  88  * set the property for the JDBC URL.  Instead, it needs to set the property
  89  * for the logical name of the data source along with the properties for
  90  * the user name and password.
  91  * <P>
  92  * NOTE:  In order to use a <code>DataSource</code> object for making a
  93  * connection, the <code>DataSource</code> object must have been registered
  94  * with a naming service that uses the Java Naming and Directory
  95  * Interface&trade; (JNDI) API.  This registration
  96  * is usually done by a person acting in the capacity of a system administrator.
  97  *
  98  * <h3>3.0 Setting the Command and Its Parameters</h3>
  99  * When a rowset gets its data from a relational database, it executes a command (a query)
 100  * that produces a <code>ResultSet</code> object.  This query is the command that is set
 101  * for the <code>RowSet</code> object's command property.  The rowset populates itself with data by reading the
 102  * data from the <code>ResultSet</code> object into itself. If the query
 103  * contains placeholders for values to be set, the <code>BaseRowSet</code> setter methods
 104  * are used to set these values. All setter methods allow these values to be set
 105  * to <code>null</code> if required.
 106  * <P>
 107  * The following code fragment illustrates how the
 108  * <code>CachedRowSet</code>&trade;
 109  * object <code>crs</code> might have its command property set.  Note that if a
 110  * tool is used to set properties, this is the code that the tool would use.
 111  * <PRE>{@code
 112  *    crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
 113  *                   "WHERE CREDIT_LIMIT > ? AND REGION = ?");
 114  * }</PRE>
 115  * <P>
 116  * In this example, the values for <code>CREDIT_LIMIT</code> and
 117  * <code>REGION</code> are placeholder parameters, which are indicated with a
 118  * question mark (?).  The first question mark is placeholder parameter number
 119  * <code>1</code>, the second question mark is placeholder parameter number
 120  * <code>2</code>, and so on.  Any placeholder parameters must be set with
 121  * values before the query can be executed. To set these
 122  * placeholder parameters, the <code>BaseRowSet</code> class provides a set of setter
 123  * methods, similar to those provided by the <code>PreparedStatement</code>
 124  * interface, for setting values of each data type.  A <code>RowSet</code> object stores the
 125  * parameter values internally, and its <code>execute</code> method uses them internally
 126  * to set values for the placeholder parameters
 127  * before it sends the command to the DBMS to be executed.
 128  * <P>
 129  * The following code fragment demonstrates
 130  * setting the two parameters in the query from the previous example.
 131  * <PRE>{@code
 132  *    crs.setInt(1, 5000);
 133  *    crs.setString(2, "West");
 134  * }</PRE>
 135  * If the <code>execute</code> method is called at this point, the query
 136  * sent to the DBMS will be:
 137  * <PRE>{@code
 138  *    "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
 139  *                   "WHERE CREDIT_LIMIT > 5000 AND REGION = 'West'"
 140  * }</PRE>
 141  * NOTE: Setting <code>Array</code>, <code>Clob</code>, <code>Blob</code> and
 142  * <code>Ref</code> objects as a command parameter, stores these values as
 143  * <code>SerialArray</code>, <code>SerialClob</code>, <code>SerialBlob</code>
 144  * and <code>SerialRef</code> objects respectively.
 145  *
 146  * <h3>4.0 Handling of Parameters Behind the Scenes</h3>
 147  *
 148  * NOTE: The <code>BaseRowSet</code> class provides two kinds of setter methods,
 149  * those that set properties and those that set placeholder parameters. The setter
 150  * methods discussed in this section are those that set placeholder parameters.
 151  * <P>
 152  * The placeholder parameters set with the <code>BaseRowSet</code> setter methods
 153  * are stored as objects in an internal <code>Hashtable</code> object.
 154  * Primitives are stored as their <code>Object</code> type. For example, <code>byte</code>
 155  * is stored as <code>Byte</code> object, and <code>int</code> is stored as
 156  * an <code>Integer</code> object.
 157  * When the method <code>execute</code> is called, the values in the
 158  * <code>Hashtable</code> object are substituted for the appropriate placeholder
 159  * parameters in the command.
 160  * <P>
 161  * A call to the method <code>getParams</code> returns the values stored in the
 162  * <code>Hashtable</code> object as an array of <code>Object</code> instances.
 163  * An element in this array may be a simple <code>Object</code> instance or an
 164  * array (which is a type of <code>Object</code>). The particular setter method used
 165  * determines whether an element in this array is an <code>Object</code> or an array.
 166  * <P>
 167  * The majority of methods for setting placeholder parameters take two parameters,
 168  *  with the first parameter
 169  * indicating which placeholder parameter is to be set, and the second parameter
 170  * giving the value to be set.  Methods such as <code>setInt</code>,
 171  * <code>setString</code>, <code>setBoolean</code>, and <code>setLong</code> fall into
 172  * this category.  After these methods have been called, a call to the method
 173  * <code>getParams</code> will return an array with the values that have been set. Each
 174  * element in the array is an <code>Object</code> instance representing the
 175  * values that have been set. The order of these values in the array is determined by the
 176  * <code>int</code> (the first parameter) passed to the setter method. The values in the
 177  * array are the values (the second parameter) passed to the setter method.
 178  * In other words, the first element in the array is the value
 179  * to be set for the first placeholder parameter in the <code>RowSet</code> object's
 180  * command. The second element is the value to
 181  * be set for the second placeholder parameter, and so on.
 182  * <P>
 183  * Several setter methods send the driver and DBMS information beyond the value to be set.
 184  * When the method <code>getParams</code> is called after one of these setter methods has
 185  * been used, the elements in the array will themselves be arrays to accommodate the
 186  * additional information. In this category, the method <code>setNull</code> is a special case
 187  * because one version takes only
 188  * two parameters (<code>setNull(int parameterIndex, int SqlType)</code>). Nevertheless,
 189  * it requires
 190  * an array to contain the information that will be passed to the driver and DBMS.  The first
 191  * element in this array is the value to be set, which is <code>null</code>, and the
 192  * second element is the <code>int</code> supplied for <i>sqlType</i>, which
 193  * indicates the type of SQL value that is being set to <code>null</code>. This information
 194  * is needed by some DBMSs and is therefore required in order to ensure that applications
 195  * are portable.
 196  * The other version is intended to be used when the value to be set to <code>null</code>
 197  * is a user-defined type. It takes three parameters
 198  * (<code>setNull(int parameterIndex, int sqlType, String typeName)</code>) and also
 199  * requires an array to contain the information to be passed to the driver and DBMS.
 200  * The first two elements in this array are the same as for the first version of
 201  * <code>setNull</code>.  The third element, <i>typeName</i>, gives the SQL name of
 202  * the user-defined type. As is true with the other setter methods, the number of the
 203  * placeholder parameter to be set is indicated by an element's position in the array
 204  * returned by <code>getParams</code>.  So, for example, if the parameter
 205  * supplied to <code>setNull</code> is <code>2</code>, the second element in the array
 206  * returned by <code>getParams</code> will be an array of two or three elements.
 207  * <P>
 208  * Some methods, such as <code>setObject</code> and <code>setDate</code> have versions
 209  * that take more than two parameters, with the extra parameters giving information
 210  * to the driver or the DBMS. For example, the methods <code>setDate</code>,
 211  * <code>setTime</code>, and <code>setTimestamp</code> can take a <code>Calendar</code>
 212  * object as their third parameter.  If the DBMS does not store time zone information,
 213  * the driver uses the <code>Calendar</code> object to construct the <code>Date</code>,
 214  * <code>Time</code>, or <code>Timestamp</code> object being set. As is true with other
 215  * methods that provide additional information, the element in the array returned
 216  * by <code>getParams</code> is an array instead of a simple <code>Object</code> instance.
 217  * <P>
 218  * The methods <code>setAsciiStream</code>, <code>setBinaryStream</code>,
 219  * <code>setCharacterStream</code>, and <code>setUnicodeStream</code> (which is
 220  * deprecated, so applications should use <code>getCharacterStream</code> instead)
 221  * take three parameters, so for them, the element in the array returned by
 222  * <code>getParams</code> is also an array.  What is different about these setter
 223  * methods is that in addition to the information provided by parameters, the array contains
 224  * one of the <code>BaseRowSet</code> constants indicating the type of stream being set.
 225 * <p>
 226 * NOTE: The method <code>getParams</code> is called internally by
 227 * <code>RowSet</code> implementations extending this class; it is not normally called by an
 228 * application programmer directly.
 229 *
 230 * <h3>5.0 Event Notification</h3>
 231 * The <code>BaseRowSet</code> class provides the event notification
 232 * mechanism for rowsets.  It contains the field
 233 * <code>listeners</code>, methods for adding and removing listeners, and
 234 * methods for notifying listeners of changes.
 235 * <P>
 236 * A listener is an object that has implemented the <code>RowSetListener</code> interface.
 237 * If it has been added to a <code>RowSet</code> object's list of listeners, it will be notified
 238 *  when an event occurs on that <code>RowSet</code> object.  Each listener's
 239 * implementation of the <code>RowSetListener</code> methods defines what that object
 240 * will do when it is notified that an event has occurred.
 241 * <P>
 242 * There are three possible events for a <code>RowSet</code> object:
 243 * <OL>
 244 * <LI>the cursor moves
 245 * <LI>an individual row is changed (updated, deleted, or inserted)
 246 * <LI>the contents of the entire <code>RowSet</code> object  are changed
 247 * </OL>
 248 * <P>
 249 * The <code>BaseRowSet</code> method used for the notification indicates the
 250 * type of event that has occurred.  For example, the method
 251 * <code>notifyRowChanged</code> indicates that a row has been updated,
 252 * deleted, or inserted.  Each of the notification methods creates a
 253 * <code>RowSetEvent</code> object, which is supplied to the listener in order to
 254 * identify the <code>RowSet</code> object on which the event occurred.
 255 * What the listener does with this information, which may be nothing, depends on how it was
 256 * implemented.
 257 *
 258 * <h3>6.0 Default Behavior</h3>
 259 * A default <code>BaseRowSet</code> object is initialized with many starting values.
 260 *
 261 * The following is true of a default <code>RowSet</code> instance that extends
 262 * the <code>BaseRowSet</code> class:
 263 * <UL>
 264 *   <LI>Has a scrollable cursor and does not show changes
 265 *       made by others.
 266 *   <LI>Is updatable.
 267 *   <LI>Does not show rows that have been deleted.
 268 *   <LI>Has no time limit for how long a driver may take to
 269 *       execute the <code>RowSet</code> object's command.
 270 *   <LI>Has no limit for the number of rows it may contain.
 271 *   <LI>Has no limit for the number of bytes a column may contain. NOTE: This
 272 *   limit applies only to columns that hold values of the
 273 *   following types:  <code>BINARY</code>, <code>VARBINARY</code>,
 274 *   <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
 275 *   and <code>LONGVARCHAR</code>.
 276 *   <LI>Will not see uncommitted data (make "dirty" reads).
 277 *   <LI>Has escape processing turned on.
 278 *   <LI>Has its connection's type map set to <code>null</code>.
 279 *   <LI>Has an empty <code>Vector</code> object for storing the values set
 280 *       for the placeholder parameters in the <code>RowSet</code> object's command.
 281 * </UL>
 282 * <p>
 283 * If other values are desired, an application must set the property values
 284 * explicitly. For example, the following line of code sets the maximum number
 285 * of rows for the <code>CachedRowSet</code> object <i>crs</i> to 500.
 286 * <PRE>
 287 *    crs.setMaxRows(500);
 288 * </PRE>
 289 * Methods implemented in extensions of this <code>BaseRowSet</code> class <b>must</b> throw an
 290 * <code>SQLException</code> object for any violation of the defined assertions.  Also, if the
 291 * extending class overrides and reimplements any <code>BaseRowSet</code> method and encounters
 292 * connectivity or underlying data source issues, that method <b>may</b> in addition throw an
 293 * <code>SQLException</code> object for that reason.
 294 *
 295 * @since 1.5
 296 */
 297 
 298 public abstract class BaseRowSet implements Serializable, Cloneable {
 299 
 300     /**
 301      * A constant indicating to a <code>RowSetReaderImpl</code> object
 302      * that a given parameter is a Unicode stream. This
 303      * <code>RowSetReaderImpl</code> object is provided as an extension of the
 304      * <code>SyncProvider</code> abstract class defined in the
 305      * <code>SyncFactory</code> static factory SPI mechanism.
 306      */
 307     public static final int UNICODE_STREAM_PARAM = 0;
 308 
 309     /**
 310      * A constant indicating to a <code>RowSetReaderImpl</code> object
 311      * that a given parameter is a binary stream. A
 312      * <code>RowSetReaderImpl</code> object is provided as an extension of the
 313      * <code>SyncProvider</code> abstract class defined in the
 314      * <code>SyncFactory</code> static factory SPI mechanism.
 315      */
 316     public static final int BINARY_STREAM_PARAM = 1;
 317 
 318     /**
 319      * A constant indicating to a <code>RowSetReaderImpl</code> object
 320      * that a given parameter is an ASCII stream. A
 321      * <code>RowSetReaderImpl</code> object is provided as an extension of the
 322      * <code>SyncProvider</code> abstract class defined in the
 323      * <code>SyncFactory</code> static factory SPI mechanism.
 324      */
 325     public static final int ASCII_STREAM_PARAM = 2;
 326 
 327     /**
 328      * The <code>InputStream</code> object that will be
 329      * returned by the method <code>getBinaryStream</code>, which is
 330      * specified in the <code>ResultSet</code> interface.
 331      * @serial
 332      */
 333     protected java.io.InputStream binaryStream;
 334 
 335     /**
 336      * The <code>InputStream</code> object that will be
 337      * returned by the method <code>getUnicodeStream</code>,
 338      * which is specified in the <code>ResultSet</code> interface.
 339      * @serial
 340      */
 341     protected java.io.InputStream unicodeStream;
 342 
 343     /**
 344      * The <code>InputStream</code> object that will be
 345      * returned by the method <code>getAsciiStream</code>,
 346      * which is specified in the <code>ResultSet</code> interface.
 347      * @serial
 348      */
 349     protected java.io.InputStream asciiStream;
 350 
 351     /**
 352      * The <code>Reader</code> object that will be
 353      * returned by the method <code>getCharacterStream</code>,
 354      * which is specified in the <code>ResultSet</code> interface.
 355      * @serial
 356      */
 357     protected java.io.Reader charStream;
 358 
 359     /**
 360      * The query that will be sent to the DBMS for execution when the
 361      * method <code>execute</code> is called.
 362      * @serial
 363      */
 364     private String command;
 365 
 366     /**
 367      * The JDBC URL the reader, writer, or both supply to the method
 368      * <code>DriverManager.getConnection</code> when the
 369      * <code>DriverManager</code> is used to get a connection.
 370      * <P>
 371      * The JDBC URL identifies the driver to be used to make the connection.
 372      * This URL can be found in the documentation supplied by the driver
 373      * vendor.
 374      * @serial
 375      */
 376     private String URL;
 377 
 378     /**
 379      * The logical name of the data source that the reader/writer should use
 380      * in order to retrieve a <code>DataSource</code> object from a Java
 381      * Directory and Naming Interface (JNDI) naming service.
 382      * @serial
 383      */
 384     private String dataSource;
 385 
 386     /**
 387      * The user name the reader, writer, or both supply to the method
 388      * <code>DriverManager.getConnection</code> when the
 389      * <code>DriverManager</code> is used to get a connection.
 390      * @serial
 391      */
 392     private transient String username;
 393 
 394     /**
 395      * The password the reader, writer, or both supply to the method
 396      * <code>DriverManager.getConnection</code> when the
 397      * <code>DriverManager</code> is used to get a connection.
 398      * @serial
 399      */
 400     private transient String password;
 401 
 402     /**
 403      * A constant indicating the type of this JDBC <code>RowSet</code>
 404      * object. It must be one of the following <code>ResultSet</code>
 405      * constants:  <code>TYPE_FORWARD_ONLY</code>,
 406      * <code>TYPE_SCROLL_INSENSITIVE</code>, or
 407      * <code>TYPE_SCROLL_SENSITIVE</code>.
 408      * @serial
 409      */
 410     private int rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
 411 
 412     /**
 413      * A <code>boolean</code> indicating whether deleted rows are visible in this
 414      * JDBC <code>RowSet</code> object .
 415      * @serial
 416      */
 417     private boolean showDeleted = false; // default is false
 418 
 419     /**
 420      * The maximum number of seconds the driver
 421      * will wait for a command to execute.  This limit applies while
 422      * this JDBC <code>RowSet</code> object is connected to its data
 423      * source, that is, while it is populating itself with
 424      * data and while it is writing data back to the data source.
 425      * @serial
 426      */
 427     private int queryTimeout = 0; // default is no timeout
 428 
 429     /**
 430      * The maximum number of rows the reader should read.
 431      * @serial
 432      */
 433     private int maxRows = 0; // default is no limit
 434 
 435     /**
 436      * The maximum field size the reader should read.
 437      * @serial
 438      */
 439     private int maxFieldSize = 0; // default is no limit
 440 
 441     /**
 442      * A constant indicating the concurrency of this JDBC <code>RowSet</code>
 443      * object. It must be one of the following <code>ResultSet</code>
 444      * constants: <code>CONCUR_READ_ONLY</code> or
 445      * <code>CONCUR_UPDATABLE</code>.
 446      * @serial
 447      */
 448     private int concurrency = ResultSet.CONCUR_UPDATABLE;
 449 
 450     /**
 451      * A <code>boolean</code> indicating whether this JDBC <code>RowSet</code>
 452      * object is read-only.  <code>true</code> indicates that it is read-only;
 453      * <code>false</code> that it is writable.
 454      * @serial
 455      */
 456     private boolean readOnly;
 457 
 458     /**
 459      * A <code>boolean</code> indicating whether the reader for this
 460      * JDBC <code>RowSet</code> object should perform escape processing.
 461      * <code>true</code> means that escape processing is turned on;
 462      * <code>false</code> that it is not. The default is <code>true</code>.
 463      * @serial
 464      */
 465     private boolean escapeProcessing;
 466 
 467     /**
 468      * A constant indicating the isolation level of the connection
 469      * for this JDBC <code>RowSet</code> object . It must be one of
 470      * the following <code>Connection</code> constants:
 471      * <code>TRANSACTION_NONE</code>,
 472      * <code>TRANSACTION_READ_UNCOMMITTED</code>,
 473      * <code>TRANSACTION_READ_COMMITTED</code>,
 474      * <code>TRANSACTION_REPEATABLE_READ</code> or
 475      * <code>TRANSACTION_SERIALIZABLE</code>.
 476      * @serial
 477      */
 478     private int isolation;
 479 
 480     /**
 481      * A constant used as a hint to the driver that indicates the direction in
 482      * which data from this JDBC <code>RowSet</code> object  is going
 483      * to be fetched. The following <code>ResultSet</code> constants are
 484      * possible values:
 485      * <code>FETCH_FORWARD</code>,
 486      * <code>FETCH_REVERSE</code>,
 487      * <code>FETCH_UNKNOWN</code>.
 488      * <P>
 489      * Unused at this time.
 490      * @serial
 491      */
 492     private int fetchDir = ResultSet.FETCH_FORWARD; // default fetch direction
 493 
 494     /**
 495      * A hint to the driver that indicates the expected number of rows
 496      * in this JDBC <code>RowSet</code> object .
 497      * <P>
 498      * Unused at this time.
 499      * @serial
 500      */
 501     private int fetchSize = 0; // default fetchSize
 502 
 503     /**
 504      * The <code>java.util.Map</code> object that contains entries mapping
 505      * SQL type names to classes in the Java programming language for the
 506      * custom mapping of user-defined types.
 507      * @serial
 508      */
 509     private Map<String, Class<?>> map;
 510 
 511     /**
 512      * A <code>Vector</code> object that holds the list of listeners
 513      * that have registered with this <code>RowSet</code> object.
 514      * @serial
 515      */
 516     private Vector<RowSetListener> listeners;
 517 
 518     /**
 519      * A <code>Vector</code> object that holds the parameters set
 520      * for this <code>RowSet</code> object's current command.
 521      * @serial
 522      */
 523     private Hashtable<Integer, Object> params; // could be transient?
 524 
 525     /**
 526      * Constructs a new <code>BaseRowSet</code> object initialized with
 527      * a default <code>Vector</code> object for its <code>listeners</code>
 528      * field. The other default values with which it is initialized are listed
 529      * in Section 6.0 of the class comment for this class.
 530      */
 531     public BaseRowSet() {
 532         // allocate the listeners collection
 533         listeners = new Vector<RowSetListener>();
 534     }
 535 
 536     /**
 537      * Performs the necessary internal configurations and initializations
 538      * to allow any JDBC <code>RowSet</code> implementation to start using
 539      * the standard facilities provided by a <code>BaseRowSet</code>
 540      * instance. This method <b>should</b> be called after the <code>RowSet</code> object
 541      * has been instantiated to correctly initialize all parameters. This method
 542      * <b>should</b> never be called by an application, but is called from with
 543      * a <code>RowSet</code> implementation extending this class.
 544      */
 545     protected void initParams() {
 546         params = new Hashtable<Integer, Object>();
 547     }
 548 
 549     //--------------------------------------------------------------------
 550     // Events
 551     //--------------------------------------------------------------------
 552 
 553     /**
 554     * The listener will be notified whenever an event occurs on this <code>RowSet</code>
 555     * object.
 556     * <P>
 557     * A listener might, for example, be a table or graph that needs to
 558     * be updated in order to accurately reflect the current state of
 559     * the <code>RowSet</code> object.
 560     * <p>
 561     * <b>Note</b>: if the <code>RowSetListener</code> object is
 562     * <code>null</code>, this method silently discards the <code>null</code>
 563     * value and does not add a null reference to the set of listeners.
 564     * <p>
 565     * <b>Note</b>: if the listener is already set, and the new <code>RowSetListener</code>
 566     * instance is added to the set of listeners already registered to receive
 567     * event notifications from this <code>RowSet</code>.
 568     *
 569     * @param listener an object that has implemented the
 570     *     <code>javax.sql.RowSetListener</code> interface and wants to be notified
 571     *     of any events that occur on this <code>RowSet</code> object; May be
 572     *     null.
 573     * @see #removeRowSetListener
 574     */
 575     public void addRowSetListener(RowSetListener listener) {
 576         listeners.add(listener);
 577     }
 578 
 579     /**
 580     * Removes the designated object from this <code>RowSet</code> object's list of listeners.
 581     * If the given argument is not a registered listener, this method
 582     * does nothing.
 583     *
 584     *  <b>Note</b>: if the <code>RowSetListener</code> object is
 585     * <code>null</code>, this method silently discards the <code>null</code>
 586     * value.
 587     *
 588     * @param listener a <code>RowSetListener</code> object that is on the list
 589     *        of listeners for this <code>RowSet</code> object
 590     * @see #addRowSetListener
 591     */
 592     public void removeRowSetListener(RowSetListener listener) {
 593         listeners.remove(listener);
 594     }
 595 
 596     /**
 597      * Determine if instance of this class extends the RowSet interface.
 598      */
 599     private void checkforRowSetInterface() throws SQLException {
 600         if ((this instanceof javax.sql.RowSet) == false) {
 601             throw new SQLException("The class extending abstract class BaseRowSet " +
 602                 "must implement javax.sql.RowSet or one of it's sub-interfaces.");
 603         }
 604     }
 605 
 606     /**
 607     * Notifies all of the listeners registered with this
 608     * <code>RowSet</code> object that its cursor has moved.
 609     * <P>
 610     * When an application calls a method to move the cursor,
 611     * that method moves the cursor and then calls this method
 612     * internally. An application <b>should</b> never invoke
 613     * this method directly.
 614     *
 615     * @throws SQLException if the class extending the <code>BaseRowSet</code>
 616     *     abstract class does not implement the <code>RowSet</code> interface or
 617     *     one of it's sub-interfaces.
 618     */
 619     protected void notifyCursorMoved() throws SQLException {
 620         checkforRowSetInterface();
 621         if (listeners.isEmpty() == false) {
 622             RowSetEvent event = new RowSetEvent((RowSet)this);
 623             for (RowSetListener rsl : listeners) {
 624                 rsl.cursorMoved(event);
 625             }
 626         }
 627     }
 628 
 629     /**
 630     * Notifies all of the listeners registered with this <code>RowSet</code> object that
 631     * one of its rows has changed.
 632     * <P>
 633     * When an application calls a method that changes a row, such as
 634     * the <code>CachedRowSet</code> methods <code>insertRow</code>,
 635     * <code>updateRow</code>, or <code>deleteRow</code>,
 636     * that method calls <code>notifyRowChanged</code>
 637     * internally. An application <b>should</b> never invoke
 638     * this method directly.
 639     *
 640     * @throws SQLException if the class extending the <code>BaseRowSet</code>
 641     *     abstract class does not implement the <code>RowSet</code> interface or
 642     *     one of it's sub-interfaces.
 643     */
 644     protected void notifyRowChanged() throws SQLException {
 645         checkforRowSetInterface();
 646         if (listeners.isEmpty() == false) {
 647                 RowSetEvent event = new RowSetEvent((RowSet)this);
 648                 for (RowSetListener rsl : listeners) {
 649                     rsl.rowChanged(event);
 650                 }
 651         }
 652     }
 653 
 654    /**
 655     * Notifies all of the listeners registered with this <code>RowSet</code>
 656     * object that its entire contents have changed.
 657     * <P>
 658     * When an application calls methods that change the entire contents
 659     * of the <code>RowSet</code> object, such as the <code>CachedRowSet</code> methods
 660     * <code>execute</code>, <code>populate</code>, <code>restoreOriginal</code>,
 661     * or <code>release</code>, that method calls <code>notifyRowSetChanged</code>
 662     * internally (either directly or indirectly). An application <b>should</b>
 663     * never invoke this method directly.
 664     *
 665     * @throws SQLException if the class extending the <code>BaseRowSet</code>
 666     *     abstract class does not implement the <code>RowSet</code> interface or
 667     *     one of it's sub-interfaces.
 668     */
 669     protected void notifyRowSetChanged() throws SQLException {
 670         checkforRowSetInterface();
 671         if (listeners.isEmpty() == false) {
 672                 RowSetEvent event = new RowSetEvent((RowSet)this);
 673                 for (RowSetListener rsl : listeners) {
 674                     rsl.rowSetChanged(event);
 675                 }
 676         }
 677 }
 678 
 679     /**
 680      * Retrieves the SQL query that is the command for this
 681      * <code>RowSet</code> object. The command property contains the query that
 682      * will be executed to populate this <code>RowSet</code> object.
 683      * <P>
 684      * The SQL query returned by this method is used by <code>RowSet</code> methods
 685      * such as <code>execute</code> and <code>populate</code>, which may be implemented
 686      * by any class that extends the <code>BaseRowSet</code> abstract class and
 687      * implements one or more of the standard JSR-114 <code>RowSet</code>
 688      * interfaces.
 689      * <P>
 690      * The command is used by the <code>RowSet</code> object's
 691      * reader to obtain a <code>ResultSet</code> object.  The reader then
 692      * reads the data from the <code>ResultSet</code> object and uses it to
 693      * to populate this <code>RowSet</code> object.
 694      * <P>
 695      * The default value for the <code>command</code> property is <code>null</code>.
 696      *
 697      * @return the <code>String</code> that is the value for this
 698      *         <code>RowSet</code> object's <code>command</code> property;
 699      *         may be <code>null</code>
 700      * @see #setCommand
 701      */
 702     public String getCommand() {
 703         return command;
 704     }
 705 
 706     /**
 707      * Sets this <code>RowSet</code> object's <code>command</code> property to
 708      * the given <code>String</code> object and clears the parameters, if any,
 709      * that were set for the previous command.
 710      * <P>
 711      * The <code>command</code> property may not be needed if the <code>RowSet</code>
 712      * object gets its data from a source that does not support commands,
 713      * such as a spreadsheet or other tabular file.
 714      * Thus, this property is optional and may be <code>null</code>.
 715      *
 716      * @param cmd a <code>String</code> object containing an SQL query
 717      *            that will be set as this <code>RowSet</code> object's command
 718      *            property; may be <code>null</code> but may not be an empty string
 719      * @throws SQLException if an empty string is provided as the command value
 720      * @see #getCommand
 721      */
 722     public void setCommand(String cmd) throws SQLException {
 723         // cmd equal to null or
 724         // cmd with length 0 (implies url =="")
 725         // are not independent events.
 726 
 727         if(cmd == null) {
 728            command = null;
 729         } else if (cmd.length() == 0) {
 730             throw new SQLException("Invalid command string detected. " +
 731             "Cannot be of length less than 0");
 732         } else {
 733             // "unbind" any parameters from any previous command.
 734             if(params == null){
 735                  throw new SQLException("Set initParams() before setCommand");
 736             }
 737             params.clear();
 738             command = cmd;
 739         }
 740 
 741     }
 742 
 743     /**
 744      * Retrieves the JDBC URL that this <code>RowSet</code> object's
 745      * <code>javax.sql.Reader</code> object uses to make a connection
 746      * with a relational database using a JDBC technology-enabled driver.
 747      *<P>
 748      * The <code>Url</code> property will be <code>null</code> if the underlying data
 749      * source is a non-SQL data source, such as a spreadsheet or an XML
 750      * data source.
 751      *
 752      * @return a <code>String</code> object that contains the JDBC URL
 753      *         used to establish the connection for this <code>RowSet</code>
 754      *         object; may be <code>null</code> (default value) if not set
 755      * @throws SQLException if an error occurs retrieving the URL value
 756      * @see #setUrl
 757      */
 758     public String getUrl() throws SQLException {
 759         return URL;
 760     }
 761 
 762     /**
 763      * Sets the Url property for this <code>RowSet</code> object
 764      * to the given <code>String</code> object and sets the dataSource name
 765      * property to <code>null</code>. The Url property is a
 766      * JDBC URL that is used when
 767      * the connection is created using a JDBC technology-enabled driver
 768      * ("JDBC driver") and the <code>DriverManager</code>.
 769      * The correct JDBC URL for the specific driver to be used can be found
 770      * in the driver documentation.  Although there are guidelines for how
 771      * a JDBC URL is formed,
 772      * a driver vendor can specify any <code>String</code> object except
 773      * one with a length of <code>0</code> (an empty string).
 774      * <P>
 775      * Setting the Url property is optional if connections are established using
 776      * a <code>DataSource</code> object instead of the <code>DriverManager</code>.
 777      * The driver will use either the URL property or the
 778      * dataSourceName property to create a connection, whichever was
 779      * specified most recently. If an application uses a JDBC URL, it
 780      * must load a JDBC driver that accepts the JDBC URL before it uses the
 781      * <code>RowSet</code> object to connect to a database.  The <code>RowSet</code>
 782      * object will use the URL internally to create a database connection in order
 783      * to read or write data.
 784      *
 785      * @param url a <code>String</code> object that contains the JDBC URL
 786      *     that will be used to establish the connection to a database for this
 787      *     <code>RowSet</code> object; may be <code>null</code> but must not
 788      *     be an empty string
 789      * @throws SQLException if an error occurs setting the Url property or the
 790      *     parameter supplied is a string with a length of <code>0</code> (an
 791      *     empty string)
 792      * @see #getUrl
 793      */
 794     public void setUrl(String url) throws SQLException {
 795         if(url == null) {
 796            url = null;
 797         } else if (url.length() < 1) {
 798             throw new SQLException("Invalid url string detected. " +
 799             "Cannot be of length less than 1");
 800         } else {
 801             URL = url;
 802         }
 803 
 804         dataSource = null;
 805 
 806     }
 807 
 808     /**
 809      * Returns the logical name that when supplied to a naming service
 810      * that uses the Java Naming and Directory Interface (JNDI) API, will
 811      * retrieve a <code>javax.sql.DataSource</code> object. This
 812      * <code>DataSource</code> object can be used to establish a connection
 813      * to the data source that it represents.
 814      * <P>
 815      * Users should set either the url or the data source name property.
 816      * The driver will use the property set most recently to establish a
 817      * connection.
 818      *
 819      * @return a <code>String</code> object that identifies the
 820      *         <code>DataSource</code> object to be used for making a
 821      *         connection; if no logical name has been set, <code>null</code>
 822      *         is returned.
 823      * @see #setDataSourceName
 824      */
 825     public String getDataSourceName() {
 826         return dataSource;
 827     }
 828 
 829 
 830     /**
 831      * Sets the <code>DataSource</code> name property for this <code>RowSet</code>
 832      * object to the given logical name and sets this <code>RowSet</code> object's
 833      * Url property to <code>null</code>. The name must have been bound to a
 834      * <code>DataSource</code> object in a JNDI naming service so that an
 835      * application can do a lookup using that name to retrieve the
 836      * <code>DataSource</code> object bound to it. The <code>DataSource</code>
 837      * object can then be used to establish a connection to the data source it
 838      * represents.
 839      * <P>
 840      * Users should set either the Url property or the dataSourceName property.
 841      * If both properties are set, the driver will use the property set most recently.
 842      *
 843      * @param name a <code>String</code> object with the name that can be supplied
 844      *     to a naming service based on JNDI technology to retrieve the
 845      *     <code>DataSource</code> object that can be used to get a connection;
 846      *     may be <code>null</code> but must not be an empty string
 847      * @throws SQLException if an empty string is provided as the <code>DataSource</code>
 848      *    name
 849      * @see #getDataSourceName
 850      */
 851     public void setDataSourceName(String name) throws SQLException {
 852 
 853         if (name == null) {
 854             dataSource = null;
 855         } else if (name.equals("")) {
 856            throw new SQLException("DataSource name cannot be empty string");
 857         } else {
 858            dataSource = name;
 859         }
 860 
 861         URL = null;
 862     }
 863 
 864     /**
 865      * Returns the user name used to create a database connection.  Because it
 866      * is not serialized, the username property is set at runtime before
 867      * calling the method <code>execute</code>.
 868      *
 869      * @return the <code>String</code> object containing the user name that
 870      *         is supplied to the data source to create a connection; may be
 871      *         <code>null</code> (default value) if not set
 872      * @see #setUsername
 873      */
 874     public String getUsername() {
 875         return username;
 876     }
 877 
 878     /**
 879      * Sets the username property for this <code>RowSet</code> object
 880      * to the given user name. Because it
 881      * is not serialized, the username property is set at run time before
 882      * calling the method <code>execute</code>.
 883      *
 884      * @param name the <code>String</code> object containing the user name that
 885      *     is supplied to the data source to create a connection. It may be null.
 886      * @see #getUsername
 887      */
 888     public void setUsername(String name) {
 889         if(name == null)
 890         {
 891            username = null;
 892         } else {
 893            username = name;
 894         }
 895     }
 896 
 897     /**
 898      * Returns the password used to create a database connection for this
 899      * <code>RowSet</code> object.  Because the password property is not
 900      * serialized, it is set at run time before calling the method
 901      * <code>execute</code>. The default value is <code>null</code>
 902      *
 903      * @return the <code>String</code> object that represents the password
 904      *         that must be supplied to the database to create a connection
 905      * @see #setPassword
 906      */
 907     public String getPassword() {
 908         return password;
 909     }
 910 
 911     /**
 912      * Sets the password used to create a database connection for this
 913      * <code>RowSet</code> object to the given <code>String</code>
 914      * object.  Because the password property is not
 915      * serialized, it is set at run time before calling the method
 916      * <code>execute</code>.
 917      *
 918      * @param pass the <code>String</code> object that represents the password
 919      *     that is supplied to the database to create a connection. It may be
 920      *     null.
 921      * @see #getPassword
 922      */
 923     public void setPassword(String pass) {
 924         if(pass == null)
 925         {
 926            password = null;
 927         } else {
 928            password = pass;
 929         }
 930     }
 931 
 932     /**
 933      * Sets the type for this <code>RowSet</code> object to the specified type.
 934      * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>.
 935      *
 936      * @param type one of the following constants:
 937      *             <code>ResultSet.TYPE_FORWARD_ONLY</code>,
 938      *             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
 939      *             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 940      * @throws SQLException if the parameter supplied is not one of the
 941      *         following constants:
 942      *          <code>ResultSet.TYPE_FORWARD_ONLY</code> or
 943      *          <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>
 944      *          <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 945      * @see #getConcurrency
 946      * @see #getType
 947      */
 948     public void setType(int type) throws SQLException {
 949 
 950         if ((type != ResultSet.TYPE_FORWARD_ONLY) &&
 951            (type != ResultSet.TYPE_SCROLL_INSENSITIVE) &&
 952            (type != ResultSet.TYPE_SCROLL_SENSITIVE)) {
 953                 throw new SQLException("Invalid type of RowSet set. Must be either " +
 954                 "ResultSet.TYPE_FORWARD_ONLY or ResultSet.TYPE_SCROLL_INSENSITIVE " +
 955                 "or ResultSet.TYPE_SCROLL_SENSITIVE.");
 956         }
 957         this.rowSetType = type;
 958     }
 959 
 960     /**
 961      * Returns the type of this <code>RowSet</code> object. The type is initially
 962      * determined by the statement that created the <code>RowSet</code> object.
 963      * The <code>RowSet</code> object can call the method
 964      * <code>setType</code> at any time to change its
 965      * type.  The default is <code>TYPE_SCROLL_INSENSITIVE</code>.
 966      *
 967      * @return the type of this JDBC <code>RowSet</code>
 968      *         object, which must be one of the following:
 969      *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,
 970      *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
 971      *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 972      * @throws SQLException if an error occurs getting the type of
 973      *     of this <code>RowSet</code> object
 974      * @see #setType
 975      */
 976     public int getType() throws SQLException {
 977         return rowSetType;
 978     }
 979 
 980     /**
 981      * Sets the concurrency for this <code>RowSet</code> object to
 982      * the specified concurrency. The default concurrency for any <code>RowSet</code>
 983      * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>,
 984      * but this method may be called at any time to change the concurrency.
 985      *
 986      * @param concurrency one of the following constants:
 987      *                    <code>ResultSet.CONCUR_READ_ONLY</code> or
 988      *                    <code>ResultSet.CONCUR_UPDATABLE</code>
 989      * @throws SQLException if the parameter supplied is not one of the
 990      *         following constants:
 991      *          <code>ResultSet.CONCUR_UPDATABLE</code> or
 992      *          <code>ResultSet.CONCUR_READ_ONLY</code>
 993      * @see #getConcurrency
 994      * @see #isReadOnly
 995      */
 996     public void setConcurrency(int concurrency) throws SQLException {
 997 
 998         if((concurrency != ResultSet.CONCUR_READ_ONLY) &&
 999            (concurrency != ResultSet.CONCUR_UPDATABLE)) {
1000                 throw new SQLException("Invalid concurrency set. Must be either " +
1001                 "ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE.");
1002         }
1003         this.concurrency = concurrency;
1004     }
1005 
1006     /**
1007      * Returns a <code>boolean</code> indicating whether this
1008      * <code>RowSet</code> object is read-only.
1009      * Any attempts to update a read-only <code>RowSet</code> object will result in an
1010      * <code>SQLException</code> being thrown. By default,
1011      * rowsets are updatable if updates are possible.
1012      *
1013      * @return <code>true</code> if this <code>RowSet</code> object
1014      *         cannot be updated; <code>false</code> otherwise
1015      * @see #setConcurrency
1016      * @see #setReadOnly
1017      */
1018     public boolean isReadOnly() {
1019         return readOnly;
1020     };
1021 
1022     /**
1023      * Sets this <code>RowSet</code> object's readOnly  property to the given <code>boolean</code>.
1024      *
1025      * @param value <code>true</code> to indicate that this
1026      *              <code>RowSet</code> object is read-only;
1027      *              <code>false</code> to indicate that it is updatable
1028      */
1029     public void setReadOnly(boolean value) {
1030         readOnly = value;
1031     }
1032 
1033     /**
1034      * Returns the transaction isolation property for this
1035      * <code>RowSet</code> object's connection. This property represents
1036      * the transaction isolation level requested for use in transactions.
1037      * <P>
1038      * For <code>RowSet</code> implementations such as
1039      * the <code>CachedRowSet</code> that operate in a disconnected environment,
1040      * the <code>SyncProvider</code> object
1041      * offers complementary locking and data integrity options. The
1042      * options described below are pertinent only to connected <code>RowSet</code>
1043      * objects (<code>JdbcRowSet</code> objects).
1044      *
1045      * @return one of the following constants:
1046      *         <code>Connection.TRANSACTION_NONE</code>,
1047      *         <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
1048      *         <code>Connection.TRANSACTION_READ_COMMITTED</code>,
1049      *         <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
1050      *         <code>Connection.TRANSACTION_SERIALIZABLE</code>
1051      * @see javax.sql.rowset.spi.SyncFactory
1052      * @see javax.sql.rowset.spi.SyncProvider
1053      * @see #setTransactionIsolation
1054 
1055      */
1056     public int getTransactionIsolation() {
1057         return isolation;
1058     };
1059 
1060     /**
1061      * Sets the transaction isolation property for this JDBC <code>RowSet</code> object to the given
1062      * constant. The DBMS will use this transaction isolation level for
1063      * transactions if it can.
1064      * <p>
1065      * For <code>RowSet</code> implementations such as
1066      * the <code>CachedRowSet</code> that operate in a disconnected environment,
1067      * the <code>SyncProvider</code> object being used
1068      * offers complementary locking and data integrity options. The
1069      * options described below are pertinent only to connected <code>RowSet</code>
1070      * objects (<code>JdbcRowSet</code> objects).
1071      *
1072      * @param level one of the following constants, listed in ascending order:
1073      *              <code>Connection.TRANSACTION_NONE</code>,
1074      *              <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
1075      *              <code>Connection.TRANSACTION_READ_COMMITTED</code>,
1076      *              <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
1077      *              <code>Connection.TRANSACTION_SERIALIZABLE</code>
1078      * @throws SQLException if the given parameter is not one of the Connection
1079      *          constants
1080      * @see javax.sql.rowset.spi.SyncFactory
1081      * @see javax.sql.rowset.spi.SyncProvider
1082      * @see #getTransactionIsolation
1083      */
1084     public void setTransactionIsolation(int level) throws SQLException {
1085         if ((level != Connection.TRANSACTION_NONE) &&
1086            (level != Connection.TRANSACTION_READ_COMMITTED) &&
1087            (level != Connection.TRANSACTION_READ_UNCOMMITTED) &&
1088            (level != Connection.TRANSACTION_REPEATABLE_READ) &&
1089            (level != Connection.TRANSACTION_SERIALIZABLE))
1090             {
1091                 throw new SQLException("Invalid transaction isolation set. Must " +
1092                 "be either " +
1093                 "Connection.TRANSACTION_NONE or " +
1094                 "Connection.TRANSACTION_READ_UNCOMMITTED or " +
1095                 "Connection.TRANSACTION_READ_COMMITTED or " +
1096                 "Connection.TRANSACTION_REPEATABLE_READ or " +
1097                 "Connection.TRANSACTION_SERIALIZABLE");
1098             }
1099         this.isolation = level;
1100     }
1101 
1102     /**
1103      * Retrieves the type map associated with the <code>Connection</code>
1104      * object for this <code>RowSet</code> object.
1105      * <P>
1106      * Drivers that support the JDBC 3.0 API will create
1107      * <code>Connection</code> objects with an associated type map.
1108      * This type map, which is initially empty, can contain one or more
1109      * fully-qualified SQL names and <code>Class</code> objects indicating
1110      * the class to which the named SQL value will be mapped. The type mapping
1111      * specified in the connection's type map is used for custom type mapping
1112      * when no other type map supersedes it.
1113      * <p>
1114      * If a type map is explicitly supplied to a method that can perform
1115      * custom mapping, that type map supersedes the connection's type map.
1116      *
1117      * @return the <code>java.util.Map</code> object that is the type map
1118      *         for this <code>RowSet</code> object's connection
1119      */
1120     public java.util.Map<String,Class<?>> getTypeMap() {
1121         return map;
1122     }
1123 
1124     /**
1125      * Installs the given <code>java.util.Map</code> object as the type map
1126      * associated with the <code>Connection</code> object for this
1127      * <code>RowSet</code> object.  The custom mapping indicated in
1128      * this type map will be used unless a different type map is explicitly
1129      * supplied to a method, in which case the type map supplied will be used.
1130      *
1131      * @param map a <code>java.util.Map</code> object that contains the
1132      *     mapping from SQL type names for user defined types (UDT) to classes in
1133      *     the Java programming language.  Each entry in the <code>Map</code>
1134      *     object consists of the fully qualified SQL name of a UDT and the
1135      *     <code>Class</code> object for the <code>SQLData</code> implementation
1136      *     of that UDT. May be <code>null</code>.
1137      */
1138     public void setTypeMap(java.util.Map<String,Class<?>> map) {
1139         this.map = map;
1140     }
1141 
1142     /**
1143      * Retrieves the maximum number of bytes that can be used for a column
1144      * value in this <code>RowSet</code> object.
1145      * This limit applies only to columns that hold values of the
1146      * following types:  <code>BINARY</code>, <code>VARBINARY</code>,
1147      * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
1148      * and <code>LONGVARCHAR</code>.  If the limit is exceeded, the excess
1149      * data is silently discarded.
1150      *
1151      * @return an <code>int</code> indicating the current maximum column size
1152      *     limit; zero means that there is no limit
1153      * @throws SQLException if an error occurs internally determining the
1154      *    maximum limit of the column size
1155      */
1156     public int getMaxFieldSize() throws SQLException {
1157         return maxFieldSize;
1158     }
1159 
1160     /**
1161      * Sets the maximum number of bytes that can be used for a column
1162      * value in this <code>RowSet</code> object to the given number.
1163      * This limit applies only to columns that hold values of the
1164      * following types:  <code>BINARY</code>, <code>VARBINARY</code>,
1165      * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
1166      * and <code>LONGVARCHAR</code>.  If the limit is exceeded, the excess
1167      * data is silently discarded. For maximum portability, it is advisable to
1168      * use values greater than 256.
1169      *
1170      * @param max an <code>int</code> indicating the new maximum column size
1171      *     limit; zero means that there is no limit
1172      * @throws SQLException if (1) an error occurs internally setting the
1173      *     maximum limit of the column size or (2) a size of less than 0 is set
1174      */
1175     public void setMaxFieldSize(int max) throws SQLException {
1176         if (max < 0) {
1177             throw new SQLException("Invalid max field size set. Cannot be of " +
1178             "value: " + max);
1179         }
1180         maxFieldSize = max;
1181     }
1182 
1183     /**
1184      * Retrieves the maximum number of rows that this <code>RowSet</code> object may contain. If
1185      * this limit is exceeded, the excess rows are silently dropped.
1186      *
1187      * @return an <code>int</code> indicating the current maximum number of
1188      *     rows; zero means that there is no limit
1189      * @throws SQLException if an error occurs internally determining the
1190      *     maximum limit of rows that a <code>Rowset</code> object can contain
1191      */
1192     public int getMaxRows() throws SQLException {
1193         return maxRows;
1194     }
1195 
1196     /**
1197      * Sets the maximum number of rows that this <code>RowSet</code> object may contain to
1198      * the given number. If this limit is exceeded, the excess rows are
1199      * silently dropped.
1200      *
1201      * @param max an <code>int</code> indicating the current maximum number
1202      *     of rows; zero means that there is no limit
1203      * @throws SQLException if an error occurs internally setting the
1204      *     maximum limit on the number of rows that a JDBC <code>RowSet</code> object
1205      *     can contain; or if <i>max</i> is less than <code>0</code>; or
1206      *     if <i>max</i> is less than the <code>fetchSize</code> of the
1207      *     <code>RowSet</code>
1208      */
1209     public void setMaxRows(int max) throws SQLException {
1210         if (max < 0) {
1211             throw new SQLException("Invalid max row size set. Cannot be of " +
1212                 "value: " + max);
1213         } else if (max < this.getFetchSize()) {
1214             throw new SQLException("Invalid max row size set. Cannot be less " +
1215                 "than the fetchSize.");
1216         }
1217         this.maxRows = max;
1218     }
1219 
1220     /**
1221      * Sets to the given <code>boolean</code> whether or not the driver will
1222      * scan for escape syntax and do escape substitution before sending SQL
1223      * statements to the database. The default is for the driver to do escape
1224      * processing.
1225      * <P>
1226      * Note: Since <code>PreparedStatement</code> objects have usually been
1227      * parsed prior to making this call, disabling escape processing for
1228      * prepared statements will likely have no effect.
1229      *
1230      * @param enable <code>true</code> to enable escape processing;
1231      *     <code>false</code> to disable it
1232      * @throws SQLException if an error occurs setting the underlying JDBC
1233      * technology-enabled driver to process the escape syntax
1234      */
1235     public void setEscapeProcessing(boolean enable) throws SQLException {
1236         escapeProcessing = enable;
1237     }
1238 
1239     /**
1240      * Retrieves the maximum number of seconds the driver will wait for a
1241      * query to execute. If the limit is exceeded, an <code>SQLException</code>
1242      * is thrown.
1243      *
1244      * @return the current query timeout limit in seconds; zero means that
1245      *     there is no limit
1246      * @throws SQLException if an error occurs in determining the query
1247      *     time-out value
1248      */
1249     public int getQueryTimeout() throws SQLException {
1250         return queryTimeout;
1251     }
1252 
1253     /**
1254      * Sets to the given number the maximum number of seconds the driver will
1255      * wait for a query to execute. If the limit is exceeded, an
1256      * <code>SQLException</code> is thrown.
1257      *
1258      * @param seconds the new query time-out limit in seconds; zero means that
1259      *     there is no limit; must not be less than zero
1260      * @throws SQLException if an error occurs setting the query
1261      *     time-out or if the query time-out value is less than 0
1262      */
1263     public void setQueryTimeout(int seconds) throws SQLException {
1264         if (seconds < 0) {
1265             throw new SQLException("Invalid query timeout value set. Cannot be " +
1266             "of value: " + seconds);
1267         }
1268         this.queryTimeout = seconds;
1269     }
1270 
1271     /**
1272      * Retrieves a <code>boolean</code> indicating whether rows marked
1273      * for deletion appear in the set of current rows.
1274      * The default value is <code>false</code>.
1275      * <P>
1276      * Note: Allowing deleted rows to remain visible complicates the behavior
1277      * of some of the methods.  However, most <code>RowSet</code> object users
1278      * can simply ignore this extra detail because only sophisticated
1279      * applications will likely want to take advantage of this feature.
1280      *
1281      * @return <code>true</code> if deleted rows are visible;
1282      *         <code>false</code> otherwise
1283      * @throws SQLException if an error occurs determining if deleted rows
1284      * are visible or not
1285      * @see #setShowDeleted
1286      */
1287     public boolean getShowDeleted() throws SQLException {
1288         return showDeleted;
1289     }
1290 
1291     /**
1292      * Sets the property <code>showDeleted</code> to the given
1293      * <code>boolean</code> value, which determines whether
1294      * rows marked for deletion appear in the set of current rows.
1295      *
1296      * @param value <code>true</code> if deleted rows should be shown;
1297      *     <code>false</code> otherwise
1298      * @throws SQLException if an error occurs setting whether deleted
1299      *     rows are visible or not
1300      * @see #getShowDeleted
1301      */
1302     public void setShowDeleted(boolean value) throws SQLException {
1303         showDeleted = value;
1304     }
1305 
1306     /**
1307      * Ascertains whether escape processing is enabled for this
1308      * <code>RowSet</code> object.
1309      *
1310      * @return <code>true</code> if escape processing is turned on;
1311      *         <code>false</code> otherwise
1312      * @throws SQLException if an error occurs determining if escape
1313      *     processing is enabled or not or if the internal escape
1314      *     processing trigger has not been enabled
1315      */
1316     public boolean getEscapeProcessing() throws SQLException {
1317         return escapeProcessing;
1318     }
1319 
1320     /**
1321      * Gives the driver a performance hint as to the direction in
1322      * which the rows in this <code>RowSet</code> object will be
1323      * processed.  The driver may ignore this hint.
1324      * <P>
1325      * A <code>RowSet</code> object inherits the default properties of the
1326      * <code>ResultSet</code> object from which it got its data.  That
1327      * <code>ResultSet</code> object's default fetch direction is set by
1328      * the <code>Statement</code> object that created it.
1329      * <P>
1330      * This method applies to a <code>RowSet</code> object only while it is
1331      * connected to a database using a JDBC driver.
1332      * <p>
1333      * A <code>RowSet</code> object may use this method at any time to change
1334      * its setting for the fetch direction.
1335      *
1336      * @param direction one of <code>ResultSet.FETCH_FORWARD</code>,
1337      *                  <code>ResultSet.FETCH_REVERSE</code>, or
1338      *                  <code>ResultSet.FETCH_UNKNOWN</code>
1339      * @throws SQLException if (1) the <code>RowSet</code> type is
1340      *     <code>TYPE_FORWARD_ONLY</code> and the given fetch direction is not
1341      *     <code>FETCH_FORWARD</code> or (2) the given fetch direction is not
1342      *     one of the following:
1343      *        ResultSet.FETCH_FORWARD,
1344      *        ResultSet.FETCH_REVERSE, or
1345      *        ResultSet.FETCH_UNKNOWN
1346      * @see #getFetchDirection
1347      */
1348     public void setFetchDirection(int direction) throws SQLException {
1349         // Changed the condition checking to the below as there were two
1350         // conditions that had to be checked
1351         // 1. RowSet is TYPE_FORWARD_ONLY and direction is not FETCH_FORWARD
1352         // 2. Direction is not one of the valid values
1353 
1354         if (((getType() == ResultSet.TYPE_FORWARD_ONLY) && (direction != ResultSet.FETCH_FORWARD)) ||
1355             ((direction != ResultSet.FETCH_FORWARD) &&
1356             (direction != ResultSet.FETCH_REVERSE) &&
1357             (direction != ResultSet.FETCH_UNKNOWN))) {
1358             throw new SQLException("Invalid Fetch Direction");
1359         }
1360         fetchDir = direction;
1361     }
1362 
1363     /**
1364      * Retrieves this <code>RowSet</code> object's current setting for the
1365      * fetch direction. The default type is <code>ResultSet.FETCH_FORWARD</code>
1366      *
1367      * @return one of <code>ResultSet.FETCH_FORWARD</code>,
1368      *                  <code>ResultSet.FETCH_REVERSE</code>, or
1369      *                  <code>ResultSet.FETCH_UNKNOWN</code>
1370      * @throws SQLException if an error occurs in determining the
1371      *     current fetch direction for fetching rows
1372      * @see #setFetchDirection
1373      */
1374     public int getFetchDirection() throws SQLException {
1375 
1376         //Added the following code to throw a
1377         //SQL Exception if the fetchDir is not
1378         //set properly.Bug id:4914155
1379 
1380         // This checking is not necessary!
1381 
1382         /*
1383          if((fetchDir != ResultSet.FETCH_FORWARD) &&
1384            (fetchDir != ResultSet.FETCH_REVERSE) &&
1385            (fetchDir != ResultSet.FETCH_UNKNOWN)) {
1386             throw new SQLException("Fetch Direction Invalid");
1387          }
1388          */
1389         return (fetchDir);
1390     }
1391 
1392     /**
1393      * Sets the fetch size for this <code>RowSet</code> object to the given number of
1394      * rows.  The fetch size gives a JDBC technology-enabled driver ("JDBC driver")
1395      * a hint as to the
1396      * number of rows that should be fetched from the database when more rows
1397      * are needed for this <code>RowSet</code> object. If the fetch size specified
1398      * is zero, the driver ignores the value and is free to make its own best guess
1399      * as to what the fetch size should be.
1400      * <P>
1401      * A <code>RowSet</code> object inherits the default properties of the
1402      * <code>ResultSet</code> object from which it got its data.  That
1403      * <code>ResultSet</code> object's default fetch size is set by
1404      * the <code>Statement</code> object that created it.
1405      * <P>
1406      * This method applies to a <code>RowSet</code> object only while it is
1407      * connected to a database using a JDBC driver.
1408      * For connected <code>RowSet</code> implementations such as
1409      * <code>JdbcRowSet</code>, this method has a direct and immediate effect
1410      * on the underlying JDBC driver.
1411      * <P>
1412      * A <code>RowSet</code> object may use this method at any time to change
1413      * its setting for the fetch size.
1414      * <p>
1415      * For <code>RowSet</code> implementations such as
1416      * <code>CachedRowSet</code>, which operate in a disconnected environment,
1417      * the <code>SyncProvider</code> object being used
1418      * may leverage the fetch size to poll the data source and
1419      * retrieve a number of rows that do not exceed the fetch size and that may
1420      * form a subset of the actual rows returned by the original query. This is
1421      * an implementation variance determined by the specific <code>SyncProvider</code>
1422      * object employed by the disconnected <code>RowSet</code> object.
1423      *
1424      * @param rows the number of rows to fetch; <code>0</code> to let the
1425      *        driver decide what the best fetch size is; must not be less
1426      *        than <code>0</code> or more than the maximum number of rows
1427      *        allowed for this <code>RowSet</code> object (the number returned
1428      *        by a call to the method {@link #getMaxRows})
1429      * @throws SQLException if the specified fetch size is less than <code>0</code>
1430      *        or more than the limit for the maximum number of rows
1431      * @see #getFetchSize
1432      */
1433     public void setFetchSize(int rows) throws SQLException {
1434         //Added this checking as maxRows can be 0 when this function is called
1435         //maxRows = 0 means rowset can hold any number of rows, os this checking
1436         // is needed to take care of this condition.
1437         if (getMaxRows() == 0 && rows >= 0)  {
1438             fetchSize = rows;
1439             return;
1440         }
1441         if ((rows < 0) || (rows > getMaxRows())) {
1442             throw new SQLException("Invalid fetch size set. Cannot be of " +
1443             "value: " + rows);
1444         }
1445         fetchSize = rows;
1446     }
1447 
1448     /**
1449      * Returns the fetch size for this <code>RowSet</code> object. The default
1450      * value is zero.
1451      *
1452      * @return the number of rows suggested as the fetch size when this <code>RowSet</code> object
1453      *     needs more rows from the database
1454      * @throws SQLException if an error occurs determining the number of rows in the
1455      *     current fetch size
1456      * @see #setFetchSize
1457      */
1458     public int getFetchSize() throws SQLException {
1459         return fetchSize;
1460     }
1461 
1462     /**
1463      * Returns the concurrency for this <code>RowSet</code> object.
1464      * The default is <code>CONCUR_UPDATABLE</code> for both connected and
1465      * disconnected <code>RowSet</code> objects.
1466      * <P>
1467      * An application can call the method <code>setConcurrency</code> at any time
1468      * to change a <code>RowSet</code> object's concurrency.
1469      *
1470      * @return the concurrency type for this <code>RowSet</code>
1471      *     object, which must be one of the following:
1472      *     <code>ResultSet.CONCUR_READ_ONLY</code> or
1473      *     <code>ResultSet.CONCUR_UPDATABLE</code>
1474      * @throws SQLException if an error occurs getting the concurrency
1475      *     of this <code>RowSet</code> object
1476      * @see #setConcurrency
1477      * @see #isReadOnly
1478      */
1479     public int getConcurrency() throws SQLException {
1480         return concurrency;
1481     }
1482 
1483     //-----------------------------------------------------------------------
1484     // Parameters
1485     //-----------------------------------------------------------------------
1486 
1487     /**
1488      * Checks the given index to see whether it is less than <code>1</code> and
1489      * throws an <code>SQLException</code> object if it is.
1490      * <P>
1491      * This method is called by many methods internally; it is never
1492      * called by an application directly.
1493      *
1494      * @param idx an <code>int</code> indicating which parameter is to be
1495      *     checked; the first parameter is <code>1</code>
1496      * @throws SQLException if the parameter is less than <code>1</code>
1497      */
1498     private void checkParamIndex(int idx) throws SQLException {
1499         if ((idx < 1)) {
1500             throw new SQLException("Invalid Parameter Index");
1501         }
1502     }
1503 
1504     //---------------------------------------------------------------------
1505     // setter methods for setting the parameters in a <code>RowSet</code> object's command
1506     //---------------------------------------------------------------------
1507 
1508     /**
1509      * Sets the designated parameter to SQL <code>NULL</code>.
1510      * Note that the parameter's SQL type must be specified using one of the
1511          * type codes defined in <code>java.sql.Types</code>.  This SQL type is
1512      * specified in the second parameter.
1513      * <p>
1514      * Note that the second parameter tells the DBMS the data type of the value being
1515      * set to <code>NULL</code>. Some DBMSs require this information, so it is required
1516      * in order to make code more portable.
1517      * <P>
1518      * The parameter value set by this method is stored internally and
1519      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1520      * object's command when the method <code>execute</code> is called.
1521      * Methods such as <code>execute</code> and <code>populate</code> must be
1522      * provided in any class that extends this class and implements one or
1523      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1524      * <P>
1525      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1526      * as it is undefined in this class.
1527      * <P>
1528      * Calls made to the method <code>getParams</code> after this version of
1529      * <code>setNull</code>
1530      * has been called will return an <code>Object</code> array containing the parameter values that
1531      * have been set.  In that array, the element that represents the values
1532      * set with this method will itself be an array. The first element of that array
1533      * is <code>null</code>.
1534      * The second element is the value set for <i>sqlType</i>.
1535      * The parameter number is indicated by an element's position in the array
1536      * returned by the method <code>getParams</code>,
1537      * with the first element being the value for the first placeholder parameter, the
1538      * second element being the value for the second placeholder parameter, and so on.
1539      * In other words, if the second placeholder parameter is being set to
1540      * <code>null</code>, the array containing it will be the second element in
1541      * the array returned by <code>getParams</code>.
1542      * <P>
1543      * Note that because the numbering of elements in an array starts at zero,
1544      * the array element that corresponds to placeholder parameter number
1545      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
1546      *
1547      * @param parameterIndex the ordinal number of the placeholder parameter
1548      *        in this <code>RowSet</code> object's command that is to be set.
1549      *        The first parameter is 1, the second is 2, and so on; must be
1550      *        <code>1</code> or greater
1551      * @param sqlType an <code>int</code> that is one of the SQL type codes
1552      *        defined in the class {@link java.sql.Types}. If a non-standard
1553      *        <i>sqlType</i> is supplied, this method will not throw a
1554      *        <code>SQLException</code>. This allows implicit support for
1555      *        non-standard SQL types.
1556      * @throws SQLException if a database access error occurs or the given
1557      *        parameter index is out of bounds
1558      * @see #getParams
1559      */
1560     public void setNull(int parameterIndex, int sqlType) throws SQLException {
1561         Object nullVal[];
1562         checkParamIndex(parameterIndex);
1563 
1564         nullVal = new Object[2];
1565         nullVal[0] = null;
1566         nullVal[1] = Integer.valueOf(sqlType);
1567 
1568        if (params == null){
1569             throw new SQLException("Set initParams() before setNull");
1570        }
1571 
1572         params.put(Integer.valueOf(parameterIndex - 1), nullVal);
1573     }
1574 
1575     /**
1576      * Sets the designated parameter to SQL <code>NULL</code>.
1577      *
1578      * Although this version of the  method <code>setNull</code> is intended
1579      * for user-defined
1580      * and <code>REF</code> parameters, this method may be used to set a null
1581      * parameter for any JDBC type. The following are user-defined types:
1582      * <code>STRUCT</code>, <code>DISTINCT</code>, and <code>JAVA_OBJECT</code>,
1583      * and named array types.
1584      *
1585      * <P><B>Note:</B> To be portable, applications must give the
1586      * SQL type code and the fully qualified SQL type name when specifying
1587      * a <code>NULL</code> user-defined or <code>REF</code> parameter.
1588      * In the case of a user-defined type, the name is the type name of
1589      * the parameter itself.  For a <code>REF</code> parameter, the name is
1590      * the type name of the referenced type.  If a JDBC technology-enabled
1591      * driver does not need the type code or type name information,
1592      * it may ignore it.
1593      * <P>
1594      * If the parameter does not have a user-defined or <code>REF</code> type,
1595      * the given <code>typeName</code> parameter is ignored.
1596      * <P>
1597      * The parameter value set by this method is stored internally and
1598      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1599      * object's command when the method <code>execute</code> is called.
1600      * Methods such as <code>execute</code> and <code>populate</code> must be
1601      * provided in any class that extends this class and implements one or
1602      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1603      * <P>
1604      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1605      * as it is undefined in this class.
1606      * <P>
1607      * Calls made to the method <code>getParams</code> after this version of
1608      * <code>setNull</code>
1609      * has been called will return an <code>Object</code> array containing the parameter values that
1610      * have been set.  In that array, the element that represents the values
1611      * set with this method will itself be an array. The first element of that array
1612      * is <code>null</code>.
1613      * The second element is the value set for <i>sqlType</i>, and the third
1614      * element is the value set for <i>typeName</i>.
1615      * The parameter number is indicated by an element's position in the array
1616      * returned by the method <code>getParams</code>,
1617      * with the first element being the value for the first placeholder parameter, the
1618      * second element being the value for the second placeholder parameter, and so on.
1619      * In other words, if the second placeholder parameter is being set to
1620      * <code>null</code>, the array containing it will be the second element in
1621      * the array returned by <code>getParams</code>.
1622      * <P>
1623      * Note that because the numbering of elements in an array starts at zero,
1624      * the array element that corresponds to placeholder parameter number
1625      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
1626      *
1627      * @param parameterIndex the ordinal number of the placeholder parameter
1628      *        in this <code>RowSet</code> object's command that is to be set.
1629      *        The first parameter is 1, the second is 2, and so on; must be
1630      *        <code>1</code> or greater
1631      * @param sqlType a value from <code>java.sql.Types</code>
1632      * @param typeName the fully qualified name of an SQL user-defined type,
1633      *                 which is ignored if the parameter is not a user-defined
1634      *                 type or <code>REF</code> value
1635      * @throws SQLException if an error occurs or the given parameter index
1636      *            is out of bounds
1637      * @see #getParams
1638      */
1639     public void setNull(int parameterIndex, int sqlType, String typeName)
1640         throws SQLException {
1641 
1642         Object nullVal[];
1643         checkParamIndex(parameterIndex);
1644 
1645         nullVal = new Object[3];
1646         nullVal[0] = null;
1647         nullVal[1] = Integer.valueOf(sqlType);
1648         nullVal[2] = typeName;
1649 
1650        if(params == null){
1651             throw new SQLException("Set initParams() before setNull");
1652        }
1653 
1654         params.put(Integer.valueOf(parameterIndex - 1), nullVal);
1655     }
1656 
1657 
1658     /**
1659      * Sets the designated parameter to the given <code>boolean</code> in the
1660      * Java programming language.  The driver converts this to an SQL
1661      * <code>BIT</code> value when it sends it to the database.
1662      * <P>
1663      * The parameter value set by this method is stored internally and
1664      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1665      * object's command when the method <code>execute</code> is called.
1666      * Methods such as <code>execute</code>, <code>populate</code> must be
1667      * provided in any class that extends this class and implements one or
1668      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1669      * <p>
1670      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1671      * as it is undefined in this class.
1672      *
1673      * @param parameterIndex the ordinal number of the placeholder parameter
1674      *        in this <code>RowSet</code> object's command that is to be set.
1675      *        The first parameter is 1, the second is 2, and so on; must be
1676      *        <code>1</code> or greater
1677      * @param x the parameter value
1678      * @throws SQLException if an error occurs or the
1679      *                         parameter index is out of bounds
1680      * @see #getParams
1681      */
1682     public void setBoolean(int parameterIndex, boolean x) throws SQLException {
1683         checkParamIndex(parameterIndex);
1684 
1685        if(params == null){
1686             throw new SQLException("Set initParams() before setNull");
1687        }
1688 
1689         params.put(Integer.valueOf(parameterIndex - 1), Boolean.valueOf(x));
1690     }
1691 
1692     /**
1693      * Sets the designated parameter to the given <code>byte</code> in the Java
1694      * programming language.  The driver converts this to an SQL
1695      * <code>TINYINT</code> value when it sends it to the database.
1696      * <P>
1697      * The parameter value set by this method is stored internally and
1698      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1699      * object's command when the method <code>execute</code> is called.
1700      * Methods such as <code>execute</code> and <code>populate</code> must be
1701      * provided in any class that extends this class and implements one or
1702      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1703      * <p>
1704      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1705      * as it is undefined in this class.
1706      *
1707      * @param parameterIndex the ordinal number of the placeholder parameter
1708      *        in this <code>RowSet</code> object's command that is to be set.
1709      *        The first parameter is 1, the second is 2, and so on; must be
1710      *        <code>1</code> or greater
1711      * @param x the parameter value
1712      * @throws SQLException if an error occurs or the
1713      *                         parameter index is out of bounds
1714      * @see #getParams
1715      */
1716     public void setByte(int parameterIndex, byte x) throws SQLException {
1717         checkParamIndex(parameterIndex);
1718 
1719        if(params == null){
1720             throw new SQLException("Set initParams() before setByte");
1721        }
1722 
1723         params.put(Integer.valueOf(parameterIndex - 1), Byte.valueOf(x));
1724     }
1725 
1726     /**
1727      * Sets the designated parameter to the given <code>short</code> in the
1728      * Java programming language.  The driver converts this to an SQL
1729      * <code>SMALLINT</code> value when it sends it to the database.
1730      * <P>
1731      * The parameter value set by this method is stored internally and
1732      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1733      * object's command when the method <code>execute</code> is called.
1734      * Methods such as <code>execute</code> and <code>populate</code> must be
1735      * provided in any class that extends this class and implements one or
1736      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1737      * <p>
1738      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1739      * as it is undefined in this class.
1740      *
1741      * @param parameterIndex the ordinal number of the placeholder parameter
1742      *        in this <code>RowSet</code> object's command that is to be set.
1743      *        The first parameter is 1, the second is 2, and so on; must be
1744      *        <code>1</code> or greater
1745      * @param x the parameter value
1746      * @throws SQLException if an error occurs or the
1747      *                         parameter index is out of bounds
1748      * @see #getParams
1749      */
1750     public void setShort(int parameterIndex, short x) throws SQLException {
1751         checkParamIndex(parameterIndex);
1752 
1753         if(params == null){
1754              throw new SQLException("Set initParams() before setShort");
1755         }
1756 
1757         params.put(Integer.valueOf(parameterIndex - 1), Short.valueOf(x));
1758     }
1759 
1760     /**
1761      * Sets the designated parameter to an <code>int</code> in the Java
1762      * programming language.  The driver converts this to an SQL
1763      * <code>INTEGER</code> value when it sends it to the database.
1764      * <P>
1765      * The parameter value set by this method is stored internally and
1766      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1767      * object's command when the method <code>execute</code> is called.
1768      * Methods such as <code>execute</code> and <code>populate</code> must be
1769      * provided in any class that extends this class and implements one or
1770      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1771      * <P>
1772      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1773      * as it is undefined in this class.
1774      *
1775      * @param parameterIndex the ordinal number of the placeholder parameter
1776      *        in this <code>RowSet</code> object's command that is to be set.
1777      *        The first parameter is 1, the second is 2, and so on; must be
1778      *        <code>1</code> or greater
1779      * @param x the parameter value
1780      * @throws SQLException if an error occurs or the
1781      *                         parameter index is out of bounds
1782      * @see #getParams
1783      */
1784     public void setInt(int parameterIndex, int x) throws SQLException {
1785         checkParamIndex(parameterIndex);
1786         if(params == null){
1787              throw new SQLException("Set initParams() before setInt");
1788         }
1789         params.put(Integer.valueOf(parameterIndex - 1), Integer.valueOf(x));
1790     }
1791 
1792     /**
1793      * Sets the designated parameter to the given <code>long</code> in the Java
1794      * programming language.  The driver converts this to an SQL
1795      * <code>BIGINT</code> value when it sends it to the database.
1796      * <P>
1797      * The parameter value set by this method is stored internally and
1798      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1799      * object's command when the method <code>execute</code> is called.
1800      * Methods such as <code>execute</code> and <code>populate</code> must be
1801      * provided in any class that extends this class and implements one or
1802      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1803      * <P>
1804      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1805      * as it is undefined in this class.
1806      *
1807      * @param parameterIndex the ordinal number of the placeholder parameter
1808      *        in this <code>RowSet</code> object's command that is to be set.
1809      *        The first parameter is 1, the second is 2, and so on; must be
1810      *        <code>1</code> or greater
1811      * @param x the parameter value
1812      * @throws SQLException if an error occurs or the
1813      *                         parameter index is out of bounds
1814      * @see #getParams
1815      */
1816     public void setLong(int parameterIndex, long x) throws SQLException {
1817         checkParamIndex(parameterIndex);
1818         if(params == null){
1819              throw new SQLException("Set initParams() before setLong");
1820         }
1821         params.put(Integer.valueOf(parameterIndex - 1), Long.valueOf(x));
1822     }
1823 
1824     /**
1825      * Sets the designated parameter to the given <code>float</code> in the
1826      * Java programming language.  The driver converts this to an SQL
1827      * <code>FLOAT</code> value when it sends it to the database.
1828      * <P>
1829      * The parameter value set by this method is stored internally and
1830      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1831      * object's command when the method <code>execute</code> is called.
1832      * Methods such as <code>execute</code> and <code>populate</code> must be
1833      * provided in any class that extends this class and implements one or
1834      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1835      * <P>
1836      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1837      * as it is undefined in this class.
1838      *
1839      * @param parameterIndex the ordinal number of the placeholder parameter
1840      *        in this <code>RowSet</code> object's command that is to be set.
1841      *        The first parameter is 1, the second is 2, and so on; must be
1842      *        <code>1</code> or greater
1843      * @param x the parameter value
1844      * @throws SQLException if an error occurs or the
1845      *                         parameter index is out of bounds
1846      * @see #getParams
1847      */
1848     public void setFloat(int parameterIndex, float x) throws SQLException {
1849         checkParamIndex(parameterIndex);
1850         if(params == null){
1851              throw new SQLException("Set initParams() before setFloat");
1852         }
1853         params.put(Integer.valueOf(parameterIndex - 1), Float.valueOf(x));
1854     }
1855 
1856     /**
1857      * Sets the designated parameter to the given <code>double</code> in the
1858      * Java programming language.  The driver converts this to an SQL
1859      * <code>DOUBLE</code> value when it sends it to the database.
1860      * <P>
1861      * The parameter value set by this method is stored internally and
1862      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1863      * object's command when the method <code>execute</code> is called.
1864      * Methods such as <code>execute</code> and <code>populate</code> must be
1865      * provided in any class that extends this class and implements one or
1866      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1867      * <P>
1868      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1869      * as it is undefined in this class.
1870      *
1871      * @param parameterIndex the ordinal number of the placeholder parameter
1872      *        in this <code>RowSet</code> object's command that is to be set.
1873      *        The first parameter is 1, the second is 2, and so on; must be
1874      *        <code>1</code> or greater
1875      * @param x the parameter value
1876      * @throws SQLException if an error occurs or the
1877      *                         parameter index is out of bounds
1878      * @see #getParams
1879      */
1880     public void setDouble(int parameterIndex, double x) throws SQLException {
1881         checkParamIndex(parameterIndex);
1882         if(params == null){
1883              throw new SQLException("Set initParams() before setDouble");
1884         }
1885         params.put(Integer.valueOf(parameterIndex - 1), Double.valueOf(x));
1886     }
1887 
1888     /**
1889      * Sets the designated parameter to the given
1890      * <code>java.lang.BigDecimal</code> value.  The driver converts this to
1891      * an SQL <code>NUMERIC</code> value when it sends it to the database.
1892      * <P>
1893      * The parameter value set by this method is stored internally and
1894      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1895      * object's command when the method <code>execute</code> is called.
1896      * Methods such as <code>execute</code> and <code>populate</code> must be
1897      * provided in any class that extends this class and implements one or
1898      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1899      * <P>
1900      * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1901      * as it is undefined in this class.
1902      *
1903      * @param parameterIndex the ordinal number of the placeholder parameter
1904      *        in this <code>RowSet</code> object's command that is to be set.
1905      *        The first parameter is 1, the second is 2, and so on; must be
1906      *        <code>1</code> or greater
1907      * @param x the parameter value
1908      * @throws SQLException if an error occurs or the
1909      *                         parameter index is out of bounds
1910      * @see #getParams
1911      */
1912     public void setBigDecimal(int parameterIndex, java.math.BigDecimal x) throws SQLException {
1913         checkParamIndex(parameterIndex);
1914         if(params == null){
1915              throw new SQLException("Set initParams() before setBigDecimal");
1916         }
1917         params.put(Integer.valueOf(parameterIndex - 1), x);
1918     }
1919 
1920     /**
1921      * Sets the designated parameter to the given <code>String</code>
1922      * value.  The driver converts this to an SQL
1923      * <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
1924      * (depending on the argument's size relative to the driver's limits
1925      * on <code>VARCHAR</code> values) when it sends it to the database.
1926      * <P>
1927      * The parameter value set by this method is stored internally and
1928      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1929      * object's command when the method <code>execute</code> is called.
1930      * Methods such as <code>execute</code> and <code>populate</code> must be
1931      * provided in any class that extends this class and implements one or
1932      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1933      * <p>
1934      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1935      * as it is undefined in this class.
1936      *
1937      * @param parameterIndex the ordinal number of the placeholder parameter
1938      *        in this <code>RowSet</code> object's command that is to be set.
1939      *        The first parameter is 1, the second is 2, and so on; must be
1940      *        <code>1</code> or greater
1941      * @param x the parameter value
1942      * @throws SQLException if an error occurs or the
1943      *                         parameter index is out of bounds
1944      * @see #getParams
1945      */
1946     public void setString(int parameterIndex, String x) throws SQLException {
1947         checkParamIndex(parameterIndex);
1948         if(params == null){
1949              throw new SQLException("Set initParams() before setString");
1950         }
1951         params.put(Integer.valueOf(parameterIndex - 1), x);
1952     }
1953 
1954     /**
1955      * Sets the designated parameter to the given array of bytes.
1956      * The driver converts this to an SQL
1957      * <code>VARBINARY</code> or <code>LONGVARBINARY</code> value
1958      * (depending on the argument's size relative to the driver's limits
1959      * on <code>VARBINARY</code> values) when it sends it to the database.
1960      * <P>
1961      * The parameter value set by this method is stored internally and
1962      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1963      * object's command when the method <code>execute</code> is called.
1964      * Methods such as <code>execute</code> and <code>populate</code> must be
1965      * provided in any class that extends this class and implements one or
1966      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1967      * <p>
1968      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
1969      * as it is undefined in this class.
1970      *
1971      * @param parameterIndex the ordinal number of the placeholder parameter
1972      *        in this <code>RowSet</code> object's command that is to be set.
1973      *        The first parameter is 1, the second is 2, and so on; must be
1974      *        <code>1</code> or greater
1975      * @param x the parameter value
1976      * @throws SQLException if an error occurs or the
1977      *                         parameter index is out of bounds
1978      * @see #getParams
1979      */
1980     public void setBytes(int parameterIndex, byte x[]) throws SQLException {
1981         checkParamIndex(parameterIndex);
1982         if(params == null){
1983              throw new SQLException("Set initParams() before setBytes");
1984         }
1985         params.put(Integer.valueOf(parameterIndex - 1), x);
1986     }
1987 
1988     /**
1989      * Sets the designated parameter to the given <code>java.sql.Date</code>
1990      * value. The driver converts this to an SQL
1991      * <code>DATE</code> value when it sends it to the database.
1992      * <P>
1993      * The parameter value set by this method is stored internally and
1994      * will be supplied as the appropriate parameter in this <code>RowSet</code>
1995      * object's command when the method <code>execute</code> is called.
1996      * Methods such as <code>execute</code> and <code>populate</code> must be
1997      * provided in any class that extends this class and implements one or
1998      * more of the standard JSR-114 <code>RowSet</code> interfaces.
1999      * <P>
2000      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2001      * as it is undefined in this class.
2002      * <P>
2003      * Calls made to the method <code>getParams</code> after this version
2004      * of <code>setDate</code>
2005      * has been called will return an array with the value to be set for
2006      * placeholder parameter number <i>parameterIndex</i> being the <code>Date</code>
2007      * object supplied as the second parameter.
2008      * Note that because the numbering of elements in an array starts at zero,
2009      * the array element that corresponds to placeholder parameter number
2010      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2011      *
2012      * @param parameterIndex the ordinal number of the placeholder parameter
2013      *        in this <code>RowSet</code> object's command that is to be set.
2014      *        The first parameter is 1, the second is 2, and so on; must be
2015      *        <code>1</code> or greater
2016      * @param x the parameter value
2017      * @throws SQLException if an error occurs or the
2018      *                         parameter index is out of bounds
2019      * @see #getParams
2020      */
2021     public void setDate(int parameterIndex, java.sql.Date x) throws SQLException {
2022         checkParamIndex(parameterIndex);
2023 
2024         if(params == null){
2025              throw new SQLException("Set initParams() before setDate");
2026         }
2027         params.put(Integer.valueOf(parameterIndex - 1), x);
2028     }
2029 
2030     /**
2031      * Sets the designated parameter to the given <code>java.sql.Time</code>
2032      * value.  The driver converts this to an SQL <code>TIME</code> value
2033      * when it sends it to the database.
2034      * <P>
2035      * The parameter value set by this method is stored internally and
2036      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2037      * object's command when the method <code>execute</code> is called.
2038      * Methods such as <code>execute</code> and <code>populate</code> must be
2039      * provided in any class that extends this class and implements one or
2040      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2041      * <P>
2042      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2043      * as it is undefined in this class.
2044      * <P>
2045      * Calls made to the method <code>getParams</code> after this version
2046      * of the method <code>setTime</code>
2047      * has been called will return an array of the parameters that have been set.
2048      * The parameter to be set for parameter placeholder number <i>parameterIndex</i>
2049      * will be the <code>Time</code> object that was set as the second parameter
2050      * to this method.
2051      * <P>
2052      * Note that because the numbering of elements in an array starts at zero,
2053      * the array element that corresponds to placeholder parameter number
2054      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2055      *
2056      * @param parameterIndex the ordinal number of the placeholder parameter
2057      *        in this <code>RowSet</code> object's command that is to be set.
2058      *        The first parameter is 1, the second is 2, and so on; must be
2059      *        <code>1</code> or greater
2060      * @param x a <code>java.sql.Time</code> object, which is to be set as the value
2061      *              for placeholder parameter <i>parameterIndex</i>
2062      * @throws SQLException if an error occurs or the
2063      *                         parameter index is out of bounds
2064      * @see #getParams
2065      */
2066     public void setTime(int parameterIndex, java.sql.Time x) throws SQLException {
2067         checkParamIndex(parameterIndex);
2068         if(params == null){
2069              throw new SQLException("Set initParams() before setTime");
2070         }
2071 
2072         params.put(Integer.valueOf(parameterIndex - 1), x);
2073     }
2074 
2075     /**
2076      * Sets the designated parameter to the given
2077      * <code>java.sql.Timestamp</code> value.
2078      * The driver converts this to an SQL <code>TIMESTAMP</code> value when it
2079      * sends it to the database.
2080      * <P>
2081      * The parameter value set by this method is stored internally and
2082      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2083      * object's command when the method <code>execute</code> is called.
2084      * Methods such as <code>execute</code> and <code>populate</code> must be
2085      * provided in any class that extends this class and implements one or
2086      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2087      * <P>
2088      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2089      * as it is undefined in this class.
2090      * <P>
2091      * Calls made to the method <code>getParams</code> after this version of
2092      * <code>setTimestamp</code>
2093      * has been called will return an array with the value for parameter placeholder
2094      * number <i>parameterIndex</i> being the <code>Timestamp</code> object that was
2095      * supplied as the second parameter to this method.
2096      * Note that because the numbering of elements in an array starts at zero,
2097      * the array element that corresponds to placeholder parameter number
2098      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2099      *
2100      * @param parameterIndex the ordinal number of the placeholder parameter
2101      *        in this <code>RowSet</code> object's command that is to be set.
2102      *        The first parameter is 1, the second is 2, and so on; must be
2103      *        <code>1</code> or greater
2104      * @param x a <code>java.sql.Timestamp</code> object
2105      * @throws SQLException if an error occurs or the
2106      *                         parameter index is out of bounds
2107      * @see #getParams
2108      */
2109     public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException {
2110         checkParamIndex(parameterIndex);
2111         if(params == null){
2112              throw new SQLException("Set initParams() before setTimestamp");
2113         }
2114 
2115         params.put(Integer.valueOf(parameterIndex - 1), x);
2116     }
2117 
2118     /**
2119      * Sets the designated parameter to the given
2120      * <code>java.io.InputStream</code> object,
2121      * which will have the specified number of bytes.
2122      * The contents of the stream will be read and sent to the database.
2123      * This method throws an <code>SQLException</code> object if the number of bytes
2124      * read and sent to the database is not equal to <i>length</i>.
2125      * <P>
2126      * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2127      * parameter, it may be more practical to send it via a
2128      * <code>java.io.InputStream</code> object. A JDBC technology-enabled
2129      * driver will read the data from the stream as needed until it reaches
2130      * end-of-file. The driver will do any necessary conversion from ASCII to
2131      * the database <code>CHAR</code> format.
2132      *
2133      * <P><B>Note:</B> This stream object can be either a standard
2134      * Java stream object or your own subclass that implements the
2135      * standard interface.
2136      * <P>
2137      * The parameter value set by this method is stored internally and
2138      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2139      * object's command when the method <code>execute</code> is called.
2140      * Methods such as <code>execute</code> and <code>populate</code> must be
2141      * provided in any class that extends this class and implements one or
2142      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2143      * <P>
2144      * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2145      * as it is undefined in this class.
2146      * <P>
2147      * Calls made to the method <code>getParams</code> after <code>setAsciiStream</code>
2148      * has been called will return an array containing the parameter values that
2149      * have been set.  The element in the array that represents the values
2150      * set with this method will itself be an array. The first element of that array
2151      * is the given <code>java.io.InputStream</code> object.
2152      * The second element is the value set for <i>length</i>.
2153      * The third element is an internal <code>BaseRowSet</code> constant
2154      * specifying that the stream passed to this method is an ASCII stream.
2155      * The parameter number is indicated by an element's position in the array
2156      * returned by the method <code>getParams</code>,
2157      * with the first element being the value for the first placeholder parameter, the
2158      * second element being the value for the second placeholder parameter, and so on.
2159      * In other words, if the input stream being set is the value for the second
2160      * placeholder parameter, the array containing it will be the second element in
2161      * the array returned by <code>getParams</code>.
2162      * <P>
2163      * Note that because the numbering of elements in an array starts at zero,
2164      * the array element that corresponds to placeholder parameter number
2165      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2166      *
2167      * @param parameterIndex the ordinal number of the placeholder parameter
2168      *        in this <code>RowSet</code> object's command that is to be set.
2169      *        The first parameter is 1, the second is 2, and so on; must be
2170      *        <code>1</code> or greater
2171      * @param x the Java input stream that contains the ASCII parameter value
2172      * @param length the number of bytes in the stream. This is the number of bytes
2173      *       the driver will send to the DBMS; lengths of 0 or less are
2174      *       are undefined but will cause an invalid length exception to be
2175      *       thrown in the underlying JDBC driver.
2176      * @throws SQLException if an error occurs, the parameter index is out of bounds,
2177      *       or when connected to a data source, the number of bytes the driver reads
2178      *       and sends to the database is not equal to the number of bytes specified
2179      *       in <i>length</i>
2180      * @see #getParams
2181      */
2182     public void setAsciiStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2183         Object asciiStream[];
2184         checkParamIndex(parameterIndex);
2185 
2186         asciiStream = new Object[3];
2187         asciiStream[0] = x;
2188         asciiStream[1] = Integer.valueOf(length);
2189         asciiStream[2] = Integer.valueOf(ASCII_STREAM_PARAM);
2190 
2191         if(params == null){
2192              throw new SQLException("Set initParams() before setAsciiStream");
2193         }
2194 
2195         params.put(Integer.valueOf(parameterIndex - 1), asciiStream);
2196     }
2197 
2198   /**
2199    * Sets the designated parameter in this <code>RowSet</code> object's command
2200    * to the given input stream.
2201    * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
2202    * parameter, it may be more practical to send it via a
2203    * <code>java.io.InputStream</code>. Data will be read from the stream
2204    * as needed until end-of-file is reached.  The JDBC driver will
2205    * do any necessary conversion from ASCII to the database char format.
2206    *
2207    * <P><B>Note:</B> This stream object can either be a standard
2208    * Java stream object or your own subclass that implements the
2209    * standard interface.
2210    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2211    * it might be more efficient to use a version of
2212    * <code>setAsciiStream</code> which takes a length parameter.
2213    *
2214    * @param parameterIndex the first parameter is 1, the second is 2, ...
2215    * @param x the Java input stream that contains the ASCII parameter value
2216    * @exception SQLException if a database access error occurs or
2217    * this method is called on a closed <code>PreparedStatement</code>
2218    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
2219    * @since 1.6
2220    */
2221   public void setAsciiStream(int parameterIndex, java.io.InputStream x)
2222                       throws SQLException {
2223       throw new SQLFeatureNotSupportedException("Feature not supported");
2224   }
2225 
2226     /**
2227      * Sets the designated parameter to the given <code>java.io.InputStream</code>
2228      * object, which will have the specified number of bytes.
2229      * The contents of the stream will be read and sent to the database.
2230      * This method throws an <code>SQLException</code> object if the number of bytes
2231      * read and sent to the database is not equal to <i>length</i>.
2232      * <P>
2233      * When a very large binary value is input to a
2234      * <code>LONGVARBINARY</code> parameter, it may be more practical
2235      * to send it via a <code>java.io.InputStream</code> object.
2236      * A JDBC technology-enabled driver will read the data from the
2237      * stream as needed until it reaches end-of-file.
2238      *
2239      * <P><B>Note:</B> This stream object can be either a standard
2240      * Java stream object or your own subclass that implements the
2241      * standard interface.
2242      * <P>
2243      * The parameter value set by this method is stored internally and
2244      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2245      * object's command when the method <code>execute</code> is called.
2246      * Methods such as <code>execute</code> and <code>populate</code> must be
2247      * provided in any class that extends this class and implements one or
2248      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2249      *<P>
2250      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2251      * as it is undefined in this class.
2252      * <P>
2253      * Calls made to the method <code>getParams</code> after <code>setBinaryStream</code>
2254      * has been called will return an array containing the parameter values that
2255      * have been set.  In that array, the element that represents the values
2256      * set with this method will itself be an array. The first element of that array
2257      * is the given <code>java.io.InputStream</code> object.
2258      * The second element is the value set for <i>length</i>.
2259      * The third element is an internal <code>BaseRowSet</code> constant
2260      * specifying that the stream passed to this method is a binary stream.
2261      * The parameter number is indicated by an element's position in the array
2262      * returned by the method <code>getParams</code>,
2263      * with the first element being the value for the first placeholder parameter, the
2264      * second element being the value for the second placeholder parameter, and so on.
2265      * In other words, if the input stream being set is the value for the second
2266      * placeholder parameter, the array containing it will be the second element in
2267      * the array returned by <code>getParams</code>.
2268      * <P>
2269      * Note that because the numbering of elements in an array starts at zero,
2270      * the array element that corresponds to placeholder parameter number
2271      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2272      *
2273      * @param parameterIndex the ordinal number of the placeholder parameter
2274      *        in this <code>RowSet</code> object's command that is to be set.
2275      *        The first parameter is 1, the second is 2, and so on; must be
2276      *        <code>1</code> or greater
2277      * @param x the input stream that contains the binary value to be set
2278      * @param length the number of bytes in the stream; lengths of 0 or less are
2279      *         are undefined but will cause an invalid length exception to be
2280      *         thrown in the underlying JDBC driver.
2281      * @throws SQLException if an error occurs, the parameter index is out of bounds,
2282      *         or when connected to a data source, the number of bytes the driver
2283      *         reads and sends to the database is not equal to the number of bytes
2284      *         specified in <i>length</i>
2285      * @see #getParams
2286      */
2287     public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2288         Object binaryStream[];
2289         checkParamIndex(parameterIndex);
2290 
2291         binaryStream = new Object[3];
2292         binaryStream[0] = x;
2293         binaryStream[1] = Integer.valueOf(length);
2294         binaryStream[2] = Integer.valueOf(BINARY_STREAM_PARAM);
2295         if(params == null){
2296              throw new SQLException("Set initParams() before setBinaryStream");
2297         }
2298 
2299         params.put(Integer.valueOf(parameterIndex - 1), binaryStream);
2300     }
2301 
2302 
2303    /**
2304    * Sets the designated parameter in this <code>RowSet</code> object's command
2305    * to the given input stream.
2306    * When a very large binary value is input to a <code>LONGVARBINARY</code>
2307    * parameter, it may be more practical to send it via a
2308    * <code>java.io.InputStream</code> object. The data will be read from the
2309    * stream as needed until end-of-file is reached.
2310    *
2311    * <P><B>Note:</B> This stream object can either be a standard
2312    * Java stream object or your own subclass that implements the
2313    * standard interface.
2314    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2315    * it might be more efficient to use a version of
2316    * <code>setBinaryStream</code> which takes a length parameter.
2317    *
2318    * @param parameterIndex the first parameter is 1, the second is 2, ...
2319    * @param x the java input stream which contains the binary parameter value
2320    * @exception SQLException if a database access error occurs or
2321    * this method is called on a closed <code>PreparedStatement</code>
2322    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
2323    * @since 1.6
2324    */
2325   public void setBinaryStream(int parameterIndex, java.io.InputStream x)
2326                               throws SQLException {
2327       throw new SQLFeatureNotSupportedException("Feature not supported");
2328   }
2329 
2330 
2331     /**
2332      * Sets the designated parameter to the given
2333      * <code>java.io.InputStream</code> object, which will have the specified
2334      * number of bytes. The contents of the stream will be read and sent
2335      * to the database.
2336      * This method throws an <code>SQLException</code> if the number of bytes
2337      * read and sent to the database is not equal to <i>length</i>.
2338      * <P>
2339      * When a very large Unicode value is input to a
2340      * <code>LONGVARCHAR</code> parameter, it may be more practical
2341      * to send it via a <code>java.io.InputStream</code> object.
2342      * A JDBC technology-enabled driver will read the data from the
2343      * stream as needed, until it reaches end-of-file.
2344      * The driver will do any necessary conversion from Unicode to the
2345      * database <code>CHAR</code> format.
2346      * The byte format of the Unicode stream must be Java UTF-8, as
2347      * defined in the Java Virtual Machine Specification.
2348      *
2349      * <P><B>Note:</B> This stream object can be either a standard
2350      * Java stream object or your own subclass that implements the
2351      * standard interface.
2352      * <P>
2353      * This method is deprecated; the method <code>getCharacterStream</code>
2354      * should be used in its place.
2355      * <P>
2356      * The parameter value set by this method is stored internally and
2357      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2358      * object's command when the method <code>execute</code> is called.
2359      * Calls made to the method <code>getParams</code> after <code>setUnicodeStream</code>
2360      * has been called will return an array containing the parameter values that
2361      * have been set.  In that array, the element that represents the values
2362      * set with this method will itself be an array. The first element of that array
2363      * is the given <code>java.io.InputStream</code> object.
2364      * The second element is the value set for <i>length</i>.
2365      * The third element is an internal <code>BaseRowSet</code> constant
2366      * specifying that the stream passed to this method is a Unicode stream.
2367      * The parameter number is indicated by an element's position in the array
2368      * returned by the method <code>getParams</code>,
2369      * with the first element being the value for the first placeholder parameter, the
2370      * second element being the value for the second placeholder parameter, and so on.
2371      * In other words, if the input stream being set is the value for the second
2372      * placeholder parameter, the array containing it will be the second element in
2373      * the array returned by <code>getParams</code>.
2374      * <P>
2375      * Note that because the numbering of elements in an array starts at zero,
2376      * the array element that corresponds to placeholder parameter number
2377      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2378      *
2379      * @param parameterIndex the ordinal number of the placeholder parameter
2380      *        in this <code>RowSet</code> object's command that is to be set.
2381      *        The first parameter is 1, the second is 2, and so on; must be
2382      *        <code>1</code> or greater
2383      * @param x the <code>java.io.InputStream</code> object that contains the
2384      *          UNICODE parameter value
2385      * @param length the number of bytes in the input stream
2386      * @throws SQLException if an error occurs, the parameter index is out of bounds,
2387      *         or the number of bytes the driver reads and sends to the database is
2388      *         not equal to the number of bytes specified in <i>length</i>
2389      * @deprecated getCharacterStream should be used in its place
2390      * @see #getParams
2391      */
2392     @Deprecated
2393     public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
2394         Object unicodeStream[];
2395         checkParamIndex(parameterIndex);
2396 
2397         unicodeStream = new Object[3];
2398         unicodeStream[0] = x;
2399         unicodeStream[1] = Integer.valueOf(length);
2400         unicodeStream[2] = Integer.valueOf(UNICODE_STREAM_PARAM);
2401         if(params == null){
2402              throw new SQLException("Set initParams() before setUnicodeStream");
2403         }
2404         params.put(Integer.valueOf(parameterIndex - 1), unicodeStream);
2405     }
2406 
2407     /**
2408      * Sets the designated parameter to the given <code>java.io.Reader</code>
2409      * object, which will have the specified number of characters. The
2410      * contents of the reader will be read and sent to the database.
2411      * This method throws an <code>SQLException</code> if the number of bytes
2412      * read and sent to the database is not equal to <i>length</i>.
2413      * <P>
2414      * When a very large Unicode value is input to a
2415      * <code>LONGVARCHAR</code> parameter, it may be more practical
2416      * to send it via a <code>Reader</code> object.
2417      * A JDBC technology-enabled driver will read the data from the
2418      * stream as needed until it reaches end-of-file.
2419      * The driver will do any necessary conversion from Unicode to the
2420      * database <code>CHAR</code> format.
2421      * The byte format of the Unicode stream must be Java UTF-8, as
2422      * defined in the Java Virtual Machine Specification.
2423      *
2424      * <P><B>Note:</B> This stream object can be either a standard
2425      * Java stream object or your own subclass that implements the
2426      * standard interface.
2427      * <P>
2428      * The parameter value set by this method is stored internally and
2429      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2430      * object's command when the method <code>execute</code> is called.
2431      * Methods such as <code>execute</code> and <code>populate</code> must be
2432      * provided in any class that extends this class and implements one or
2433      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2434      * <P>
2435      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2436      * as it is undefined in this class.
2437      * <P>
2438      * Calls made to the method <code>getParams</code> after
2439      * <code>setCharacterStream</code>
2440      * has been called will return an array containing the parameter values that
2441      * have been set.  In that array, the element that represents the values
2442      * set with this method will itself be an array. The first element of that array
2443      * is the given <code>java.io.Reader</code> object.
2444      * The second element is the value set for <i>length</i>.
2445      * The parameter number is indicated by an element's position in the array
2446      * returned by the method <code>getParams</code>,
2447      * with the first element being the value for the first placeholder parameter, the
2448      * second element being the value for the second placeholder parameter, and so on.
2449      * In other words, if the reader being set is the value for the second
2450      * placeholder parameter, the array containing it will be the second element in
2451      * the array returned by <code>getParams</code>.
2452      * <P>
2453      * Note that because the numbering of elements in an array starts at zero,
2454      * the array element that corresponds to placeholder parameter number
2455      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2456      *
2457      * @param parameterIndex the ordinal number of the placeholder parameter
2458      *        in this <code>RowSet</code> object's command that is to be set.
2459      *        The first parameter is 1, the second is 2, and so on; must be
2460      *        <code>1</code> or greater
2461      * @param reader the <code>Reader</code> object that contains the
2462      *        Unicode data
2463      * @param length the number of characters in the stream; lengths of 0 or
2464      *        less are undefined but will cause an invalid length exception to
2465      *        be thrown in the underlying JDBC driver.
2466      * @throws SQLException if an error occurs, the parameter index is out of bounds,
2467      *        or when connected to a data source, the number of bytes the driver
2468      *        reads and sends to the database is not equal to the number of bytes
2469      *        specified in <i>length</i>
2470      * @see #getParams
2471      */
2472     public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
2473         Object charStream[];
2474         checkParamIndex(parameterIndex);
2475 
2476         charStream = new Object[2];
2477         charStream[0] = reader;
2478         charStream[1] = Integer.valueOf(length);
2479         if(params == null){
2480              throw new SQLException("Set initParams() before setCharacterStream");
2481         }
2482         params.put(Integer.valueOf(parameterIndex - 1), charStream);
2483     }
2484 
2485    /**
2486    * Sets the designated parameter in this <code>RowSet</code> object's command
2487    * to the given <code>Reader</code>
2488    * object.
2489    * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
2490    * parameter, it may be more practical to send it via a
2491    * <code>java.io.Reader</code> object. The data will be read from the stream
2492    * as needed until end-of-file is reached.  The JDBC driver will
2493    * do any necessary conversion from UNICODE to the database char format.
2494    *
2495    * <P><B>Note:</B> This stream object can either be a standard
2496    * Java stream object or your own subclass that implements the
2497    * standard interface.
2498    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
2499    * it might be more efficient to use a version of
2500    * <code>setCharacterStream</code> which takes a length parameter.
2501    *
2502    * @param parameterIndex the first parameter is 1, the second is 2, ...
2503    * @param reader the <code>java.io.Reader</code> object that contains the
2504    *        Unicode data
2505    * @exception SQLException if a database access error occurs or
2506    * this method is called on a closed <code>PreparedStatement</code>
2507    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
2508    * @since 1.6
2509    */
2510   public void setCharacterStream(int parameterIndex,
2511                           java.io.Reader reader) throws SQLException {
2512       throw new SQLFeatureNotSupportedException("Feature not supported");
2513   }
2514 
2515     /**
2516      * Sets the designated parameter to an <code>Object</code> in the Java
2517      * programming language. The second parameter must be an
2518      * <code>Object</code> type.  For integral values, the
2519      * <code>java.lang</code> equivalent
2520      * objects should be used. For example, use the class <code>Integer</code>
2521      * for an <code>int</code>.
2522      * <P>
2523      * The driver converts this object to the specified
2524      * target SQL type before sending it to the database.
2525      * If the object has a custom mapping (is of a class implementing
2526      * <code>SQLData</code>), the driver should call the method
2527      * <code>SQLData.writeSQL</code> to write the object to the SQL
2528      * data stream. If, on the other hand, the object is of a class
2529      * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2530      * <code>Struct</code>, or <code>Array</code>,
2531      * the driver should pass it to the database as a value of the
2532      * corresponding SQL type.
2533      *
2534      * <p>Note that this method may be used to pass database-
2535      * specific abstract data types.
2536      * <P>
2537      * The parameter value set by this method is stored internally and
2538      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2539      * object's command when the method <code>execute</code> is called.
2540      * Methods such as <code>execute</code> and <code>populate</code> must be
2541      * provided in any class that extends this class and implements one or
2542      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2543      * <P>
2544      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2545      * as it is undefined in this class.
2546      * <P>
2547      * Calls made to the method <code>getParams</code> after this version of
2548      * <code>setObject</code>
2549      * has been called will return an array containing the parameter values that
2550      * have been set.  In that array, the element that represents the values
2551      * set with this method will itself be an array. The first element of that array
2552      * is the given <code>Object</code> instance, and the
2553      * second element is the value set for <i>targetSqlType</i>.  The
2554      * third element is the value set for <i>scale</i>, which the driver will
2555      * ignore if the type of the object being set is not
2556      * <code>java.sql.Types.NUMERIC</code> or <code>java.sql.Types.DECIMAL</code>.
2557      * The parameter number is indicated by an element's position in the array
2558      * returned by the method <code>getParams</code>,
2559      * with the first element being the value for the first placeholder parameter, the
2560      * second element being the value for the second placeholder parameter, and so on.
2561      * In other words, if the object being set is the value for the second
2562      * placeholder parameter, the array containing it will be the second element in
2563      * the array returned by <code>getParams</code>.
2564      *<P>
2565      * Note that because the numbering of elements in an array starts at zero,
2566      * the array element that corresponds to placeholder parameter number
2567      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2568      *
2569      *
2570      * @param parameterIndex the ordinal number of the placeholder parameter
2571      *        in this <code>RowSet</code> object's command that is to be set.
2572      *        The first parameter is 1, the second is 2, and so on; must be
2573      *        <code>1</code> or greater
2574      * @param x the <code>Object</code> containing the input parameter value;
2575      *        must be an <code>Object</code> type
2576      * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
2577      *        to be sent to the database. The <code>scale</code> argument may
2578      *        further qualify this type. If a non-standard <i>targetSqlType</i>
2579      *        is supplied, this method will not throw a <code>SQLException</code>.
2580      *        This allows implicit support for non-standard SQL types.
2581      * @param scale for the types <code>java.sql.Types.DECIMAL</code> and
2582      *        <code>java.sql.Types.NUMERIC</code>, this is the number
2583      *        of digits after the decimal point.  For all other types, this
2584      *        value will be ignored.
2585      * @throws SQLException if an error occurs or the parameter index is out of bounds
2586      * @see #getParams
2587      */
2588     public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
2589         Object obj[];
2590         checkParamIndex(parameterIndex);
2591 
2592         obj = new Object[3];
2593         obj[0] = x;
2594         obj[1] = Integer.valueOf(targetSqlType);
2595         obj[2] = Integer.valueOf(scale);
2596         if(params == null){
2597              throw new SQLException("Set initParams() before setObject");
2598         }
2599         params.put(Integer.valueOf(parameterIndex - 1), obj);
2600     }
2601 
2602     /**
2603      * Sets the value of the designated parameter with the given
2604      * <code>Object</code> value.
2605      * This method is like <code>setObject(int parameterIndex, Object x, int
2606      * targetSqlType, int scale)</code> except that it assumes a scale of zero.
2607      * <P>
2608      * The parameter value set by this method is stored internally and
2609      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2610      * object's command when the method <code>execute</code> is called.
2611      * Methods such as <code>execute</code> and <code>populate</code> must be
2612      * provided in any class that extends this class and implements one or
2613      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2614      * <P>
2615      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2616      * as it is undefined in this class.
2617      * <P>
2618      * Calls made to the method <code>getParams</code> after this version of
2619      * <code>setObject</code>
2620      * has been called will return an array containing the parameter values that
2621      * have been set.  In that array, the element that represents the values
2622      * set with this method will itself be an array. The first element of that array
2623      * is the given <code>Object</code> instance.
2624      * The second element is the value set for <i>targetSqlType</i>.
2625      * The parameter number is indicated by an element's position in the array
2626      * returned by the method <code>getParams</code>,
2627      * with the first element being the value for the first placeholder parameter, the
2628      * second element being the value for the second placeholder parameter, and so on.
2629      * In other words, if the object being set is the value for the second
2630      * placeholder parameter, the array containing it will be the second element in
2631      * the array returned by <code>getParams</code>.
2632      * <P>
2633      * Note that because the numbering of elements in an array starts at zero,
2634      * the array element that corresponds to placeholder parameter number
2635      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2636      *
2637      * @param parameterIndex the ordinal number of the placeholder parameter
2638      *        in this <code>RowSet</code> object's command that is to be set.
2639      *        The first parameter is 1, the second is 2, and so on; must be
2640      *        <code>1</code> or greater
2641      * @param x the <code>Object</code> containing the input parameter value;
2642      *        must be an <code>Object</code> type
2643      * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
2644      *        to be sent to the database. If a non-standard <i>targetSqlType</i>
2645      *        is supplied, this method will not throw a <code>SQLException</code>.
2646      *        This allows implicit support for non-standard SQL types.
2647      * @throws SQLException if an error occurs or the parameter index
2648      *        is out of bounds
2649      * @see #getParams
2650      */
2651     public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
2652         Object obj[];
2653         checkParamIndex(parameterIndex);
2654 
2655         obj = new Object[2];
2656         obj[0] = x;
2657         obj[1] = Integer.valueOf(targetSqlType);
2658         if (params == null){
2659              throw new SQLException("Set initParams() before setObject");
2660         }
2661         params.put(Integer.valueOf(parameterIndex - 1), obj);
2662     }
2663 
2664     /**
2665      * Sets the designated parameter to an <code>Object</code> in the Java
2666      * programming language. The second parameter must be an
2667      * <code>Object</code>
2668      * type.  For integral values, the <code>java.lang</code> equivalent
2669      * objects should be used. For example, use the class <code>Integer</code>
2670      * for an <code>int</code>.
2671      * <P>
2672      * The JDBC specification defines a standard mapping from
2673      * Java <code>Object</code> types to SQL types.  The driver will
2674      * use this standard mapping to  convert the given object
2675      * to its corresponding SQL type before sending it to the database.
2676      * If the object has a custom mapping (is of a class implementing
2677      * <code>SQLData</code>), the driver should call the method
2678      * <code>SQLData.writeSQL</code> to write the object to the SQL
2679      * data stream.
2680      * <P>
2681      * If, on the other hand, the object is of a class
2682      * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
2683      * <code>Struct</code>, or <code>Array</code>,
2684      * the driver should pass it to the database as a value of the
2685      * corresponding SQL type.
2686      * <P>
2687      * This method throws an exception if there
2688      * is an ambiguity, for example, if the object is of a class
2689      * implementing more than one interface.
2690      * <P>
2691      * Note that this method may be used to pass database-specific
2692      * abstract data types.
2693      * <P>
2694      * The parameter value set by this method is stored internally and
2695      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2696      * object's command when the method <code>execute</code> is called.
2697      * Methods such as <code>execute</code> and <code>populate</code> must be
2698      * provided in any class that extends this class and implements one or
2699      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2700      * <p>
2701      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2702      * as it is undefined in this class.
2703      * <P>
2704      * After this method has been called, a call to the
2705      * method <code>getParams</code>
2706      * will return an object array of the current command parameters, which will
2707      * include the <code>Object</code> set for placeholder parameter number
2708      * <code>parameterIndex</code>.
2709      * Note that because the numbering of elements in an array starts at zero,
2710      * the array element that corresponds to placeholder parameter number
2711      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2712      *
2713      * @param parameterIndex the ordinal number of the placeholder parameter
2714      *        in this <code>RowSet</code> object's command that is to be set.
2715      *        The first parameter is 1, the second is 2, and so on; must be
2716      *        <code>1</code> or greater
2717      * @param x the object containing the input parameter value
2718      * @throws SQLException if an error occurs the
2719      *                         parameter index is out of bounds, or there
2720      *                         is ambiguity in the implementation of the
2721      *                         object being set
2722      * @see #getParams
2723      */
2724     public void setObject(int parameterIndex, Object x) throws SQLException {
2725         checkParamIndex(parameterIndex);
2726         if (params == null) {
2727              throw new SQLException("Set initParams() before setObject");
2728         }
2729         params.put(Integer.valueOf(parameterIndex - 1), x);
2730     }
2731 
2732     /**
2733      * Sets the designated parameter to the given <code>Ref</code> object in
2734      * the Java programming language.  The driver converts this to an SQL
2735      * <code>REF</code> value when it sends it to the database. Internally, the
2736      * <code>Ref</code> is represented as a <code>SerialRef</code> to ensure
2737      * serializability.
2738      * <P>
2739      * The parameter value set by this method is stored internally and
2740      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2741      * object's command when the method <code>execute</code> is called.
2742      * Methods such as <code>execute</code> and <code>populate</code> must be
2743      * provided in any class that extends this class and implements one or
2744      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2745      * <p>
2746      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2747      * as it is undefined in this class.
2748      * <p>
2749      * After this method has been called, a call to the
2750      * method <code>getParams</code>
2751      * will return an object array of the current command parameters, which will
2752      * include the <code>Ref</code> object set for placeholder parameter number
2753      * <code>parameterIndex</code>.
2754      * Note that because the numbering of elements in an array starts at zero,
2755      * the array element that corresponds to placeholder parameter number
2756      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2757      *
2758      * @param parameterIndex the ordinal number of the placeholder parameter
2759      *        in this <code>RowSet</code> object's command that is to be set.
2760      *        The first parameter is 1, the second is 2, and so on; must be
2761      *        <code>1</code> or greater
2762      * @param ref a <code>Ref</code> object representing an SQL <code>REF</code>
2763      *         value; cannot be null
2764      * @throws SQLException if an error occurs; the parameter index is out of
2765      *         bounds or the <code>Ref</code> object is <code>null</code>; or
2766      *         the <code>Ref</code> object returns a <code>null</code> base type
2767      *         name.
2768      * @see #getParams
2769      * @see javax.sql.rowset.serial.SerialRef
2770      */
2771     public void setRef (int parameterIndex, Ref ref) throws SQLException {
2772         checkParamIndex(parameterIndex);
2773         if (params == null) {
2774              throw new SQLException("Set initParams() before setRef");
2775         }
2776         params.put(Integer.valueOf(parameterIndex - 1), new SerialRef(ref));
2777     }
2778 
2779     /**
2780      * Sets the designated parameter to the given <code>Blob</code> object in
2781      * the Java programming language.  The driver converts this to an SQL
2782      * <code>BLOB</code> value when it sends it to the database. Internally,
2783      * the <code>Blob</code> is represented as a <code>SerialBlob</code>
2784      * to ensure serializability.
2785      * <P>
2786      * The parameter value set by this method is stored internally and
2787      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2788      * object's command when the method <code>execute</code> is called.
2789      * Methods such as <code>execute</code> and <code>populate</code> must be
2790      * provided in any class that extends this class and implements one or
2791      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2792      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2793      * as it is undefined in this class.
2794      * <p>
2795      * After this method has been called, a call to the
2796      * method <code>getParams</code>
2797      * will return an object array of the current command parameters, which will
2798      * include the <code>Blob</code> object set for placeholder parameter number
2799      * <code>parameterIndex</code>.
2800      * Note that because the numbering of elements in an array starts at zero,
2801      * the array element that corresponds to placeholder parameter number
2802      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2803      *
2804      * @param parameterIndex the ordinal number of the placeholder parameter
2805      *        in this <code>RowSet</code> object's command that is to be set.
2806      *        The first parameter is 1, the second is 2, and so on; must be
2807      *        <code>1</code> or greater
2808      * @param x a <code>Blob</code> object representing an SQL
2809      *          <code>BLOB</code> value
2810      * @throws SQLException if an error occurs or the
2811      *                         parameter index is out of bounds
2812      * @see #getParams
2813      * @see javax.sql.rowset.serial.SerialBlob
2814      */
2815     public void setBlob (int parameterIndex, Blob x) throws SQLException {
2816         checkParamIndex(parameterIndex);
2817         if(params == null){
2818              throw new SQLException("Set initParams() before setBlob");
2819         }
2820         params.put(Integer.valueOf(parameterIndex - 1), new SerialBlob(x));
2821     }
2822 
2823     /**
2824      * Sets the designated parameter to the given <code>Clob</code> object in
2825      * the Java programming language.  The driver converts this to an SQL
2826      * <code>CLOB</code> value when it sends it to the database. Internally, the
2827      * <code>Clob</code> is represented as a <code>SerialClob</code> to ensure
2828      * serializability.
2829      * <P>
2830      * The parameter value set by this method is stored internally and
2831      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2832      * object's command when the method <code>execute</code> is called.
2833      * Methods such as <code>execute</code> and <code>populate</code> must be
2834      * provided in any class that extends this class and implements one or
2835      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2836      * <p>
2837      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2838      * as it is undefined in this class.
2839      * <p>
2840      * After this method has been called, a call to the
2841      * method <code>getParams</code>
2842      * will return an object array of the current command parameters, which will
2843      * include the <code>Clob</code> object set for placeholder parameter number
2844      * <code>parameterIndex</code>.
2845      * Note that because the numbering of elements in an array starts at zero,
2846      * the array element that corresponds to placeholder parameter number
2847      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2848      *
2849      * @param parameterIndex the ordinal number of the placeholder parameter
2850      *     in this <code>RowSet</code> object's command that is to be set.
2851      *     The first parameter is 1, the second is 2, and so on; must be
2852      *     <code>1</code> or greater
2853      * @param x a <code>Clob</code> object representing an SQL
2854      *     <code>CLOB</code> value; cannot be null
2855      * @throws SQLException if an error occurs; the parameter index is out of
2856      *     bounds or the <code>Clob</code> is null
2857      * @see #getParams
2858      * @see javax.sql.rowset.serial.SerialBlob
2859      */
2860     public void setClob (int parameterIndex, Clob x) throws SQLException {
2861         checkParamIndex(parameterIndex);
2862         if(params == null){
2863              throw new SQLException("Set initParams() before setClob");
2864         }
2865         params.put(Integer.valueOf(parameterIndex - 1), new SerialClob(x));
2866     }
2867 
2868     /**
2869      * Sets the designated parameter to an <code>Array</code> object in the
2870      * Java programming language.  The driver converts this to an SQL
2871      * <code>ARRAY</code> value when it sends it to the database. Internally,
2872      * the <code>Array</code> is represented as a <code>SerialArray</code>
2873      * to ensure serializability.
2874      * <P>
2875      * The parameter value set by this method is stored internally and
2876      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2877      * object's command when the method <code>execute</code> is called.
2878      * Methods such as <code>execute</code> and <code>populate</code> must be
2879      * provided in any class that extends this class and implements one or
2880      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2881      * <P>
2882      * Note: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2883      * as it is undefined in this class.
2884      * <p>
2885      * After this method has been called, a call to the
2886      * method <code>getParams</code>
2887      * will return an object array of the current command parameters, which will
2888      * include the <code>Array</code> object set for placeholder parameter number
2889      * <code>parameterIndex</code>.
2890      * Note that because the numbering of elements in an array starts at zero,
2891      * the array element that corresponds to placeholder parameter number
2892      * <i>parameterIndex</i> is element number <i>parameterIndex</i> -1.
2893      *
2894      * @param parameterIndex the ordinal number of the placeholder parameter
2895      *        in this <code>RowSet</code> object's command that is to be set.
2896      *        The first parameter is 1, the second is 2, and so on; must be
2897      *        <code>1</code> or greater
2898      * @param array an <code>Array</code> object representing an SQL
2899      *        <code>ARRAY</code> value; cannot be null. The <code>Array</code> object
2900      *        passed to this method must return a non-null Object for all
2901      *        <code>getArray()</code> method calls. A null value will cause a
2902      *        <code>SQLException</code> to be thrown.
2903      * @throws SQLException if an error occurs; the parameter index is out of
2904      *        bounds or the <code>ARRAY</code> is null
2905      * @see #getParams
2906      * @see javax.sql.rowset.serial.SerialArray
2907      */
2908     public void setArray (int parameterIndex, Array array) throws SQLException {
2909         checkParamIndex(parameterIndex);
2910         if (params == null){
2911              throw new SQLException("Set initParams() before setArray");
2912         }
2913         params.put(Integer.valueOf(parameterIndex - 1), new SerialArray(array));
2914     }
2915 
2916     /**
2917      * Sets the designated parameter to the given <code>java.sql.Date</code>
2918      * object.
2919      * When the DBMS does not store time zone information, the driver will use
2920      * the given <code>Calendar</code> object to construct the SQL <code>DATE</code>
2921      * value to send to the database. With a
2922      * <code>Calendar</code> object, the driver can calculate the date
2923      * taking into account a custom time zone.  If no <code>Calendar</code>
2924      * object is specified, the driver uses the time zone of the Virtual Machine
2925      * that is running the application.
2926      * <P>
2927      * The parameter value set by this method is stored internally and
2928      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2929      * object's command when the method <code>execute</code> is called.
2930      * Methods such as <code>execute</code> and <code>populate</code> must be
2931      * provided in any class that extends this class and implements one or
2932      * more of the standard JSR-114 <code>RowSet</code> interfaces.
2933      * <P>
2934      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
2935      * as it is undefined in this class.
2936      * <P>
2937      * Calls made to the method <code>getParams</code> after this version of
2938      * <code>setDate</code>
2939      * has been called will return an array containing the parameter values that
2940      * have been set.  In that array, the element that represents the values
2941      * set with this method will itself be an array. The first element of that array
2942      * is the given <code>java.sql.Date</code> object.
2943      * The second element is the value set for <i>cal</i>.
2944      * The parameter number is indicated by an element's position in the array
2945      * returned by the method <code>getParams</code>,
2946      * with the first element being the value for the first placeholder parameter, the
2947      * second element being the value for the second placeholder parameter, and so on.
2948      * In other words, if the date being set is the value for the second
2949      * placeholder parameter, the array containing it will be the second element in
2950      * the array returned by <code>getParams</code>.
2951      * <P>
2952      * Note that because the numbering of elements in an array starts at zero,
2953      * the array element that corresponds to placeholder parameter number
2954      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
2955      *
2956      * @param parameterIndex the ordinal number of the placeholder parameter
2957      *        in this <code>RowSet</code> object's command that is to be set.
2958      *        The first parameter is 1, the second is 2, and so on; must be
2959      *        <code>1</code> or greater
2960      * @param x a <code>java.sql.Date</code> object representing an SQL
2961      *        <code>DATE</code> value
2962      * @param cal a <code>java.util.Calendar</code> object to use when
2963      *        when constructing the date
2964      * @throws SQLException if an error occurs or the
2965      *                         parameter index is out of bounds
2966      * @see #getParams
2967      */
2968     public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException {
2969         Object date[];
2970         checkParamIndex(parameterIndex);
2971 
2972         date = new Object[2];
2973         date[0] = x;
2974         date[1] = cal;
2975         if(params == null){
2976              throw new SQLException("Set initParams() before setDate");
2977         }
2978         params.put(Integer.valueOf(parameterIndex - 1), date);
2979     }
2980 
2981     /**
2982      * Sets the designated parameter to the given <code>java.sql.Time</code>
2983      * object.  The driver converts this
2984      * to an SQL <code>TIME</code> value when it sends it to the database.
2985      * <P>
2986      * When the DBMS does not store time zone information, the driver will use
2987      * the given <code>Calendar</code> object to construct the SQL <code>TIME</code>
2988      * value to send to the database. With a
2989      * <code>Calendar</code> object, the driver can calculate the date
2990      * taking into account a custom time zone.  If no <code>Calendar</code>
2991      * object is specified, the driver uses the time zone of the Virtual Machine
2992      * that is running the application.
2993      * <P>
2994      * The parameter value set by this method is stored internally and
2995      * will be supplied as the appropriate parameter in this <code>RowSet</code>
2996      * object's command when the method <code>execute</code> is called.
2997      * Methods such as <code>execute</code> and <code>populate</code> must be
2998      * provided in any class that extends this class and implements one or
2999      * more of the standard JSR-114 <code>RowSet</code> interfaces.
3000      * <P>
3001      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
3002      * as it is undefined in this class.
3003      * <P>
3004      * Calls made to the method <code>getParams</code> after this version of
3005      * <code>setTime</code>
3006      * has been called will return an array containing the parameter values that
3007      * have been set.  In that array, the element that represents the values
3008      * set with this method will itself be an array. The first element of that array
3009      * is the given <code>java.sql.Time</code> object.
3010      * The second element is the value set for <i>cal</i>.
3011      * The parameter number is indicated by an element's position in the array
3012      * returned by the method <code>getParams</code>,
3013      * with the first element being the value for the first placeholder parameter, the
3014      * second element being the value for the second placeholder parameter, and so on.
3015      * In other words, if the time being set is the value for the second
3016      * placeholder parameter, the array containing it will be the second element in
3017      * the array returned by <code>getParams</code>.
3018      * <P>
3019      * Note that because the numbering of elements in an array starts at zero,
3020      * the array element that corresponds to placeholder parameter number
3021      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
3022      *
3023      * @param parameterIndex the ordinal number of the placeholder parameter
3024      *        in this <code>RowSet</code> object's command that is to be set.
3025      *        The first parameter is 1, the second is 2, and so on; must be
3026      *        <code>1</code> or greater
3027      * @param x a <code>java.sql.Time</code> object
3028      * @param cal the <code>java.util.Calendar</code> object the driver can use to
3029      *         construct the time
3030      * @throws SQLException if an error occurs or the
3031      *                         parameter index is out of bounds
3032      * @see #getParams
3033      */
3034     public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException {
3035         Object time[];
3036         checkParamIndex(parameterIndex);
3037 
3038         time = new Object[2];
3039         time[0] = x;
3040         time[1] = cal;
3041         if(params == null){
3042              throw new SQLException("Set initParams() before setTime");
3043         }
3044         params.put(Integer.valueOf(parameterIndex - 1), time);
3045     }
3046 
3047     /**
3048      * Sets the designated parameter to the given
3049      * <code>java.sql.Timestamp</code> object.  The driver converts this
3050      * to an SQL <code>TIMESTAMP</code> value when it sends it to the database.
3051      * <P>
3052      * When the DBMS does not store time zone information, the driver will use
3053      * the given <code>Calendar</code> object to construct the SQL <code>TIMESTAMP</code>
3054      * value to send to the database. With a
3055      * <code>Calendar</code> object, the driver can calculate the timestamp
3056      * taking into account a custom time zone.  If no <code>Calendar</code>
3057      * object is specified, the driver uses the time zone of the Virtual Machine
3058      * that is running the application.
3059      * <P>
3060      * The parameter value set by this method is stored internally and
3061      * will be supplied as the appropriate parameter in this <code>RowSet</code>
3062      * object's command when the method <code>execute</code> is called.
3063      * Methods such as <code>execute</code> and <code>populate</code> must be
3064      * provided in any class that extends this class and implements one or
3065      * more of the standard JSR-114 <code>RowSet</code> interfaces.
3066      * <P>
3067      * NOTE: <code>JdbcRowSet</code> does not require the <code>populate</code> method
3068      * as it is undefined in this class.
3069      * <P>
3070      * Calls made to the method <code>getParams</code> after this version of
3071      * <code>setTimestamp</code>
3072      * has been called will return an array containing the parameter values that
3073      * have been set.  In that array, the element that represents the values
3074      * set with this method will itself be an array. The first element of that array
3075      * is the given <code>java.sql.Timestamp</code> object.
3076      * The second element is the value set for <i>cal</i>.
3077      * The parameter number is indicated by an element's position in the array
3078      * returned by the method <code>getParams</code>,
3079      * with the first element being the value for the first placeholder parameter, the
3080      * second element being the value for the second placeholder parameter, and so on.
3081      * In other words, if the timestamp being set is the value for the second
3082      * placeholder parameter, the array containing it will be the second element in
3083      * the array returned by <code>getParams</code>.
3084      * <P>
3085      * Note that because the numbering of elements in an array starts at zero,
3086      * the array element that corresponds to placeholder parameter number
3087      * <i>parameterIndex</i> is <i>parameterIndex</i> -1.
3088      *
3089      * @param parameterIndex the ordinal number of the placeholder parameter
3090      *        in this <code>RowSet</code> object's command that is to be set.
3091      *        The first parameter is 1, the second is 2, and so on; must be
3092      *        <code>1</code> or greater
3093      * @param x a <code>java.sql.Timestamp</code> object
3094      * @param cal the <code>java.util.Calendar</code> object the driver can use to
3095      *         construct the timestamp
3096      * @throws SQLException if an error occurs or the
3097      *                         parameter index is out of bounds
3098      * @see #getParams
3099      */
3100     public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException {
3101         Object timestamp[];
3102         checkParamIndex(parameterIndex);
3103 
3104         timestamp = new Object[2];
3105         timestamp[0] = x;
3106         timestamp[1] = cal;
3107         if(params == null){
3108              throw new SQLException("Set initParams() before setTimestamp");
3109         }
3110         params.put(Integer.valueOf(parameterIndex - 1), timestamp);
3111     }
3112 
3113     /**
3114      * Clears all of the current parameter values in this <code>RowSet</code>
3115      * object's internal representation of the parameters to be set in
3116      * this <code>RowSet</code> object's command when it is executed.
3117      * <P>
3118      * In general, parameter values remain in force for repeated use in
3119      * this <code>RowSet</code> object's command. Setting a parameter value with the
3120      * setter methods automatically clears the value of the
3121      * designated parameter and replaces it with the new specified value.
3122      * <P>
3123      * This method is called internally by the <code>setCommand</code>
3124      * method to clear all of the parameters set for the previous command.
3125      * <P>
3126      * Furthermore, this method differs from the <code>initParams</code>
3127      * method in that it maintains the schema of the <code>RowSet</code> object.
3128      *
3129      * @throws SQLException if an error occurs clearing the parameters
3130      */
3131     public void clearParameters() throws SQLException {
3132         params.clear();
3133     }
3134 
3135     /**
3136      * Retrieves an array containing the parameter values (both Objects and
3137      * primitives) that have been set for this
3138      * <code>RowSet</code> object's command and throws an <code>SQLException</code> object
3139      * if all parameters have not been set.   Before the command is sent to the
3140      * DBMS to be executed, these parameters will be substituted
3141      * for placeholder parameters in the  <code>PreparedStatement</code> object
3142      * that is the command for a <code>RowSet</code> implementation extending
3143      * the <code>BaseRowSet</code> class.
3144      * <P>
3145      * Each element in the array that is returned is an <code>Object</code> instance
3146      * that contains the values of the parameters supplied to a setter method.
3147      * The order of the elements is determined by the value supplied for
3148      * <i>parameterIndex</i>.  If the setter method takes only the parameter index
3149      * and the value to be set (possibly null), the array element will contain the value to be set
3150      * (which will be expressed as an <code>Object</code>).  If there are additional
3151      * parameters, the array element will itself be an array containing the value to be set
3152      * plus any additional parameter values supplied to the setter method. If the method
3153      * sets a stream, the array element includes the type of stream being supplied to the
3154      * method. These additional parameters are for the use of the driver or the DBMS and may or
3155      * may not be used.
3156      * <P>
3157      * NOTE: Stored parameter values of types <code>Array</code>, <code>Blob</code>,
3158      * <code>Clob</code> and <code>Ref</code> are returned as <code>SerialArray</code>,
3159      * <code>SerialBlob</code>, <code>SerialClob</code> and <code>SerialRef</code>
3160      * respectively.
3161      *
3162      * @return an array of <code>Object</code> instances that includes the
3163      *         parameter values that may be set in this <code>RowSet</code> object's
3164      *         command; an empty array if no parameters have been set
3165      * @throws SQLException if an error occurs retrieving the object array of
3166      *         parameters of this <code>RowSet</code> object or if not all parameters have
3167      *         been set
3168      */
3169     public Object[] getParams() throws SQLException {
3170         if (params == null) {
3171 
3172             initParams();
3173             Object [] paramsArray = new Object[params.size()];
3174             return paramsArray;
3175 
3176         } else {
3177             // The parameters may be set in random order
3178             // but all must be set, check to verify all
3179             // have been set till the last parameter
3180             // else throw exception.
3181 
3182             Object[] paramsArray = new Object[params.size()];
3183             for (int i = 0; i < params.size(); i++) {
3184                paramsArray[i] = params.get(Integer.valueOf(i));
3185                if (paramsArray[i] == null) {
3186                  throw new SQLException("missing parameter: " + (i + 1));
3187                } //end if
3188             } //end for
3189             return paramsArray;
3190 
3191         } //end if
3192 
3193     } //end getParams
3194 
3195 
3196    /**
3197     * Sets the designated parameter to SQL <code>NULL</code>.
3198     *
3199     * <P><B>Note:</B> You must specify the parameter's SQL type.
3200     *
3201     * @param parameterName the name of the parameter
3202     * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
3203     * @exception SQLException if a database access error occurs or
3204     * this method is called on a closed <code>CallableStatement</code>
3205     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3206     * this method
3207     * @since 1.4
3208     */
3209    public void setNull(String parameterName, int sqlType) throws SQLException {
3210         throw new SQLFeatureNotSupportedException("Feature not supported");
3211    }
3212 
3213    /**
3214     * Sets the designated parameter to SQL <code>NULL</code>.
3215     * This version of the method <code>setNull</code> should
3216     * be used for user-defined types and REF type parameters.  Examples
3217     * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
3218     * named array types.
3219     *
3220     * <P><B>Note:</B> To be portable, applications must give the
3221     * SQL type code and the fully-qualified SQL type name when specifying
3222     * a NULL user-defined or REF parameter.  In the case of a user-defined type
3223     * the name is the type name of the parameter itself.  For a REF
3224     * parameter, the name is the type name of the referenced type.  If
3225     * a JDBC driver does not need the type code or type name information,
3226     * it may ignore it.
3227     *
3228     * Although it is intended for user-defined and Ref parameters,
3229     * this method may be used to set a null parameter of any JDBC type.
3230     * If the parameter does not have a user-defined or REF type, the given
3231     * typeName is ignored.
3232     *
3233     *
3234     * @param parameterName the name of the parameter
3235     * @param sqlType a value from <code>java.sql.Types</code>
3236     * @param typeName the fully-qualified name of an SQL user-defined type;
3237     *        ignored if the parameter is not a user-defined type or
3238     *        SQL <code>REF</code> value
3239     * @exception SQLException if a database access error occurs or
3240     * this method is called on a closed <code>CallableStatement</code>
3241     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3242     * this method
3243     * @since 1.4
3244     */
3245    public void setNull (String parameterName, int sqlType, String typeName)
3246        throws SQLException{
3247         throw new SQLFeatureNotSupportedException("Feature not supported");
3248    }
3249 
3250    /**
3251     * Sets the designated parameter to the given Java <code>boolean</code> value.
3252     * The driver converts this
3253     * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
3254     *
3255     * @param parameterName the name of the parameter
3256     * @param x the parameter value
3257     * @exception SQLException if a database access error occurs or
3258     * this method is called on a closed <code>CallableStatement</code>
3259     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3260     * this method
3261     * @see #getParams
3262     * @since 1.4
3263     */
3264    public void setBoolean(String parameterName, boolean x) throws SQLException{
3265         throw new SQLFeatureNotSupportedException("Feature not supported");
3266    }
3267 
3268    /**
3269     * Sets the designated parameter to the given Java <code>byte</code> value.
3270     * The driver converts this
3271     * to an SQL <code>TINYINT</code> value when it sends it to the database.
3272     *
3273     * @param parameterName the name of the parameter
3274     * @param x the parameter value
3275     * @exception SQLException if a database access error occurs or
3276     * this method is called on a closed <code>CallableStatement</code>
3277     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3278     * this method
3279     * @see #getParams
3280     * @since 1.4
3281     */
3282    public void setByte(String parameterName, byte x) throws SQLException{
3283         throw new SQLFeatureNotSupportedException("Feature not supported");
3284    }
3285 
3286    /**
3287     * Sets the designated parameter to the given Java <code>short</code> value.
3288     * The driver converts this
3289     * to an SQL <code>SMALLINT</code> value when it sends it to the database.
3290     *
3291     * @param parameterName the name of the parameter
3292     * @param x the parameter value
3293     * @exception SQLException if a database access error occurs or
3294     * this method is called on a closed <code>CallableStatement</code>
3295     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3296     * this method
3297     * @see #getParams
3298     * @since 1.4
3299     */
3300    public void setShort(String parameterName, short x) throws SQLException{
3301         throw new SQLFeatureNotSupportedException("Feature not supported");
3302    }
3303 
3304    /**
3305     * Sets the designated parameter to the given Java <code>int</code> value.
3306     * The driver converts this
3307     * to an SQL <code>INTEGER</code> value when it sends it to the database.
3308     *
3309     * @param parameterName the name of the parameter
3310     * @param x the parameter value
3311     * @exception SQLException if a database access error occurs or
3312     * this method is called on a closed <code>CallableStatement</code>
3313     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3314     * this method
3315     * @see #getParams
3316     * @since 1.4
3317     */
3318    public void setInt(String parameterName, int x) throws SQLException{
3319         throw new SQLFeatureNotSupportedException("Feature not supported");
3320    }
3321 
3322 
3323    /**
3324     * Sets the designated parameter to the given Java <code>long</code> value.
3325     * The driver converts this
3326     * to an SQL <code>BIGINT</code> value when it sends it to the database.
3327     *
3328     * @param parameterName the name of the parameter
3329     * @param x the parameter value
3330     * @exception SQLException if a database access error occurs or
3331     * this method is called on a closed <code>CallableStatement</code>
3332     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3333     * this method
3334     * @see #getParams
3335     * @since 1.4
3336     */
3337    public void setLong(String parameterName, long x) throws SQLException{
3338         throw new SQLFeatureNotSupportedException("Feature not supported");
3339    }
3340 
3341    /**
3342     * Sets the designated parameter to the given Java <code>float</code> value.
3343     * The driver converts this
3344     * to an SQL <code>FLOAT</code> value when it sends it to the database.
3345     *
3346     * @param parameterName the name of the parameter
3347     * @param x the parameter value
3348     * @exception SQLException if a database access error occurs or
3349     * this method is called on a closed <code>CallableStatement</code>
3350     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3351     * this method
3352     * @see #getParams
3353     * @since 1.4
3354     */
3355    public void setFloat(String parameterName, float x) throws SQLException{
3356         throw new SQLFeatureNotSupportedException("Feature not supported");
3357    }
3358 
3359    /**
3360     * Sets the designated parameter to the given Java <code>double</code> value.
3361     * The driver converts this
3362     * to an SQL <code>DOUBLE</code> value when it sends it to the database.
3363     *
3364     * @param parameterName the name of the parameter
3365     * @param x the parameter value
3366     * @exception SQLException if a database access error occurs or
3367     * this method is called on a closed <code>CallableStatement</code>
3368     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3369     * this method
3370     * @see #getParams
3371     * @since 1.4
3372     */
3373    public void setDouble(String parameterName, double x) throws SQLException{
3374         throw new SQLFeatureNotSupportedException("Feature not supported");
3375    }
3376 
3377    /**
3378     * Sets the designated parameter to the given
3379     * <code>java.math.BigDecimal</code> value.
3380     * The driver converts this to an SQL <code>NUMERIC</code> value when
3381     * it sends it to the database.
3382     *
3383     * @param parameterName the name of the parameter
3384     * @param x the parameter value
3385     * @exception SQLException if a database access error occurs or
3386     * this method is called on a closed <code>CallableStatement</code>
3387     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3388     * this method
3389     * @see #getParams
3390     * @since 1.4
3391     */
3392    public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
3393         throw new SQLFeatureNotSupportedException("Feature not supported");
3394    }
3395 
3396    /**
3397     * Sets the designated parameter to the given Java <code>String</code> value.
3398     * The driver converts this
3399     * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
3400     * (depending on the argument's
3401     * size relative to the driver's limits on <code>VARCHAR</code> values)
3402     * when it sends it to the database.
3403     *
3404     * @param parameterName the name of the parameter
3405     * @param x the parameter value
3406     * @exception SQLException if a database access error occurs or
3407     * this method is called on a closed <code>CallableStatement</code>
3408     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3409     * this method
3410     * @see #getParams
3411     * @since 1.4
3412     */
3413    public void setString(String parameterName, String x) throws SQLException{
3414         throw new SQLFeatureNotSupportedException("Feature not supported");
3415    }
3416 
3417    /**
3418     * Sets the designated parameter to the given Java array of bytes.
3419     * The driver converts this to an SQL <code>VARBINARY</code> or
3420     * <code>LONGVARBINARY</code> (depending on the argument's size relative
3421     * to the driver's limits on <code>VARBINARY</code> values) when it sends
3422     * it to the database.
3423     *
3424     * @param parameterName the name of the parameter
3425     * @param x the parameter value
3426     * @exception SQLException if a database access error occurs or
3427     * this method is called on a closed <code>CallableStatement</code>
3428     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3429     * this method
3430     * @see #getParams
3431     * @since 1.4
3432     */
3433    public void setBytes(String parameterName, byte x[]) throws SQLException{
3434         throw new SQLFeatureNotSupportedException("Feature not supported");
3435    }
3436 
3437    /**
3438     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
3439     * The driver
3440     * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
3441     * database.
3442     *
3443     * @param parameterName the name of the parameter
3444     * @param x the parameter value
3445     * @exception SQLException if a database access error occurs or
3446     * this method is called on a closed <code>CallableStatement</code>
3447     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3448     * this method
3449     * @see #getParams
3450     * @since 1.4
3451     */
3452    public void setTimestamp(String parameterName, java.sql.Timestamp x)
3453        throws SQLException{
3454         throw new SQLFeatureNotSupportedException("Feature not supported");
3455    }
3456 
3457    /**
3458     * Sets the designated parameter to the given input stream, which will have
3459     * the specified number of bytes.
3460     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
3461     * parameter, it may be more practical to send it via a
3462     * <code>java.io.InputStream</code>. Data will be read from the stream
3463     * as needed until end-of-file is reached.  The JDBC driver will
3464     * do any necessary conversion from ASCII to the database char format.
3465     *
3466     * <P><B>Note:</B> This stream object can either be a standard
3467     * Java stream object or your own subclass that implements the
3468     * standard interface.
3469     *
3470     * @param parameterName the name of the parameter
3471     * @param x the Java input stream that contains the ASCII parameter value
3472     * @param length the number of bytes in the stream
3473     * @exception SQLException if a database access error occurs or
3474     * this method is called on a closed <code>CallableStatement</code>
3475     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3476     * this method
3477     * @since 1.4
3478     */
3479    public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
3480        throws SQLException{
3481         throw new SQLFeatureNotSupportedException("Feature not supported");
3482    }
3483 
3484    /**
3485     * Sets the designated parameter to the given input stream, which will have
3486     * the specified number of bytes.
3487     * When a very large binary value is input to a <code>LONGVARBINARY</code>
3488     * parameter, it may be more practical to send it via a
3489     * <code>java.io.InputStream</code> object. The data will be read from the stream
3490     * as needed until end-of-file is reached.
3491     *
3492     * <P><B>Note:</B> This stream object can either be a standard
3493     * Java stream object or your own subclass that implements the
3494     * standard interface.
3495     *
3496     * @param parameterName the name of the parameter
3497     * @param x the java input stream which contains the binary parameter value
3498     * @param length the number of bytes in the stream
3499     * @exception SQLException if a database access error occurs or
3500     * this method is called on a closed <code>CallableStatement</code>
3501     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3502     * this method
3503     * @since 1.4
3504     */
3505    public void setBinaryStream(String parameterName, java.io.InputStream x,
3506                         int length) throws SQLException{
3507         throw new SQLFeatureNotSupportedException("Feature not supported");
3508    }
3509 
3510    /**
3511     * Sets the designated parameter to the given <code>Reader</code>
3512     * object, which is the given number of characters long.
3513     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3514     * parameter, it may be more practical to send it via a
3515     * <code>java.io.Reader</code> object. The data will be read from the stream
3516     * as needed until end-of-file is reached.  The JDBC driver will
3517     * do any necessary conversion from UNICODE to the database char format.
3518     *
3519     * <P><B>Note:</B> This stream object can either be a standard
3520     * Java stream object or your own subclass that implements the
3521     * standard interface.
3522     *
3523     * @param parameterName the name of the parameter
3524     * @param reader the <code>java.io.Reader</code> object that
3525     *        contains the UNICODE data used as the designated parameter
3526     * @param length the number of characters in the stream
3527     * @exception SQLException if a database access error occurs or
3528     * this method is called on a closed <code>CallableStatement</code>
3529     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3530     * this method
3531     * @since 1.4
3532     */
3533    public void setCharacterStream(String parameterName,
3534                            java.io.Reader reader,
3535                            int length) throws SQLException{
3536         throw new SQLFeatureNotSupportedException("Feature not supported");
3537    }
3538 
3539   /**
3540    * Sets the designated parameter to the given input stream.
3541    * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
3542    * parameter, it may be more practical to send it via a
3543    * <code>java.io.InputStream</code>. Data will be read from the stream
3544    * as needed until end-of-file is reached.  The JDBC driver will
3545    * do any necessary conversion from ASCII to the database char format.
3546    *
3547    * <P><B>Note:</B> This stream object can either be a standard
3548    * Java stream object or your own subclass that implements the
3549    * standard interface.
3550    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3551    * it might be more efficient to use a version of
3552    * <code>setAsciiStream</code> which takes a length parameter.
3553    *
3554    * @param parameterName the name of the parameter
3555    * @param x the Java input stream that contains the ASCII parameter value
3556    * @exception SQLException if a database access error occurs or
3557    * this method is called on a closed <code>CallableStatement</code>
3558    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3559    * @since 1.6
3560   */
3561   public void setAsciiStream(String parameterName, java.io.InputStream x)
3562           throws SQLException{
3563         throw new SQLFeatureNotSupportedException("Feature not supported");
3564    }
3565 
3566    /**
3567     * Sets the designated parameter to the given input stream.
3568     * When a very large binary value is input to a <code>LONGVARBINARY</code>
3569     * parameter, it may be more practical to send it via a
3570     * <code>java.io.InputStream</code> object. The data will be read from the
3571     * stream as needed until end-of-file is reached.
3572     *
3573     * <P><B>Note:</B> This stream object can either be a standard
3574     * Java stream object or your own subclass that implements the
3575     * standard interface.
3576     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3577     * it might be more efficient to use a version of
3578     * <code>setBinaryStream</code> which takes a length parameter.
3579     *
3580     * @param parameterName the name of the parameter
3581     * @param x the java input stream which contains the binary parameter value
3582     * @exception SQLException if a database access error occurs or
3583     * this method is called on a closed <code>CallableStatement</code>
3584     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3585     * @since 1.6
3586     */
3587    public void setBinaryStream(String parameterName, java.io.InputStream x)
3588    throws SQLException{
3589         throw new SQLFeatureNotSupportedException("Feature not supported");
3590    }
3591 
3592    /**
3593     * Sets the designated parameter to the given <code>Reader</code>
3594     * object.
3595     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
3596     * parameter, it may be more practical to send it via a
3597     * <code>java.io.Reader</code> object. The data will be read from the stream
3598     * as needed until end-of-file is reached.  The JDBC driver will
3599     * do any necessary conversion from UNICODE to the database char format.
3600     *
3601     * <P><B>Note:</B> This stream object can either be a standard
3602     * Java stream object or your own subclass that implements the
3603     * standard interface.
3604     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3605     * it might be more efficient to use a version of
3606     * <code>setCharacterStream</code> which takes a length parameter.
3607     *
3608     * @param parameterName the name of the parameter
3609     * @param reader the <code>java.io.Reader</code> object that contains the
3610     *        Unicode data
3611     * @exception SQLException if a database access error occurs or
3612     * this method is called on a closed <code>CallableStatement</code>
3613     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3614     * @since 1.6
3615     */
3616    public void setCharacterStream(String parameterName,
3617                          java.io.Reader reader) throws SQLException{
3618         throw new SQLFeatureNotSupportedException("Feature not supported");
3619    }
3620 
3621  /**
3622   * Sets the designated parameter in this <code>RowSet</code> object's command
3623   * to a <code>Reader</code> object. The
3624   * <code>Reader</code> reads the data till end-of-file is reached. The
3625   * driver does the necessary conversion from Java character format to
3626   * the national character set in the database.
3627   *
3628   * <P><B>Note:</B> This stream object can either be a standard
3629   * Java stream object or your own subclass that implements the
3630   * standard interface.
3631   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3632   * it might be more efficient to use a version of
3633   * <code>setNCharacterStream</code> which takes a length parameter.
3634   *
3635   * @param parameterIndex of the first parameter is 1, the second is 2, ...
3636   * @param value the parameter value
3637   * @throws SQLException if the driver does not support national
3638   *         character sets;  if the driver can detect that a data conversion
3639   *  error could occur ; if a database access error occurs; or
3640   * this method is called on a closed <code>PreparedStatement</code>
3641   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3642   * @since 1.6
3643   */
3644   public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{
3645         throw new SQLFeatureNotSupportedException("Feature not supported");
3646    }
3647 
3648    /**
3649     * Sets the value of the designated parameter with the given object. The second
3650     * argument must be an object type; for integral values, the
3651     * <code>java.lang</code> equivalent objects should be used.
3652     *
3653     * <p>The given Java object will be converted to the given targetSqlType
3654     * before being sent to the database.
3655     *
3656     * If the object has a custom mapping (is of a class implementing the
3657     * interface <code>SQLData</code>),
3658     * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
3659     * to the SQL data stream.
3660     * If, on the other hand, the object is of a class implementing
3661     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
3662     *  <code>Struct</code>, <code>java.net.URL</code>,
3663     * or <code>Array</code>, the driver should pass it to the database as a
3664     * value of the corresponding SQL type.
3665     * <P>
3666     * Note that this method may be used to pass database-
3667     * specific abstract data types.
3668     *
3669     * @param parameterName the name of the parameter
3670     * @param x the object containing the input parameter value
3671     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
3672     * sent to the database. The scale argument may further qualify this type.
3673     * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
3674     *          this is the number of digits after the decimal point.  For all other
3675     *          types, this value will be ignored.
3676     * @exception SQLException if a database access error occurs or
3677     * this method is called on a closed <code>CallableStatement</code>
3678     * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
3679     * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
3680     * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
3681     * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
3682     *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
3683     * or  <code>STRUCT</code> data type and the JDBC driver does not support
3684     * this data type
3685     * @see Types
3686     * @see #getParams
3687     * @since 1.4
3688     */
3689    public void setObject(String parameterName, Object x, int targetSqlType, int scale)
3690        throws SQLException{
3691         throw new SQLFeatureNotSupportedException("Feature not supported");
3692    }
3693 
3694    /**
3695     * Sets the value of the designated parameter with the given object.
3696     * This method is like the method <code>setObject</code>
3697     * above, except that it assumes a scale of zero.
3698     *
3699     * @param parameterName the name of the parameter
3700     * @param x the object containing the input parameter value
3701     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
3702     *                      sent to the database
3703     * @exception SQLException if a database access error occurs or
3704     * this method is called on a closed <code>CallableStatement</code>
3705     * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
3706     * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
3707     * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
3708     * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
3709     *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
3710     * or  <code>STRUCT</code> data type and the JDBC driver does not support
3711     * this data type
3712     * @see #getParams
3713     * @since 1.4
3714     */
3715    public void setObject(String parameterName, Object x, int targetSqlType)
3716        throws SQLException{
3717         throw new SQLFeatureNotSupportedException("Feature not supported");
3718    }
3719 
3720   /**
3721    * Sets the value of the designated parameter with the given object.
3722    * The second parameter must be of type <code>Object</code>; therefore, the
3723    * <code>java.lang</code> equivalent objects should be used for built-in types.
3724    *
3725    * <p>The JDBC specification specifies a standard mapping from
3726    * Java <code>Object</code> types to SQL types.  The given argument
3727    * will be converted to the corresponding SQL type before being
3728    * sent to the database.
3729    *
3730    * <p>Note that this method may be used to pass database-
3731    * specific abstract data types, by using a driver-specific Java
3732    * type.
3733    *
3734    * If the object is of a class implementing the interface <code>SQLData</code>,
3735    * the JDBC driver should call the method <code>SQLData.writeSQL</code>
3736    * to write it to the SQL data stream.
3737    * If, on the other hand, the object is of a class implementing
3738    * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
3739    *  <code>Struct</code>, <code>java.net.URL</code>,
3740    * or <code>Array</code>, the driver should pass it to the database as a
3741    * value of the corresponding SQL type.
3742    * <P>
3743    * This method throws an exception if there is an ambiguity, for example, if the
3744    * object is of a class implementing more than one of the interfaces named above.
3745    *
3746    * @param parameterName the name of the parameter
3747    * @param x the object containing the input parameter value
3748    * @exception SQLException if a database access error occurs,
3749    * this method is called on a closed <code>CallableStatement</code> or if the given
3750    *            <code>Object</code> parameter is ambiguous
3751    * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3752    * this method
3753    * @see #getParams
3754    * @since 1.4
3755    */
3756   public void setObject(String parameterName, Object x) throws SQLException{
3757         throw new SQLFeatureNotSupportedException("Feature not supported");
3758    }
3759 
3760    /**
3761     * Sets the designated parameter to a <code>InputStream</code> object.
3762     * The <code>InputStream</code> must contain  the number
3763     * of characters specified by length otherwise a <code>SQLException</code> will be
3764     * generated when the <code>PreparedStatement</code> is executed.
3765     * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
3766     * method because it informs the driver that the parameter value should be
3767     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
3768     * the driver may have to do extra work to determine whether the parameter
3769     * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3770     * @param parameterIndex index of the first parameter is 1,
3771     * the second is 2, ...
3772     * @param inputStream An object that contains the data to set the parameter
3773     * value to.
3774     * @param length the number of bytes in the parameter data.
3775     * @throws SQLException if a database access error occurs,
3776     * this method is called on a closed <code>PreparedStatement</code>,
3777     * if parameterIndex does not correspond
3778     * to a parameter marker in the SQL statement,  if the length specified
3779     * is less than zero or if the number of bytes in the
3780     * <code>InputStream</code> does not match the specified length.
3781     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3782     *
3783     * @since 1.6
3784     */
3785     public void setBlob(int parameterIndex, InputStream inputStream, long length)
3786        throws SQLException{
3787         throw new SQLFeatureNotSupportedException("Feature not supported");
3788    }
3789 
3790    /**
3791     * Sets the designated parameter to a <code>InputStream</code> object.
3792     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
3793     * method because it informs the driver that the parameter value should be
3794     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
3795     * the driver may have to do extra work to determine whether the parameter
3796     * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3797     *
3798     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3799     * it might be more efficient to use a version of
3800     * <code>setBlob</code> which takes a length parameter.
3801     *
3802     * @param parameterIndex index of the first parameter is 1,
3803     * the second is 2, ...
3804     * @param inputStream An object that contains the data to set the parameter
3805     * value to.
3806     * @throws SQLException if a database access error occurs,
3807     * this method is called on a closed <code>PreparedStatement</code> or
3808     * if parameterIndex does not correspond
3809     * to a parameter marker in the SQL statement,
3810     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3811     *
3812     * @since 1.6
3813     */
3814     public void setBlob(int parameterIndex, InputStream inputStream)
3815        throws SQLException{
3816         throw new SQLFeatureNotSupportedException("Feature not supported");
3817     }
3818 
3819     /**
3820      * Sets the designated parameter to a <code>InputStream</code> object.
3821      * The <code>Inputstream</code> must contain  the number
3822      * of characters specified by length, otherwise a <code>SQLException</code> will be
3823      * generated when the <code>CallableStatement</code> is executed.
3824      * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
3825      * method because it informs the driver that the parameter value should be
3826      * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
3827      * the driver may have to do extra work to determine whether the parameter
3828      * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3829      *
3830      * @param parameterName the name of the parameter to be set
3831      * the second is 2, ...
3832      *
3833      * @param inputStream An object that contains the data to set the parameter
3834      * value to.
3835      * @param length the number of bytes in the parameter data.
3836      * @throws SQLException  if parameterIndex does not correspond
3837      * to a parameter marker in the SQL statement,  or if the length specified
3838      * is less than zero; if the number of bytes in the <code>InputStream</code> does not match
3839      * the specified length; if a database access error occurs or
3840      * this method is called on a closed <code>CallableStatement</code>
3841      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3842      * this method
3843      *
3844      * @since 1.6
3845      */
3846      public void setBlob(String parameterName, InputStream inputStream, long length)
3847         throws SQLException{
3848         throw new SQLFeatureNotSupportedException("Feature not supported");
3849    }
3850 
3851    /**
3852     * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
3853     * The driver converts this to an SQL <code>BLOB</code> value when it
3854     * sends it to the database.
3855     *
3856     * @param parameterName the name of the parameter
3857     * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
3858     * @exception SQLException if a database access error occurs or
3859     * this method is called on a closed <code>CallableStatement</code>
3860     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3861     * this method
3862     * @since 1.6
3863     */
3864    public void setBlob (String parameterName, Blob x) throws SQLException{
3865         throw new SQLFeatureNotSupportedException("Feature not supported");
3866    }
3867 
3868    /**
3869     * Sets the designated parameter to a <code>InputStream</code> object.
3870     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
3871     * method because it informs the driver that the parameter value should be
3872     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
3873     * the driver may have to do extra work to determine whether the parameter
3874     * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
3875     *
3876     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3877     * it might be more efficient to use a version of
3878     * <code>setBlob</code> which takes a length parameter.
3879     *
3880     * @param parameterName the name of the parameter
3881     * @param inputStream An object that contains the data to set the parameter
3882     * value to.
3883     * @throws SQLException if a database access error occurs or
3884     * this method is called on a closed <code>CallableStatement</code>
3885     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3886     *
3887     * @since 1.6
3888     */
3889     public void setBlob(String parameterName, InputStream inputStream)
3890        throws SQLException{
3891         throw new SQLFeatureNotSupportedException("Feature not supported");
3892     }
3893 
3894    /**
3895     * Sets the designated parameter to a <code>Reader</code> object.
3896     * The reader must contain  the number
3897     * of characters specified by length otherwise a <code>SQLException</code> will be
3898     * generated when the <code>PreparedStatement</code> is executed.
3899     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
3900     * because it informs the driver that the parameter value should be sent to
3901     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
3902     * driver may have to do extra work to determine whether the parameter
3903     * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3904     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
3905     * @param reader An object that contains the data to set the parameter value to.
3906     * @param length the number of characters in the parameter data.
3907     * @throws SQLException if a database access error occurs, this method is called on
3908     * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
3909     * marker in the SQL statement, or if the length specified is less than zero.
3910     *
3911     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3912     * @since 1.6
3913     */
3914    public void setClob(int parameterIndex, Reader reader, long length)
3915      throws SQLException{
3916         throw new SQLFeatureNotSupportedException("Feature not supported");
3917    }
3918 
3919   /**
3920    * Sets the designated parameter to a <code>Reader</code> object.
3921    * This method differs from the <code>setCharacterStream (int, Reader)</code> method
3922    * because it informs the driver that the parameter value should be sent to
3923    * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
3924    * driver may have to do extra work to determine whether the parameter
3925    * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3926    *
3927    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3928    * it might be more efficient to use a version of
3929    * <code>setClob</code> which takes a length parameter.
3930    *
3931    * @param parameterIndex index of the first parameter is 1, the second is 2, ...
3932    * @param reader An object that contains the data to set the parameter value to.
3933    * @throws SQLException if a database access error occurs, this method is called on
3934    * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
3935    * marker in the SQL statement
3936    *
3937    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
3938    * @since 1.6
3939    */
3940    public void setClob(int parameterIndex, Reader reader)
3941      throws SQLException{
3942         throw new SQLFeatureNotSupportedException("Feature not supported");
3943    }
3944 
3945    /**
3946     * Sets the designated parameter to a <code>Reader</code> object.
3947     * The <code>reader</code> must contain  the number
3948     * of characters specified by length otherwise a <code>SQLException</code> will be
3949     * generated when the <code>CallableStatement</code> is executed.
3950     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
3951     * because it informs the driver that the parameter value should be sent to
3952     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
3953     * driver may have to do extra work to determine whether the parameter
3954     * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3955     * @param parameterName the name of the parameter to be set
3956     * @param reader An object that contains the data to set the parameter value to.
3957     * @param length the number of characters in the parameter data.
3958     * @throws SQLException if parameterIndex does not correspond to a parameter
3959     * marker in the SQL statement; if the length specified is less than zero;
3960     * a database access error occurs or
3961     * this method is called on a closed <code>CallableStatement</code>
3962     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3963     * this method
3964     *
3965     * @since 1.6
3966     */
3967    public void setClob(String parameterName, Reader reader, long length)
3968       throws SQLException {
3969        throw new SQLFeatureNotSupportedException("Feature not supported");
3970    }
3971 
3972    /**
3973     * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
3974     * The driver converts this to an SQL <code>CLOB</code> value when it
3975     * sends it to the database.
3976     *
3977     * @param parameterName the name of the parameter
3978     * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
3979     * @exception SQLException if a database access error occurs or
3980     * this method is called on a closed <code>CallableStatement</code>
3981     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
3982     * this method
3983     * @since 1.6
3984     */
3985    public void setClob (String parameterName, Clob x) throws SQLException {
3986        throw new SQLFeatureNotSupportedException("Feature not supported");
3987    }
3988 
3989    /**
3990     * Sets the designated parameter to a <code>Reader</code> object.
3991     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
3992     * because it informs the driver that the parameter value should be sent to
3993     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
3994     * driver may have to do extra work to determine whether the parameter
3995     * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
3996     *
3997     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
3998     * it might be more efficient to use a version of
3999     * <code>setClob</code> which takes a length parameter.
4000     *
4001     * @param parameterName the name of the parameter
4002     * @param reader An object that contains the data to set the parameter value to.
4003     * @throws SQLException if a database access error occurs or this method is called on
4004     * a closed <code>CallableStatement</code>
4005     *
4006     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
4007     * @since 1.6
4008     */
4009     public void setClob(String parameterName, Reader reader) throws SQLException {
4010         throw new SQLFeatureNotSupportedException("Feature not supported");
4011     }
4012 
4013    /**
4014     * Sets the designated parameter to the given <code>java.sql.Date</code> value
4015     * using the default time zone of the virtual machine that is running
4016     * the application.
4017     * The driver converts this
4018     * to an SQL <code>DATE</code> value when it sends it to the database.
4019     *
4020     * @param parameterName the name of the parameter
4021     * @param x the parameter value
4022     * @exception SQLException if a database access error occurs or
4023     * this method is called on a closed <code>CallableStatement</code>
4024     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4025     * this method
4026     * @see #getParams
4027     * @since 1.4
4028     */
4029    public void setDate(String parameterName, java.sql.Date x)
4030            throws SQLException {
4031        throw new SQLFeatureNotSupportedException("Feature not supported");
4032    }
4033 
4034    /**
4035     * Sets the designated parameter to the given <code>java.sql.Date</code> value,
4036     * using the given <code>Calendar</code> object.  The driver uses
4037     * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
4038     * which the driver then sends to the database.  With a
4039     * a <code>Calendar</code> object, the driver can calculate the date
4040     * taking into account a custom timezone.  If no
4041     * <code>Calendar</code> object is specified, the driver uses the default
4042     * timezone, which is that of the virtual machine running the application.
4043     *
4044     * @param parameterName the name of the parameter
4045     * @param x the parameter value
4046     * @param cal the <code>Calendar</code> object the driver will use
4047     *            to construct the date
4048     * @exception SQLException if a database access error occurs or
4049     * this method is called on a closed <code>CallableStatement</code>
4050     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4051     * this method
4052     * @see #getParams
4053     * @since 1.4
4054     */
4055    public void setDate(String parameterName, java.sql.Date x, Calendar cal)
4056            throws SQLException {
4057         throw new SQLFeatureNotSupportedException("Feature not supported");
4058    }
4059 
4060    /**
4061     * Sets the designated parameter to the given <code>java.sql.Time</code> value.
4062     * The driver converts this
4063     * to an SQL <code>TIME</code> value when it sends it to the database.
4064     *
4065     * @param parameterName the name of the parameter
4066     * @param x the parameter value
4067     * @exception SQLException if a database access error occurs or
4068     * this method is called on a closed <code>CallableStatement</code>
4069     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4070     * this method
4071     * @see #getParams
4072     * @since 1.4
4073     */
4074    public void setTime(String parameterName, java.sql.Time x)
4075            throws SQLException {
4076         throw new SQLFeatureNotSupportedException("Feature not supported");
4077    }
4078 
4079    /**
4080     * Sets the designated parameter to the given <code>java.sql.Time</code> value,
4081     * using the given <code>Calendar</code> object.  The driver uses
4082     * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
4083     * which the driver then sends to the database.  With a
4084     * a <code>Calendar</code> object, the driver can calculate the time
4085     * taking into account a custom timezone.  If no
4086     * <code>Calendar</code> object is specified, the driver uses the default
4087     * timezone, which is that of the virtual machine running the application.
4088     *
4089     * @param parameterName the name of the parameter
4090     * @param x the parameter value
4091     * @param cal the <code>Calendar</code> object the driver will use
4092     *            to construct the time
4093     * @exception SQLException if a database access error occurs or
4094     * this method is called on a closed <code>CallableStatement</code>
4095     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4096     * this method
4097     * @see #getParams
4098     * @since 1.4
4099     */
4100    public void setTime(String parameterName, java.sql.Time x, Calendar cal)
4101            throws SQLException {
4102         throw new SQLFeatureNotSupportedException("Feature not supported");
4103    }
4104 
4105    /**
4106     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
4107     * using the given <code>Calendar</code> object.  The driver uses
4108     * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
4109     * which the driver then sends to the database.  With a
4110     * a <code>Calendar</code> object, the driver can calculate the timestamp
4111     * taking into account a custom timezone.  If no
4112     * <code>Calendar</code> object is specified, the driver uses the default
4113     * timezone, which is that of the virtual machine running the application.
4114     *
4115     * @param parameterName the name of the parameter
4116     * @param x the parameter value
4117     * @param cal the <code>Calendar</code> object the driver will use
4118     *            to construct the timestamp
4119     * @exception SQLException if a database access error occurs or
4120     * this method is called on a closed <code>CallableStatement</code>
4121     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4122     * this method
4123     * @see #getParams
4124     * @since 1.4
4125     */
4126    public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
4127            throws SQLException {
4128         throw new SQLFeatureNotSupportedException("Feature not supported");
4129    }
4130 
4131    /**
4132     * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4133     * SQL <code>XML</code> value when it sends it to the database.
4134     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4135     * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
4136     * @throws SQLException if a database access error occurs, this method
4137     *  is called on a closed result set,
4138     * the <code>java.xml.transform.Result</code>,
4139     *  <code>Writer</code> or <code>OutputStream</code> has not been closed
4140     * for the <code>SQLXML</code> object  or
4141     *  if there is an error processing the XML value.  The <code>getCause</code> method
4142     *  of the exception may provide a more detailed exception, for example, if the
4143     *  stream does not contain valid XML.
4144     * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4145     * support this method
4146     * @since 1.6
4147     */
4148    public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
4149        throw new SQLFeatureNotSupportedException("Feature not supported");
4150    }
4151 
4152    /**
4153     * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4154     * <code>SQL XML</code> value when it sends it to the database.
4155     * @param parameterName the name of the parameter
4156     * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
4157     * @throws SQLException if a database access error occurs, this method
4158     *  is called on a closed result set,
4159     * the <code>java.xml.transform.Result</code>,
4160     *  <code>Writer</code> or <code>OutputStream</code> has not been closed
4161     * for the <code>SQLXML</code> object  or
4162     *  if there is an error processing the XML value.  The <code>getCause</code> method
4163     *  of the exception may provide a more detailed exception, for example, if the
4164     *  stream does not contain valid XML.
4165     * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4166     * support this method
4167     * @since 1.6
4168     */
4169    public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
4170        throw new SQLFeatureNotSupportedException("Feature not supported");
4171    }
4172 
4173    /**
4174    * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
4175    * driver converts this to a SQL <code>ROWID</code> value when it sends it
4176    * to the database
4177    *
4178    * @param parameterIndex the first parameter is 1, the second is 2, ...
4179    * @param x the parameter value
4180    * @throws SQLException if a database access error occurs
4181    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4182    * support this method
4183    *
4184    * @since 1.6
4185    */
4186   public void setRowId(int parameterIndex, RowId x) throws SQLException {
4187       throw new SQLFeatureNotSupportedException("Feature not supported");
4188   }
4189 
4190   /**
4191    * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
4192    * driver converts this to a SQL <code>ROWID</code> when it sends it to the
4193    * database.
4194    *
4195    * @param parameterName the name of the parameter
4196    * @param x the parameter value
4197    * @throws SQLException if a database access error occurs
4198    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4199    * support this method
4200    * @since 1.6
4201    */
4202   public void setRowId(String parameterName, RowId x) throws SQLException {
4203       throw new SQLFeatureNotSupportedException("Feature not supported");
4204   }
4205 
4206   /**
4207    * Sets the designated parameter to the given <code>String</code> object.
4208    * The driver converts this to a SQL <code>NCHAR</code> or
4209    * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
4210    * (depending on the argument's
4211    * size relative to the driver's limits on <code>NVARCHAR</code> values)
4212    * when it sends it to the database.
4213    *
4214    * @param parameterIndex of the first parameter is 1, the second is 2, ...
4215    * @param value the parameter value
4216    * @throws SQLException if the driver does not support national
4217    * character sets;  if the driver can detect that a data conversion
4218    * error could occur ; or if a database access error occurs
4219    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4220    * support this method
4221    * @since 1.6
4222    */
4223   public void setNString(int parameterIndex, String value) throws SQLException {
4224       throw new SQLFeatureNotSupportedException("Feature not supported");
4225   }
4226 
4227   /**
4228    * Sets the designated parameter to the given <code>String</code> object.
4229    * The driver converts this to a SQL <code>NCHAR</code> or
4230    * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
4231    * @param parameterName the name of the column to be set
4232    * @param value the parameter value
4233    * @throws SQLException if the driver does not support national
4234    * character sets;  if the driver can detect that a data conversion
4235    * error could occur; or if a database access error occurs
4236    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4237    * support this method
4238    * @since 1.6
4239    */
4240   public void setNString(String parameterName, String value) throws SQLException {
4241      throw new SQLFeatureNotSupportedException("Feature not supported");
4242   }
4243 
4244   /**
4245    * Sets the designated parameter to a <code>Reader</code> object. The
4246    * <code>Reader</code> reads the data till end-of-file is reached. The
4247    * driver does the necessary conversion from Java character format to
4248    * the national character set in the database.
4249    * @param parameterIndex of the first parameter is 1, the second is 2, ...
4250    * @param value the parameter value
4251    * @param length the number of characters in the parameter data.
4252    * @throws SQLException if the driver does not support national
4253    *         character sets;  if the driver can detect that a data conversion
4254    *  error could occur ; or if a database access error occurs
4255    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
4256    * support this method
4257    * @since 1.6
4258    */
4259   public void setNCharacterStream(int parameterIndex, Reader value, long length)
4260           throws SQLException {
4261       throw new SQLFeatureNotSupportedException("Feature not supported");
4262   }
4263 
4264   /**
4265    * Sets the designated parameter to a <code>Reader</code> object. The
4266    * <code>Reader</code> reads the data till end-of-file is reached. The
4267    * driver does the necessary conversion from Java character format to
4268    * the national character set in the database.
4269    * @param parameterName the name of the column to be set
4270    * @param value the parameter value
4271    * @param length the number of characters in the parameter data.
4272    * @throws SQLException if the driver does not support national
4273    *         character sets;  if the driver can detect that a data conversion
4274    *  error could occur; or if a database access error occurs
4275    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
4276    * support this method
4277    * @since 1.6
4278    */
4279   public void setNCharacterStream(String parameterName, Reader value, long length)
4280           throws SQLException {
4281       throw new SQLFeatureNotSupportedException("Feature not supported");
4282   }
4283 
4284   /**
4285    * Sets the designated parameter to a <code>Reader</code> object. The
4286    * <code>Reader</code> reads the data till end-of-file is reached. The
4287    * driver does the necessary conversion from Java character format to
4288    * the national character set in the database.
4289    * <P><B>Note:</B> This stream object can either be a standard
4290    * Java stream object or your own subclass that implements the
4291    * standard interface.
4292    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4293    * it might be more efficient to use a version of
4294    * <code>setNCharacterStream</code> which takes a length parameter.
4295    *
4296    * @param parameterName the name of the parameter
4297    * @param value the parameter value
4298    * @throws SQLException if the driver does not support national
4299    *         character sets;  if the driver can detect that a data conversion
4300    *  error could occur ; if a database access error occurs; or
4301    * this method is called on a closed <code>CallableStatement</code>
4302    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
4303    * @since 1.6
4304    */
4305   public void setNCharacterStream(String parameterName, Reader value)
4306           throws SQLException {
4307       throw new SQLFeatureNotSupportedException("Feature not supported");
4308    }
4309 
4310    /**
4311     * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
4312     * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
4313     * object maps to a SQL <code>NCLOB</code>.
4314     * @param parameterName the name of the column to be set
4315     * @param value the parameter value
4316     * @throws SQLException if the driver does not support national
4317     *         character sets;  if the driver can detect that a data conversion
4318     *  error could occur; or if a database access error occurs
4319     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
4320     * support this method
4321     * @since 1.6
4322     */
4323    public void setNClob(String parameterName, NClob value) throws SQLException {
4324        throw new SQLFeatureNotSupportedException("Feature not supported");
4325    }
4326 
4327    /**
4328     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain
4329     * the number
4330     * of characters specified by length otherwise a <code>SQLException</code> will be
4331     * generated when the <code>CallableStatement</code> is executed.
4332     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
4333     * because it informs the driver that the parameter value should be sent to
4334     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
4335     * driver may have to do extra work to determine whether the parameter
4336     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4337     *
4338     * @param parameterName the name of the parameter to be set
4339     * @param reader An object that contains the data to set the parameter value to.
4340     * @param length the number of characters in the parameter data.
4341     * @throws SQLException if parameterIndex does not correspond to a parameter
4342     * marker in the SQL statement; if the length specified is less than zero;
4343     * if the driver does not support national
4344     *         character sets;  if the driver can detect that a data conversion
4345     *  error could occur; if a database access error occurs or
4346     * this method is called on a closed <code>CallableStatement</code>
4347     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
4348     * this method
4349     * @since 1.6
4350     */
4351    public void setNClob(String parameterName, Reader reader, long length)
4352            throws SQLException {
4353        throw new SQLFeatureNotSupportedException("Feature not supported");
4354    }
4355 
4356    /**
4357     * Sets the designated parameter to a <code>Reader</code> object.
4358     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
4359     * because it informs the driver that the parameter value should be sent to
4360     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
4361     * driver may have to do extra work to determine whether the parameter
4362     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4363     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4364     * it might be more efficient to use a version of
4365     * <code>setNClob</code> which takes a length parameter.
4366     *
4367     * @param parameterName the name of the parameter
4368     * @param reader An object that contains the data to set the parameter value to.
4369     * @throws SQLException if the driver does not support national character sets;
4370     * if the driver can detect that a data conversion
4371     *  error could occur;  if a database access error occurs or
4372     * this method is called on a closed <code>CallableStatement</code>
4373     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
4374     *
4375     * @since 1.6
4376     */
4377    public void setNClob(String parameterName, Reader reader) throws SQLException {
4378        throw new SQLFeatureNotSupportedException("Feature not supported");
4379    }
4380 
4381    /**
4382     * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
4383     * of characters specified by length otherwise a <code>SQLException</code> will be
4384     * generated when the <code>PreparedStatement</code> is executed.
4385     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
4386     * because it informs the driver that the parameter value should be sent to
4387     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
4388     * driver may have to do extra work to determine whether the parameter
4389     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4390     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4391     * @param reader An object that contains the data to set the parameter value to.
4392     * @param length the number of characters in the parameter data.
4393     * @throws SQLException if parameterIndex does not correspond to a parameter
4394     * marker in the SQL statement; if the length specified is less than zero;
4395     * if the driver does not support national character sets;
4396     * if the driver can detect that a data conversion
4397     *  error could occur;  if a database access error occurs or
4398     * this method is called on a closed <code>PreparedStatement</code>
4399     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
4400     * support this method
4401     *
4402     * @since 1.6
4403     */
4404    public void setNClob(int parameterIndex, Reader reader, long length)
4405            throws SQLException {
4406        throw new SQLFeatureNotSupportedException("Feature not supported");
4407    }
4408 
4409    /**
4410     * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this oa
4411     * SQL <code>NCLOB</code> value when it sends it to the database.
4412     * @param parameterIndex of the first parameter is 1, the second is 2, ...
4413     * @param value the parameter value
4414     * @throws SQLException if the driver does not support national
4415     *         character sets;  if the driver can detect that a data conversion
4416     *  error could occur ; or if a database access error occurs
4417     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
4418     * support this method
4419     * @since 1.6
4420     */
4421    public void setNClob(int parameterIndex, NClob value) throws SQLException {
4422         throw new SQLFeatureNotSupportedException("Feature not supported");
4423    }
4424 
4425    /**
4426     * Sets the designated parameter to a <code>Reader</code> object.
4427     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
4428     * because it informs the driver that the parameter value should be sent to
4429     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
4430     * driver may have to do extra work to determine whether the parameter
4431     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
4432     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
4433     * it might be more efficient to use a version of
4434     * <code>setNClob</code> which takes a length parameter.
4435     *
4436     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4437     * @param reader An object that contains the data to set the parameter value to.
4438     * @throws SQLException if parameterIndex does not correspond to a parameter
4439     * marker in the SQL statement;
4440     * if the driver does not support national character sets;
4441     * if the driver can detect that a data conversion
4442     *  error could occur;  if a database access error occurs or
4443     * this method is called on a closed <code>PreparedStatement</code>
4444     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
4445     *
4446     * @since 1.6
4447     */
4448    public void setNClob(int parameterIndex, Reader reader)throws SQLException {
4449        throw new SQLFeatureNotSupportedException("Feature not supported");
4450    }
4451 
4452    /**
4453     * Sets the designated parameter to the given <code>java.net.URL</code> value.
4454     * The driver converts this to an SQL <code>DATALINK</code> value
4455     * when it sends it to the database.
4456     *
4457     * @param parameterIndex the first parameter is 1, the second is 2, ...
4458     * @param x the <code>java.net.URL</code> object to be set
4459     * @exception SQLException if a database access error occurs or
4460     * this method is called on a closed <code>PreparedStatement</code>
4461     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
4462     * @since 1.4
4463     */
4464    public void setURL(int parameterIndex, java.net.URL x) throws SQLException {
4465        throw new SQLFeatureNotSupportedException("Feature not supported");
4466    }
4467 
4468    static final long serialVersionUID = 4886719666485113312L;
4469 
4470 } //end class