1/* 2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26package javax.sql.rowset; 27 28import java.sql.*; 29import javax.sql.*; 30import java.util.*; 31import java.io.*; 32import java.math.*; 33import java.io.Serializable; 34 35import 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™ 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™ (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>™ 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 298public 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 = true; 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 */ 3208 public void setNull(String parameterName, int sqlType) throws SQLException { 3209 throw new SQLFeatureNotSupportedException("Feature not supported"); 3210 } 3211 3212 /** 3213 * Sets the designated parameter to SQL <code>NULL</code>. 3214 * This version of the method <code>setNull</code> should 3215 * be used for user-defined types and REF type parameters. Examples 3216 * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and 3217 * named array types. 3218 * 3219 * <P><B>Note:</B> To be portable, applications must give the 3220 * SQL type code and the fully-qualified SQL type name when specifying 3221 * a NULL user-defined or REF parameter. In the case of a user-defined type 3222 * the name is the type name of the parameter itself. For a REF 3223 * parameter, the name is the type name of the referenced type. If 3224 * a JDBC driver does not need the type code or type name information, 3225 * it may ignore it. 3226 * 3227 * Although it is intended for user-defined and Ref parameters, 3228 * this method may be used to set a null parameter of any JDBC type. 3229 * If the parameter does not have a user-defined or REF type, the given 3230 * typeName is ignored. 3231 * 3232 * 3233 * @param parameterName the name of the parameter 3234 * @param sqlType a value from <code>java.sql.Types</code> 3235 * @param typeName the fully-qualified name of an SQL user-defined type; 3236 * ignored if the parameter is not a user-defined type or 3237 * SQL <code>REF</code> value 3238 * @exception SQLException if a database access error occurs or 3239 * this method is called on a closed <code>CallableStatement</code> 3240 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3241 * this method 3242 */ 3243 public void setNull (String parameterName, int sqlType, String typeName) 3244 throws SQLException{ 3245 throw new SQLFeatureNotSupportedException("Feature not supported"); 3246 } 3247 3248 /** 3249 * Sets the designated parameter to the given Java <code>boolean</code> value. 3250 * The driver converts this 3251 * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database. 3252 * 3253 * @param parameterName the name of the parameter 3254 * @param x the parameter value 3255 * @exception SQLException if a database access error occurs or 3256 * this method is called on a closed <code>CallableStatement</code> 3257 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3258 * this method 3259 * @see #getParams 3260 */ 3261 public void setBoolean(String parameterName, boolean x) throws SQLException{ 3262 throw new SQLFeatureNotSupportedException("Feature not supported"); 3263 } 3264 3265 /** 3266 * Sets the designated parameter to the given Java <code>byte</code> value. 3267 * The driver converts this 3268 * to an SQL <code>TINYINT</code> value when it sends it to the database. 3269 * 3270 * @param parameterName the name of the parameter 3271 * @param x the parameter value 3272 * @exception SQLException if a database access error occurs or 3273 * this method is called on a closed <code>CallableStatement</code> 3274 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3275 * this method 3276 * @see #getParams 3277 */ 3278 public void setByte(String parameterName, byte x) throws SQLException{ 3279 throw new SQLFeatureNotSupportedException("Feature not supported"); 3280 } 3281 3282 /** 3283 * Sets the designated parameter to the given Java <code>short</code> value. 3284 * The driver converts this 3285 * to an SQL <code>SMALLINT</code> value when it sends it to the database. 3286 * 3287 * @param parameterName the name of the parameter 3288 * @param x the parameter value 3289 * @exception SQLException if a database access error occurs or 3290 * this method is called on a closed <code>CallableStatement</code> 3291 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3292 * this method 3293 * @see #getParams 3294 */ 3295 public void setShort(String parameterName, short x) throws SQLException{ 3296 throw new SQLFeatureNotSupportedException("Feature not supported"); 3297 } 3298 3299 /** 3300 * Sets the designated parameter to the given Java <code>int</code> value. 3301 * The driver converts this 3302 * to an SQL <code>INTEGER</code> value when it sends it to the database. 3303 * 3304 * @param parameterName the name of the parameter 3305 * @param x the parameter value 3306 * @exception SQLException if a database access error occurs or 3307 * this method is called on a closed <code>CallableStatement</code> 3308 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3309 * this method 3310 * @see #getParams 3311 */ 3312 public void setInt(String parameterName, int x) throws SQLException{ 3313 throw new SQLFeatureNotSupportedException("Feature not supported"); 3314 } 3315 3316 3317 /** 3318 * Sets the designated parameter to the given Java <code>long</code> value. 3319 * The driver converts this 3320 * to an SQL <code>BIGINT</code> value when it sends it to the database. 3321 * 3322 * @param parameterName the name of the parameter 3323 * @param x the parameter value 3324 * @exception SQLException if a database access error occurs or 3325 * this method is called on a closed <code>CallableStatement</code> 3326 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3327 * this method 3328 * @see #getParams 3329 */ 3330 public void setLong(String parameterName, long x) throws SQLException{ 3331 throw new SQLFeatureNotSupportedException("Feature not supported"); 3332 } 3333 3334 /** 3335 * Sets the designated parameter to the given Java <code>float</code> value. 3336 * The driver converts this 3337 * to an SQL <code>FLOAT</code> value when it sends it to the database. 3338 * 3339 * @param parameterName the name of the parameter 3340 * @param x the parameter value 3341 * @exception SQLException if a database access error occurs or 3342 * this method is called on a closed <code>CallableStatement</code> 3343 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3344 * this method 3345 * @see #getParams 3346 */ 3347 public void setFloat(String parameterName, float x) throws SQLException{ 3348 throw new SQLFeatureNotSupportedException("Feature not supported"); 3349 } 3350 3351 /** 3352 * Sets the designated parameter to the given Java <code>double</code> value. 3353 * The driver converts this 3354 * to an SQL <code>DOUBLE</code> value when it sends it to the database. 3355 * 3356 * @param parameterName the name of the parameter 3357 * @param x the parameter value 3358 * @exception SQLException if a database access error occurs or 3359 * this method is called on a closed <code>CallableStatement</code> 3360 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3361 * this method 3362 * @see #getParams 3363 */ 3364 public void setDouble(String parameterName, double x) throws SQLException{ 3365 throw new SQLFeatureNotSupportedException("Feature not supported"); 3366 } 3367 3368 /** 3369 * Sets the designated parameter to the given 3370 * <code>java.math.BigDecimal</code> value. 3371 * The driver converts this to an SQL <code>NUMERIC</code> value when 3372 * it sends it to the database. 3373 * 3374 * @param parameterName the name of the parameter 3375 * @param x the parameter value 3376 * @exception SQLException if a database access error occurs or 3377 * this method is called on a closed <code>CallableStatement</code> 3378 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3379 * this method 3380 * @see #getParams 3381 */ 3382 public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{ 3383 throw new SQLFeatureNotSupportedException("Feature not supported"); 3384 } 3385 3386 /** 3387 * Sets the designated parameter to the given Java <code>String</code> value. 3388 * The driver converts this 3389 * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value 3390 * (depending on the argument's 3391 * size relative to the driver's limits on <code>VARCHAR</code> values) 3392 * when it sends it to the database. 3393 * 3394 * @param parameterName the name of the parameter 3395 * @param x the parameter value 3396 * @exception SQLException if a database access error occurs or 3397 * this method is called on a closed <code>CallableStatement</code> 3398 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3399 * this method 3400 * @see #getParams 3401 */ 3402 public void setString(String parameterName, String x) throws SQLException{ 3403 throw new SQLFeatureNotSupportedException("Feature not supported"); 3404 } 3405 3406 /** 3407 * Sets the designated parameter to the given Java array of bytes. 3408 * The driver converts this to an SQL <code>VARBINARY</code> or 3409 * <code>LONGVARBINARY</code> (depending on the argument's size relative 3410 * to the driver's limits on <code>VARBINARY</code> values) when it sends 3411 * it to the database. 3412 * 3413 * @param parameterName the name of the parameter 3414 * @param x the parameter value 3415 * @exception SQLException if a database access error occurs or 3416 * this method is called on a closed <code>CallableStatement</code> 3417 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3418 * this method 3419 * @see #getParams 3420 */ 3421 public void setBytes(String parameterName, byte x[]) throws SQLException{ 3422 throw new SQLFeatureNotSupportedException("Feature not supported"); 3423 } 3424 3425 /** 3426 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value. 3427 * The driver 3428 * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the 3429 * database. 3430 * 3431 * @param parameterName the name of the parameter 3432 * @param x the parameter value 3433 * @exception SQLException if a database access error occurs or 3434 * this method is called on a closed <code>CallableStatement</code> 3435 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3436 * this method 3437 * @see #getParams 3438 */ 3439 public void setTimestamp(String parameterName, java.sql.Timestamp x) 3440 throws SQLException{ 3441 throw new SQLFeatureNotSupportedException("Feature not supported"); 3442 } 3443 3444 /** 3445 * Sets the designated parameter to the given input stream, which will have 3446 * the specified number of bytes. 3447 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 3448 * parameter, it may be more practical to send it via a 3449 * <code>java.io.InputStream</code>. Data will be read from the stream 3450 * as needed until end-of-file is reached. The JDBC driver will 3451 * do any necessary conversion from ASCII to the database char format. 3452 * 3453 * <P><B>Note:</B> This stream object can either be a standard 3454 * Java stream object or your own subclass that implements the 3455 * standard interface. 3456 * 3457 * @param parameterName the name of the parameter 3458 * @param x the Java input stream that contains the ASCII parameter value 3459 * @param length the number of bytes in the stream 3460 * @exception SQLException if a database access error occurs or 3461 * this method is called on a closed <code>CallableStatement</code> 3462 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3463 * this method 3464 */ 3465 public void setAsciiStream(String parameterName, java.io.InputStream x, int length) 3466 throws SQLException{ 3467 throw new SQLFeatureNotSupportedException("Feature not supported"); 3468 } 3469 3470 /** 3471 * Sets the designated parameter to the given input stream, which will have 3472 * the specified number of bytes. 3473 * When a very large binary value is input to a <code>LONGVARBINARY</code> 3474 * parameter, it may be more practical to send it via a 3475 * <code>java.io.InputStream</code> object. The data will be read from the stream 3476 * as needed until end-of-file is reached. 3477 * 3478 * <P><B>Note:</B> This stream object can either be a standard 3479 * Java stream object or your own subclass that implements the 3480 * standard interface. 3481 * 3482 * @param parameterName the name of the parameter 3483 * @param x the java input stream which contains the binary parameter value 3484 * @param length the number of bytes in the stream 3485 * @exception SQLException if a database access error occurs or 3486 * this method is called on a closed <code>CallableStatement</code> 3487 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3488 * this method 3489 */ 3490 public void setBinaryStream(String parameterName, java.io.InputStream x, 3491 int length) throws SQLException{ 3492 throw new SQLFeatureNotSupportedException("Feature not supported"); 3493 } 3494 3495 /** 3496 * Sets the designated parameter to the given <code>Reader</code> 3497 * object, which is the given number of characters long. 3498 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 3499 * parameter, it may be more practical to send it via a 3500 * <code>java.io.Reader</code> object. The data will be read from the stream 3501 * as needed until end-of-file is reached. The JDBC driver will 3502 * do any necessary conversion from UNICODE to the database char format. 3503 * 3504 * <P><B>Note:</B> This stream object can either be a standard 3505 * Java stream object or your own subclass that implements the 3506 * standard interface. 3507 * 3508 * @param parameterName the name of the parameter 3509 * @param reader the <code>java.io.Reader</code> object that 3510 * contains the UNICODE data used as the designated parameter 3511 * @param length the number of characters in the stream 3512 * @exception SQLException if a database access error occurs or 3513 * this method is called on a closed <code>CallableStatement</code> 3514 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3515 * this method 3516 */ 3517 public void setCharacterStream(String parameterName, 3518 java.io.Reader reader, 3519 int length) throws SQLException{ 3520 throw new SQLFeatureNotSupportedException("Feature not supported"); 3521 } 3522 3523 /** 3524 * Sets the designated parameter to the given input stream. 3525 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 3526 * parameter, it may be more practical to send it via a 3527 * <code>java.io.InputStream</code>. Data will be read from the stream 3528 * as needed until end-of-file is reached. The JDBC driver will 3529 * do any necessary conversion from ASCII to the database char format. 3530 * 3531 * <P><B>Note:</B> This stream object can either be a standard 3532 * Java stream object or your own subclass that implements the 3533 * standard interface. 3534 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3535 * it might be more efficient to use a version of 3536 * <code>setAsciiStream</code> which takes a length parameter. 3537 * 3538 * @param parameterName the name of the parameter 3539 * @param x the Java input stream that contains the ASCII parameter value 3540 * @exception SQLException if a database access error occurs or 3541 * this method is called on a closed <code>CallableStatement</code> 3542 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3543 * @since 1.6 3544 */ 3545 public void setAsciiStream(String parameterName, java.io.InputStream x) 3546 throws SQLException{ 3547 throw new SQLFeatureNotSupportedException("Feature not supported"); 3548 } 3549 3550 /** 3551 * Sets the designated parameter to the given input stream. 3552 * When a very large binary value is input to a <code>LONGVARBINARY</code> 3553 * parameter, it may be more practical to send it via a 3554 * <code>java.io.InputStream</code> object. The data will be read from the 3555 * stream as needed until end-of-file is reached. 3556 * 3557 * <P><B>Note:</B> This stream object can either be a standard 3558 * Java stream object or your own subclass that implements the 3559 * standard interface. 3560 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3561 * it might be more efficient to use a version of 3562 * <code>setBinaryStream</code> which takes a length parameter. 3563 * 3564 * @param parameterName the name of the parameter 3565 * @param x the java input stream which contains the binary parameter value 3566 * @exception SQLException if a database access error occurs or 3567 * this method is called on a closed <code>CallableStatement</code> 3568 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3569 * @since 1.6 3570 */ 3571 public void setBinaryStream(String parameterName, java.io.InputStream x) 3572 throws SQLException{ 3573 throw new SQLFeatureNotSupportedException("Feature not supported"); 3574 } 3575 3576 /** 3577 * Sets the designated parameter to the given <code>Reader</code> 3578 * object. 3579 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 3580 * parameter, it may be more practical to send it via a 3581 * <code>java.io.Reader</code> object. The data will be read from the stream 3582 * as needed until end-of-file is reached. The JDBC driver will 3583 * do any necessary conversion from UNICODE to the database char format. 3584 * 3585 * <P><B>Note:</B> This stream object can either be a standard 3586 * Java stream object or your own subclass that implements the 3587 * standard interface. 3588 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3589 * it might be more efficient to use a version of 3590 * <code>setCharacterStream</code> which takes a length parameter. 3591 * 3592 * @param parameterName the name of the parameter 3593 * @param reader the <code>java.io.Reader</code> object that contains the 3594 * Unicode data 3595 * @exception SQLException if a database access error occurs or 3596 * this method is called on a closed <code>CallableStatement</code> 3597 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3598 * @since 1.6 3599 */ 3600 public void setCharacterStream(String parameterName, 3601 java.io.Reader reader) throws SQLException{ 3602 throw new SQLFeatureNotSupportedException("Feature not supported"); 3603 } 3604 3605 /** 3606 * Sets the designated parameter in this <code>RowSet</code> object's command 3607 * to a <code>Reader</code> object. The 3608 * <code>Reader</code> reads the data till end-of-file is reached. The 3609 * driver does the necessary conversion from Java character format to 3610 * the national character set in the database. 3611 * 3612 * <P><B>Note:</B> This stream object can either be a standard 3613 * Java stream object or your own subclass that implements the 3614 * standard interface. 3615 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3616 * it might be more efficient to use a version of 3617 * <code>setNCharacterStream</code> which takes a length parameter. 3618 * 3619 * @param parameterIndex of the first parameter is 1, the second is 2, ... 3620 * @param value the parameter value 3621 * @throws SQLException if the driver does not support national 3622 * character sets; if the driver can detect that a data conversion 3623 * error could occur ; if a database access error occurs; or 3624 * this method is called on a closed <code>PreparedStatement</code> 3625 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3626 * @since 1.6 3627 */ 3628 public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{ 3629 throw new SQLFeatureNotSupportedException("Feature not supported"); 3630 } 3631 3632 /** 3633 * Sets the value of the designated parameter with the given object. The second 3634 * argument must be an object type; for integral values, the 3635 * <code>java.lang</code> equivalent objects should be used. 3636 * 3637 * <p>The given Java object will be converted to the given targetSqlType 3638 * before being sent to the database. 3639 * 3640 * If the object has a custom mapping (is of a class implementing the 3641 * interface <code>SQLData</code>), 3642 * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it 3643 * to the SQL data stream. 3644 * If, on the other hand, the object is of a class implementing 3645 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, 3646 * <code>Struct</code>, <code>java.net.URL</code>, 3647 * or <code>Array</code>, the driver should pass it to the database as a 3648 * value of the corresponding SQL type. 3649 * <P> 3650 * Note that this method may be used to pass database- 3651 * specific abstract data types. 3652 * 3653 * @param parameterName the name of the parameter 3654 * @param x the object containing the input parameter value 3655 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 3656 * sent to the database. The scale argument may further qualify this type. 3657 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, 3658 * this is the number of digits after the decimal point. For all other 3659 * types, this value will be ignored. 3660 * @exception SQLException if a database access error occurs or 3661 * this method is called on a closed <code>CallableStatement</code> 3662 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is 3663 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, 3664 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, 3665 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, 3666 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> 3667 * or <code>STRUCT</code> data type and the JDBC driver does not support 3668 * this data type 3669 * @see Types 3670 * @see #getParams 3671 */ 3672 public void setObject(String parameterName, Object x, int targetSqlType, int scale) 3673 throws SQLException{ 3674 throw new SQLFeatureNotSupportedException("Feature not supported"); 3675 } 3676 3677 /** 3678 * Sets the value of the designated parameter with the given object. 3679 * This method is like the method <code>setObject</code> 3680 * above, except that it assumes a scale of zero. 3681 * 3682 * @param parameterName the name of the parameter 3683 * @param x the object containing the input parameter value 3684 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 3685 * sent to the database 3686 * @exception SQLException if a database access error occurs or 3687 * this method is called on a closed <code>CallableStatement</code> 3688 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is 3689 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, 3690 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, 3691 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, 3692 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> 3693 * or <code>STRUCT</code> data type and the JDBC driver does not support 3694 * this data type 3695 * @see #getParams 3696 */ 3697 public void setObject(String parameterName, Object x, int targetSqlType) 3698 throws SQLException{ 3699 throw new SQLFeatureNotSupportedException("Feature not supported"); 3700 } 3701 3702 /** 3703 * Sets the value of the designated parameter with the given object. 3704 * The second parameter must be of type <code>Object</code>; therefore, the 3705 * <code>java.lang</code> equivalent objects should be used for built-in types. 3706 * 3707 * <p>The JDBC specification specifies a standard mapping from 3708 * Java <code>Object</code> types to SQL types. The given argument 3709 * will be converted to the corresponding SQL type before being 3710 * sent to the database. 3711 * 3712 * <p>Note that this method may be used to pass database- 3713 * specific abstract data types, by using a driver-specific Java 3714 * type. 3715 * 3716 * If the object is of a class implementing the interface <code>SQLData</code>, 3717 * the JDBC driver should call the method <code>SQLData.writeSQL</code> 3718 * to write it to the SQL data stream. 3719 * If, on the other hand, the object is of a class implementing 3720 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, 3721 * <code>Struct</code>, <code>java.net.URL</code>, 3722 * or <code>Array</code>, the driver should pass it to the database as a 3723 * value of the corresponding SQL type. 3724 * <P> 3725 * This method throws an exception if there is an ambiguity, for example, if the 3726 * object is of a class implementing more than one of the interfaces named above. 3727 * 3728 * @param parameterName the name of the parameter 3729 * @param x the object containing the input parameter value 3730 * @exception SQLException if a database access error occurs, 3731 * this method is called on a closed <code>CallableStatement</code> or if the given 3732 * <code>Object</code> parameter is ambiguous 3733 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3734 * this method 3735 * @see #getParams 3736 */ 3737 public void setObject(String parameterName, Object x) throws SQLException{ 3738 throw new SQLFeatureNotSupportedException("Feature not supported"); 3739 } 3740 3741 /** 3742 * Sets the designated parameter to a <code>InputStream</code> object. 3743 * The <code>InputStream</code> must contain the number 3744 * of characters specified by length otherwise a <code>SQLException</code> will be 3745 * generated when the <code>PreparedStatement</code> is executed. 3746 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> 3747 * method because it informs the driver that the parameter value should be 3748 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 3749 * the driver may have to do extra work to determine whether the parameter 3750 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 3751 * @param parameterIndex index of the first parameter is 1, 3752 * the second is 2, ... 3753 * @param inputStream An object that contains the data to set the parameter 3754 * value to. 3755 * @param length the number of bytes in the parameter data. 3756 * @throws SQLException if a database access error occurs, 3757 * this method is called on a closed <code>PreparedStatement</code>, 3758 * if parameterIndex does not correspond 3759 * to a parameter marker in the SQL statement, if the length specified 3760 * is less than zero or if the number of bytes in the 3761 * <code>InputStream</code> does not match the specified length. 3762 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3763 * 3764 * @since 1.6 3765 */ 3766 public void setBlob(int parameterIndex, InputStream inputStream, long length) 3767 throws SQLException{ 3768 throw new SQLFeatureNotSupportedException("Feature not supported"); 3769 } 3770 3771 /** 3772 * Sets the designated parameter to a <code>InputStream</code> object. 3773 * This method differs from the <code>setBinaryStream (int, InputStream)</code> 3774 * method because it informs the driver that the parameter value should be 3775 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 3776 * the driver may have to do extra work to determine whether the parameter 3777 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 3778 * 3779 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3780 * it might be more efficient to use a version of 3781 * <code>setBlob</code> which takes a length parameter. 3782 * 3783 * @param parameterIndex index of the first parameter is 1, 3784 * the second is 2, ... 3785 * @param inputStream An object that contains the data to set the parameter 3786 * value to. 3787 * @throws SQLException if a database access error occurs, 3788 * this method is called on a closed <code>PreparedStatement</code> or 3789 * if parameterIndex does not correspond 3790 * to a parameter marker in the SQL statement, 3791 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3792 * 3793 * @since 1.6 3794 */ 3795 public void setBlob(int parameterIndex, InputStream inputStream) 3796 throws SQLException{ 3797 throw new SQLFeatureNotSupportedException("Feature not supported"); 3798 } 3799 3800 /** 3801 * Sets the designated parameter to a <code>InputStream</code> object. 3802 * The <code>Inputstream</code> must contain the number 3803 * of characters specified by length, otherwise a <code>SQLException</code> will be 3804 * generated when the <code>CallableStatement</code> is executed. 3805 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> 3806 * method because it informs the driver that the parameter value should be 3807 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 3808 * the driver may have to do extra work to determine whether the parameter 3809 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 3810 * 3811 * @param parameterName the name of the parameter to be set 3812 * the second is 2, ... 3813 * 3814 * @param inputStream An object that contains the data to set the parameter 3815 * value to. 3816 * @param length the number of bytes in the parameter data. 3817 * @throws SQLException if parameterIndex does not correspond 3818 * to a parameter marker in the SQL statement, or if the length specified 3819 * is less than zero; if the number of bytes in the <code>InputStream</code> does not match 3820 * the specified length; if a database access error occurs or 3821 * this method is called on a closed <code>CallableStatement</code> 3822 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3823 * this method 3824 * 3825 * @since 1.6 3826 */ 3827 public void setBlob(String parameterName, InputStream inputStream, long length) 3828 throws SQLException{ 3829 throw new SQLFeatureNotSupportedException("Feature not supported"); 3830 } 3831 3832 /** 3833 * Sets the designated parameter to the given <code>java.sql.Blob</code> object. 3834 * The driver converts this to an SQL <code>BLOB</code> value when it 3835 * sends it to the database. 3836 * 3837 * @param parameterName the name of the parameter 3838 * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value 3839 * @exception SQLException 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 * @since 1.6 3844 */ 3845 public void setBlob (String parameterName, Blob x) throws SQLException{ 3846 throw new SQLFeatureNotSupportedException("Feature not supported"); 3847 } 3848 3849 /** 3850 * Sets the designated parameter to a <code>InputStream</code> object. 3851 * This method differs from the <code>setBinaryStream (int, InputStream)</code> 3852 * method because it informs the driver that the parameter value should be 3853 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 3854 * the driver may have to do extra work to determine whether the parameter 3855 * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 3856 * 3857 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3858 * it might be more efficient to use a version of 3859 * <code>setBlob</code> which takes a length parameter. 3860 * 3861 * @param parameterName the name of the parameter 3862 * @param inputStream An object that contains the data to set the parameter 3863 * value to. 3864 * @throws SQLException if a database access error occurs or 3865 * this method is called on a closed <code>CallableStatement</code> 3866 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3867 * 3868 * @since 1.6 3869 */ 3870 public void setBlob(String parameterName, InputStream inputStream) 3871 throws SQLException{ 3872 throw new SQLFeatureNotSupportedException("Feature not supported"); 3873 } 3874 3875 /** 3876 * Sets the designated parameter to a <code>Reader</code> object. 3877 * The reader must contain the number 3878 * of characters specified by length otherwise a <code>SQLException</code> will be 3879 * generated when the <code>PreparedStatement</code> is executed. 3880 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 3881 * because it informs the driver that the parameter value should be sent to 3882 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 3883 * driver may have to do extra work to determine whether the parameter 3884 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 3885 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 3886 * @param reader An object that contains the data to set the parameter value to. 3887 * @param length the number of characters in the parameter data. 3888 * @throws SQLException if a database access error occurs, this method is called on 3889 * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter 3890 * marker in the SQL statement, or if the length specified is less than zero. 3891 * 3892 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3893 * @since 1.6 3894 */ 3895 public void setClob(int parameterIndex, Reader reader, long length) 3896 throws SQLException{ 3897 throw new SQLFeatureNotSupportedException("Feature not supported"); 3898 } 3899 3900 /** 3901 * Sets the designated parameter to a <code>Reader</code> object. 3902 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 3903 * because it informs the driver that the parameter value should be sent to 3904 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 3905 * driver may have to do extra work to determine whether the parameter 3906 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 3907 * 3908 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3909 * it might be more efficient to use a version of 3910 * <code>setClob</code> which takes a length parameter. 3911 * 3912 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 3913 * @param reader An object that contains the data to set the parameter value to. 3914 * @throws SQLException if a database access error occurs, this method is called on 3915 * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter 3916 * marker in the SQL statement 3917 * 3918 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3919 * @since 1.6 3920 */ 3921 public void setClob(int parameterIndex, Reader reader) 3922 throws SQLException{ 3923 throw new SQLFeatureNotSupportedException("Feature not supported"); 3924 } 3925 3926 /** 3927 * Sets the designated parameter to a <code>Reader</code> object. 3928 * The <code>reader</code> must contain the number 3929 * of characters specified by length otherwise a <code>SQLException</code> will be 3930 * generated when the <code>CallableStatement</code> is executed. 3931 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 3932 * because it informs the driver that the parameter value should be sent to 3933 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 3934 * driver may have to do extra work to determine whether the parameter 3935 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 3936 * @param parameterName the name of the parameter to be set 3937 * @param reader An object that contains the data to set the parameter value to. 3938 * @param length the number of characters in the parameter data. 3939 * @throws SQLException if parameterIndex does not correspond to a parameter 3940 * marker in the SQL statement; if the length specified is less than zero; 3941 * a database access error occurs or 3942 * this method is called on a closed <code>CallableStatement</code> 3943 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 3944 * this method 3945 * 3946 * @since 1.6 3947 */ 3948 public void setClob(String parameterName, Reader reader, long length) 3949 throws SQLException { 3950 throw new SQLFeatureNotSupportedException("Feature not supported"); 3951 } 3952 3953 /** 3954 * Sets the designated parameter to the given <code>java.sql.Clob</code> object. 3955 * The driver converts this to an SQL <code>CLOB</code> value when it 3956 * sends it to the database. 3957 * 3958 * @param parameterName the name of the parameter 3959 * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value 3960 * @exception SQLException if 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 * @since 1.6 3965 */ 3966 public void setClob (String parameterName, Clob x) throws SQLException { 3967 throw new SQLFeatureNotSupportedException("Feature not supported"); 3968 } 3969 3970 /** 3971 * Sets the designated parameter to a <code>Reader</code> object. 3972 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 3973 * because it informs the driver that the parameter value should be sent to 3974 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 3975 * driver may have to do extra work to determine whether the parameter 3976 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 3977 * 3978 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 3979 * it might be more efficient to use a version of 3980 * <code>setClob</code> which takes a length parameter. 3981 * 3982 * @param parameterName the name of the parameter 3983 * @param reader An object that contains the data to set the parameter value to. 3984 * @throws SQLException if a database access error occurs or this method is called on 3985 * a closed <code>CallableStatement</code> 3986 * 3987 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 3988 * @since 1.6 3989 */ 3990 public void setClob(String parameterName, Reader reader) throws SQLException { 3991 throw new SQLFeatureNotSupportedException("Feature not supported"); 3992 } 3993 3994 /** 3995 * Sets the designated parameter to the given <code>java.sql.Date</code> value 3996 * using the default time zone of the virtual machine that is running 3997 * the application. 3998 * The driver converts this 3999 * to an SQL <code>DATE</code> value when it sends it to the database. 4000 * 4001 * @param parameterName the name of the parameter 4002 * @param x the parameter value 4003 * @exception SQLException if a database access error occurs or 4004 * this method is called on a closed <code>CallableStatement</code> 4005 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4006 * this method 4007 * @see #getParams 4008 */ 4009 public void setDate(String parameterName, java.sql.Date x) 4010 throws SQLException { 4011 throw new SQLFeatureNotSupportedException("Feature not supported"); 4012 } 4013 4014 /** 4015 * Sets the designated parameter to the given <code>java.sql.Date</code> value, 4016 * using the given <code>Calendar</code> object. The driver uses 4017 * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value, 4018 * which the driver then sends to the database. With a 4019 * a <code>Calendar</code> object, the driver can calculate the date 4020 * taking into account a custom timezone. If no 4021 * <code>Calendar</code> object is specified, the driver uses the default 4022 * timezone, which is that of the virtual machine running the application. 4023 * 4024 * @param parameterName the name of the parameter 4025 * @param x the parameter value 4026 * @param cal the <code>Calendar</code> object the driver will use 4027 * to construct the date 4028 * @exception SQLException if a database access error occurs or 4029 * this method is called on a closed <code>CallableStatement</code> 4030 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4031 * this method 4032 * @see #getParams 4033 */ 4034 public void setDate(String parameterName, java.sql.Date x, Calendar cal) 4035 throws SQLException { 4036 throw new SQLFeatureNotSupportedException("Feature not supported"); 4037 } 4038 4039 /** 4040 * Sets the designated parameter to the given <code>java.sql.Time</code> value. 4041 * The driver converts this 4042 * to an SQL <code>TIME</code> value when it sends it to the database. 4043 * 4044 * @param parameterName the name of the parameter 4045 * @param x the parameter value 4046 * @exception SQLException if a database access error occurs or 4047 * this method is called on a closed <code>CallableStatement</code> 4048 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4049 * this method 4050 * @see #getParams 4051 */ 4052 public void setTime(String parameterName, java.sql.Time x) 4053 throws SQLException { 4054 throw new SQLFeatureNotSupportedException("Feature not supported"); 4055 } 4056 4057 /** 4058 * Sets the designated parameter to the given <code>java.sql.Time</code> value, 4059 * using the given <code>Calendar</code> object. The driver uses 4060 * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value, 4061 * which the driver then sends to the database. With a 4062 * a <code>Calendar</code> object, the driver can calculate the time 4063 * taking into account a custom timezone. If no 4064 * <code>Calendar</code> object is specified, the driver uses the default 4065 * timezone, which is that of the virtual machine running the application. 4066 * 4067 * @param parameterName the name of the parameter 4068 * @param x the parameter value 4069 * @param cal the <code>Calendar</code> object the driver will use 4070 * to construct the time 4071 * @exception SQLException if a database access error occurs or 4072 * this method is called on a closed <code>CallableStatement</code> 4073 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4074 * this method 4075 * @see #getParams 4076 */ 4077 public void setTime(String parameterName, java.sql.Time x, Calendar cal) 4078 throws SQLException { 4079 throw new SQLFeatureNotSupportedException("Feature not supported"); 4080 } 4081 4082 /** 4083 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value, 4084 * using the given <code>Calendar</code> object. The driver uses 4085 * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value, 4086 * which the driver then sends to the database. With a 4087 * a <code>Calendar</code> object, the driver can calculate the timestamp 4088 * taking into account a custom timezone. If no 4089 * <code>Calendar</code> object is specified, the driver uses the default 4090 * timezone, which is that of the virtual machine running the application. 4091 * 4092 * @param parameterName the name of the parameter 4093 * @param x the parameter value 4094 * @param cal the <code>Calendar</code> object the driver will use 4095 * to construct the timestamp 4096 * @exception SQLException if a database access error occurs or 4097 * this method is called on a closed <code>CallableStatement</code> 4098 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4099 * this method 4100 * @see #getParams 4101 */ 4102 public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) 4103 throws SQLException { 4104 throw new SQLFeatureNotSupportedException("Feature not supported"); 4105 } 4106 4107 /** 4108 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an 4109 * SQL <code>XML</code> value when it sends it to the database. 4110 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 4111 * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value 4112 * @throws SQLException if a database access error occurs, this method 4113 * is called on a closed result set, 4114 * the <code>java.xml.transform.Result</code>, 4115 * <code>Writer</code> or <code>OutputStream</code> has not been closed 4116 * for the <code>SQLXML</code> object or 4117 * if there is an error processing the XML value. The <code>getCause</code> method 4118 * of the exception may provide a more detailed exception, for example, if the 4119 * stream does not contain valid XML. 4120 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4121 * support this method 4122 * @since 1.6 4123 */ 4124 public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { 4125 throw new SQLFeatureNotSupportedException("Feature not supported"); 4126 } 4127 4128 /** 4129 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an 4130 * <code>SQL XML</code> value when it sends it to the database. 4131 * @param parameterName the name of the parameter 4132 * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value 4133 * @throws SQLException if a database access error occurs, this method 4134 * is called on a closed result set, 4135 * the <code>java.xml.transform.Result</code>, 4136 * <code>Writer</code> or <code>OutputStream</code> has not been closed 4137 * for the <code>SQLXML</code> object or 4138 * if there is an error processing the XML value. The <code>getCause</code> method 4139 * of the exception may provide a more detailed exception, for example, if the 4140 * stream does not contain valid XML. 4141 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4142 * support this method 4143 * @since 1.6 4144 */ 4145 public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { 4146 throw new SQLFeatureNotSupportedException("Feature not supported"); 4147 } 4148 4149 /** 4150 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The 4151 * driver converts this to a SQL <code>ROWID</code> value when it sends it 4152 * to the database 4153 * 4154 * @param parameterIndex the first parameter is 1, the second is 2, ... 4155 * @param x the parameter value 4156 * @throws SQLException if a database access error occurs 4157 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4158 * support this method 4159 * 4160 * @since 1.6 4161 */ 4162 public void setRowId(int parameterIndex, RowId x) throws SQLException { 4163 throw new SQLFeatureNotSupportedException("Feature not supported"); 4164 } 4165 4166 /** 4167 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The 4168 * driver converts this to a SQL <code>ROWID</code> when it sends it to the 4169 * database. 4170 * 4171 * @param parameterName the name of the parameter 4172 * @param x the parameter value 4173 * @throws SQLException if a database access error occurs 4174 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4175 * support this method 4176 * @since 1.6 4177 */ 4178 public void setRowId(String parameterName, RowId x) throws SQLException { 4179 throw new SQLFeatureNotSupportedException("Feature not supported"); 4180 } 4181 4182 /** 4183 * Sets the designated parameter to the given <code>String</code> object. 4184 * The driver converts this to a SQL <code>NCHAR</code> or 4185 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value 4186 * (depending on the argument's 4187 * size relative to the driver's limits on <code>NVARCHAR</code> values) 4188 * when it sends it to the database. 4189 * 4190 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4191 * @param value the parameter value 4192 * @throws SQLException if the driver does not support national 4193 * character sets; if the driver can detect that a data conversion 4194 * error could occur ; or if a database access error occurs 4195 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4196 * support this method 4197 * @since 1.6 4198 */ 4199 public void setNString(int parameterIndex, String value) throws SQLException { 4200 throw new SQLFeatureNotSupportedException("Feature not supported"); 4201 } 4202 4203 /** 4204 * Sets the designated parameter to the given <code>String</code> object. 4205 * The driver converts this to a SQL <code>NCHAR</code> or 4206 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> 4207 * @param parameterName the name of the column to be set 4208 * @param value the parameter value 4209 * @throws SQLException if the driver does not support national 4210 * character sets; if the driver can detect that a data conversion 4211 * error could occur; or if a database access error occurs 4212 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4213 * support this method 4214 * @since 1.6 4215 */ 4216 public void setNString(String parameterName, String value) throws SQLException { 4217 throw new SQLFeatureNotSupportedException("Feature not supported"); 4218 } 4219 4220 /** 4221 * Sets the designated parameter to a <code>Reader</code> object. The 4222 * <code>Reader</code> reads the data till end-of-file is reached. The 4223 * driver does the necessary conversion from Java character format to 4224 * the national character set in the database. 4225 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4226 * @param value the parameter value 4227 * @param length the number of characters in the parameter data. 4228 * @throws SQLException if the driver does not support national 4229 * character sets; if the driver can detect that a data conversion 4230 * error could occur ; or if a database access error occurs 4231 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4232 * support this method 4233 * @since 1.6 4234 */ 4235 public void setNCharacterStream(int parameterIndex, Reader value, long length) 4236 throws SQLException { 4237 throw new SQLFeatureNotSupportedException("Feature not supported"); 4238 } 4239 4240 /** 4241 * Sets the designated parameter to a <code>Reader</code> object. The 4242 * <code>Reader</code> reads the data till end-of-file is reached. The 4243 * driver does the necessary conversion from Java character format to 4244 * the national character set in the database. 4245 * @param parameterName the name of the column to be set 4246 * @param value the parameter value 4247 * @param length the number of characters in the parameter data. 4248 * @throws SQLException if the driver does not support national 4249 * character sets; if the driver can detect that a data conversion 4250 * error could occur; or if a database access error occurs 4251 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4252 * support this method 4253 * @since 1.6 4254 */ 4255 public void setNCharacterStream(String parameterName, Reader value, long length) 4256 throws SQLException { 4257 throw new SQLFeatureNotSupportedException("Feature not supported"); 4258 } 4259 4260 /** 4261 * Sets the designated parameter to a <code>Reader</code> object. The 4262 * <code>Reader</code> reads the data till end-of-file is reached. The 4263 * driver does the necessary conversion from Java character format to 4264 * the national character set in the database. 4265 * <P><B>Note:</B> This stream object can either be a standard 4266 * Java stream object or your own subclass that implements the 4267 * standard interface. 4268 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4269 * it might be more efficient to use a version of 4270 * <code>setNCharacterStream</code> which takes a length parameter. 4271 * 4272 * @param parameterName the name of the parameter 4273 * @param value the parameter value 4274 * @throws SQLException if the driver does not support national 4275 * character sets; if the driver can detect that a data conversion 4276 * error could occur ; if a database access error occurs; or 4277 * this method is called on a closed <code>CallableStatement</code> 4278 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4279 * @since 1.6 4280 */ 4281 public void setNCharacterStream(String parameterName, Reader value) 4282 throws SQLException { 4283 throw new SQLFeatureNotSupportedException("Feature not supported"); 4284 } 4285 4286 /** 4287 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object 4288 * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code> 4289 * object maps to a SQL <code>NCLOB</code>. 4290 * @param parameterName the name of the column to be set 4291 * @param value the parameter value 4292 * @throws SQLException if the driver does not support national 4293 * character sets; if the driver can detect that a data conversion 4294 * error could occur; or if a database access error occurs 4295 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4296 * support this method 4297 * @since 1.6 4298 */ 4299 public void setNClob(String parameterName, NClob value) throws SQLException { 4300 throw new SQLFeatureNotSupportedException("Feature not supported"); 4301 } 4302 4303 /** 4304 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain 4305 * the number 4306 * of characters specified by length otherwise a <code>SQLException</code> will be 4307 * generated when the <code>CallableStatement</code> is executed. 4308 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 4309 * because it informs the driver that the parameter value should be sent to 4310 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 4311 * driver may have to do extra work to determine whether the parameter 4312 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 4313 * 4314 * @param parameterName the name of the parameter to be set 4315 * @param reader An object that contains the data to set the parameter value to. 4316 * @param length the number of characters in the parameter data. 4317 * @throws SQLException if parameterIndex does not correspond to a parameter 4318 * marker in the SQL statement; if the length specified is less than zero; 4319 * if the driver does not support national 4320 * character sets; if the driver can detect that a data conversion 4321 * error could occur; if a database access error occurs or 4322 * this method is called on a closed <code>CallableStatement</code> 4323 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4324 * this method 4325 * @since 1.6 4326 */ 4327 public void setNClob(String parameterName, Reader reader, long length) 4328 throws SQLException { 4329 throw new SQLFeatureNotSupportedException("Feature not supported"); 4330 } 4331 4332 /** 4333 * Sets the designated parameter to a <code>Reader</code> object. 4334 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 4335 * because it informs the driver that the parameter value should be sent to 4336 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 4337 * driver may have to do extra work to determine whether the parameter 4338 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 4339 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4340 * it might be more efficient to use a version of 4341 * <code>setNClob</code> which takes a length parameter. 4342 * 4343 * @param parameterName the name of the parameter 4344 * @param reader An object that contains the data to set the parameter value to. 4345 * @throws SQLException if the driver does not support national character sets; 4346 * if the driver can detect that a data conversion 4347 * error could occur; if a database access error occurs or 4348 * this method is called on a closed <code>CallableStatement</code> 4349 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4350 * 4351 * @since 1.6 4352 */ 4353 public void setNClob(String parameterName, Reader reader) throws SQLException { 4354 throw new SQLFeatureNotSupportedException("Feature not supported"); 4355 } 4356 4357 /** 4358 * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number 4359 * of characters specified by length otherwise a <code>SQLException</code> will be 4360 * generated when the <code>PreparedStatement</code> is executed. 4361 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 4362 * because it informs the driver that the parameter value should be sent to 4363 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 4364 * driver may have to do extra work to determine whether the parameter 4365 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 4366 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 4367 * @param reader An object that contains the data to set the parameter value to. 4368 * @param length the number of characters in the parameter data. 4369 * @throws SQLException if parameterIndex does not correspond to a parameter 4370 * marker in the SQL statement; if the length specified is less than zero; 4371 * if the driver does not support national character sets; 4372 * if the driver can detect that a data conversion 4373 * error could occur; if a database access error occurs or 4374 * this method is called on a closed <code>PreparedStatement</code> 4375 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4376 * support this method 4377 * 4378 * @since 1.6 4379 */ 4380 public void setNClob(int parameterIndex, Reader reader, long length) 4381 throws SQLException { 4382 throw new SQLFeatureNotSupportedException("Feature not supported"); 4383 } 4384 4385 /** 4386 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this oa 4387 * SQL <code>NCLOB</code> value when it sends it to the database. 4388 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4389 * @param value the parameter value 4390 * @throws SQLException if the driver does not support national 4391 * character sets; if the driver can detect that a data conversion 4392 * error could occur ; or if a database access error occurs 4393 * @throws SQLFeatureNotSupportedException if the JDBC driver does not 4394 * support this method 4395 * @since 1.6 4396 */ 4397 public void setNClob(int parameterIndex, NClob value) throws SQLException { 4398 throw new SQLFeatureNotSupportedException("Feature not supported"); 4399 } 4400 4401 /** 4402 * Sets the designated parameter to a <code>Reader</code> object. 4403 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 4404 * because it informs the driver that the parameter value should be sent to 4405 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 4406 * driver may have to do extra work to determine whether the parameter 4407 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 4408 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4409 * it might be more efficient to use a version of 4410 * <code>setNClob</code> which takes a length parameter. 4411 * 4412 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 4413 * @param reader An object that contains the data to set the parameter value to. 4414 * @throws SQLException if parameterIndex does not correspond to a parameter 4415 * marker in the SQL statement; 4416 * if the driver does not support national character sets; 4417 * if the driver can detect that a data conversion 4418 * error could occur; if a database access error occurs or 4419 * this method is called on a closed <code>PreparedStatement</code> 4420 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4421 * 4422 * @since 1.6 4423 */ 4424 public void setNClob(int parameterIndex, Reader reader)throws SQLException { 4425 throw new SQLFeatureNotSupportedException("Feature not supported"); 4426 } 4427 4428 /** 4429 * Sets the designated parameter to the given <code>java.net.URL</code> value. 4430 * The driver converts this to an SQL <code>DATALINK</code> value 4431 * when it sends it to the database. 4432 * 4433 * @param parameterIndex the first parameter is 1, the second is 2, ... 4434 * @param x the <code>java.net.URL</code> object to be set 4435 * @exception SQLException if a database access error occurs or 4436 * this method is called on a closed <code>PreparedStatement</code> 4437 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4438 */ 4439 public void setURL(int parameterIndex, java.net.URL x) throws SQLException { 4440 throw new SQLFeatureNotSupportedException("Feature not supported"); 4441 } 4442 4443 static final long serialVersionUID = 4886719666485113312L; 4444 4445} //end class 4446