1 /*
2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.rowset;
27
28 import java.sql.*;
29 import javax.sql.*;
30 import java.io.*;
31 import java.math.*;
32 import java.util.*;
33 import java.text.*;
34 import java.security.AccessController;
35 import java.security.PrivilegedActionException;
36 import java.security.PrivilegedExceptionAction;
37
38 import javax.sql.rowset.*;
39 import javax.sql.rowset.spi.*;
40 import javax.sql.rowset.serial.*;
41 import com.sun.rowset.internal.*;
42 import com.sun.rowset.providers.*;
43 import sun.reflect.misc.ReflectUtil;
44
45 /**
46 * The standard implementation of the <code>CachedRowSet</code> interface.
47 *
48 * See interface definition for full behavior and implementation requirements.
49 * This reference implementation has made provision for a one-to-one write back
50 * facility and it is curremtly be possible to change the peristence provider
51 * during the life-time of any CachedRowSetImpl.
52 *
53 * @author Jonathan Bruce, Amit Handa
54 */
55
56 public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetInternal, Serializable, Cloneable, CachedRowSet {
57
58 /**
59 * The <code>SyncProvider</code> used by the CachedRowSet
60 */
61 private SyncProvider provider;
62
63 /**
64 * The <code>RowSetReaderImpl</code> object that is the reader
65 * for this rowset. The method <code>execute</code> uses this
66 * reader as part of its implementation.
67 * @serial
68 */
69 private RowSetReader rowSetReader;
70
71 /**
72 * The <code>RowSetWriterImpl</code> object that is the writer
73 * for this rowset. The method <code>acceptChanges</code> uses
74 * this writer as part of its implementation.
75 * @serial
76 */
77 private RowSetWriter rowSetWriter;
78
79 /**
80 * The <code>Connection</code> object that connects with this
81 * <code>CachedRowSetImpl</code> object's current underlying data source.
82 */
83 private transient Connection conn;
84
85 /**
86 * The <code>ResultSetMetaData</code> object that contains information
87 * about the columns in the <code>ResultSet</code> object that is the
88 * current source of data for this <code>CachedRowSetImpl</code> object.
89 */
90 private transient ResultSetMetaData RSMD;
91
92 /**
93 * The <code>RowSetMetaData</code> object that contains information about
94 * the columns in this <code>CachedRowSetImpl</code> object.
95 * @serial
96 */
97 private RowSetMetaDataImpl RowSetMD;
98
99 // Properties of this RowSet
100
101 /**
102 * An array containing the columns in this <code>CachedRowSetImpl</code>
103 * object that form a unique identifier for a row. This array
104 * is used by the writer.
105 * @serial
106 */
107 private int keyCols[];
108
109 /**
110 * The name of the table in the underlying database to which updates
111 * should be written. This name is needed because most drivers
112 * do not return this information in a <code>ResultSetMetaData</code>
113 * object.
114 * @serial
115 */
116 private String tableName;
117
118 /**
119 * A <code>Vector</code> object containing the <code>Row</code>
120 * objects that comprise this <code>CachedRowSetImpl</code> object.
121 * @serial
122 */
123 private Vector<Object> rvh;
124
125 /**
126 * The current position of the cursor in this <code>CachedRowSetImpl</code>
127 * object.
128 * @serial
129 */
130 private int cursorPos;
131
132 /**
133 * The current position of the cursor in this <code>CachedRowSetImpl</code>
134 * object not counting rows that have been deleted, if any.
135 * <P>
136 * For example, suppose that the cursor is on the last row of a rowset
137 * that started with five rows and subsequently had the second and third
138 * rows deleted. The <code>absolutePos</code> would be <code>3</code>,
139 * whereas the <code>cursorPos</code> would be <code>5</code>.
140 * @serial
141 */
142 private int absolutePos;
143
144 /**
145 * The number of deleted rows currently in this <code>CachedRowSetImpl</code>
146 * object.
147 * @serial
148 */
149 private int numDeleted;
150
151 /**
152 * The total number of rows currently in this <code>CachedRowSetImpl</code>
153 * object.
154 * @serial
155 */
156 private int numRows;
157
158 /**
159 * A special row used for constructing a new row. A new
160 * row is constructed by using <code>ResultSet.updateXXX</code>
161 * methods to insert column values into the insert row.
162 * @serial
163 */
164 private InsertRow insertRow;
165
166 /**
167 * A <code>boolean</code> indicating whether the cursor is
168 * currently on the insert row.
169 * @serial
170 */
171 private boolean onInsertRow;
172
173 /**
174 * The field that temporarily holds the last position of the
175 * cursor before it moved to the insert row, thus preserving
176 * the number of the current row to which the cursor may return.
177 * @serial
178 */
179 private int currentRow;
180
181 /**
182 * A <code>boolean</code> indicating whether the last value
183 * returned was an SQL <code>NULL</code>.
184 * @serial
185 */
186 private boolean lastValueNull;
187
188 /**
189 * A <code>SQLWarning</code> which logs on the warnings
190 */
191 private SQLWarning sqlwarn;
192
193 /**
194 * Used to track match column for JoinRowSet consumption
195 */
196 private String strMatchColumn ="";
197
198 /**
199 * Used to track match column for JoinRowSet consumption
200 */
201 private int iMatchColumn = -1;
202
203 /**
204 * A <code>RowSetWarning</code> which logs on the warnings
205 */
206 private RowSetWarning rowsetWarning;
207
208 /**
209 * The default SyncProvider for the RI CachedRowSetImpl
210 */
211 private String DEFAULT_SYNC_PROVIDER = "com.sun.rowset.providers.RIOptimisticProvider";
212
213 /**
214 * The boolean variable indicating locatorsUpdateValue
215 */
216 private boolean dbmslocatorsUpdateCopy;
217
218 /**
219 * The <code>ResultSet</code> object that is used to maintain the data when
220 * a ResultSet and start position are passed as parameters to the populate function
221 */
222 private transient ResultSet resultSet;
223
224 /**
225 * The integer value indicating the end position in the ResultSetwhere the picking
226 * up of rows for populating a CachedRowSet object was left off.
227 */
228 private int endPos;
229
230 /**
231 * The integer value indicating the end position in the ResultSetwhere the picking
232 * up of rows for populating a CachedRowSet object was left off.
233 */
234 private int prevEndPos;
235
236 /**
237 * The integer value indicating the position in the ResultSet, to populate the
238 * CachedRowSet object.
239 */
240 private int startPos;
241
242 /**
243 * The integer value indicating the position from where the page prior to this
244 * was populated.
245 */
246 private int startPrev;
247
248 /**
249 * The integer value indicating size of the page.
250 */
251 private int pageSize;
252
253 /**
254 * The integer value indicating number of rows that have been processed so far.
255 * Used for checking whether maxRows has been reached or not.
256 */
257 private int maxRowsreached;
258 /**
259 * The boolean value when true signifies that pages are still to follow and a
260 * false value indicates that this is the last page.
261 */
262 private boolean pagenotend = true;
263
264 /**
265 * The boolean value indicating whether this is the first page or not.
266 */
267 private boolean onFirstPage;
268
269 /**
270 * The boolean value indicating whether this is the last page or not.
271 */
272 private boolean onLastPage;
273
274 /**
275 * The integer value indicating how many times the populate function has been called.
276 */
277 private int populatecallcount;
278
279 /**
280 * The integer value indicating the total number of rows to be processed in the
281 * ResultSet object passed to the populate function.
282 */
283 private int totalRows;
284
285 /**
286 * The boolean value indicating how the CahedRowSet object has been populated for
287 * paging purpose. True indicates that connection parameter is passed.
288 */
289 private boolean callWithCon;
290
291 /**
292 * CachedRowSet reader object to read the data from the ResultSet when a connection
293 * parameter is passed to populate the CachedRowSet object for paging.
294 */
295 private CachedRowSetReader crsReader;
296
297 /**
298 * The Vector holding the Match Columns
299 */
300 private Vector<Integer> iMatchColumns;
301
302 /**
303 * The Vector that will hold the Match Column names.
304 */
305 private Vector<String> strMatchColumns;
306
307 /**
308 * Trigger that indicates whether the active SyncProvider is exposes the
309 * additional TransactionalWriter method
310 */
311 private boolean tXWriter = false;
312
313 /**
314 * The field object for a transactional RowSet writer
315 */
316 private TransactionalWriter tWriter = null;
317
318 protected transient JdbcRowSetResourceBundle resBundle;
319
320 private boolean updateOnInsert;
321
322
323
324 /**
325 * Constructs a new default <code>CachedRowSetImpl</code> object with
326 * the capacity to hold 100 rows. This new object has no metadata
327 * and has the following default values:
328 * <pre>
329 * onInsertRow = false
330 * insertRow = null
331 * cursorPos = 0
332 * numRows = 0
333 * showDeleted = false
334 * queryTimeout = 0
335 * maxRows = 0
336 * maxFieldSize = 0
337 * rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE
338 * concurrency = ResultSet.CONCUR_UPDATABLE
339 * readOnly = false
340 * isolation = Connection.TRANSACTION_READ_COMMITTED
341 * escapeProcessing = true
342 * onInsertRow = false
343 * insertRow = null
344 * cursorPos = 0
345 * absolutePos = 0
346 * numRows = 0
347 * </pre>
348 * A <code>CachedRowSetImpl</code> object is configured to use the default
349 * <code>RIOptimisticProvider</code> implementation to provide connectivity
350 * and synchronization capabilities to the set data source.
351 * <P>
352 * @throws SQLException if an error occurs
353 */
354 public CachedRowSetImpl() throws SQLException {
355
356 try {
357 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
358 } catch(IOException ioe) {
359 throw new RuntimeException(ioe);
360 }
361
362 // set the Reader, this maybe overridden latter
363 try {
364 provider = AccessController.doPrivileged(new PrivilegedExceptionAction<>() {
365 @Override
366 public SyncProvider run() throws SyncFactoryException {
367 return SyncFactory.getInstance(DEFAULT_SYNC_PROVIDER);
368 }
369 }, null, new RuntimePermission("accessClassInPackage.com.sun.rowset.providers"));
370 } catch (PrivilegedActionException pae) {
371 throw (SyncFactoryException) pae.getException();
372 }
373
374 if (!(provider instanceof RIOptimisticProvider)) {
375 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidp").toString());
376 }
377
378 rowSetReader = (CachedRowSetReader)provider.getRowSetReader();
379 rowSetWriter = (CachedRowSetWriter)provider.getRowSetWriter();
380
381 // allocate the parameters collection
382 initParams();
383
384 initContainer();
385
386 // set up some default values
387 initProperties();
388
389 // insert row setup
390 onInsertRow = false;
391 insertRow = null;
392
393 // set the warninings
394 sqlwarn = new SQLWarning();
395 rowsetWarning = new RowSetWarning();
396
397 }
398
399 /**
400 * Provides a <code>CachedRowSetImpl</code> instance with the same default properties as
401 * as the zero parameter constructor.
402 * <pre>
403 * onInsertRow = false
404 * insertRow = null
405 * cursorPos = 0
406 * numRows = 0
407 * showDeleted = false
408 * queryTimeout = 0
409 * maxRows = 0
410 * maxFieldSize = 0
411 * rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE
412 * concurrency = ResultSet.CONCUR_UPDATABLE
413 * readOnly = false
414 * isolation = Connection.TRANSACTION_READ_COMMITTED
415 * escapeProcessing = true
416 * onInsertRow = false
417 * insertRow = null
418 * cursorPos = 0
419 * absolutePos = 0
420 * numRows = 0
421 * </pre>
422 *
423 * However, applications will have the means to specify at runtime the
424 * desired <code>SyncProvider</code> object.
425 * <p>
426 * For example, creating a <code>CachedRowSetImpl</code> object as follows ensures
427 * that a it is established with the <code>com.foo.provider.Impl</code> synchronization
428 * implementation providing the synchronization mechanism for this disconnected
429 * <code>RowSet</code> object.
430 * <pre>
431 * Hashtable env = new Hashtable();
432 * env.put(javax.sql.rowset.spi.SyncFactory.ROWSET_PROVIDER_NAME,
433 * "com.foo.provider.Impl");
434 * CachedRowSetImpl crs = new CachedRowSet(env);
435 * </pre>
436 * <p>
437 * Calling this constructor with a <code>null</code> parameter will
438 * cause the <code>SyncFactory</code> to provide the reference
439 * optimistic provider <code>com.sun.rowset.providers.RIOptimisticProvider</code>.
440 * <p>
441 * In addition, the following properties can be associated with the
442 * provider to assist in determining the choice of the synchronizaton
443 * provider such as:
444 * <ul>
445 * <li><code>ROWSET_SYNC_PROVIDER</code> - the property specifying the
446 * <code>SyncProvider</code> class name to be instantiated by the
447 * <code>SyncFacttory</code>
448 * <li><code>ROWSET_SYNC_VENDOR</code> - the property specifying the software
449 * vendor associated with a <code>SyncProvider</code> implementation.
450 * <li><code>ROWSET_SYNC_PROVIDER_VER</code> - the property specifying the
451 * version of the <code>SyncProvider</code> implementation provided by the
452 * software vendor.
453 * </ul>
454 * More specific detailes are available in the <code>SyncFactory</code>
455 * and <code>SyncProvider</code> specificiations later in this document.
456 * <p>
457 * @param env a <code>Hashtable</code> object with a list of desired
458 * synchronization providers
459 * @throws SQLException if the requested provider cannot be found by the
460 * synchronization factory
461 * @see SyncProvider
462 */
463 public CachedRowSetImpl(@SuppressWarnings("rawtypes") Hashtable env) throws SQLException {
464
465
466 try {
467 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
468 } catch(IOException ioe) {
469 throw new RuntimeException(ioe);
470 }
471
472 if (env == null) {
473 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nullhash").toString());
474 }
475
476 String providerName = (String)env.get(
477 javax.sql.rowset.spi.SyncFactory.ROWSET_SYNC_PROVIDER);
478
479 // set the Reader, this maybe overridden latter
480 provider =
481 SyncFactory.getInstance(providerName);
482
483 rowSetReader = provider.getRowSetReader();
484 rowSetWriter = provider.getRowSetWriter();
485
486 initParams(); // allocate the parameters collection
487 initContainer();
488 initProperties(); // set up some default values
489 }
490
491 /**
492 * Sets the <code>rvh</code> field to a new <code>Vector</code>
493 * object with a capacity of 100 and sets the
494 * <code>cursorPos</code> and <code>numRows</code> fields to zero.
495 */
496 private void initContainer() {
497
498 rvh = new Vector<Object>(100);
499 cursorPos = 0;
500 absolutePos = 0;
501 numRows = 0;
502 numDeleted = 0;
503 }
504
505 /**
506 * Sets the properties for this <code>CachedRowSetImpl</code> object to
507 * their default values. This method is called internally by the
508 * default constructor.
509 */
510
511 private void initProperties() throws SQLException {
512
513 if(resBundle == null) {
514 try {
515 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
516 } catch(IOException ioe) {
517 throw new RuntimeException(ioe);
518 }
519 }
520 setShowDeleted(false);
521 setQueryTimeout(0);
522 setMaxRows(0);
523 setMaxFieldSize(0);
524 setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
525 setConcurrency(ResultSet.CONCUR_UPDATABLE);
526 if((rvh.size() > 0) && (isReadOnly() == false))
527 setReadOnly(false);
528 else
529 setReadOnly(true);
530 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
531 setEscapeProcessing(true);
532 //setTypeMap(null);
533 checkTransactionalWriter();
534
535 //Instantiating the vector for MatchColumns
536
537 iMatchColumns = new Vector<Integer>(10);
538 for(int i = 0; i < 10 ; i++) {
539 iMatchColumns.add(i, -1);
540 }
541
542 strMatchColumns = new Vector<String>(10);
543 for(int j = 0; j < 10; j++) {
544 strMatchColumns.add(j,null);
545 }
546 }
547
548 /**
549 * Determine whether the SyncProvider's writer implements the
550 * <code>TransactionalWriter<code> interface
551 */
552 private void checkTransactionalWriter() {
553 if (rowSetWriter != null) {
554 Class<?> c = rowSetWriter.getClass();
555 if (c != null) {
556 Class<?>[] theInterfaces = c.getInterfaces();
557 for (int i = 0; i < theInterfaces.length; i++) {
558 if ((theInterfaces[i].getName()).indexOf("TransactionalWriter") > 0) {
559 tXWriter = true;
560 establishTransactionalWriter();
561 }
562 }
563 }
564 }
565 }
566
567 /**
568 * Sets an private field to all transaction bounddaries to be set
569 */
570 private void establishTransactionalWriter() {
571 tWriter = (TransactionalWriter)provider.getRowSetWriter();
572 }
573
574 //-----------------------------------------------------------------------
575 // Properties
576 //-----------------------------------------------------------------------
577
578 /**
579 * Sets this <code>CachedRowSetImpl</code> object's command property
580 * to the given <code>String</code> object and clears the parameters,
581 * if any, that were set for the previous command.
582 * <P>
583 * The command property may not be needed
584 * if the rowset is produced by a data source, such as a spreadsheet,
585 * that does not support commands. Thus, this property is optional
586 * and may be <code>null</code>.
587 *
588 * @param cmd a <code>String</code> object containing an SQL query
589 * that will be set as the command; may be <code>null</code>
590 * @throws SQLException if an error occurs
591 */
592 public void setCommand(String cmd) throws SQLException {
593
594 super.setCommand(cmd);
595
596 if(!buildTableName(cmd).equals("")) {
597 this.setTableName(buildTableName(cmd));
598 }
599 }
600
601
602 //---------------------------------------------------------------------
603 // Reading and writing data
604 //---------------------------------------------------------------------
605
606 /**
607 * Populates this <code>CachedRowSetImpl</code> object with data from
608 * the given <code>ResultSet</code> object. This
609 * method is an alternative to the method <code>execute</code>
610 * for filling the rowset with data. The method <code>populate</code>
611 * does not require that the properties needed by the method
612 * <code>execute</code>, such as the <code>command</code> property,
613 * be set. This is true because the method <code>populate</code>
614 * is given the <code>ResultSet</code> object from
615 * which to get data and thus does not need to use the properties
616 * required for setting up a connection and executing this
617 * <code>CachedRowSetImpl</code> object's command.
618 * <P>
619 * After populating this rowset with data, the method
620 * <code>populate</code> sets the rowset's metadata and
621 * then sends a <code>RowSetChangedEvent</code> object
622 * to all registered listeners prior to returning.
623 *
624 * @param data the <code>ResultSet</code> object containing the data
625 * to be read into this <code>CachedRowSetImpl</code> object
626 * @throws SQLException if an error occurs; or the max row setting is
627 * violated while populating the RowSet
628 * @see #execute
629 */
630
631 public void populate(ResultSet data) throws SQLException {
632 int rowsFetched;
633 Row currentRow;
634 int numCols;
635 int i;
636 Map<String, Class<?>> map = getTypeMap();
637 Object obj;
638 int mRows;
639
640 if (data == null) {
641 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.populate").toString());
642 }
643 this.resultSet = data;
644
645 // get the meta data for this ResultSet
646 RSMD = data.getMetaData();
647
648 // set up the metadata
649 RowSetMD = new RowSetMetaDataImpl();
650 initMetaData(RowSetMD, RSMD);
651
652 // release the meta-data so that aren't tempted to use it.
653 RSMD = null;
654 numCols = RowSetMD.getColumnCount();
655 mRows = this.getMaxRows();
656 rowsFetched = 0;
657 currentRow = null;
658
659 while ( data.next()) {
660
661 currentRow = new Row(numCols);
662
663 if ( rowsFetched > mRows && mRows > 0) {
664 rowsetWarning.setNextWarning(new RowSetWarning("Populating rows "
665 + "setting has exceeded max row setting"));
666 }
667 for ( i = 1; i <= numCols; i++) {
668 /*
669 * check if the user has set a map. If no map
670 * is set then use plain getObject. This lets
671 * us work with drivers that do not support
672 * getObject with a map in fairly sensible way
673 */
674 if (map == null || map.isEmpty()) {
675 obj = data.getObject(i);
676 } else {
677 obj = data.getObject(i, map);
678 }
679 /*
680 * the following block checks for the various
681 * types that we have to serialize in order to
682 * store - right now only structs have been tested
683 */
684 if (obj instanceof Struct) {
685 obj = new SerialStruct((Struct)obj, map);
686 } else if (obj instanceof SQLData) {
687 obj = new SerialStruct((SQLData)obj, map);
688 } else if (obj instanceof Blob) {
689 obj = new SerialBlob((Blob)obj);
690 } else if (obj instanceof Clob) {
691 obj = new SerialClob((Clob)obj);
692 } else if (obj instanceof java.sql.Array) {
693 if(map != null)
694 obj = new SerialArray((java.sql.Array)obj, map);
695 else
696 obj = new SerialArray((java.sql.Array)obj);
697 }
698
699 currentRow.initColumnObject(i, obj);
700 }
701 rowsFetched++;
702 rvh.add(currentRow);
703 }
704
705 numRows = rowsFetched ;
706 // Also rowsFetched should be equal to rvh.size()
707
708 // notify any listeners that the rowset has changed
709 notifyRowSetChanged();
710
711
712 }
713
714 /**
715 * Initializes the given <code>RowSetMetaData</code> object with the values
716 * in the given <code>ResultSetMetaData</code> object.
717 *
718 * @param md the <code>RowSetMetaData</code> object for this
719 * <code>CachedRowSetImpl</code> object, which will be set with
720 * values from rsmd
721 * @param rsmd the <code>ResultSetMetaData</code> object from which new
722 * values for md will be read
723 * @throws SQLException if an error occurs
724 */
725 private void initMetaData(RowSetMetaDataImpl md, ResultSetMetaData rsmd) throws SQLException {
726 int numCols = rsmd.getColumnCount();
727
728 md.setColumnCount(numCols);
729 for (int col=1; col <= numCols; col++) {
730 md.setAutoIncrement(col, rsmd.isAutoIncrement(col));
731 if(rsmd.isAutoIncrement(col))
732 updateOnInsert = true;
733 md.setCaseSensitive(col, rsmd.isCaseSensitive(col));
734 md.setCurrency(col, rsmd.isCurrency(col));
735 md.setNullable(col, rsmd.isNullable(col));
736 md.setSigned(col, rsmd.isSigned(col));
737 md.setSearchable(col, rsmd.isSearchable(col));
738 /*
739 * The PostgreSQL drivers sometimes return negative columnDisplaySize,
740 * which causes an exception to be thrown. Check for it.
741 */
742 int size = rsmd.getColumnDisplaySize(col);
743 if (size < 0) {
744 size = 0;
745 }
746 md.setColumnDisplaySize(col, size);
747 md.setColumnLabel(col, rsmd.getColumnLabel(col));
748 md.setColumnName(col, rsmd.getColumnName(col));
749 md.setSchemaName(col, rsmd.getSchemaName(col));
750 /*
751 * Drivers return some strange values for precision, for non-numeric data, including reports of
752 * non-integer values; maybe we should check type, & set to 0 for non-numeric types.
753 */
754 int precision = rsmd.getPrecision(col);
755 if (precision < 0) {
756 precision = 0;
757 }
758 md.setPrecision(col, precision);
759
760 /*
761 * It seems, from a bug report, that a driver can sometimes return a negative
762 * value for scale. javax.sql.rowset.RowSetMetaDataImpl will throw an exception
763 * if we attempt to set a negative value. As such, we'll check for this case.
764 */
765 int scale = rsmd.getScale(col);
766 if (scale < 0) {
767 scale = 0;
768 }
769 md.setScale(col, scale);
770 md.setTableName(col, rsmd.getTableName(col));
771 md.setCatalogName(col, rsmd.getCatalogName(col));
772 md.setColumnType(col, rsmd.getColumnType(col));
773 md.setColumnTypeName(col, rsmd.getColumnTypeName(col));
774 }
775
776 if( conn != null){
777 // JDBC 4.0 mandates as does the Java EE spec that all DataBaseMetaData methods
778 // must be implemented, therefore, the previous fix for 5055528 is being backed out
779 dbmslocatorsUpdateCopy = conn.getMetaData().locatorsUpdateCopy();
780 }
781 }
782
783 /**
784 * Populates this <code>CachedRowSetImpl</code> object with data,
785 * using the given connection to produce the result set from
786 * which data will be read. A second form of this method,
787 * which takes no arguments, uses the values from this rowset's
788 * user, password, and either url or data source properties to
789 * create a new database connection. The form of <code>execute</code>
790 * that is given a connection ignores these properties.
791 *
792 * @param conn A standard JDBC <code>Connection</code> object that this
793 * <code>CachedRowSet</code> object can pass to a synchronization provider
794 * to establish a connection to the data source
795 * @throws SQLException if an invalid <code>Connection</code> is supplied
796 * or an error occurs in establishing the connection to the
797 * data source
798 * @see #populate
799 * @see java.sql.Connection
800 */
801 public void execute(Connection conn) throws SQLException {
802 // store the connection so the reader can find it.
803 setConnection(conn);
804
805 if(getPageSize() != 0){
806 crsReader = (CachedRowSetReader)provider.getRowSetReader();
807 crsReader.setStartPosition(1);
808 callWithCon = true;
809 crsReader.readData((RowSetInternal)this);
810 }
811
812 // Now call the current reader's readData method
813 else {
814 rowSetReader.readData((RowSetInternal)this);
815 }
816 RowSetMD = (RowSetMetaDataImpl)this.getMetaData();
817
818 if(conn != null){
819 // JDBC 4.0 mandates as does the Java EE spec that all DataBaseMetaData methods
820 // must be implemented, therefore, the previous fix for 5055528 is being backed out
821 dbmslocatorsUpdateCopy = conn.getMetaData().locatorsUpdateCopy();
822 }
823
824 }
825
826 /**
827 * Sets this <code>CachedRowSetImpl</code> object's connection property
828 * to the given <code>Connection</code> object. This method is called
829 * internally by the version of the method <code>execute</code> that takes a
830 * <code>Connection</code> object as an argument. The reader for this
831 * <code>CachedRowSetImpl</code> object can retrieve the connection stored
832 * in the rowset's connection property by calling its
833 * <code>getConnection</code> method.
834 *
835 * @param connection the <code>Connection</code> object that was passed in
836 * to the method <code>execute</code> and is to be stored
837 * in this <code>CachedRowSetImpl</code> object's connection
838 * property
839 */
840 private void setConnection (Connection connection) {
841 conn = connection;
842 }
843
844
845 /**
846 * Propagates all row update, insert, and delete changes to the
847 * underlying data source backing this <code>CachedRowSetImpl</code>
848 * object.
849 * <P>
850 * <b>Note</b>In the reference implementation an optimistic concurrency implementation
851 * is provided as a sample implementation of a the <code>SyncProvider</code>
852 * abstract class.
853 * <P>
854 * This method fails if any of the updates cannot be propagated back
855 * to the data source. When it fails, the caller can assume that
856 * none of the updates are reflected in the data source.
857 * When an exception is thrown, the current row
858 * is set to the first "updated" row that resulted in an exception
859 * unless the row that caused the exception is a "deleted" row.
860 * In that case, when deleted rows are not shown, which is usually true,
861 * the current row is not affected.
862 * <P>
863 * If no <code>SyncProvider</code> is configured, the reference implementation
864 * leverages the <code>RIOptimisticProvider</code> available which provides the
865 * default and reference synchronization capabilities for disconnected
866 * <code>RowSets</code>.
867 *
868 * @throws SQLException if the cursor is on the insert row or the underlying
869 * reference synchronization provider fails to commit the updates
870 * to the datasource
871 * @throws SyncProviderException if an internal error occurs within the
872 * <code>SyncProvider</code> instance during either during the
873 * process or at any time when the <code>SyncProvider</code>
874 * instance touches the data source.
875 * @see #acceptChanges(java.sql.Connection)
876 * @see javax.sql.RowSetWriter
877 * @see javax.sql.rowset.spi.SyncProvider
878 */
879 public void acceptChanges() throws SyncProviderException {
880 if (onInsertRow == true) {
881 throw new SyncProviderException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
882 }
883
884 int saveCursorPos = cursorPos;
885 boolean success = false;
886 boolean conflict = false;
887
888 try {
889 if (rowSetWriter != null) {
890 saveCursorPos = cursorPos;
891 conflict = rowSetWriter.writeData((RowSetInternal)this);
892 cursorPos = saveCursorPos;
893 }
894
895 if (tXWriter) {
896 // do commit/rollback's here
897 if (!conflict) {
898 tWriter = (TransactionalWriter)rowSetWriter;
899 tWriter.rollback();
900 success = false;
901 } else {
902 tWriter = (TransactionalWriter)rowSetWriter;
903 if (tWriter instanceof CachedRowSetWriter) {
904 ((CachedRowSetWriter)tWriter).commit(this, updateOnInsert);
905 } else {
906 tWriter.commit();
907 }
908
909 success = true;
910 }
911 }
912
913 if (success == true) {
914 setOriginal();
915 } else if (!(success) ) {
916 throw new SyncProviderException(resBundle.handleGetObject("cachedrowsetimpl.accfailed").toString());
917 }
918
919 } catch (SyncProviderException spe) {
920 throw spe;
921 } catch (SQLException e) {
922 e.printStackTrace();
923 throw new SyncProviderException(e.getMessage());
924 } catch (SecurityException e) {
925 throw new SyncProviderException(e.getMessage());
926 }
927 }
928
929 /**
930 * Propagates all row update, insert, and delete changes to the
931 * data source backing this <code>CachedRowSetImpl</code> object
932 * using the given <code>Connection</code> object.
933 * <P>
934 * The reference implementation <code>RIOptimisticProvider</code>
935 * modifies its synchronization to a write back function given
936 * the updated connection
937 * The reference implementation modifies its synchronization behaviour
938 * via the <code>SyncProvider</code> to ensure the synchronization
939 * occurs according to the updated JDBC <code>Connection</code>
940 * properties.
941 *
942 * @param con a standard JDBC <code>Connection</code> object
943 * @throws SQLException if the cursor is on the insert row or the underlying
944 * synchronization provider fails to commit the updates
945 * back to the data source
946 * @see #acceptChanges
947 * @see javax.sql.RowSetWriter
948 * @see javax.sql.rowset.spi.SyncFactory
949 * @see javax.sql.rowset.spi.SyncProvider
950 */
951 public void acceptChanges(Connection con) throws SyncProviderException{
952 setConnection(con);
953 acceptChanges();
954 }
955
956 /**
957 * Restores this <code>CachedRowSetImpl</code> object to its original state,
958 * that is, its state before the last set of changes.
959 * <P>
960 * Before returning, this method moves the cursor before the first row
961 * and sends a <code>rowSetChanged</code> event to all registered
962 * listeners.
963 * @throws SQLException if an error is occurs rolling back the RowSet
964 * state to the definied original value.
965 * @see javax.sql.RowSetListener#rowSetChanged
966 */
967 public void restoreOriginal() throws SQLException {
968 Row currentRow;
969 for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
970 currentRow = (Row)i.next();
971 if (currentRow.getInserted() == true) {
972 i.remove();
973 --numRows;
974 } else {
975 if (currentRow.getDeleted() == true) {
976 currentRow.clearDeleted();
977 }
978 if (currentRow.getUpdated() == true) {
979 currentRow.clearUpdated();
980 }
981 }
982 }
983 // move to before the first
984 cursorPos = 0;
985
986 // notify any listeners
987 notifyRowSetChanged();
988 }
989
990 /**
991 * Releases the current contents of this <code>CachedRowSetImpl</code>
992 * object and sends a <code>rowSetChanged</code> event object to all
993 * registered listeners.
994 *
995 * @throws SQLException if an error occurs flushing the contents of
996 * RowSet.
997 * @see javax.sql.RowSetListener#rowSetChanged
998 */
999 public void release() throws SQLException {
1000 initContainer();
1001 notifyRowSetChanged();
1002 }
1003
1004 /**
1005 * Cancels deletion of the current row and notifies listeners that
1006 * a row has changed.
1007 * <P>
1008 * Note: This method can be ignored if deleted rows are not being shown,
1009 * which is the normal case.
1010 *
1011 * @throws SQLException if the cursor is not on a valid row
1012 */
1013 public void undoDelete() throws SQLException {
1014 if (getShowDeleted() == false) {
1015 return;
1016 }
1017 // make sure we are on a row
1018 checkCursor();
1019
1020 // don't want this to happen...
1021 if (onInsertRow == true) {
1022 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
1023 }
1024
1025 Row currentRow = (Row)getCurrentRow();
1026 if (currentRow.getDeleted() == true) {
1027 currentRow.clearDeleted();
1028 --numDeleted;
1029 notifyRowChanged();
1030 }
1031 }
1032
1033 /**
1034 * Immediately removes the current row from this
1035 * <code>CachedRowSetImpl</code> object if the row has been inserted, and
1036 * also notifies listeners the a row has changed. An exception is thrown
1037 * if the row is not a row that has been inserted or the cursor is before
1038 * the first row, after the last row, or on the insert row.
1039 * <P>
1040 * This operation cannot be undone.
1041 *
1042 * @throws SQLException if an error occurs,
1043 * the cursor is not on a valid row,
1044 * or the row has not been inserted
1045 */
1046 public void undoInsert() throws SQLException {
1047 // make sure we are on a row
1048 checkCursor();
1049
1050 // don't want this to happen...
1051 if (onInsertRow == true) {
1052 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
1053 }
1054
1055 Row currentRow = (Row)getCurrentRow();
1056 if (currentRow.getInserted() == true) {
1057 rvh.remove(cursorPos-1);
1058 --numRows;
1059 notifyRowChanged();
1060 } else {
1061 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.illegalop").toString());
1062 }
1063 }
1064
1065 /**
1066 * Immediately reverses the last update operation if the
1067 * row has been modified. This method can be
1068 * called to reverse updates on a all columns until all updates in a row have
1069 * been rolled back to their originating state since the last synchronization
1070 * (<code>acceptChanges</code>) or population. This method may also be called
1071 * while performing updates to the insert row.
1072 * <P>
1073 * {@code undoUpdate} may be called at any time during the life-time of a
1074 * rowset, however after a synchronization has occurs this method has no
1075 * affect until further modification to the RowSet data occurs.
1076 *
1077 * @throws SQLException if cursor is before the first row, after the last
1078 * row in rowset.
1079 * @see #undoDelete
1080 * @see #undoInsert
1081 * @see java.sql.ResultSet#cancelRowUpdates
1082 */
1083 public void undoUpdate() throws SQLException {
1084 // if on insert row, cancel the insert row
1085 // make the insert row flag,
1086 // cursorPos back to the current row
1087 moveToCurrentRow();
1088
1089 // else if not on insert row
1090 // call undoUpdate or undoInsert
1091 undoDelete();
1092
1093 undoInsert();
1094
1095 }
1096
1097 //--------------------------------------------------------------------
1098 // Views
1099 //--------------------------------------------------------------------
1100
1101 /**
1102 * Returns a new <code>RowSet</code> object backed by the same data as
1103 * that of this <code>CachedRowSetImpl</code> object and sharing a set of cursors
1104 * with it. This allows cursors to interate over a shared set of rows, providing
1105 * multiple views of the underlying data.
1106 *
1107 * @return a <code>RowSet</code> object that is a copy of this <code>CachedRowSetImpl</code>
1108 * object and shares a set of cursors with it
1109 * @throws SQLException if an error occurs or cloning is
1110 * not supported
1111 * @see javax.sql.RowSetEvent
1112 * @see javax.sql.RowSetListener
1113 */
1114 public RowSet createShared() throws SQLException {
1115 RowSet clone;
1116 try {
1117 clone = (RowSet)clone();
1118 } catch (CloneNotSupportedException ex) {
1119 throw new SQLException(ex.getMessage());
1120 }
1121 return clone;
1122 }
1123
1124 /**
1125 * Returns a new <code>RowSet</code> object containing by the same data
1126 * as this <code>CachedRowSetImpl</code> object. This method
1127 * differs from the method <code>createCopy</code> in that it throws a
1128 * <code>CloneNotSupportedException</code> object instead of an
1129 * <code>SQLException</code> object, as the method <code>createShared</code>
1130 * does. This <code>clone</code>
1131 * method is called internally by the method <code>createShared</code>,
1132 * which catches the <code>CloneNotSupportedException</code> object
1133 * and in turn throws a new <code>SQLException</code> object.
1134 *
1135 * @return a copy of this <code>CachedRowSetImpl</code> object
1136 * @throws CloneNotSupportedException if an error occurs when
1137 * attempting to clone this <code>CachedRowSetImpl</code> object
1138 * @see #createShared
1139 */
1140 protected Object clone() throws CloneNotSupportedException {
1141 return (super.clone());
1142 }
1143
1144 /**
1145 * Creates a <code>RowSet</code> object that is a deep copy of
1146 * this <code>CachedRowSetImpl</code> object's data, including
1147 * constraints. Updates made
1148 * on a copy are not visible to the original rowset;
1149 * a copy of a rowset is completely independent from the original.
1150 * <P>
1151 * Making a copy saves the cost of creating an identical rowset
1152 * from first principles, which can be quite expensive.
1153 * For example, it can eliminate the need to query a
1154 * remote database server.
1155 * @return a new <code>CachedRowSet</code> object that is a deep copy
1156 * of this <code>CachedRowSet</code> object and is
1157 * completely independent from this <code>CachedRowSetImpl</code>
1158 * object.
1159 * @throws SQLException if an error occurs in generating the copy of this
1160 * of the <code>CachedRowSetImpl</code>
1161 * @see #createShared
1162 * @see javax.sql.RowSetEvent
1163 * @see javax.sql.RowSetListener
1164 */
1165 public CachedRowSet createCopy() throws SQLException {
1166 ObjectOutputStream out;
1167 ByteArrayOutputStream bOut = new ByteArrayOutputStream();
1168 try {
1169 out = new ObjectOutputStream(bOut);
1170 out.writeObject(this);
1171 } catch (IOException ex) {
1172 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1173 }
1174
1175 ObjectInputStream in;
1176
1177 try {
1178 ByteArrayInputStream bIn = new ByteArrayInputStream(bOut.toByteArray());
1179 in = new ObjectInputStream(bIn);
1180 } catch (StreamCorruptedException ex) {
1181 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1182 } catch (IOException ex) {
1183 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1184 }
1185
1186 try {
1187 //return ((CachedRowSet)(in.readObject()));
1188 CachedRowSetImpl crsTemp = (CachedRowSetImpl)in.readObject();
1189 crsTemp.resBundle = this.resBundle;
1190 return ((CachedRowSet)crsTemp);
1191
1192 } catch (ClassNotFoundException ex) {
1193 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1194 } catch (OptionalDataException ex) {
1195 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1196 } catch (IOException ex) {
1197 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage()));
1198 }
1199 }
1200
1201 /**
1202 * Creates a <code>RowSet</code> object that is a copy of
1203 * this <code>CachedRowSetImpl</code> object's table structure
1204 * and the constraints only.
1205 * There will be no data in the object being returned.
1206 * Updates made on a copy are not visible to the original rowset.
1207 * <P>
1208 * This helps in getting the underlying XML schema which can
1209 * be used as the basis for populating a <code>WebRowSet</code>.
1210 *
1211 * @return a new <code>CachedRowSet</code> object that is a copy
1212 * of this <code>CachedRowSetImpl</code> object's schema and
1213 * retains all the constraints on the original rowset but contains
1214 * no data
1215 * @throws SQLException if an error occurs in generating the copy
1216 * of the <code>CachedRowSet</code> object
1217 * @see #createShared
1218 * @see #createCopy
1219 * @see #createCopyNoConstraints
1220 * @see javax.sql.RowSetEvent
1221 * @see javax.sql.RowSetListener
1222 */
1223 public CachedRowSet createCopySchema() throws SQLException {
1224 // Copy everything except data i.e all constraints
1225
1226 // Store the number of rows of "this"
1227 // and make numRows equals zero.
1228 // and make data also zero.
1229 int nRows = numRows;
1230 numRows = 0;
1231
1232 CachedRowSet crs = this.createCopy();
1233
1234 // reset this object back to number of rows.
1235 numRows = nRows;
1236
1237 return crs;
1238 }
1239
1240 /**
1241 * Creates a <code>CachedRowSet</code> object that is a copy of
1242 * this <code>CachedRowSetImpl</code> object's data only.
1243 * All constraints set in this object will not be there
1244 * in the returning object. Updates made
1245 * on a copy are not visible to the original rowset.
1246 *
1247 * @return a new <code>CachedRowSet</code> object that is a deep copy
1248 * of this <code>CachedRowSetImpl</code> object and is
1249 * completely independent from this <code>CachedRowSetImpl</code> object
1250 * @throws SQLException if an error occurs in generating the copy of the
1251 * of the <code>CachedRowSet</code>
1252 * @see #createShared
1253 * @see #createCopy
1254 * @see #createCopySchema
1255 * @see javax.sql.RowSetEvent
1256 * @see javax.sql.RowSetListener
1257 */
1258 public CachedRowSet createCopyNoConstraints() throws SQLException {
1259 // Copy the whole data ONLY without any constraints.
1260 CachedRowSetImpl crs;
1261 crs = (CachedRowSetImpl)this.createCopy();
1262
1263 crs.initProperties();
1264 try {
1265 crs.unsetMatchColumn(crs.getMatchColumnIndexes());
1266 } catch(SQLException sqle) {
1267 //do nothing, if the setMatchColumn is not set.
1268 }
1269
1270 try {
1271 crs.unsetMatchColumn(crs.getMatchColumnNames());
1272 } catch(SQLException sqle) {
1273 //do nothing, if the setMatchColumn is not set.
1274 }
1275
1276 return crs;
1277 }
1278
1279 /**
1280 * Converts this <code>CachedRowSetImpl</code> object to a collection
1281 * of tables. The sample implementation utilitizes the <code>TreeMap</code>
1282 * collection type.
1283 * This class guarantees that the map will be in ascending key order,
1284 * sorted according to the natural order for the key's class.
1285 *
1286 * @return a <code>Collection</code> object consisting of tables,
1287 * each of which is a copy of a row in this
1288 * <code>CachedRowSetImpl</code> object
1289 * @throws SQLException if an error occurs in generating the collection
1290 * @see #toCollection(int)
1291 * @see #toCollection(String)
1292 * @see java.util.TreeMap
1293 */
1294 public Collection<?> toCollection() throws SQLException {
1295
1296 TreeMap<Integer, Object> tMap = new TreeMap<>();
1297
1298 for (int i = 0; i<numRows; i++) {
1299 tMap.put(i, rvh.get(i));
1300 }
1301
1302 return (tMap.values());
1303 }
1304
1305 /**
1306 * Returns the specified column of this <code>CachedRowSetImpl</code> object
1307 * as a <code>Collection</code> object. This method makes a copy of the
1308 * column's data and utilitizes the <code>Vector</code> to establish the
1309 * collection. The <code>Vector</code> class implements a growable array
1310 * objects allowing the individual components to be accessed using an
1311 * an integer index similar to that of an array.
1312 *
1313 * @return a <code>Collection</code> object that contains the value(s)
1314 * stored in the specified column of this
1315 * <code>CachedRowSetImpl</code>
1316 * object
1317 * @throws SQLException if an error occurs generated the collection; or
1318 * an invalid column is provided.
1319 * @see #toCollection()
1320 * @see #toCollection(String)
1321 * @see java.util.Vector
1322 */
1323 public Collection<?> toCollection(int column) throws SQLException {
1324
1325 int nRows = numRows;
1326 Vector<Object> vec = new Vector<>(nRows);
1327
1328 // create a copy
1329 CachedRowSetImpl crsTemp;
1330 crsTemp = (CachedRowSetImpl) this.createCopy();
1331
1332 while(nRows!=0) {
1333 crsTemp.next();
1334 vec.add(crsTemp.getObject(column));
1335 nRows--;
1336 }
1337
1338 return (Collection)vec;
1339 }
1340
1341 /**
1342 * Returns the specified column of this <code>CachedRowSetImpl</code> object
1343 * as a <code>Collection</code> object. This method makes a copy of the
1344 * column's data and utilitizes the <code>Vector</code> to establish the
1345 * collection. The <code>Vector</code> class implements a growable array
1346 * objects allowing the individual components to be accessed using an
1347 * an integer index similar to that of an array.
1348 *
1349 * @return a <code>Collection</code> object that contains the value(s)
1350 * stored in the specified column of this
1351 * <code>CachedRowSetImpl</code>
1352 * object
1353 * @throws SQLException if an error occurs generated the collection; or
1354 * an invalid column is provided.
1355 * @see #toCollection()
1356 * @see #toCollection(int)
1357 * @see java.util.Vector
1358 */
1359 public Collection<?> toCollection(String column) throws SQLException {
1360 return toCollection(getColIdxByName(column));
1361 }
1362
1363 //--------------------------------------------------------------------
1364 // Advanced features
1365 //--------------------------------------------------------------------
1366
1367
1368 /**
1369 * Returns the <code>SyncProvider</code> implementation being used
1370 * with this <code>CachedRowSetImpl</code> implementation rowset.
1371 *
1372 * @return the SyncProvider used by the rowset. If not provider was
1373 * set when the rowset was instantiated, the reference
1374 * implementation (default) provider is returned.
1375 * @throws SQLException if error occurs while return the
1376 * <code>SyncProvider</code> instance.
1377 */
1378 public SyncProvider getSyncProvider() throws SQLException {
1379 return provider;
1380 }
1381
1382 /**
1383 * Sets the active <code>SyncProvider</code> and attempts to load
1384 * load the new provider using the <code>SyncFactory</code> SPI.
1385 *
1386 * @throws SQLException if an error occurs while resetting the
1387 * <code>SyncProvider</code>.
1388 */
1389 public void setSyncProvider(String providerStr) throws SQLException {
1390 provider =
1391 SyncFactory.getInstance(providerStr);
1392
1393 rowSetReader = provider.getRowSetReader();
1394 rowSetWriter = provider.getRowSetWriter();
1395 }
1396
1397
1398 //-----------------
1399 // methods inherited from RowSet
1400 //-----------------
1401
1402
1403
1404
1405
1406
1407 //---------------------------------------------------------------------
1408 // Reading and writing data
1409 //---------------------------------------------------------------------
1410
1411 /**
1412 * Populates this <code>CachedRowSetImpl</code> object with data.
1413 * This form of the method uses the rowset's user, password, and url or
1414 * data source name properties to create a database
1415 * connection. If properties that are needed
1416 * have not been set, this method will throw an exception.
1417 * <P>
1418 * Another form of this method uses an existing JDBC <code>Connection</code>
1419 * object instead of creating a new one; therefore, it ignores the
1420 * properties used for establishing a new connection.
1421 * <P>
1422 * The query specified by the command property is executed to create a
1423 * <code>ResultSet</code> object from which to retrieve data.
1424 * The current contents of the rowset are discarded, and the
1425 * rowset's metadata is also (re)set. If there are outstanding updates,
1426 * they are also ignored.
1427 * <P>
1428 * The method <code>execute</code> closes any database connections that it
1429 * creates.
1430 *
1431 * @throws SQLException if an error occurs or the
1432 * necessary properties have not been set
1433 */
1434 public void execute() throws SQLException {
1435 execute(null);
1436 }
1437
1438
1439
1440 //-----------------------------------
1441 // Methods inherited from ResultSet
1442 //-----------------------------------
1443
1444 /**
1445 * Moves the cursor down one row from its current position and
1446 * returns <code>true</code> if the new cursor position is a
1447 * valid row.
1448 * The cursor for a new <code>ResultSet</code> object is initially
1449 * positioned before the first row. The first call to the method
1450 * <code>next</code> moves the cursor to the first row, making it
1451 * the current row; the second call makes the second row the
1452 * current row, and so on.
1453 *
1454 * <P>If an input stream from the previous row is open, it is
1455 * implicitly closed. The <code>ResultSet</code> object's warning
1456 * chain is cleared when a new row is read.
1457 *
1458 * @return <code>true</code> if the new current row is valid;
1459 * <code>false</code> if there are no more rows
1460 * @throws SQLException if an error occurs or
1461 * the cursor is not positioned in the rowset, before
1462 * the first row, or after the last row
1463 */
1464 public boolean next() throws SQLException {
1465 /*
1466 * make sure things look sane. The cursor must be
1467 * positioned in the rowset or before first (0) or
1468 * after last (numRows + 1)
1469 */
1470 if (cursorPos < 0 || cursorPos >= numRows + 1) {
1471 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
1472 }
1473 // now move and notify
1474 boolean ret = this.internalNext();
1475 notifyCursorMoved();
1476
1477 return ret;
1478 }
1479
1480 /**
1481 * Moves this <code>CachedRowSetImpl</code> object's cursor to the next
1482 * row and returns <code>true</code> if the cursor is still in the rowset;
1483 * returns <code>false</code> if the cursor has moved to the position after
1484 * the last row.
1485 * <P>
1486 * This method handles the cases where the cursor moves to a row that
1487 * has been deleted.
1488 * If this rowset shows deleted rows and the cursor moves to a row
1489 * that has been deleted, this method moves the cursor to the next
1490 * row until the cursor is on a row that has not been deleted.
1491 * <P>
1492 * The method <code>internalNext</code> is called by methods such as
1493 * <code>next</code>, <code>absolute</code>, and <code>relative</code>,
1494 * and, as its name implies, is only called internally.
1495 * <p>
1496 * This is a implementation only method and is not required as a standard
1497 * implementation of the <code>CachedRowSet</code> interface.
1498 *
1499 * @return <code>true</code> if the cursor is on a valid row in this
1500 * rowset; <code>false</code> if it is after the last row
1501 * @throws SQLException if an error occurs
1502 */
1503 protected boolean internalNext() throws SQLException {
1504 boolean ret = false;
1505
1506 do {
1507 if (cursorPos < numRows) {
1508 ++cursorPos;
1509 ret = true;
1510 } else if (cursorPos == numRows) {
1511 // increment to after last
1512 ++cursorPos;
1513 ret = false;
1514 break;
1515 }
1516 } while ((getShowDeleted() == false) && (rowDeleted() == true));
1517
1518 /* each call to internalNext may increment cursorPos multiple
1519 * times however, the absolutePos only increments once per call.
1520 */
1521 if (ret == true)
1522 absolutePos++;
1523 else
1524 absolutePos = 0;
1525
1526 return ret;
1527 }
1528
1529 /**
1530 * Closes this <code>CachedRowSetImpl</code> objecy and releases any resources
1531 * it was using.
1532 *
1533 * @throws SQLException if an error occurs when releasing any resources in use
1534 * by this <code>CachedRowSetImpl</code> object
1535 */
1536 public void close() throws SQLException {
1537
1538 // close all data structures holding
1539 // the disconnected rowset
1540
1541 cursorPos = 0;
1542 absolutePos = 0;
1543 numRows = 0;
1544 numDeleted = 0;
1545
1546 // set all insert(s), update(s) & delete(s),
1547 // if at all, to their initial values.
1548 initProperties();
1549
1550 // clear the vector of it's present contents
1551 rvh.clear();
1552
1553 // this will make it eligible for gc
1554 // rvh = null;
1555 }
1556
1557 /**
1558 * Reports whether the last column read was SQL <code>NULL</code>.
1559 * Note that you must first call the method <code>getXXX</code>
1560 * on a column to try to read its value and then call the method
1561 * <code>wasNull</code> to determine whether the value was
1562 * SQL <code>NULL</code>.
1563 *
1564 * @return <code>true</code> if the value in the last column read
1565 * was SQL <code>NULL</code>; <code>false</code> otherwise
1566 * @throws SQLException if an error occurs
1567 */
1568 public boolean wasNull() throws SQLException {
1569 return lastValueNull;
1570 }
1571
1572 /**
1573 * Sets the field <code>lastValueNull</code> to the given
1574 * <code>boolean</code> value.
1575 *
1576 * @param value <code>true</code> to indicate that the value of
1577 * the last column read was SQL <code>NULL</code>;
1578 * <code>false</code> to indicate that it was not
1579 */
1580 private void setLastValueNull(boolean value) {
1581 lastValueNull = value;
1582 }
1583
1584 // Methods for accessing results by column index
1585
1586 /**
1587 * Checks to see whether the given index is a valid column number
1588 * in this <code>CachedRowSetImpl</code> object and throws
1589 * an <code>SQLException</code> if it is not. The index is out of bounds
1590 * if it is less than <code>1</code> or greater than the number of
1591 * columns in this rowset.
1592 * <P>
1593 * This method is called internally by the <code>getXXX</code> and
1594 * <code>updateXXX</code> methods.
1595 *
1596 * @param idx the number of a column in this <code>CachedRowSetImpl</code>
1597 * object; must be between <code>1</code> and the number of
1598 * rows in this rowset
1599 * @throws SQLException if the given index is out of bounds
1600 */
1601 private void checkIndex(int idx) throws SQLException {
1602 if (idx < 1 || idx > RowSetMD.getColumnCount()) {
1603 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcol").toString());
1604 }
1605 }
1606
1607 /**
1608 * Checks to see whether the cursor for this <code>CachedRowSetImpl</code>
1609 * object is on a row in the rowset and throws an
1610 * <code>SQLException</code> if it is not.
1611 * <P>
1612 * This method is called internally by <code>getXXX</code> methods, by
1613 * <code>updateXXX</code> methods, and by methods that update, insert,
1614 * or delete a row or that cancel a row update, insert, or delete.
1615 *
1616 * @throws SQLException if the cursor for this <code>CachedRowSetImpl</code>
1617 * object is not on a valid row
1618 */
1619 private void checkCursor() throws SQLException {
1620 if (isAfterLast() == true || isBeforeFirst() == true) {
1621 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
1622 }
1623 }
1624
1625 /**
1626 * Returns the column number of the column with the given name in this
1627 * <code>CachedRowSetImpl</code> object. This method throws an
1628 * <code>SQLException</code> if the given name is not the name of
1629 * one of the columns in this rowset.
1630 *
1631 * @param name a <code>String</code> object that is the name of a column in
1632 * this <code>CachedRowSetImpl</code> object
1633 * @throws SQLException if the given name does not match the name of one of
1634 * the columns in this rowset
1635 */
1636 private int getColIdxByName(String name) throws SQLException {
1637 RowSetMD = (RowSetMetaDataImpl)this.getMetaData();
1638 int cols = RowSetMD.getColumnCount();
1639
1640 for (int i=1; i <= cols; ++i) {
1641 String colName = RowSetMD.getColumnName(i);
1642 if (colName != null)
1643 if (name.equalsIgnoreCase(colName))
1644 return (i);
1645 else
1646 continue;
1647 }
1648 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalcolnm").toString());
1649
1650 }
1651
1652 /**
1653 * Returns the insert row or the current row of this
1654 * <code>CachedRowSetImpl</code>object.
1655 *
1656 * @return the <code>Row</code> object on which this <code>CachedRowSetImpl</code>
1657 * objects's cursor is positioned
1658 */
1659 protected BaseRow getCurrentRow() {
1660 if (onInsertRow == true) {
1661 return (BaseRow)insertRow;
1662 } else {
1663 return (BaseRow)(rvh.get(cursorPos - 1));
1664 }
1665 }
1666
1667 /**
1668 * Removes the row on which the cursor is positioned.
1669 * <p>
1670 * This is a implementation only method and is not required as a standard
1671 * implementation of the <code>CachedRowSet</code> interface.
1672 *
1673 * @throws SQLException if the cursor is positioned on the insert
1674 * row
1675 */
1676 protected void removeCurrentRow() {
1677 ((Row)getCurrentRow()).setDeleted();
1678 rvh.remove(cursorPos - 1);
1679 --numRows;
1680 }
1681
1682
1683 /**
1684 * Retrieves the value of the designated column in the current row
1685 * of this <code>CachedRowSetImpl</code> object as a
1686 * <code>String</code> object.
1687 *
1688 * @param columnIndex the first column is <code>1</code>, the second
1689 * is <code>2</code>, and so on; must be <code>1</code> or larger
1690 * and equal to or less than the number of columns in the rowset
1691 * @return the column value; if the value is SQL <code>NULL</code>, the
1692 * result is <code>null</code>
1693 * @throws SQLException if (1) the given column index is out of bounds,
1694 * (2) the cursor is not on one of this rowset's rows or its
1695 * insert row, or (3) the designated column does not store an
1696 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1697 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>, <b>VARCHAR</b></code>
1698 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1699 * recommended return type.
1700 */
1701 public String getString(int columnIndex) throws SQLException {
1702 Object value;
1703
1704 // sanity check.
1705 checkIndex(columnIndex);
1706 // make sure the cursor is on a valid row
1707 checkCursor();
1708
1709 setLastValueNull(false);
1710 value = getCurrentRow().getColumnObject(columnIndex);
1711
1712 // check for SQL NULL
1713 if (value == null) {
1714 setLastValueNull(true);
1715 return null;
1716 }
1717
1718 return value.toString();
1719 }
1720
1721 /**
1722 * Retrieves the value of the designated column in the current row
1723 * of this <code>CachedRowSetImpl</code> object as a
1724 * <code>boolean</code> value.
1725 *
1726 * @param columnIndex the first column is <code>1</code>, the second
1727 * is <code>2</code>, and so on; must be <code>1</code> or larger
1728 * and equal to or less than the number of columns in the rowset
1729 * @return the column value as a <code>boolean</code> in the Java progamming language;
1730 * if the value is SQL <code>NULL</code>, the result is <code>false</code>
1731 * @throws SQLException if (1) the given column index is out of bounds,
1732 * (2) the cursor is not on one of this rowset's rows or its
1733 * insert row, or (3) the designated column does not store an
1734 * SQL <code>BOOLEAN</code> value
1735 * @see #getBoolean(String)
1736 */
1737 public boolean getBoolean(int columnIndex) throws SQLException {
1738 Object value;
1739
1740 // sanity check.
1741 checkIndex(columnIndex);
1742 // make sure the cursor is on a valid row
1743 checkCursor();
1744
1745 setLastValueNull(false);
1746 value = getCurrentRow().getColumnObject(columnIndex);
1747
1748 // check for SQL NULL
1749 if (value == null) {
1750 setLastValueNull(true);
1751 return false;
1752 }
1753
1754 // check for Boolean...
1755 if (value instanceof Boolean) {
1756 return ((Boolean)value).booleanValue();
1757 }
1758
1759 // convert to a Double and compare to zero
1760 try {
1761 return Double.compare(Double.parseDouble(value.toString()), 0) != 0;
1762 } catch (NumberFormatException ex) {
1763 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.boolfail").toString(),
1764 new Object[] {value.toString().trim(), columnIndex}));
1765 }
1766 }
1767
1768 /**
1769 * Retrieves the value of the designated column in the current row
1770 * of this <code>CachedRowSetImpl</code> object as a
1771 * <code>byte</code> value.
1772 *
1773 * @param columnIndex the first column is <code>1</code>, the second
1774 * is <code>2</code>, and so on; must be <code>1</code> or larger
1775 * and equal to or less than the number of columns in the rowset
1776 * @return the column value as a <code>byte</code> in the Java programming
1777 * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1778 * @throws SQLException if (1) the given column index is out of bounds,
1779 * (2) the cursor is not on one of this rowset's rows or its
1780 * insert row, or (3) the designated column does not store an
1781 * SQL <code><b>TINYINT</b>, SMALLINT, INTEGER, BIGINT, REAL,
1782 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1783 * or <code>LONGVARCHAR</code> value. The bold SQL type
1784 * designates the recommended return type.
1785 * @see #getByte(String)
1786 */
1787 public byte getByte(int columnIndex) throws SQLException {
1788 Object value;
1789
1790 // sanity check.
1791 checkIndex(columnIndex);
1792 // make sure the cursor is on a valid row
1793 checkCursor();
1794
1795 setLastValueNull(false);
1796 value = getCurrentRow().getColumnObject(columnIndex);
1797
1798 // check for SQL NULL
1799 if (value == null) {
1800 setLastValueNull(true);
1801 return (byte)0;
1802 }
1803 try {
1804 return ((Byte.valueOf(value.toString())).byteValue());
1805 } catch (NumberFormatException ex) {
1806 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.bytefail").toString(),
1807 new Object[] {value.toString().trim(), columnIndex}));
1808 }
1809 }
1810
1811 /**
1812 * Retrieves the value of the designated column in the current row
1813 * of this <code>CachedRowSetImpl</code> object as a
1814 * <code>short</code> value.
1815 *
1816 * @param columnIndex the first column is <code>1</code>, the second
1817 * is <code>2</code>, and so on; must be <code>1</code> or larger
1818 * and equal to or less than the number of columns in the rowset
1819 * @return the column value; if the value is SQL <code>NULL</code>, the
1820 * result is <code>0</code>
1821 * @throws SQLException if (1) the given column index is out of bounds,
1822 * (2) the cursor is not on one of this rowset's rows or its
1823 * insert row, or (3) the designated column does not store an
1824 * SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER, BIGINT, REAL
1825 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1826 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1827 * recommended return type.
1828 * @see #getShort(String)
1829 */
1830 public short getShort(int columnIndex) throws SQLException {
1831 Object value;
1832
1833 // sanity check.
1834 checkIndex(columnIndex);
1835 // make sure the cursor is on a valid row
1836 checkCursor();
1837
1838 setLastValueNull(false);
1839 value = getCurrentRow().getColumnObject(columnIndex);
1840
1841 // check for SQL NULL
1842 if (value == null) {
1843 setLastValueNull(true);
1844 return (short)0;
1845 }
1846
1847 try {
1848 return ((Short.valueOf(value.toString().trim())).shortValue());
1849 } catch (NumberFormatException ex) {
1850 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.shortfail").toString(),
1851 new Object[] {value.toString().trim(), columnIndex}));
1852 }
1853 }
1854
1855 /**
1856 * Retrieves the value of the designated column in the current row
1857 * of this <code>CachedRowSetImpl</code> object as an
1858 * <code>int</code> value.
1859 *
1860 * @param columnIndex the first column is <code>1</code>, the second
1861 * is <code>2</code>, and so on; must be <code>1</code> or larger
1862 * and equal to or less than the number of columns in the rowset
1863 * @return the column value; if the value is SQL <code>NULL</code>, the
1864 * result is <code>0</code>
1865 * @throws SQLException if (1) the given column index is out of bounds,
1866 * (2) the cursor is not on one of this rowset's rows or its
1867 * insert row, or (3) the designated column does not store an
1868 * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1869 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1870 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1871 * recommended return type.
1872 */
1873 public int getInt(int columnIndex) throws SQLException {
1874 Object value;
1875
1876 // sanity check.
1877 checkIndex(columnIndex);
1878 // make sure the cursor is on a valid row
1879 checkCursor();
1880
1881 setLastValueNull(false);
1882 value = getCurrentRow().getColumnObject(columnIndex);
1883
1884 // check for SQL NULL
1885 if (value == null) {
1886 setLastValueNull(true);
1887 return 0;
1888 }
1889
1890 try {
1891 return ((Integer.valueOf(value.toString().trim())).intValue());
1892 } catch (NumberFormatException ex) {
1893 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.intfail").toString(),
1894 new Object[] {value.toString().trim(), columnIndex}));
1895 }
1896 }
1897
1898 /**
1899 * Retrieves the value of the designated column in the current row
1900 * of this <code>CachedRowSetImpl</code> object as a
1901 * <code>long</code> value.
1902 *
1903 * @param columnIndex the first column is <code>1</code>, the second
1904 * is <code>2</code>, and so on; must be <code>1</code> or larger
1905 * and equal to or less than the number of columns in the rowset
1906 * @return the column value; if the value is SQL <code>NULL</code>, the
1907 * result is <code>0</code>
1908 * @throws SQLException if (1) the given column index is out of bounds,
1909 * (2) the cursor is not on one of this rowset's rows or its
1910 * insert row, or (3) the designated column does not store an
1911 * SQL <code>TINYINT, SMALLINT, INTEGER, <b>BIGINT</b>, REAL
1912 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1913 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1914 * recommended return type.
1915 * @see #getLong(String)
1916 */
1917 public long getLong(int columnIndex) throws SQLException {
1918 Object value;
1919
1920 // sanity check.
1921 checkIndex(columnIndex);
1922 // make sure the cursor is on a valid row
1923 checkCursor();
1924
1925 setLastValueNull(false);
1926 value = getCurrentRow().getColumnObject(columnIndex);
1927
1928 // check for SQL NULL
1929 if (value == null) {
1930 setLastValueNull(true);
1931 return (long)0;
1932 }
1933 try {
1934 return ((Long.valueOf(value.toString().trim())).longValue());
1935 } catch (NumberFormatException ex) {
1936 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.longfail").toString(),
1937 new Object[] {value.toString().trim(), columnIndex}));
1938 }
1939 }
1940
1941 /**
1942 * Retrieves the value of the designated column in the current row
1943 * of this <code>CachedRowSetImpl</code> object as a
1944 * <code>float</code> value.
1945 *
1946 * @param columnIndex the first column is <code>1</code>, the second
1947 * is <code>2</code>, and so on; must be <code>1</code> or larger
1948 * and equal to or less than the number of columns in the rowset
1949 * @return the column value; if the value is SQL <code>NULL</code>, the
1950 * result is <code>0</code>
1951 * @throws SQLException if (1) the given column index is out of bounds,
1952 * (2) the cursor is not on one of this rowset's rows or its
1953 * insert row, or (3) the designated column does not store an
1954 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, <b>REAL</b>,
1955 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1956 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1957 * recommended return type.
1958 * @see #getFloat(String)
1959 */
1960 public float getFloat(int columnIndex) throws SQLException {
1961 Object value;
1962
1963 // sanity check.
1964 checkIndex(columnIndex);
1965 // make sure the cursor is on a valid row
1966 checkCursor();
1967
1968 setLastValueNull(false);
1969 value = getCurrentRow().getColumnObject(columnIndex);
1970
1971 // check for SQL NULL
1972 if (value == null) {
1973 setLastValueNull(true);
1974 return (float)0;
1975 }
1976 try {
1977 return Float.parseFloat(value.toString());
1978 } catch (NumberFormatException ex) {
1979 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.floatfail").toString(),
1980 new Object[] {value.toString().trim(), columnIndex}));
1981 }
1982 }
1983
1984 /**
1985 * Retrieves the value of the designated column in the current row
1986 * of this <code>CachedRowSetImpl</code> object as a
1987 * <code>double</code> value.
1988 *
1989 * @param columnIndex the first column is <code>1</code>, the second
1990 * is <code>2</code>, and so on; must be <code>1</code> or larger
1991 * and equal to or less than the number of columns in the rowset
1992 * @return the column value; if the value is SQL <code>NULL</code>, the
1993 * result is <code>0</code>
1994 * @throws SQLException if (1) the given column index is out of bounds,
1995 * (2) the cursor is not on one of this rowset's rows or its
1996 * insert row, or (3) the designated column does not store an
1997 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1998 * <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1999 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
2000 * recommended return type.
2001 * @see #getDouble(String)
2002 *
2003 */
2004 public double getDouble(int columnIndex) throws SQLException {
2005 Object value;
2006
2007 // sanity check.
2008 checkIndex(columnIndex);
2009 // make sure the cursor is on a valid row
2010 checkCursor();
2011
2012 setLastValueNull(false);
2013 value = getCurrentRow().getColumnObject(columnIndex);
2014
2015 // check for SQL NULL
2016 if (value == null) {
2017 setLastValueNull(true);
2018 return (double)0;
2019 }
2020 try {
2021 return Double.parseDouble(value.toString().trim());
2022 } catch (NumberFormatException ex) {
2023 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.doublefail").toString(),
2024 new Object[] {value.toString().trim(), columnIndex}));
2025 }
2026 }
2027
2028 /**
2029 * Retrieves the value of the designated column in the current row
2030 * of this <code>CachedRowSetImpl</code> object as a
2031 * <code>java.math.BigDecimal</code> object.
2032 * <P>
2033 * This method is deprecated; use the version of <code>getBigDecimal</code>
2034 * that does not take a scale parameter and returns a value with full
2035 * precision.
2036 *
2037 * @param columnIndex the first column is <code>1</code>, the second
2038 * is <code>2</code>, and so on; must be <code>1</code> or larger
2039 * and equal to or less than the number of columns in the rowset
2040 * @param scale the number of digits to the right of the decimal point in the
2041 * value returned
2042 * @return the column value with the specified number of digits to the right
2043 * of the decimal point; if the value is SQL <code>NULL</code>, the
2044 * result is <code>null</code>
2045 * @throws SQLException if the given column index is out of bounds,
2046 * the cursor is not on a valid row, or this method fails
2047 * @deprecated
2048 */
2049 @Deprecated
2050 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
2051 Object value;
2052 BigDecimal bDecimal, retVal;
2053
2054 // sanity check.
2055 checkIndex(columnIndex);
2056 // make sure the cursor is on a valid row
2057 checkCursor();
2058
2059 setLastValueNull(false);
2060 value = getCurrentRow().getColumnObject(columnIndex);
2061
2062 // check for SQL NULL
2063 if (value == null) {
2064 setLastValueNull(true);
2065 return (new BigDecimal(0));
2066 }
2067
2068 bDecimal = this.getBigDecimal(columnIndex);
2069
2070 retVal = bDecimal.setScale(scale);
2071
2072 return retVal;
2073 }
2074
2075 /**
2076 * Retrieves the value of the designated column in the current row
2077 * of this <code>CachedRowSetImpl</code> object as a
2078 * <code>byte</code> array value.
2079 *
2080 * @param columnIndex the first column is <code>1</code>, the second
2081 * is <code>2</code>, and so on; must be <code>1</code> or larger
2082 * and equal to or less than the number of columns in the rowset
2083 * @return the column value as a <code>byte</code> array in the Java programming
2084 * language; if the value is SQL <code>NULL</code>, the
2085 * result is <code>null</code>
2086 *
2087 * @throws SQLException if (1) the given column index is out of bounds,
2088 * (2) the cursor is not on one of this rowset's rows or its
2089 * insert row, or (3) the designated column does not store an
2090 * SQL <code><b>BINARY</b>, <b>VARBINARY</b> or
2091 * LONGVARBINARY</code> value.
2092 * The bold SQL type designates the recommended return type.
2093 * @see #getBytes(String)
2094 */
2095 public byte[] getBytes(int columnIndex) throws SQLException {
2096 // sanity check.
2097 checkIndex(columnIndex);
2098 // make sure the cursor is on a valid row
2099 checkCursor();
2100
2101 if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
2102 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
2103 }
2104
2105 return (byte[])(getCurrentRow().getColumnObject(columnIndex));
2106 }
2107
2108 /**
2109 * Retrieves the value of the designated column in the current row
2110 * of this <code>CachedRowSetImpl</code> object as a
2111 * <code>java.sql.Date</code> object.
2112 *
2113 * @param columnIndex the first column is <code>1</code>, the second
2114 * is <code>2</code>, and so on; must be <code>1</code> or larger
2115 * and equal to or less than the number of columns in the rowset
2116 * @return the column value as a <code>java.sql.Data</code> object; if
2117 * the value is SQL <code>NULL</code>, the
2118 * result is <code>null</code>
2119 * @throws SQLException if the given column index is out of bounds,
2120 * the cursor is not on a valid row, or this method fails
2121 */
2122 public java.sql.Date getDate(int columnIndex) throws SQLException {
2123 Object value;
2124
2125 // sanity check.
2126 checkIndex(columnIndex);
2127 // make sure the cursor is on a valid row
2128 checkCursor();
2129
2130 setLastValueNull(false);
2131 value = getCurrentRow().getColumnObject(columnIndex);
2132
2133 // check for SQL NULL
2134 if (value == null) {
2135 setLastValueNull(true);
2136 return null;
2137 }
2138
2139 /*
2140 * The object coming back from the db could be
2141 * a date, a timestamp, or a char field variety.
2142 * If it's a date type return it, a timestamp
2143 * we turn into a long and then into a date,
2144 * char strings we try to parse. Yuck.
2145 */
2146 switch (RowSetMD.getColumnType(columnIndex)) {
2147 case java.sql.Types.DATE: {
2148 long sec = ((java.sql.Date)value).getTime();
2149 return new java.sql.Date(sec);
2150 }
2151 case java.sql.Types.TIMESTAMP: {
2152 long sec = ((java.sql.Timestamp)value).getTime();
2153 return new java.sql.Date(sec);
2154 }
2155 case java.sql.Types.CHAR:
2156 case java.sql.Types.VARCHAR:
2157 case java.sql.Types.LONGVARCHAR: {
2158 try {
2159 DateFormat df = DateFormat.getDateInstance();
2160 return ((java.sql.Date)(df.parse(value.toString())));
2161 } catch (ParseException ex) {
2162 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.datefail").toString(),
2163 new Object[] {value.toString().trim(), columnIndex}));
2164 }
2165 }
2166 default: {
2167 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.datefail").toString(),
2168 new Object[] {value.toString().trim(), columnIndex}));
2169 }
2170 }
2171 }
2172
2173 /**
2174 * Retrieves the value of the designated column in the current row
2175 * of this <code>CachedRowSetImpl</code> object as a
2176 * <code>java.sql.Time</code> object.
2177 *
2178 * @param columnIndex the first column is <code>1</code>, the second
2179 * is <code>2</code>, and so on; must be <code>1</code> or larger
2180 * and equal to or less than the number of columns in the rowset
2181 * @return the column value; if the value is SQL <code>NULL</code>, the
2182 * result is <code>null</code>
2183 * @throws SQLException if the given column index is out of bounds,
2184 * the cursor is not on a valid row, or this method fails
2185 */
2186 public java.sql.Time getTime(int columnIndex) throws SQLException {
2187 Object value;
2188
2189 // sanity check.
2190 checkIndex(columnIndex);
2191 // make sure the cursor is on a valid row
2192 checkCursor();
2193
2194 setLastValueNull(false);
2195 value = getCurrentRow().getColumnObject(columnIndex);
2196
2197 // check for SQL NULL
2198 if (value == null) {
2199 setLastValueNull(true);
2200 return null;
2201 }
2202
2203 /*
2204 * The object coming back from the db could be
2205 * a date, a timestamp, or a char field variety.
2206 * If it's a date type return it, a timestamp
2207 * we turn into a long and then into a date,
2208 * char strings we try to parse. Yuck.
2209 */
2210 switch (RowSetMD.getColumnType(columnIndex)) {
2211 case java.sql.Types.TIME: {
2212 return (java.sql.Time)value;
2213 }
2214 case java.sql.Types.TIMESTAMP: {
2215 long sec = ((java.sql.Timestamp)value).getTime();
2216 return new java.sql.Time(sec);
2217 }
2218 case java.sql.Types.CHAR:
2219 case java.sql.Types.VARCHAR:
2220 case java.sql.Types.LONGVARCHAR: {
2221 try {
2222 DateFormat tf = DateFormat.getTimeInstance();
2223 return ((java.sql.Time)(tf.parse(value.toString())));
2224 } catch (ParseException ex) {
2225 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(),
2226 new Object[] {value.toString().trim(), columnIndex}));
2227 }
2228 }
2229 default: {
2230 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(),
2231 new Object[] {value.toString().trim(), columnIndex}));
2232 }
2233 }
2234 }
2235
2236 /**
2237 * Retrieves the value of the designated column in the current row
2238 * of this <code>CachedRowSetImpl</code> object as a
2239 * <code>java.sql.Timestamp</code> object.
2240 *
2241 * @param columnIndex the first column is <code>1</code>, the second
2242 * is <code>2</code>, and so on; must be <code>1</code> or larger
2243 * and equal to or less than the number of columns in the rowset
2244 * @return the column value; if the value is SQL <code>NULL</code>, the
2245 * result is <code>null</code>
2246 * @throws SQLException if the given column index is out of bounds,
2247 * the cursor is not on a valid row, or this method fails
2248 */
2249 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
2250 Object value;
2251
2252 // sanity check.
2253 checkIndex(columnIndex);
2254 // make sure the cursor is on a valid row
2255 checkCursor();
2256
2257 setLastValueNull(false);
2258 value = getCurrentRow().getColumnObject(columnIndex);
2259
2260 // check for SQL NULL
2261 if (value == null) {
2262 setLastValueNull(true);
2263 return null;
2264 }
2265
2266 /*
2267 * The object coming back from the db could be
2268 * a date, a timestamp, or a char field variety.
2269 * If it's a date type return it; a timestamp
2270 * we turn into a long and then into a date;
2271 * char strings we try to parse. Yuck.
2272 */
2273 switch (RowSetMD.getColumnType(columnIndex)) {
2274 case java.sql.Types.TIMESTAMP: {
2275 return (java.sql.Timestamp)value;
2276 }
2277 case java.sql.Types.TIME: {
2278 long sec = ((java.sql.Time)value).getTime();
2279 return new java.sql.Timestamp(sec);
2280 }
2281 case java.sql.Types.DATE: {
2282 long sec = ((java.sql.Date)value).getTime();
2283 return new java.sql.Timestamp(sec);
2284 }
2285 case java.sql.Types.CHAR:
2286 case java.sql.Types.VARCHAR:
2287 case java.sql.Types.LONGVARCHAR: {
2288 try {
2289 DateFormat tf = DateFormat.getTimeInstance();
2290 return ((java.sql.Timestamp)(tf.parse(value.toString())));
2291 } catch (ParseException ex) {
2292 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(),
2293 new Object[] {value.toString().trim(), columnIndex}));
2294 }
2295 }
2296 default: {
2297 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(),
2298 new Object[] {value.toString().trim(), columnIndex}));
2299 }
2300 }
2301 }
2302
2303 /**
2304 * Retrieves the value of the designated column in the current row of this
2305 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
2306 * object.
2307 *
2308 * A column value can be retrieved as a stream of ASCII characters
2309 * and then read in chunks from the stream. This method is particularly
2310 * suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC
2311 * driver will do any necessary conversion from the database format into ASCII.
2312 *
2313 * <P><B>Note:</B> All the data in the returned stream must be
2314 * read prior to getting the value of any other column. The next
2315 * call to a get method implicitly closes the stream. . Also, a
2316 * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
2317 * whether there is data available or not.
2318 *
2319 * @param columnIndex the first column is <code>1</code>, the second
2320 * is <code>2</code>, and so on; must be <code>1</code> or larger
2321 * and equal to or less than the number of columns in this rowset
2322 * @return a Java input stream that delivers the database column value
2323 * as a stream of one-byte ASCII characters. If the value is SQL
2324 * <code>NULL</code>, the result is <code>null</code>.
2325 * @throws SQLException if (1) the given column index is out of bounds,
2326 * (2) the cursor is not on one of this rowset's rows or its
2327 * insert row, or (3) the designated column does not store an
2328 * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
2329 * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
2330 * bold SQL type designates the recommended return types that this method is
2331 * used to retrieve.
2332 * @see #getAsciiStream(String)
2333 */
2334 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
2335 Object value;
2336
2337 // always free an old stream
2338 asciiStream = null;
2339
2340 // sanity check
2341 checkIndex(columnIndex);
2342 //make sure the cursor is on a vlid row
2343 checkCursor();
2344
2345 value = getCurrentRow().getColumnObject(columnIndex);
2346 if (value == null) {
2347 lastValueNull = true;
2348 return null;
2349 }
2350
2351 try {
2352 if (isString(RowSetMD.getColumnType(columnIndex))) {
2353 asciiStream = new ByteArrayInputStream(((String)value).getBytes("ASCII"));
2354 } else {
2355 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
2356 }
2357 } catch (java.io.UnsupportedEncodingException ex) {
2358 throw new SQLException(ex.getMessage());
2359 }
2360
2361 return asciiStream;
2362 }
2363
2364 /**
2365 * A column value can be retrieved as a stream of Unicode characters
2366 * and then read in chunks from the stream. This method is particularly
2367 * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
2368 * do any necessary conversion from the database format into Unicode.
2369 *
2370 * <P><B>Note:</B> All the data in the returned stream must be
2371 * read prior to getting the value of any other column. The next
2372 * call to a get method implicitly closes the stream. . Also, a
2373 * stream may return 0 for available() whether there is data
2374 * available or not.
2375 *
2376 * @param columnIndex the first column is <code>1</code>, the second
2377 * is <code>2</code>, and so on; must be <code>1</code> or larger
2378 * and equal to or less than the number of columns in this rowset
2379 * @return a Java input stream that delivers the database column value
2380 * as a stream of two byte Unicode characters. If the value is SQL NULL
2381 * then the result is null.
2382 * @throws SQLException if an error occurs
2383 * @deprecated
2384 */
2385 @Deprecated
2386 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
2387 // always free an old stream
2388 unicodeStream = null;
2389
2390 // sanity check.
2391 checkIndex(columnIndex);
2392 // make sure the cursor is on a valid row
2393 checkCursor();
2394
2395 if (isBinary(RowSetMD.getColumnType(columnIndex)) == false &&
2396 isString(RowSetMD.getColumnType(columnIndex)) == false) {
2397 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
2398 }
2399
2400 Object value = getCurrentRow().getColumnObject(columnIndex);
2401 if (value == null) {
2402 lastValueNull = true;
2403 return null;
2404 }
2405
2406 unicodeStream = new StringBufferInputStream(value.toString());
2407
2408 return unicodeStream;
2409 }
2410
2411 /**
2412 * Retrieves the value of the designated column in the current row of this
2413 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
2414 * object.
2415 * <P>
2416 * A column value can be retrieved as a stream of uninterpreted bytes
2417 * and then read in chunks from the stream. This method is particularly
2418 * suitable for retrieving large <code>LONGVARBINARY</code> values.
2419 *
2420 * <P><B>Note:</B> All the data in the returned stream must be
2421 * read prior to getting the value of any other column. The next
2422 * call to a get method implicitly closes the stream. Also, a
2423 * stream may return <code>0</code> for
2424 * <code>CachedRowSetImpl.available()</code> whether there is data
2425 * available or not.
2426 *
2427 * @param columnIndex the first column is <code>1</code>, the second
2428 * is <code>2</code>, and so on; must be <code>1</code> or larger
2429 * and equal to or less than the number of columns in the rowset
2430 * @return a Java input stream that delivers the database column value
2431 * as a stream of uninterpreted bytes. If the value is SQL <code>NULL</code>
2432 * then the result is <code>null</code>.
2433 * @throws SQLException if (1) the given column index is out of bounds,
2434 * (2) the cursor is not on one of this rowset's rows or its
2435 * insert row, or (3) the designated column does not store an
2436 * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
2437 * The bold type indicates the SQL type that this method is recommened
2438 * to retrieve.
2439 * @see #getBinaryStream(String)
2440 */
2441 public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
2442
2443 // always free an old stream
2444 binaryStream = null;
2445
2446 // sanity check.
2447 checkIndex(columnIndex);
2448 // make sure the cursor is on a valid row
2449 checkCursor();
2450
2451 if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
2452 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
2453 }
2454
2455 Object value = getCurrentRow().getColumnObject(columnIndex);
2456 if (value == null) {
2457 lastValueNull = true;
2458 return null;
2459 }
2460
2461 binaryStream = new ByteArrayInputStream((byte[])value);
2462
2463 return binaryStream;
2464
2465 }
2466
2467
2468 // Methods for accessing results by column name
2469
2470 /**
2471 * Retrieves the value stored in the designated column
2472 * of the current row as a <code>String</code> object.
2473 *
2474 * @param columnName a <code>String</code> object giving the SQL name of
2475 * a column in this <code>CachedRowSetImpl</code> object
2476 * @return the column value; if the value is SQL <code>NULL</code>,
2477 * the result is <code>null</code>
2478 * @throws SQLException if (1) the given column name is not the name of
2479 * a column in this rowset, (2) the cursor is not on one of
2480 * this rowset's rows or its insert row, or (3) the designated
2481 * column does not store an SQL {@code TINYINT, SMALLINT, INTEGER
2482 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, }
2483 * <b>{@code CHAR, VARCHAR}</b> or
2484 * <b>{@code LONGVARCHAR}</b> value.
2485 * The bold SQL type designates the recommended return type.
2486 */
2487 public String getString(String columnName) throws SQLException {
2488 return getString(getColIdxByName(columnName));
2489 }
2490
2491 /**
2492 * Retrieves the value stored in the designated column
2493 * of the current row as a <code>boolean</code> value.
2494 *
2495 * @param columnName a <code>String</code> object giving the SQL name of
2496 * a column in this <code>CachedRowSetImpl</code> object
2497 * @return the column value as a <code>boolean</code> in the Java programming
2498 * language; if the value is SQL <code>NULL</code>,
2499 * the result is <code>false</code>
2500 * @throws SQLException if (1) the given column name is not the name of
2501 * a column in this rowset, (2) the cursor is not on one of
2502 * this rowset's rows or its insert row, or (3) the designated
2503 * column does not store an SQL <code>BOOLEAN</code> value
2504 * @see #getBoolean(int)
2505 */
2506 public boolean getBoolean(String columnName) throws SQLException {
2507 return getBoolean(getColIdxByName(columnName));
2508 }
2509
2510 /**
2511 * Retrieves the value stored in the designated column
2512 * of the current row as a <code>byte</code> value.
2513 *
2514 * @param columnName a <code>String</code> object giving the SQL name of
2515 * a column in this <code>CachedRowSetImpl</code> object
2516 * @return the column value as a <code>byte</code> in the Java programming
2517 * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
2518 * @throws SQLException if (1) the given column name is not the name of
2519 * a column in this rowset, (2) the cursor is not on one of
2520 * this rowset's rows or its insert row, or (3) the designated
2521 * column does not store an SQL <code><B>TINYINT</B>, SMALLINT, INTEGER,
2522 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
2523 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The
2524 * bold type designates the recommended return type
2525 */
2526 public byte getByte(String columnName) throws SQLException {
2527 return getByte(getColIdxByName(columnName));
2528 }
2529
2530 /**
2531 * Retrieves the value stored in the designated column
2532 * of the current row as a <code>short</code> value.
2533 *
2534 * @param columnName a <code>String</code> object giving the SQL name of
2535 * a column in this <code>CachedRowSetImpl</code> object
2536 * @return the column value; if the value is SQL <code>NULL</code>,
2537 * the result is <code>0</code>
2538 * @throws SQLException if (1) the given column name is not the name of
2539 * a column in this rowset, (2) the cursor is not on one of
2540 * this rowset's rows or its insert row, or (3) the designated
2541 * column does not store an SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER
2542 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
2543 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2544 * designates the recommended return type.
2545 * @see #getShort(int)
2546 */
2547 public short getShort(String columnName) throws SQLException {
2548 return getShort(getColIdxByName(columnName));
2549 }
2550
2551 /**
2552 * Retrieves the value stored in the designated column
2553 * of the current row as an <code>int</code> value.
2554 *
2555 * @param columnName a <code>String</code> object giving the SQL name of
2556 * a column in this <code>CachedRowSetImpl</code> object
2557 * @return the column value; if the value is SQL <code>NULL</code>,
2558 * the result is <code>0</code>
2559 * @throws SQLException if (1) the given column name is not the name
2560 * of a column in this rowset,
2561 * (2) the cursor is not on one of this rowset's rows or its
2562 * insert row, or (3) the designated column does not store an
2563 * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
2564 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
2565 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
2566 * recommended return type.
2567 */
2568 public int getInt(String columnName) throws SQLException {
2569 return getInt(getColIdxByName(columnName));
2570 }
2571
2572 /**
2573 * Retrieves the value stored in the designated column
2574 * of the current row as a <code>long</code> value.
2575 *
2576 * @param columnName a <code>String</code> object giving the SQL name of
2577 * a column in this <code>CachedRowSetImpl</code> object
2578 * @return the column value; if the value is SQL <code>NULL</code>,
2579 * the result is <code>0</code>
2580 * @throws SQLException if (1) the given column name is not the name of
2581 * a column in this rowset, (2) the cursor is not on one of
2582 * this rowset's rows or its insert row, or (3) the designated
2583 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2584 * <b>BIGINT</b>, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
2585 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2586 * designates the recommended return type.
2587 * @see #getLong(int)
2588 */
2589 public long getLong(String columnName) throws SQLException {
2590 return getLong(getColIdxByName(columnName));
2591 }
2592
2593 /**
2594 * Retrieves the value stored in the designated column
2595 * of the current row as a <code>float</code> value.
2596 *
2597 * @param columnName a <code>String</code> object giving the SQL name of
2598 * a column in this <code>CachedRowSetImpl</code> object
2599 * @return the column value; if the value is SQL <code>NULL</code>,
2600 * the result is <code>0</code>
2601 * @throws SQLException if (1) the given column name is not the name of
2602 * a column in this rowset, (2) the cursor is not on one of
2603 * this rowset's rows or its insert row, or (3) the designated
2604 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2605 * BIGINT, <b>REAL</b>, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
2606 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2607 * designates the recommended return type.
2608 * @see #getFloat(String)
2609 */
2610 public float getFloat(String columnName) throws SQLException {
2611 return getFloat(getColIdxByName(columnName));
2612 }
2613
2614 /**
2615 * Retrieves the value stored in the designated column
2616 * of the current row of this <code>CachedRowSetImpl</code> object
2617 * as a <code>double</code> value.
2618 *
2619 * @param columnName a <code>String</code> object giving the SQL name of
2620 * a column in this <code>CachedRowSetImpl</code> object
2621 * @return the column value; if the value is SQL <code>NULL</code>,
2622 * the result is <code>0</code>
2623 * @throws SQLException if (1) the given column name is not the name of
2624 * a column in this rowset, (2) the cursor is not on one of
2625 * this rowset's rows or its insert row, or (3) the designated
2626 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2627 * BIGINT, REAL, <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR,
2628 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2629 * designates the recommended return types.
2630 * @see #getDouble(int)
2631 */
2632 public double getDouble(String columnName) throws SQLException {
2633 return getDouble(getColIdxByName(columnName));
2634 }
2635
2636 /**
2637 * Retrieves the value stored in the designated column
2638 * of the current row as a <code>java.math.BigDecimal</code> object.
2639 *
2640 * @param columnName a <code>String</code> object giving the SQL name of
2641 * a column in this <code>CachedRowSetImpl</code> object
2642 * @param scale the number of digits to the right of the decimal point
2643 * @return a java.math.BugDecimal object with <code><i>scale</i></code>
2644 * number of digits to the right of the decimal point.
2645 * @throws SQLException if (1) the given column name is not the name of
2646 * a column in this rowset, (2) the cursor is not on one of
2647 * this rowset's rows or its insert row, or (3) the designated
2648 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2649 * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
2650 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2651 * designates the recommended return type that this method is used to
2652 * retrieve.
2653 * @deprecated Use the <code>getBigDecimal(String columnName)</code>
2654 * method instead
2655 */
2656 @Deprecated
2657 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
2658 return getBigDecimal(getColIdxByName(columnName), scale);
2659 }
2660
2661 /**
2662 * Retrieves the value stored in the designated column
2663 * of the current row as a <code>byte</code> array.
2664 * The bytes represent the raw values returned by the driver.
2665 *
2666 * @param columnName a <code>String</code> object giving the SQL name of
2667 * a column in this <code>CachedRowSetImpl</code> object
2668 * @return the column value as a <code>byte</code> array in the Java programming
2669 * language; if the value is SQL <code>NULL</code>, the result is <code>null</code>
2670 * @throws SQLException if (1) the given column name is not the name of
2671 * a column in this rowset, (2) the cursor is not on one of
2672 * this rowset's rows or its insert row, or (3) the designated
2673 * column does not store an SQL <code><b>BINARY</b>, <b>VARBINARY</b>
2674 * </code> or <code>LONGVARBINARY</code> values
2675 * The bold SQL type designates the recommended return type.
2676 * @see #getBytes(int)
2677 */
2678 public byte[] getBytes(String columnName) throws SQLException {
2679 return getBytes(getColIdxByName(columnName));
2680 }
2681
2682 /**
2683 * Retrieves the value stored in the designated column
2684 * of the current row as a <code>java.sql.Date</code> object.
2685 *
2686 * @param columnName a <code>String</code> object giving the SQL name of
2687 * a column in this <code>CachedRowSetImpl</code> object
2688 * @return the column value; if the value is SQL <code>NULL</code>,
2689 * the result is <code>null</code>
2690 * @throws SQLException if (1) the given column name is not the name of
2691 * a column in this rowset, (2) the cursor is not on one of
2692 * this rowset's rows or its insert row, or (3) the designated
2693 * column does not store an SQL <code>DATE</code> or
2694 * <code>TIMESTAMP</code> value
2695 */
2696 public java.sql.Date getDate(String columnName) throws SQLException {
2697 return getDate(getColIdxByName(columnName));
2698 }
2699
2700 /**
2701 * Retrieves the value stored in the designated column
2702 * of the current row as a <code>java.sql.Time</code> object.
2703 *
2704 * @param columnName a <code>String</code> object giving the SQL name of
2705 * a column in this <code>CachedRowSetImpl</code> object
2706 * @return the column value; if the value is SQL <code>NULL</code>,
2707 * the result is <code>null</code>
2708 * @throws SQLException if the given column name does not match one of
2709 * this rowset's column names or the cursor is not on one of
2710 * this rowset's rows or its insert row
2711 */
2712 public java.sql.Time getTime(String columnName) throws SQLException {
2713 return getTime(getColIdxByName(columnName));
2714 }
2715
2716 /**
2717 * Retrieves the value stored in the designated column
2718 * of the current row as a <code>java.sql.Timestamp</code> object.
2719 *
2720 * @param columnName a <code>String</code> object giving the SQL name of
2721 * a column in this <code>CachedRowSetImpl</code> object
2722 * @return the column value; if the value is SQL <code>NULL</code>,
2723 * the result is <code>null</code>
2724 * @throws SQLException if the given column name does not match one of
2725 * this rowset's column names or the cursor is not on one of
2726 * this rowset's rows or its insert row
2727 */
2728 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
2729 return getTimestamp(getColIdxByName(columnName));
2730 }
2731
2732 /**
2733 * Retrieves the value of the designated column in the current row of this
2734 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
2735 * object.
2736 *
2737 * A column value can be retrieved as a stream of ASCII characters
2738 * and then read in chunks from the stream. This method is particularly
2739 * suitable for retrieving large <code>LONGVARCHAR</code> values. The
2740 * <code>SyncProvider</code> will rely on the JDBC driver to do any necessary
2741 * conversion from the database format into ASCII format.
2742 *
2743 * <P><B>Note:</B> All the data in the returned stream must
2744 * be read prior to getting the value of any other column. The
2745 * next call to a <code>getXXX</code> method implicitly closes the stream.
2746 *
2747 * @param columnName a <code>String</code> object giving the SQL name of
2748 * a column in this <code>CachedRowSetImpl</code> object
2749 * @return a Java input stream that delivers the database column value
2750 * as a stream of one-byte ASCII characters. If the value is SQL
2751 * <code>NULL</code>, the result is <code>null</code>.
2752 * @throws SQLException if (1) the given column name is not the name of
2753 * a column in this rowset
2754 * (2) the cursor is not on one of this rowset's rows or its
2755 * insert row, or (3) the designated column does not store an
2756 * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
2757 * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
2758 * bold SQL type designates the recommended return types that this method is
2759 * used to retrieve.
2760 * @see #getAsciiStream(int)
2761 */
2762 public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
2763 return getAsciiStream(getColIdxByName(columnName));
2764
2765 }
2766
2767 /**
2768 * A column value can be retrieved as a stream of Unicode characters
2769 * and then read in chunks from the stream. This method is particularly
2770 * suitable for retrieving large <code>LONGVARCHAR</code> values.
2771 * The JDBC driver will do any necessary conversion from the database
2772 * format into Unicode.
2773 *
2774 * <P><B>Note:</B> All the data in the returned stream must
2775 * be read prior to getting the value of any other column. The
2776 * next call to a <code>getXXX</code> method implicitly closes the stream.
2777 *
2778 * @param columnName a <code>String</code> object giving the SQL name of
2779 * a column in this <code>CachedRowSetImpl</code> object
2780 * @return a Java input stream that delivers the database column value
2781 * as a stream of two-byte Unicode characters. If the value is
2782 * SQL <code>NULL</code>, the result is <code>null</code>.
2783 * @throws SQLException if the given column name does not match one of
2784 * this rowset's column names or the cursor is not on one of
2785 * this rowset's rows or its insert row
2786 * @deprecated use the method <code>getCharacterStream</code> instead
2787 */
2788 @Deprecated
2789 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
2790 return getUnicodeStream(getColIdxByName(columnName));
2791 }
2792
2793 /**
2794 * Retrieves the value of the designated column in the current row of this
2795 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
2796 * object.
2797 * <P>
2798 * A column value can be retrieved as a stream of uninterpreted bytes
2799 * and then read in chunks from the stream. This method is particularly
2800 * suitable for retrieving large <code>LONGVARBINARY</code> values.
2801 *
2802 * <P><B>Note:</B> All the data in the returned stream must be
2803 * read prior to getting the value of any other column. The next
2804 * call to a get method implicitly closes the stream. Also, a
2805 * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
2806 * whether there is data available or not.
2807 *
2808 * @param columnName a <code>String</code> object giving the SQL name of
2809 * a column in this <code>CachedRowSetImpl</code> object
2810 * @return a Java input stream that delivers the database column value
2811 * as a stream of uninterpreted bytes. If the value is SQL
2812 * <code>NULL</code>, the result is <code>null</code>.
2813 * @throws SQLException if (1) the given column name is unknown,
2814 * (2) the cursor is not on one of this rowset's rows or its
2815 * insert row, or (3) the designated column does not store an
2816 * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
2817 * The bold type indicates the SQL type that this method is recommened
2818 * to retrieve.
2819 * @see #getBinaryStream(int)
2820 *
2821 */
2822 public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
2823 return getBinaryStream(getColIdxByName(columnName));
2824 }
2825
2826
2827 // Advanced features:
2828
2829 /**
2830 * The first warning reported by calls on this <code>CachedRowSetImpl</code>
2831 * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
2832 * be chained to this <code>SQLWarning</code>.
2833 *
2834 * <P>The warning chain is automatically cleared each time a new
2835 * row is read.
2836 *
2837 * <P><B>Note:</B> This warning chain only covers warnings caused
2838 * by <code>ResultSet</code> methods. Any warning caused by statement
2839 * methods (such as reading OUT parameters) will be chained on the
2840 * <code>Statement</code> object.
2841 *
2842 * @return the first SQLWarning or null
2843 */
2844 public SQLWarning getWarnings() {
2845 return sqlwarn;
2846 }
2847
2848 /**
2849 * Clears all the warnings reporeted for the <code>CachedRowSetImpl</code>
2850 * object. After a call to this method, the <code>getWarnings</code> method
2851 * returns <code>null</code> until a new warning is reported for this
2852 * <code>CachedRowSetImpl</code> object.
2853 */
2854 public void clearWarnings() {
2855 sqlwarn = null;
2856 }
2857
2858 /**
2859 * Retrieves the name of the SQL cursor used by this
2860 * <code>CachedRowSetImpl</code> object.
2861 *
2862 * <P>In SQL, a result table is retrieved through a cursor that is
2863 * named. The current row of a <code>ResultSet</code> can be updated or deleted
2864 * using a positioned update/delete statement that references the
2865 * cursor name. To ensure that the cursor has the proper isolation
2866 * level to support an update operation, the cursor's <code>SELECT</code>
2867 * statement should be of the form <code>select for update</code>.
2868 * If the <code>for update</code> clause
2869 * is omitted, positioned updates may fail.
2870 *
2871 * <P>JDBC supports this SQL feature by providing the name of the
2872 * SQL cursor used by a <code>ResultSet</code> object. The current row
2873 * of a result set is also the current row of this SQL cursor.
2874 *
2875 * <P><B>Note:</B> If positioned updates are not supported, an
2876 * <code>SQLException</code> is thrown.
2877 *
2878 * @return the SQL cursor name for this <code>CachedRowSetImpl</code> object's
2879 * cursor
2880 * @throws SQLException if an error occurs
2881 */
2882 public String getCursorName() throws SQLException {
2883 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.posupdate").toString());
2884 }
2885
2886 /**
2887 * Retrieves a <code>ResultSetMetaData</code> object instance that
2888 * contains information about the <code>CachedRowSet</code> object.
2889 * However, applications should cast the returned object to a
2890 * <code>RowSetMetaData</code> interface implementation. In the
2891 * reference implementation, this cast can be done on the
2892 * <code>RowSetMetaDataImpl</code> class.
2893 * <P>
2894 * For example:
2895 * <pre>
2896 * CachedRowSet crs = new CachedRowSetImpl();
2897 * RowSetMetaDataImpl metaData =
2898 * (RowSetMetaDataImpl)crs.getMetaData();
2899 * // Set the number of columns in the RowSet object for
2900 * // which this RowSetMetaDataImpl object was created to the
2901 * // given number.
2902 * metaData.setColumnCount(3);
2903 * crs.setMetaData(metaData);
2904 * </pre>
2905 *
2906 * @return the <code>ResultSetMetaData</code> object that describes this
2907 * <code>CachedRowSetImpl</code> object's columns
2908 * @throws SQLException if an error occurs in generating the RowSet
2909 * meta data; or if the <code>CachedRowSetImpl</code> is empty.
2910 * @see javax.sql.RowSetMetaData
2911 */
2912 public ResultSetMetaData getMetaData() throws SQLException {
2913 return (ResultSetMetaData)RowSetMD;
2914 }
2915
2916
2917 /**
2918 * Retrieves the value of the designated column in the current row
2919 * of this <code>CachedRowSetImpl</code> object as an
2920 * <code>Object</code> value.
2921 * <P>
2922 * The type of the <code>Object</code> will be the default
2923 * Java object type corresponding to the column's SQL type,
2924 * following the mapping for built-in types specified in the JDBC 3.0
2925 * specification.
2926 * <P>
2927 * This method may also be used to read datatabase-specific
2928 * abstract data types.
2929 * <P>
2930 * This implementation of the method <code>getObject</code> extends its
2931 * behavior so that it gets the attributes of an SQL structured type
2932 * as an array of <code>Object</code> values. This method also custom
2933 * maps SQL user-defined types to classes in the Java programming language.
2934 * When the specified column contains
2935 * a structured or distinct value, the behavior of this method is as
2936 * if it were a call to the method <code>getObject(columnIndex,
2937 * this.getStatement().getConnection().getTypeMap())</code>.
2938 *
2939 * @param columnIndex the first column is <code>1</code>, the second
2940 * is <code>2</code>, and so on; must be <code>1</code> or larger
2941 * and equal to or less than the number of columns in the rowset
2942 * @return a <code>java.lang.Object</code> holding the column value;
2943 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2944 * @throws SQLException if the given column index is out of bounds,
2945 * the cursor is not on a valid row, or there is a problem getting
2946 * the <code>Class</code> object for a custom mapping
2947 * @see #getObject(String)
2948 */
2949 public Object getObject(int columnIndex) throws SQLException {
2950 Object value;
2951 Map<String, Class<?>> map;
2952
2953 // sanity check.
2954 checkIndex(columnIndex);
2955 // make sure the cursor is on a valid row
2956 checkCursor();
2957
2958 setLastValueNull(false);
2959 value = getCurrentRow().getColumnObject(columnIndex);
2960
2961 // check for SQL NULL
2962 if (value == null) {
2963 setLastValueNull(true);
2964 return null;
2965 }
2966 if (value instanceof Struct) {
2967 Struct s = (Struct)value;
2968 map = getTypeMap();
2969 // look up the class in the map
2970 Class<?> c = map.get(s.getSQLTypeName());
2971 if (c != null) {
2972 // create new instance of the class
2973 SQLData obj = null;
2974 try {
2975 ReflectUtil.checkPackageAccess(c);
2976 @SuppressWarnings("deprecation")
2977 Object tmp = c.newInstance();
2978 obj = (SQLData) tmp;
2979 } catch(Exception ex) {
2980 throw new SQLException("Unable to Instantiate: ", ex);
2981 }
2982 // get the attributes from the struct
2983 Object attribs[] = s.getAttributes(map);
2984 // create the SQLInput "stream"
2985 SQLInputImpl sqlInput = new SQLInputImpl(attribs, map);
2986 // read the values...
2987 obj.readSQL(sqlInput, s.getSQLTypeName());
2988 return (Object)obj;
2989 }
2990 }
2991 return value;
2992 }
2993
2994 /**
2995 * Retrieves the value of the designated column in the current row
2996 * of this <code>CachedRowSetImpl</code> object as an
2997 * <code>Object</code> value.
2998 * <P>
2999 * The type of the <code>Object</code> will be the default
3000 * Java object type corresponding to the column's SQL type,
3001 * following the mapping for built-in types specified in the JDBC 3.0
3002 * specification.
3003 * <P>
3004 * This method may also be used to read datatabase-specific
3005 * abstract data types.
3006 * <P>
3007 * This implementation of the method <code>getObject</code> extends its
3008 * behavior so that it gets the attributes of an SQL structured type
3009 * as an array of <code>Object</code> values. This method also custom
3010 * maps SQL user-defined types to classes
3011 * in the Java programming language. When the specified column contains
3012 * a structured or distinct value, the behavior of this method is as
3013 * if it were a call to the method <code>getObject(columnIndex,
3014 * this.getStatement().getConnection().getTypeMap())</code>.
3015 *
3016 * @param columnName a <code>String</code> object that must match the
3017 * SQL name of a column in this rowset, ignoring case
3018 * @return a <code>java.lang.Object</code> holding the column value;
3019 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
3020 * @throws SQLException if (1) the given column name does not match one of
3021 * this rowset's column names, (2) the cursor is not
3022 * on a valid row, or (3) there is a problem getting
3023 * the <code>Class</code> object for a custom mapping
3024 * @see #getObject(int)
3025 */
3026 public Object getObject(String columnName) throws SQLException {
3027 return getObject(getColIdxByName(columnName));
3028 }
3029
3030 //----------------------------------------------------------------
3031
3032 /**
3033 * Maps the given column name for one of this <code>CachedRowSetImpl</code>
3034 * object's columns to its column number.
3035 *
3036 * @param columnName a <code>String</code> object that must match the
3037 * SQL name of a column in this rowset, ignoring case
3038 * @return the column index of the given column name
3039 * @throws SQLException if the given column name does not match one
3040 * of this rowset's column names
3041 */
3042 public int findColumn(String columnName) throws SQLException {
3043 return getColIdxByName(columnName);
3044 }
3045
3046
3047 //--------------------------JDBC 2.0-----------------------------------
3048
3049 //---------------------------------------------------------------------
3050 // Getter's and Setter's
3051 //---------------------------------------------------------------------
3052
3053 /**
3054 * Retrieves the value stored in the designated column
3055 * of the current row as a <code>java.io.Reader</code> object.
3056 *
3057 * <P><B>Note:</B> All the data in the returned stream must
3058 * be read prior to getting the value of any other column. The
3059 * next call to a <code>getXXX</code> method implicitly closes the stream.
3060 *
3061 * @param columnIndex the first column is <code>1</code>, the second
3062 * is <code>2</code>, and so on; must be <code>1</code> or larger
3063 * and equal to or less than the number of columns in the rowset
3064 * @return a Java character stream that delivers the database column value
3065 * as a stream of two-byte unicode characters in a
3066 * <code>java.io.Reader</code> object. If the value is
3067 * SQL <code>NULL</code>, the result is <code>null</code>.
3068 * @throws SQLException if (1) the given column index is out of bounds,
3069 * (2) the cursor is not on one of this rowset's rows or its
3070 * insert row, or (3) the designated column does not store an
3071 * SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, BINARY, VARBINARY</code> or
3072 * <code>LONGVARBINARY</code> value.
3073 * The bold SQL type designates the recommended return type.
3074 * @see #getCharacterStream(String)
3075 */
3076 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException{
3077
3078 // sanity check.
3079 checkIndex(columnIndex);
3080 // make sure the cursor is on a valid row
3081 checkCursor();
3082
3083 if (isBinary(RowSetMD.getColumnType(columnIndex))) {
3084 Object value = getCurrentRow().getColumnObject(columnIndex);
3085 if (value == null) {
3086 lastValueNull = true;
3087 return null;
3088 }
3089 charStream = new InputStreamReader
3090 (new ByteArrayInputStream((byte[])value));
3091 } else if (isString(RowSetMD.getColumnType(columnIndex))) {
3092 Object value = getCurrentRow().getColumnObject(columnIndex);
3093 if (value == null) {
3094 lastValueNull = true;
3095 return null;
3096 }
3097 charStream = new StringReader(value.toString());
3098 } else {
3099 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
3100 }
3101
3102 return charStream;
3103 }
3104
3105 /**
3106 * Retrieves the value stored in the designated column
3107 * of the current row as a <code>java.io.Reader</code> object.
3108 *
3109 * <P><B>Note:</B> All the data in the returned stream must
3110 * be read prior to getting the value of any other column. The
3111 * next call to a <code>getXXX</code> method implicitly closes the stream.
3112 *
3113 * @param columnName a <code>String</code> object giving the SQL name of
3114 * a column in this <code>CachedRowSetImpl</code> object
3115 * @return a Java input stream that delivers the database column value
3116 * as a stream of two-byte Unicode characters. If the value is
3117 * SQL <code>NULL</code>, the result is <code>null</code>.
3118 * @throws SQLException if (1) the given column name is not the name of
3119 * a column in this rowset, (2) the cursor is not on one of
3120 * this rowset's rows or its insert row, or (3) the designated
3121 * column does not store an SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>,
3122 * BINARY, VARYBINARY</code> or <code>LONGVARBINARY</code> value.
3123 * The bold SQL type designates the recommended return type.
3124 */
3125 public java.io.Reader getCharacterStream(String columnName) throws SQLException {
3126 return getCharacterStream(getColIdxByName(columnName));
3127 }
3128
3129 /**
3130 * Retrieves the value of the designated column in the current row
3131 * of this <code>CachedRowSetImpl</code> object as a
3132 * <code>java.math.BigDecimal</code> object.
3133 *
3134 * @param columnIndex the first column is <code>1</code>, the second
3135 * is <code>2</code>, and so on; must be <code>1</code> or larger
3136 * and equal to or less than the number of columns in the rowset
3137 * @return a <code>java.math.BigDecimal</code> value with full precision;
3138 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
3139 * @throws SQLException if (1) the given column index is out of bounds,
3140 * (2) the cursor is not on one of this rowset's rows or its
3141 * insert row, or (3) the designated column does not store an
3142 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
3143 * FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT, CHAR, VARCHAR</code>
3144 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
3145 * recommended return types that this method is used to retrieve.
3146 * @see #getBigDecimal(String)
3147 */
3148 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
3149 Object value;
3150
3151 // sanity check.
3152 checkIndex(columnIndex);
3153 // make sure the cursor is on a valid row
3154 checkCursor();
3155
3156 setLastValueNull(false);
3157 value = getCurrentRow().getColumnObject(columnIndex);
3158
3159 // check for SQL NULL
3160 if (value == null) {
3161 setLastValueNull(true);
3162 return null;
3163 }
3164 try {
3165 return (new BigDecimal(value.toString().trim()));
3166 } catch (NumberFormatException ex) {
3167 throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.doublefail").toString(),
3168 new Object[] {value.toString().trim(), columnIndex}));
3169 }
3170 }
3171
3172 /**
3173 * Retrieves the value of the designated column in the current row
3174 * of this <code>CachedRowSetImpl</code> object as a
3175 * <code>java.math.BigDecimal</code> object.
3176 *
3177 * @param columnName a <code>String</code> object that must match the
3178 * SQL name of a column in this rowset, ignoring case
3179 * @return a <code>java.math.BigDecimal</code> value with full precision;
3180 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
3181 * @throws SQLException if (1) the given column name is not the name of
3182 * a column in this rowset, (2) the cursor is not on one of
3183 * this rowset's rows or its insert row, or (3) the designated
3184 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
3185 * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
3186 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
3187 * designates the recommended return type that this method is used to
3188 * retrieve
3189 * @see #getBigDecimal(int)
3190 */
3191 public BigDecimal getBigDecimal(String columnName) throws SQLException {
3192 return getBigDecimal(getColIdxByName(columnName));
3193 }
3194
3195 //---------------------------------------------------------------------
3196 // Traversal/Positioning
3197 //---------------------------------------------------------------------
3198
3199 /**
3200 * Returns the number of rows in this <code>CachedRowSetImpl</code> object.
3201 *
3202 * @return number of rows in the rowset
3203 */
3204 public int size() {
3205 return numRows;
3206 }
3207
3208 /**
3209 * Indicates whether the cursor is before the first row in this
3210 * <code>CachedRowSetImpl</code> object.
3211 *
3212 * @return <code>true</code> if the cursor is before the first row;
3213 * <code>false</code> otherwise or if the rowset contains no rows
3214 * @throws SQLException if an error occurs
3215 */
3216 public boolean isBeforeFirst() throws SQLException {
3217 if (cursorPos == 0 && numRows > 0) {
3218 return true;
3219 } else {
3220 return false;
3221 }
3222 }
3223
3224 /**
3225 * Indicates whether the cursor is after the last row in this
3226 * <code>CachedRowSetImpl</code> object.
3227 *
3228 * @return <code>true</code> if the cursor is after the last row;
3229 * <code>false</code> otherwise or if the rowset contains no rows
3230 * @throws SQLException if an error occurs
3231 */
3232 public boolean isAfterLast() throws SQLException {
3233 if (cursorPos == numRows+1 && numRows > 0) {
3234 return true;
3235 } else {
3236 return false;
3237 }
3238 }
3239
3240 /**
3241 * Indicates whether the cursor is on the first row in this
3242 * <code>CachedRowSetImpl</code> object.
3243 *
3244 * @return <code>true</code> if the cursor is on the first row;
3245 * <code>false</code> otherwise or if the rowset contains no rows
3246 * @throws SQLException if an error occurs
3247 */
3248 public boolean isFirst() throws SQLException {
3249 // this becomes nasty because of deletes.
3250 int saveCursorPos = cursorPos;
3251 int saveAbsoluteCursorPos = absolutePos;
3252 internalFirst();
3253 if (cursorPos == saveCursorPos) {
3254 return true;
3255 } else {
3256 cursorPos = saveCursorPos;
3257 absolutePos = saveAbsoluteCursorPos;
3258 return false;
3259 }
3260 }
3261
3262 /**
3263 * Indicates whether the cursor is on the last row in this
3264 * <code>CachedRowSetImpl</code> object.
3265 * <P>
3266 * Note: Calling the method <code>isLast</code> may be expensive
3267 * because the JDBC driver might need to fetch ahead one row in order
3268 * to determine whether the current row is the last row in this rowset.
3269 *
3270 * @return <code>true</code> if the cursor is on the last row;
3271 * <code>false</code> otherwise or if this rowset contains no rows
3272 * @throws SQLException if an error occurs
3273 */
3274 public boolean isLast() throws SQLException {
3275 int saveCursorPos = cursorPos;
3276 int saveAbsoluteCursorPos = absolutePos;
3277 boolean saveShowDeleted = getShowDeleted();
3278 setShowDeleted(true);
3279 internalLast();
3280 if (cursorPos == saveCursorPos) {
3281 setShowDeleted(saveShowDeleted);
3282 return true;
3283 } else {
3284 setShowDeleted(saveShowDeleted);
3285 cursorPos = saveCursorPos;
3286 absolutePos = saveAbsoluteCursorPos;
3287 return false;
3288 }
3289 }
3290
3291 /**
3292 * Moves this <code>CachedRowSetImpl</code> object's cursor to the front of
3293 * the rowset, just before the first row. This method has no effect if
3294 * this rowset contains no rows.
3295 *
3296 * @throws SQLException if an error occurs or the type of this rowset
3297 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
3298 */
3299 public void beforeFirst() throws SQLException {
3300 if (getType() == ResultSet.TYPE_FORWARD_ONLY) {
3301 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.beforefirst").toString());
3302 }
3303 cursorPos = 0;
3304 absolutePos = 0;
3305 notifyCursorMoved();
3306 }
3307
3308 /**
3309 * Moves this <code>CachedRowSetImpl</code> object's cursor to the end of
3310 * the rowset, just after the last row. This method has no effect if
3311 * this rowset contains no rows.
3312 *
3313 * @throws SQLException if an error occurs
3314 */
3315 public void afterLast() throws SQLException {
3316 if (numRows > 0) {
3317 cursorPos = numRows + 1;
3318 absolutePos = 0;
3319 notifyCursorMoved();
3320 }
3321 }
3322
3323 /**
3324 * Moves this <code>CachedRowSetImpl</code> object's cursor to the first row
3325 * and returns <code>true</code> if the operation was successful. This
3326 * method also notifies registered listeners that the cursor has moved.
3327 *
3328 * @return <code>true</code> if the cursor is on a valid row;
3329 * <code>false</code> otherwise or if there are no rows in this
3330 * <code>CachedRowSetImpl</code> object
3331 * @throws SQLException if the type of this rowset
3332 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
3333 */
3334 public boolean first() throws SQLException {
3335 if(getType() == ResultSet.TYPE_FORWARD_ONLY) {
3336 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.first").toString());
3337 }
3338
3339 // move and notify
3340 boolean ret = this.internalFirst();
3341 notifyCursorMoved();
3342
3343 return ret;
3344 }
3345
3346 /**
3347 * Moves this <code>CachedRowSetImpl</code> object's cursor to the first
3348 * row and returns <code>true</code> if the operation is successful.
3349 * <P>
3350 * This method is called internally by the methods <code>first</code>,
3351 * <code>isFirst</code>, and <code>absolute</code>.
3352 * It in turn calls the method <code>internalNext</code> in order to
3353 * handle the case where the first row is a deleted row that is not visible.
3354 * <p>
3355 * This is a implementation only method and is not required as a standard
3356 * implementation of the <code>CachedRowSet</code> interface.
3357 *
3358 * @return <code>true</code> if the cursor moved to the first row;
3359 * <code>false</code> otherwise
3360 * @throws SQLException if an error occurs
3361 */
3362 protected boolean internalFirst() throws SQLException {
3363 boolean ret = false;
3364
3365 if (numRows > 0) {
3366 cursorPos = 1;
3367 if ((getShowDeleted() == false) && (rowDeleted() == true)) {
3368 ret = internalNext();
3369 } else {
3370 ret = true;
3371 }
3372 }
3373
3374 if (ret == true)
3375 absolutePos = 1;
3376 else
3377 absolutePos = 0;
3378
3379 return ret;
3380 }
3381
3382 /**
3383 * Moves this <code>CachedRowSetImpl</code> object's cursor to the last row
3384 * and returns <code>true</code> if the operation was successful. This
3385 * method also notifies registered listeners that the cursor has moved.
3386 *
3387 * @return <code>true</code> if the cursor is on a valid row;
3388 * <code>false</code> otherwise or if there are no rows in this
3389 * <code>CachedRowSetImpl</code> object
3390 * @throws SQLException if the type of this rowset
3391 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
3392 */
3393 public boolean last() throws SQLException {
3394 if (getType() == ResultSet.TYPE_FORWARD_ONLY) {
3395 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.last").toString());
3396 }
3397
3398 // move and notify
3399 boolean ret = this.internalLast();
3400 notifyCursorMoved();
3401
3402 return ret;
3403 }
3404
3405 /**
3406 * Moves this <code>CachedRowSetImpl</code> object's cursor to the last
3407 * row and returns <code>true</code> if the operation is successful.
3408 * <P>
3409 * This method is called internally by the method <code>last</code>
3410 * when rows have been deleted and the deletions are not visible.
3411 * The method <code>internalLast</code> handles the case where the
3412 * last row is a deleted row that is not visible by in turn calling
3413 * the method <code>internalPrevious</code>.
3414 * <p>
3415 * This is a implementation only method and is not required as a standard
3416 * implementation of the <code>CachedRowSet</code> interface.
3417 *
3418 * @return <code>true</code> if the cursor moved to the last row;
3419 * <code>false</code> otherwise
3420 * @throws SQLException if an error occurs
3421 */
3422 protected boolean internalLast() throws SQLException {
3423 boolean ret = false;
3424
3425 if (numRows > 0) {
3426 cursorPos = numRows;
3427 if ((getShowDeleted() == false) && (rowDeleted() == true)) {
3428 ret = internalPrevious();
3429 } else {
3430 ret = true;
3431 }
3432 }
3433 if (ret == true)
3434 absolutePos = numRows - numDeleted;
3435 else
3436 absolutePos = 0;
3437 return ret;
3438 }
3439
3440 /**
3441 * Returns the number of the current row in this <code>CachedRowSetImpl</code>
3442 * object. The first row is number 1, the second number 2, and so on.
3443 *
3444 * @return the number of the current row; <code>0</code> if there is no
3445 * current row
3446 * @throws SQLException if an error occurs; or if the <code>CacheRowSetImpl</code>
3447 * is empty
3448 */
3449 public int getRow() throws SQLException {
3450 // are we on a valid row? Valid rows are between first and last
3451 if (numRows > 0 &&
3452 cursorPos > 0 &&
3453 cursorPos < (numRows + 1) &&
3454 (getShowDeleted() == false && rowDeleted() == false)) {
3455 return absolutePos;
3456 } else if (getShowDeleted() == true) {
3457 return cursorPos;
3458 } else {
3459 return 0;
3460 }
3461 }
3462
3463 /**
3464 * Moves this <code>CachedRowSetImpl</code> object's cursor to the row number
3465 * specified.
3466 *
3467 * <p>If the number is positive, the cursor moves to an absolute row with
3468 * respect to the beginning of the rowset. The first row is row 1, the second
3469 * is row 2, and so on. For example, the following command, in which
3470 * <code>crs</code> is a <code>CachedRowSetImpl</code> object, moves the cursor
3471 * to the fourth row, starting from the beginning of the rowset.
3472 * <PRE><code>
3473 *
3474 * crs.absolute(4);
3475 *
3476 * </code> </PRE>
3477 * <P>
3478 * If the number is negative, the cursor moves to an absolute row position
3479 * with respect to the end of the rowset. For example, calling
3480 * <code>absolute(-1)</code> positions the cursor on the last row,
3481 * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
3482 * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
3483 * the following command moves the cursor to the fourth-to-last row, which
3484 * in the case of a rowset with five rows, is also the second row, counting
3485 * from the beginning.
3486 * <PRE><code>
3487 *
3488 * crs.absolute(-4);
3489 *
3490 * </code> </PRE>
3491 *
3492 * If the number specified is larger than the number of rows, the cursor
3493 * will move to the position after the last row. If the number specified
3494 * would move the cursor one or more rows before the first row, the cursor
3495 * moves to the position before the first row.
3496 * <P>
3497 * Note: Calling <code>absolute(1)</code> is the same as calling the
3498 * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
3499 * same as calling <code>last()</code>.
3500 *
3501 * @param row a positive number to indicate the row, starting row numbering from
3502 * the first row, which is <code>1</code>; a negative number to indicate
3503 * the row, starting row numbering from the last row, which is
3504 * <code>-1</code>; it must not be <code>0</code>
3505 * @return <code>true</code> if the cursor is on the rowset; <code>false</code>
3506 * otherwise
3507 * @throws SQLException if the given cursor position is <code>0</code> or the
3508 * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
3509 */
3510 public boolean absolute( int row ) throws SQLException {
3511 if (row == 0 || getType() == ResultSet.TYPE_FORWARD_ONLY) {
3512 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.absolute").toString());
3513 }
3514
3515 if (row > 0) { // we are moving foward
3516 if (row > numRows) {
3517 // fell off the end
3518 afterLast();
3519 return false;
3520 } else {
3521 if (absolutePos <= 0)
3522 internalFirst();
3523 }
3524 } else { // we are moving backward
3525 if (cursorPos + row < 0) {
3526 // fell off the front
3527 beforeFirst();
3528 return false;
3529 } else {
3530 if (absolutePos >= 0)
3531 internalLast();
3532 }
3533 }
3534
3535 // Now move towards the absolute row that we're looking for
3536 while (absolutePos != row) {
3537 if (absolutePos < row) {
3538 if (!internalNext())
3539 break;
3540 }
3541 else {
3542 if (!internalPrevious())
3543 break;
3544 }
3545 }
3546
3547 notifyCursorMoved();
3548
3549 if (isAfterLast() || isBeforeFirst()) {
3550 return false;
3551 } else {
3552 return true;
3553 }
3554 }
3555
3556 /**
3557 * Moves the cursor the specified number of rows from the current
3558 * position, with a positive number moving it forward and a
3559 * negative number moving it backward.
3560 * <P>
3561 * If the number is positive, the cursor moves the specified number of
3562 * rows toward the end of the rowset, starting at the current row.
3563 * For example, the following command, in which
3564 * <code>crs</code> is a <code>CachedRowSetImpl</code> object with 100 rows,
3565 * moves the cursor forward four rows from the current row. If the
3566 * current row is 50, the cursor would move to row 54.
3567 * <PRE><code>
3568 *
3569 * crs.relative(4);
3570 *
3571 * </code> </PRE>
3572 * <P>
3573 * If the number is negative, the cursor moves back toward the beginning
3574 * the specified number of rows, starting at the current row.
3575 * For example, calling the method
3576 * <code>absolute(-1)</code> positions the cursor on the last row,
3577 * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
3578 * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
3579 * the following command moves the cursor to the fourth-to-last row, which
3580 * in the case of a rowset with five rows, is also the second row
3581 * from the beginning.
3582 * <PRE><code>
3583 *
3584 * crs.absolute(-4);
3585 *
3586 * </code> </PRE>
3587 *
3588 * If the number specified is larger than the number of rows, the cursor
3589 * will move to the position after the last row. If the number specified
3590 * would move the cursor one or more rows before the first row, the cursor
3591 * moves to the position before the first row. In both cases, this method
3592 * throws an <code>SQLException</code>.
3593 * <P>
3594 * Note: Calling <code>absolute(1)</code> is the same as calling the
3595 * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
3596 * same as calling <code>last()</code>. Calling <code>relative(0)</code>
3597 * is valid, but it does not change the cursor position.
3598 *
3599 * @param rows an <code>int</code> indicating the number of rows to move
3600 * the cursor, starting at the current row; a positive number
3601 * moves the cursor forward; a negative number moves the cursor
3602 * backward; must not move the cursor past the valid
3603 * rows
3604 * @return <code>true</code> if the cursor is on a row in this
3605 * <code>CachedRowSetImpl</code> object; <code>false</code>
3606 * otherwise
3607 * @throws SQLException if there are no rows in this rowset, the cursor is
3608 * positioned either before the first row or after the last row, or
3609 * the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code>
3610 */
3611 public boolean relative(int rows) throws SQLException {
3612 if (numRows == 0 || isBeforeFirst() ||
3613 isAfterLast() || getType() == ResultSet.TYPE_FORWARD_ONLY) {
3614 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.relative").toString());
3615 }
3616
3617 if (rows == 0) {
3618 return true;
3619 }
3620
3621 if (rows > 0) { // we are moving forward
3622 if (cursorPos + rows > numRows) {
3623 // fell off the end
3624 afterLast();
3625 } else {
3626 for (int i=0; i < rows; i++) {
3627 if (!internalNext())
3628 break;
3629 }
3630 }
3631 } else { // we are moving backward
3632 if (cursorPos + rows < 0) {
3633 // fell off the front
3634 beforeFirst();
3635 } else {
3636 for (int i=rows; i < 0; i++) {
3637 if (!internalPrevious())
3638 break;
3639 }
3640 }
3641 }
3642 notifyCursorMoved();
3643
3644 if (isAfterLast() || isBeforeFirst()) {
3645 return false;
3646 } else {
3647 return true;
3648 }
3649 }
3650
3651 /**
3652 * Moves this <code>CachedRowSetImpl</code> object's cursor to the
3653 * previous row and returns <code>true</code> if the cursor is on
3654 * a valid row or <code>false</code> if it is not.
3655 * This method also notifies all listeners registered with this
3656 * <code>CachedRowSetImpl</code> object that its cursor has moved.
3657 * <P>
3658 * Note: calling the method <code>previous()</code> is not the same
3659 * as calling the method <code>relative(-1)</code>. This is true
3660 * because it is possible to call <code>previous()</code> from the insert
3661 * row, from after the last row, or from the current row, whereas
3662 * <code>relative</code> may only be called from the current row.
3663 * <P>
3664 * The method <code>previous</code> may used in a <code>while</code>
3665 * loop to iterate through a rowset starting after the last row
3666 * and moving toward the beginning. The loop ends when <code>previous</code>
3667 * returns <code>false</code>, meaning that there are no more rows.
3668 * For example, the following code fragment retrieves all the data in
3669 * the <code>CachedRowSetImpl</code> object <code>crs</code>, which has
3670 * three columns. Note that the cursor must initially be positioned
3671 * after the last row so that the first call to the method
3672 * <code>previous</code> places the cursor on the last line.
3673 * <PRE> <code>
3674 *
3675 * crs.afterLast();
3676 * while (previous()) {
3677 * String name = crs.getString(1);
3678 * int age = crs.getInt(2);
3679 * short ssn = crs.getShort(3);
3680 * System.out.println(name + " " + age + " " + ssn);
3681 * }
3682 *
3683 * </code> </PRE>
3684 * This method throws an <code>SQLException</code> if the cursor is not
3685 * on a row in the rowset, before the first row, or after the last row.
3686 *
3687 * @return <code>true</code> if the cursor is on a valid row;
3688 * <code>false</code> if it is before the first row or after the
3689 * last row
3690 * @throws SQLException if the cursor is not on a valid position or the
3691 * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
3692 */
3693 public boolean previous() throws SQLException {
3694 if (getType() == ResultSet.TYPE_FORWARD_ONLY) {
3695 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.last").toString());
3696 }
3697 /*
3698 * make sure things look sane. The cursor must be
3699 * positioned in the rowset or before first (0) or
3700 * after last (numRows + 1)
3701 */
3702 if (cursorPos < 0 || cursorPos > numRows + 1) {
3703 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
3704 }
3705 // move and notify
3706 boolean ret = this.internalPrevious();
3707 notifyCursorMoved();
3708
3709 return ret;
3710 }
3711
3712 /**
3713 * Moves the cursor to the previous row in this <code>CachedRowSetImpl</code>
3714 * object, skipping past deleted rows that are not visible; returns
3715 * <code>true</code> if the cursor is on a row in this rowset and
3716 * <code>false</code> when the cursor goes before the first row.
3717 * <P>
3718 * This method is called internally by the method <code>previous</code>.
3719 * <P>
3720 * This is a implementation only method and is not required as a standard
3721 * implementation of the <code>CachedRowSet</code> interface.
3722 *
3723 * @return <code>true</code> if the cursor is on a row in this rowset;
3724 * <code>false</code> when the cursor reaches the position before
3725 * the first row
3726 * @throws SQLException if an error occurs
3727 */
3728 protected boolean internalPrevious() throws SQLException {
3729 boolean ret = false;
3730
3731 do {
3732 if (cursorPos > 1) {
3733 --cursorPos;
3734 ret = true;
3735 } else if (cursorPos == 1) {
3736 // decrement to before first
3737 --cursorPos;
3738 ret = false;
3739 break;
3740 }
3741 } while ((getShowDeleted() == false) && (rowDeleted() == true));
3742
3743 /*
3744 * Each call to internalPrevious may move the cursor
3745 * over multiple rows, the absolute position moves one row
3746 */
3747 if (ret == true)
3748 --absolutePos;
3749 else
3750 absolutePos = 0;
3751
3752 return ret;
3753 }
3754
3755
3756 //---------------------------------------------------------------------
3757 // Updates
3758 //---------------------------------------------------------------------
3759
3760 /**
3761 * Indicates whether the current row of this <code>CachedRowSetImpl</code>
3762 * object has been updated. The value returned
3763 * depends on whether this rowset can detect updates: <code>false</code>
3764 * will always be returned if it does not detect updates.
3765 *
3766 * @return <code>true</code> if the row has been visibly updated
3767 * by the owner or another and updates are detected;
3768 * <code>false</code> otherwise
3769 * @throws SQLException if the cursor is on the insert row or not
3770 * not on a valid row
3771 *
3772 * @see DatabaseMetaData#updatesAreDetected
3773 */
3774 public boolean rowUpdated() throws SQLException {
3775 // make sure the cursor is on a valid row
3776 checkCursor();
3777 if (onInsertRow == true) {
3778 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
3779 }
3780 return(((Row)getCurrentRow()).getUpdated());
3781 }
3782
3783 /**
3784 * Indicates whether the designated column of the current row of
3785 * this <code>CachedRowSetImpl</code> object has been updated. The
3786 * value returned depends on whether this rowset can detcted updates:
3787 * <code>false</code> will always be returned if it does not detect updates.
3788 *
3789 * @param idx the index identifier of the column that may be have been updated.
3790 * @return <code>true</code> is the designated column has been updated
3791 * and the rowset detects updates; <code>false</code> if the rowset has not
3792 * been updated or the rowset does not detect updates
3793 * @throws SQLException if the cursor is on the insert row or not
3794 * on a valid row
3795 * @see DatabaseMetaData#updatesAreDetected
3796 */
3797 public boolean columnUpdated(int idx) throws SQLException {
3798 // make sure the cursor is on a valid row
3799 checkCursor();
3800 if (onInsertRow == true) {
3801 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
3802 }
3803 return (((Row)getCurrentRow()).getColUpdated(idx - 1));
3804 }
3805
3806 /**
3807 * Indicates whether the designated column of the current row of
3808 * this <code>CachedRowSetImpl</code> object has been updated. The
3809 * value returned depends on whether this rowset can detcted updates:
3810 * <code>false</code> will always be returned if it does not detect updates.
3811 *
3812 * @param columnName the <code>String</code> column name column that may be have
3813 * been updated.
3814 * @return <code>true</code> is the designated column has been updated
3815 * and the rowset detects updates; <code>false</code> if the rowset has not
3816 * been updated or the rowset does not detect updates
3817 * @throws SQLException if the cursor is on the insert row or not
3818 * on a valid row
3819 * @see DatabaseMetaData#updatesAreDetected
3820 */
3821 public boolean columnUpdated(String columnName) throws SQLException {
3822 return columnUpdated(getColIdxByName(columnName));
3823 }
3824
3825 /**
3826 * Indicates whether the current row has been inserted. The value returned
3827 * depends on whether or not the rowset can detect visible inserts.
3828 *
3829 * @return <code>true</code> if a row has been inserted and inserts are detected;
3830 * <code>false</code> otherwise
3831 * @throws SQLException if the cursor is on the insert row or not
3832 * not on a valid row
3833 *
3834 * @see DatabaseMetaData#insertsAreDetected
3835 */
3836 public boolean rowInserted() throws SQLException {
3837 // make sure the cursor is on a valid row
3838 checkCursor();
3839 if (onInsertRow == true) {
3840 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
3841 }
3842 return(((Row)getCurrentRow()).getInserted());
3843 }
3844
3845 /**
3846 * Indicates whether the current row has been deleted. A deleted row
3847 * may leave a visible "hole" in a rowset. This method can be used to
3848 * detect such holes if the rowset can detect deletions. This method
3849 * will always return <code>false</code> if this rowset cannot detect
3850 * deletions.
3851 *
3852 * @return <code>true</code> if (1)the current row is blank, indicating that
3853 * the row has been deleted, and (2)deletions are detected;
3854 * <code>false</code> otherwise
3855 * @throws SQLException if the cursor is on a valid row in this rowset
3856 * @see DatabaseMetaData#deletesAreDetected
3857 */
3858 public boolean rowDeleted() throws SQLException {
3859 // make sure the cursor is on a valid row
3860
3861 if (isAfterLast() == true ||
3862 isBeforeFirst() == true ||
3863 onInsertRow == true) {
3864
3865 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
3866 }
3867 return(((Row)getCurrentRow()).getDeleted());
3868 }
3869
3870 /**
3871 * Indicates whether the given SQL data type is a numberic type.
3872 *
3873 * @param type one of the constants from <code>java.sql.Types</code>
3874 * @return <code>true</code> if the given type is <code>NUMERIC</code>,'
3875 * <code>DECIMAL</code>, <code>BIT</code>, <code>TINYINT</code>,
3876 * <code>SMALLINT</code>, <code>INTEGER</code>, <code>BIGINT</code>,
3877 * <code>REAL</code>, <code>DOUBLE</code>, or <code>FLOAT</code>;
3878 * <code>false</code> otherwise
3879 */
3880 private boolean isNumeric(int type) {
3881 switch (type) {
3882 case java.sql.Types.NUMERIC:
3883 case java.sql.Types.DECIMAL:
3884 case java.sql.Types.BIT:
3885 case java.sql.Types.TINYINT:
3886 case java.sql.Types.SMALLINT:
3887 case java.sql.Types.INTEGER:
3888 case java.sql.Types.BIGINT:
3889 case java.sql.Types.REAL:
3890 case java.sql.Types.DOUBLE:
3891 case java.sql.Types.FLOAT:
3892 return true;
3893 default:
3894 return false;
3895 }
3896 }
3897
3898 /**
3899 * Indicates whether the given SQL data type is a string type.
3900 *
3901 * @param type one of the constants from <code>java.sql.Types</code>
3902 * @return <code>true</code> if the given type is <code>CHAR</code>,'
3903 * <code>VARCHAR</code>, or <code>LONGVARCHAR</code>;
3904 * <code>false</code> otherwise
3905 */
3906 private boolean isString(int type) {
3907 switch (type) {
3908 case java.sql.Types.CHAR:
3909 case java.sql.Types.VARCHAR:
3910 case java.sql.Types.LONGVARCHAR:
3911 return true;
3912 default:
3913 return false;
3914 }
3915 }
3916
3917 /**
3918 * Indicates whether the given SQL data type is a binary type.
3919 *
3920 * @param type one of the constants from <code>java.sql.Types</code>
3921 * @return <code>true</code> if the given type is <code>BINARY</code>,'
3922 * <code>VARBINARY</code>, or <code>LONGVARBINARY</code>;
3923 * <code>false</code> otherwise
3924 */
3925 private boolean isBinary(int type) {
3926 switch (type) {
3927 case java.sql.Types.BINARY:
3928 case java.sql.Types.VARBINARY:
3929 case java.sql.Types.LONGVARBINARY:
3930 return true;
3931 default:
3932 return false;
3933 }
3934 }
3935
3936 /**
3937 * Indicates whether the given SQL data type is a temporal type.
3938 * This method is called internally by the conversion methods
3939 * <code>convertNumeric</code> and <code>convertTemporal</code>.
3940 *
3941 * @param type one of the constants from <code>java.sql.Types</code>
3942 * @return <code>true</code> if the given type is <code>DATE</code>,
3943 * <code>TIME</code>, or <code>TIMESTAMP</code>;
3944 * <code>false</code> otherwise
3945 */
3946 private boolean isTemporal(int type) {
3947 switch (type) {
3948 case java.sql.Types.DATE:
3949 case java.sql.Types.TIME:
3950 case java.sql.Types.TIMESTAMP:
3951 return true;
3952 default:
3953 return false;
3954 }
3955 }
3956
3957 /**
3958 * Indicates whether the given SQL data type is a boolean type.
3959 * This method is called internally by the conversion methods
3960 * <code>convertNumeric</code> and <code>convertBoolean</code>.
3961 *
3962 * @param type one of the constants from <code>java.sql.Types</code>
3963 * @return <code>true</code> if the given type is <code>BIT</code>,
3964 * , or <code>BOOLEAN</code>;
3965 * <code>false</code> otherwise
3966 */
3967 private boolean isBoolean(int type) {
3968 switch (type) {
3969 case java.sql.Types.BIT:
3970 case java.sql.Types.BOOLEAN:
3971 return true;
3972 default:
3973 return false;
3974 }
3975 }
3976
3977
3978 /**
3979 * Converts the given <code>Object</code> in the Java programming language
3980 * to the standard mapping for the specified SQL target data type.
3981 * The conversion must be to a string or numeric type, but there are no
3982 * restrictions on the type to be converted. If the source type and target
3983 * type are the same, the given object is simply returned.
3984 *
3985 * @param srcObj the <code>Object</code> in the Java programming language
3986 * that is to be converted to the target type
3987 * @param srcType the data type that is the standard mapping in SQL of the
3988 * object to be converted; must be one of the constants in
3989 * <code>java.sql.Types</code>
3990 * @param trgType the SQL data type to which to convert the given object;
3991 * must be one of the following constants in
3992 * <code>java.sql.Types</code>: <code>NUMERIC</code>,
3993 * <code>DECIMAL</code>, <code>BIT</code>, <code>TINYINT</code>,
3994 * <code>SMALLINT</code>, <code>INTEGER</code>, <code>BIGINT</code>,
3995 * <code>REAL</code>, <code>DOUBLE</code>, <code>FLOAT</code>,
3996 * <code>VARCHAR</code>, <code>LONGVARCHAR</code>, or <code>CHAR</code>
3997 * @return an <code>Object</code> value.that is
3998 * the standard object mapping for the target SQL type
3999 * @throws SQLException if the given target type is not one of the string or
4000 * numeric types in <code>java.sql.Types</code>
4001 */
4002 private Object convertNumeric(Object srcObj, int srcType,
4003 int trgType) throws SQLException {
4004
4005 if (srcType == trgType) {
4006 return srcObj;
4007 }
4008
4009 if (isNumeric(trgType) == false && isString(trgType) == false) {
4010 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType);
4011 }
4012
4013 try {
4014 switch (trgType) {
4015 case java.sql.Types.BIT:
4016 Integer i = Integer.valueOf(srcObj.toString().trim());
4017 return i.equals(0) ?
4018 Boolean.valueOf(false) :
4019 Boolean.valueOf(true);
4020 case java.sql.Types.TINYINT:
4021 return Byte.valueOf(srcObj.toString().trim());
4022 case java.sql.Types.SMALLINT:
4023 return Short.valueOf(srcObj.toString().trim());
4024 case java.sql.Types.INTEGER:
4025 return Integer.valueOf(srcObj.toString().trim());
4026 case java.sql.Types.BIGINT:
4027 return Long.valueOf(srcObj.toString().trim());
4028 case java.sql.Types.NUMERIC:
4029 case java.sql.Types.DECIMAL:
4030 return new BigDecimal(srcObj.toString().trim());
4031 case java.sql.Types.REAL:
4032 case java.sql.Types.FLOAT:
4033 return Float.valueOf(srcObj.toString().trim());
4034 case java.sql.Types.DOUBLE:
4035 return Double.valueOf(srcObj.toString().trim());
4036 case java.sql.Types.CHAR:
4037 case java.sql.Types.VARCHAR:
4038 case java.sql.Types.LONGVARCHAR:
4039 return srcObj.toString();
4040 default:
4041 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()+ trgType);
4042 }
4043 } catch (NumberFormatException ex) {
4044 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType);
4045 }
4046 }
4047
4048 /**
4049 * Converts the given <code>Object</code> in the Java programming language
4050 * to the standard object mapping for the specified SQL target data type.
4051 * The conversion must be to a string or temporal type, and there are also
4052 * restrictions on the type to be converted.
4053 * <P>
4054 * <TABLE ALIGN="CENTER" BORDER CELLPADDING=10 BORDERCOLOR="#0000FF"
4055 * <CAPTION ALIGN="CENTER"><B>Parameters and Return Values</B></CAPTION>
4056 * <TR>
4057 * <TD><B>Source SQL Type</B>
4058 * <TD><B>Target SQL Type</B>
4059 * <TD><B>Object Returned</B>
4060 * </TR>
4061 * <TR>
4062 * <TD><code>TIMESTAMP</code>
4063 * <TD><code>DATE</code>
4064 * <TD><code>java.sql.Date</code>
4065 * </TR>
4066 * <TR>
4067 * <TD><code>TIMESTAMP</code>
4068 * <TD><code>TIME</code>
4069 * <TD><code>java.sql.Time</code>
4070 * </TR>
4071 * <TR>
4072 * <TD><code>TIME</code>
4073 * <TD><code>TIMESTAMP</code>
4074 * <TD><code>java.sql.Timestamp</code>
4075 * </TR>
4076 * <TR>
4077 * <TD><code>DATE</code>, <code>TIME</code>, or <code>TIMESTAMP</code>
4078 * <TD><code>CHAR</code>, <code>VARCHAR</code>, or <code>LONGVARCHAR</code>
4079 * <TD><code>java.lang.String</code>
4080 * </TR>
4081 * </TABLE>
4082 * <P>
4083 * If the source type and target type are the same,
4084 * the given object is simply returned.
4085 *
4086 * @param srcObj the <code>Object</code> in the Java programming language
4087 * that is to be converted to the target type
4088 * @param srcType the data type that is the standard mapping in SQL of the
4089 * object to be converted; must be one of the constants in
4090 * <code>java.sql.Types</code>
4091 * @param trgType the SQL data type to which to convert the given object;
4092 * must be one of the following constants in
4093 * <code>java.sql.Types</code>: <code>DATE</code>,
4094 * <code>TIME</code>, <code>TIMESTAMP</code>, <code>CHAR</code>,
4095 * <code>VARCHAR</code>, or <code>LONGVARCHAR</code>
4096 * @return an <code>Object</code> value.that is
4097 * the standard object mapping for the target SQL type
4098 * @throws SQLException if the given target type is not one of the string or
4099 * temporal types in <code>java.sql.Types</code>
4100 */
4101 private Object convertTemporal(Object srcObj,
4102 int srcType, int trgType) throws SQLException {
4103
4104 if (srcType == trgType) {
4105 return srcObj;
4106 }
4107
4108 if (isNumeric(trgType) == true ||
4109 (isString(trgType) == false && isTemporal(trgType) == false)) {
4110 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4111 }
4112
4113 try {
4114 switch (trgType) {
4115 case java.sql.Types.DATE:
4116 if (srcType == java.sql.Types.TIMESTAMP) {
4117 return new java.sql.Date(((java.sql.Timestamp)srcObj).getTime());
4118 } else {
4119 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4120 }
4121 case java.sql.Types.TIMESTAMP:
4122 if (srcType == java.sql.Types.TIME) {
4123 return new Timestamp(((java.sql.Time)srcObj).getTime());
4124 } else {
4125 return new Timestamp(((java.sql.Date)srcObj).getTime());
4126 }
4127 case java.sql.Types.TIME:
4128 if (srcType == java.sql.Types.TIMESTAMP) {
4129 return new Time(((java.sql.Timestamp)srcObj).getTime());
4130 } else {
4131 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4132 }
4133 case java.sql.Types.CHAR:
4134 case java.sql.Types.VARCHAR:
4135 case java.sql.Types.LONGVARCHAR:
4136 return srcObj.toString();
4137 default:
4138 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4139 }
4140 } catch (NumberFormatException ex) {
4141 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4142 }
4143
4144 }
4145
4146 /**
4147 * Converts the given <code>Object</code> in the Java programming language
4148 * to the standard mapping for the specified SQL target data type.
4149 * The conversion must be to a string or numeric type, but there are no
4150 * restrictions on the type to be converted. If the source type and target
4151 * type are the same, the given object is simply returned.
4152 *
4153 * @param srcObj the <code>Object</code> in the Java programming language
4154 * that is to be converted to the target type
4155 * @param srcType the data type that is the standard mapping in SQL of the
4156 * object to be converted; must be one of the constants in
4157 * <code>java.sql.Types</code>
4158 * @param trgType the SQL data type to which to convert the given object;
4159 * must be one of the following constants in
4160 * <code>java.sql.Types</code>: <code>BIT</code>,
4161 * or <code>BOOLEAN</code>
4162 * @return an <code>Object</code> value.that is
4163 * the standard object mapping for the target SQL type
4164 * @throws SQLException if the given target type is not one of the Boolean
4165 * types in <code>java.sql.Types</code>
4166 */
4167 private Object convertBoolean(Object srcObj, int srcType,
4168 int trgType) throws SQLException {
4169
4170 if (srcType == trgType) {
4171 return srcObj;
4172 }
4173
4174 if (isNumeric(trgType) == true ||
4175 (isString(trgType) == false && isBoolean(trgType) == false)) {
4176 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4177 }
4178
4179
4180 try {
4181 switch (trgType) {
4182 case java.sql.Types.BIT:
4183 Integer i = Integer.valueOf(srcObj.toString().trim());
4184 return i.equals(0) ?
4185 Boolean.valueOf(false) :
4186 Boolean.valueOf(true);
4187 case java.sql.Types.BOOLEAN:
4188 return Boolean.valueOf(srcObj.toString().trim());
4189 default:
4190 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()+ trgType);
4191 }
4192 } catch (NumberFormatException ex) {
4193 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType);
4194 }
4195 }
4196
4197 /**
4198 * Sets the designated nullable column in the current row or the
4199 * insert row of this <code>CachedRowSetImpl</code> object with
4200 * <code>null</code> value.
4201 * <P>
4202 * This method updates a column value in the current row or the insert
4203 * row of this rowset; however, another method must be called to complete
4204 * the update process. If the cursor is on a row in the rowset, the
4205 * method {@link #updateRow} must be called to mark the row as updated
4206 * and to notify listeners that the row has changed.
4207 * If the cursor is on the insert row, the method {@link #insertRow}
4208 * must be called to insert the new row into this rowset and to notify
4209 * listeners that a row has changed.
4210 * <P>
4211 * In order to propagate updates in this rowset to the underlying
4212 * data source, an application must call the method {@link #acceptChanges}
4213 * after it calls either <code>updateRow</code> or <code>insertRow</code>.
4214 *
4215 * @param columnIndex the first column is <code>1</code>, the second
4216 * is <code>2</code>, and so on; must be <code>1</code> or larger
4217 * and equal to or less than the number of columns in this rowset
4218 * @throws SQLException if (1) the given column index is out of bounds,
4219 * (2) the cursor is not on one of this rowset's rows or its
4220 * insert row, or (3) this rowset is
4221 * <code>ResultSet.CONCUR_READ_ONLY</code>
4222 */
4223 public void updateNull(int columnIndex) throws SQLException {
4224 // sanity check.
4225 checkIndex(columnIndex);
4226 // make sure the cursor is on a valid row
4227 checkCursor();
4228
4229 BaseRow row = getCurrentRow();
4230 row.setColumnObject(columnIndex, null);
4231
4232 }
4233
4234 /**
4235 * Sets the designated column in either the current row or the insert
4236 * row of this <code>CachedRowSetImpl</code> object with the given
4237 * <code>boolean</code> value.
4238 * <P>
4239 * This method updates a column value in the current row or the insert
4240 * row of this rowset, but it does not update the database.
4241 * If the cursor is on a row in the rowset, the
4242 * method {@link #updateRow} must be called to update the database.
4243 * If the cursor is on the insert row, the method {@link #insertRow}
4244 * must be called, which will insert the new row into both this rowset
4245 * and the database. Both of these methods must be called before the
4246 * cursor moves to another row.
4247 *
4248 * @param columnIndex the first column is <code>1</code>, the second
4249 * is <code>2</code>, and so on; must be <code>1</code> or larger
4250 * and equal to or less than the number of columns in this rowset
4251 * @param x the new column value
4252 * @throws SQLException if (1) the given column index is out of bounds,
4253 * (2) the cursor is not on one of this rowset's rows or its
4254 * insert row, or (3) this rowset is
4255 * <code>ResultSet.CONCUR_READ_ONLY</code>
4256 */
4257 public void updateBoolean(int columnIndex, boolean x) throws SQLException {
4258 // sanity check.
4259 checkIndex(columnIndex);
4260 // make sure the cursor is on a valid row
4261 checkCursor();
4262 Object obj = convertBoolean(Boolean.valueOf(x),
4263 java.sql.Types.BIT,
4264 RowSetMD.getColumnType(columnIndex));
4265
4266 getCurrentRow().setColumnObject(columnIndex, obj);
4267 }
4268
4269 /**
4270 * Sets the designated column in either the current row or the insert
4271 * row of this <code>CachedRowSetImpl</code> object with the given
4272 * <code>byte</code> value.
4273 * <P>
4274 * This method updates a column value in the current row or the insert
4275 * row of this rowset, but it does not update the database.
4276 * If the cursor is on a row in the rowset, the
4277 * method {@link #updateRow} must be called to update the database.
4278 * If the cursor is on the insert row, the method {@link #insertRow}
4279 * must be called, which will insert the new row into both this rowset
4280 * and the database. Both of these methods must be called before the
4281 * cursor moves to another row.
4282 *
4283 * @param columnIndex the first column is <code>1</code>, the second
4284 * is <code>2</code>, and so on; must be <code>1</code> or larger
4285 * and equal to or less than the number of columns in this rowset
4286 * @param x the new column value
4287 * @throws SQLException if (1) the given column index is out of bounds,
4288 * (2) the cursor is not on one of this rowset's rows or its
4289 * insert row, or (3) this rowset is
4290 * <code>ResultSet.CONCUR_READ_ONLY</code>
4291 */
4292 public void updateByte(int columnIndex, byte x) throws SQLException {
4293 // sanity check.
4294 checkIndex(columnIndex);
4295 // make sure the cursor is on a valid row
4296 checkCursor();
4297
4298 Object obj = convertNumeric(Byte.valueOf(x),
4299 java.sql.Types.TINYINT,
4300 RowSetMD.getColumnType(columnIndex));
4301
4302 getCurrentRow().setColumnObject(columnIndex, obj);
4303 }
4304
4305 /**
4306 * Sets the designated column in either the current row or the insert
4307 * row of this <code>CachedRowSetImpl</code> object with the given
4308 * <code>short</code> value.
4309 * <P>
4310 * This method updates a column value in the current row or the insert
4311 * row of this rowset, but it does not update the database.
4312 * If the cursor is on a row in the rowset, the
4313 * method {@link #updateRow} must be called to update the database.
4314 * If the cursor is on the insert row, the method {@link #insertRow}
4315 * must be called, which will insert the new row into both this rowset
4316 * and the database. Both of these methods must be called before the
4317 * cursor moves to another row.
4318 *
4319 * @param columnIndex the first column is <code>1</code>, the second
4320 * is <code>2</code>, and so on; must be <code>1</code> or larger
4321 * and equal to or less than the number of columns in this rowset
4322 * @param x the new column value
4323 * @throws SQLException if (1) the given column index is out of bounds,
4324 * (2) the cursor is not on one of this rowset's rows or its
4325 * insert row, or (3) this rowset is
4326 * <code>ResultSet.CONCUR_READ_ONLY</code>
4327 */
4328 public void updateShort(int columnIndex, short x) throws SQLException {
4329 // sanity check.
4330 checkIndex(columnIndex);
4331 // make sure the cursor is on a valid row
4332 checkCursor();
4333
4334 Object obj = convertNumeric(Short.valueOf(x),
4335 java.sql.Types.SMALLINT,
4336 RowSetMD.getColumnType(columnIndex));
4337
4338 getCurrentRow().setColumnObject(columnIndex, obj);
4339 }
4340
4341 /**
4342 * Sets the designated column in either the current row or the insert
4343 * row of this <code>CachedRowSetImpl</code> object with the given
4344 * <code>int</code> value.
4345 * <P>
4346 * This method updates a column value in the current row or the insert
4347 * row of this rowset, but it does not update the database.
4348 * If the cursor is on a row in the rowset, the
4349 * method {@link #updateRow} must be called to update the database.
4350 * If the cursor is on the insert row, the method {@link #insertRow}
4351 * must be called, which will insert the new row into both this rowset
4352 * and the database. Both of these methods must be called before the
4353 * cursor moves to another row.
4354 *
4355 * @param columnIndex the first column is <code>1</code>, the second
4356 * is <code>2</code>, and so on; must be <code>1</code> or larger
4357 * and equal to or less than the number of columns in this rowset
4358 * @param x the new column value
4359 * @throws SQLException if (1) the given column index is out of bounds,
4360 * (2) the cursor is not on one of this rowset's rows or its
4361 * insert row, or (3) this rowset is
4362 * <code>ResultSet.CONCUR_READ_ONLY</code>
4363 */
4364 public void updateInt(int columnIndex, int x) throws SQLException {
4365 // sanity check.
4366 checkIndex(columnIndex);
4367 // make sure the cursor is on a valid row
4368 checkCursor();
4369 Object obj = convertNumeric(x,
4370 java.sql.Types.INTEGER,
4371 RowSetMD.getColumnType(columnIndex));
4372
4373 getCurrentRow().setColumnObject(columnIndex, obj);
4374 }
4375
4376 /**
4377 * Sets the designated column in either the current row or the insert
4378 * row of this <code>CachedRowSetImpl</code> object with the given
4379 * <code>long</code> value.
4380 * <P>
4381 * This method updates a column value in the current row or the insert
4382 * row of this rowset, but it does not update the database.
4383 * If the cursor is on a row in the rowset, the
4384 * method {@link #updateRow} must be called to update the database.
4385 * If the cursor is on the insert row, the method {@link #insertRow}
4386 * must be called, which will insert the new row into both this rowset
4387 * and the database. Both of these methods must be called before the
4388 * cursor moves to another row.
4389 *
4390 * @param columnIndex the first column is <code>1</code>, the second
4391 * is <code>2</code>, and so on; must be <code>1</code> or larger
4392 * and equal to or less than the number of columns in this rowset
4393 * @param x the new column value
4394 * @throws SQLException if (1) the given column index is out of bounds,
4395 * (2) the cursor is not on one of this rowset's rows or its
4396 * insert row, or (3) this rowset is
4397 * <code>ResultSet.CONCUR_READ_ONLY</code>
4398 */
4399 public void updateLong(int columnIndex, long x) throws SQLException {
4400 // sanity check.
4401 checkIndex(columnIndex);
4402 // make sure the cursor is on a valid row
4403 checkCursor();
4404
4405 Object obj = convertNumeric(Long.valueOf(x),
4406 java.sql.Types.BIGINT,
4407 RowSetMD.getColumnType(columnIndex));
4408
4409 getCurrentRow().setColumnObject(columnIndex, obj);
4410
4411 }
4412
4413 /**
4414 * Sets the designated column in either the current row or the insert
4415 * row of this <code>CachedRowSetImpl</code> object with the given
4416 * <code>float</code> value.
4417 * <P>
4418 * This method updates a column value in the current row or the insert
4419 * row of this rowset, but it does not update the database.
4420 * If the cursor is on a row in the rowset, the
4421 * method {@link #updateRow} must be called to update the database.
4422 * If the cursor is on the insert row, the method {@link #insertRow}
4423 * must be called, which will insert the new row into both this rowset
4424 * and the database. Both of these methods must be called before the
4425 * cursor moves to another row.
4426 *
4427 * @param columnIndex the first column is <code>1</code>, the second
4428 * is <code>2</code>, and so on; must be <code>1</code> or larger
4429 * and equal to or less than the number of columns in this rowset
4430 * @param x the new column value
4431 * @throws SQLException if (1) the given column index is out of bounds,
4432 * (2) the cursor is not on one of this rowset's rows or its
4433 * insert row, or (3) this rowset is
4434 * <code>ResultSet.CONCUR_READ_ONLY</code>
4435 */
4436 public void updateFloat(int columnIndex, float x) throws SQLException {
4437 // sanity check.
4438 checkIndex(columnIndex);
4439 // make sure the cursor is on a valid row
4440 checkCursor();
4441
4442 Object obj = convertNumeric(Float.valueOf(x),
4443 java.sql.Types.REAL,
4444 RowSetMD.getColumnType(columnIndex));
4445
4446 getCurrentRow().setColumnObject(columnIndex, obj);
4447 }
4448
4449 /**
4450 * Sets the designated column in either the current row or the insert
4451 * row of this <code>CachedRowSetImpl</code> object with the given
4452 * <code>double</code> value.
4453 *
4454 * This method updates a column value in either the current row or
4455 * the insert row of this rowset, but it does not update the
4456 * database. If the cursor is on a row in the rowset, the
4457 * method {@link #updateRow} must be called to update the database.
4458 * If the cursor is on the insert row, the method {@link #insertRow}
4459 * must be called, which will insert the new row into both this rowset
4460 * and the database. Both of these methods must be called before the
4461 * cursor moves to another row.
4462 *
4463 * @param columnIndex the first column is <code>1</code>, the second
4464 * is <code>2</code>, and so on; must be <code>1</code> or larger
4465 * and equal to or less than the number of columns in this rowset
4466 * @param x the new column value
4467 * @throws SQLException if (1) the given column index is out of bounds,
4468 * (2) the cursor is not on one of this rowset's rows or its
4469 * insert row, or (3) this rowset is
4470 * <code>ResultSet.CONCUR_READ_ONLY</code>
4471 */
4472 public void updateDouble(int columnIndex, double x) throws SQLException {
4473 // sanity check.
4474 checkIndex(columnIndex);
4475 // make sure the cursor is on a valid row
4476 checkCursor();
4477 Object obj = convertNumeric(Double.valueOf(x),
4478 java.sql.Types.DOUBLE,
4479 RowSetMD.getColumnType(columnIndex));
4480
4481 getCurrentRow().setColumnObject(columnIndex, obj);
4482 }
4483
4484 /**
4485 * Sets the designated column in either the current row or the insert
4486 * row of this <code>CachedRowSetImpl</code> object with the given
4487 * <code>java.math.BigDecimal</code> object.
4488 * <P>
4489 * This method updates a column value in the current row or the insert
4490 * row of this rowset, but it does not update the database.
4491 * If the cursor is on a row in the rowset, the
4492 * method {@link #updateRow} must be called to update the database.
4493 * If the cursor is on the insert row, the method {@link #insertRow}
4494 * must be called, which will insert the new row into both this rowset
4495 * and the database. Both of these methods must be called before the
4496 * cursor moves to another row.
4497 *
4498 * @param columnIndex the first column is <code>1</code>, the second
4499 * is <code>2</code>, and so on; must be <code>1</code> or larger
4500 * and equal to or less than the number of columns in this rowset
4501 * @param x the new column value
4502 * @throws SQLException if (1) the given column index is out of bounds,
4503 * (2) the cursor is not on one of this rowset's rows or its
4504 * insert row, or (3) this rowset is
4505 * <code>ResultSet.CONCUR_READ_ONLY</code>
4506 */
4507 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
4508 // sanity check.
4509 checkIndex(columnIndex);
4510 // make sure the cursor is on a valid row
4511 checkCursor();
4512
4513 Object obj = convertNumeric(x,
4514 java.sql.Types.NUMERIC,
4515 RowSetMD.getColumnType(columnIndex));
4516
4517 getCurrentRow().setColumnObject(columnIndex, obj);
4518 }
4519
4520 /**
4521 * Sets the designated column in either the current row or the insert
4522 * row of this <code>CachedRowSetImpl</code> object with the given
4523 * <code>String</code> object.
4524 * <P>
4525 * This method updates a column value in either the current row or
4526 * the insert row of this rowset, but it does not update the
4527 * database. If the cursor is on a row in the rowset, the
4528 * method {@link #updateRow} must be called to mark the row as updated.
4529 * If the cursor is on the insert row, the method {@link #insertRow}
4530 * must be called to insert the new row into this rowset and mark it
4531 * as inserted. Both of these methods must be called before the
4532 * cursor moves to another row.
4533 * <P>
4534 * The method <code>acceptChanges</code> must be called if the
4535 * updated values are to be written back to the underlying database.
4536 *
4537 * @param columnIndex the first column is <code>1</code>, the second
4538 * is <code>2</code>, and so on; must be <code>1</code> or larger
4539 * and equal to or less than the number of columns in this rowset
4540 * @param x the new column value
4541 * @throws SQLException if (1) the given column index is out of bounds,
4542 * (2) the cursor is not on one of this rowset's rows or its
4543 * insert row, or (3) this rowset is
4544 * <code>ResultSet.CONCUR_READ_ONLY</code>
4545 */
4546 public void updateString(int columnIndex, String x) throws SQLException {
4547 // sanity check.
4548 checkIndex(columnIndex);
4549 // make sure the cursor is on a valid row
4550 checkCursor();
4551
4552 getCurrentRow().setColumnObject(columnIndex, x);
4553 }
4554
4555 /**
4556 * Sets the designated column in either the current row or the insert
4557 * row of this <code>CachedRowSetImpl</code> object with the given
4558 * <code>byte</code> array.
4559 *
4560 * This method updates a column value in either the current row or
4561 * the insert row of this rowset, but it does not update the
4562 * database. If the cursor is on a row in the rowset, the
4563 * method {@link #updateRow} must be called to update the database.
4564 * If the cursor is on the insert row, the method {@link #insertRow}
4565 * must be called, which will insert the new row into both this rowset
4566 * and the database. Both of these methods must be called before the
4567 * cursor moves to another row.
4568 *
4569 * @param columnIndex the first column is <code>1</code>, the second
4570 * is <code>2</code>, and so on; must be <code>1</code> or larger
4571 * and equal to or less than the number of columns in this rowset
4572 * @param x the new column value
4573 * @throws SQLException if (1) the given column index is out of bounds,
4574 * (2) the cursor is not on one of this rowset's rows or its
4575 * insert row, or (3) this rowset is
4576 * <code>ResultSet.CONCUR_READ_ONLY</code>
4577 */
4578 public void updateBytes(int columnIndex, byte x[]) throws SQLException {
4579 // sanity check.
4580 checkIndex(columnIndex);
4581 // make sure the cursor is on a valid row
4582 checkCursor();
4583
4584 if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
4585 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4586 }
4587
4588 getCurrentRow().setColumnObject(columnIndex, x);
4589 }
4590
4591 /**
4592 * Sets the designated column in either the current row or the insert
4593 * row of this <code>CachedRowSetImpl</code> object with the given
4594 * <code>Date</code> object.
4595 *
4596 * This method updates a column value in either the current row or
4597 * the insert row of this rowset, but it does not update the
4598 * database. If the cursor is on a row in the rowset, the
4599 * method {@link #updateRow} must be called to update the database.
4600 * If the cursor is on the insert row, the method {@link #insertRow}
4601 * must be called, which will insert the new row into both this rowset
4602 * and the database. Both of these methods must be called before the
4603 * cursor moves to another row.
4604 *
4605 * @param columnIndex the first column is <code>1</code>, the second
4606 * is <code>2</code>, and so on; must be <code>1</code> or larger
4607 * and equal to or less than the number of columns in this rowset
4608 * @param x the new column value
4609 * @throws SQLException if (1) the given column index is out of bounds,
4610 * (2) the cursor is not on one of this rowset's rows or its
4611 * insert row, (3) the type of the designated column is not
4612 * an SQL <code>DATE</code> or <code>TIMESTAMP</code>, or
4613 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4614 */
4615 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
4616 // sanity check.
4617 checkIndex(columnIndex);
4618 // make sure the cursor is on a valid row
4619 checkCursor();
4620
4621 Object obj = convertTemporal(x,
4622 java.sql.Types.DATE,
4623 RowSetMD.getColumnType(columnIndex));
4624
4625 getCurrentRow().setColumnObject(columnIndex, obj);
4626 }
4627
4628 /**
4629 * Sets the designated column in either the current row or the insert
4630 * row of this <code>CachedRowSetImpl</code> object with the given
4631 * <code>Time</code> object.
4632 *
4633 * This method updates a column value in either the current row or
4634 * the insert row of this rowset, but it does not update the
4635 * database. If the cursor is on a row in the rowset, the
4636 * method {@link #updateRow} must be called to update the database.
4637 * If the cursor is on the insert row, the method {@link #insertRow}
4638 * must be called, which will insert the new row into both this rowset
4639 * and the database. Both of these methods must be called before the
4640 * cursor moves to another row.
4641 *
4642 * @param columnIndex the first column is <code>1</code>, the second
4643 * is <code>2</code>, and so on; must be <code>1</code> or larger
4644 * and equal to or less than the number of columns in this rowset
4645 * @param x the new column value
4646 * @throws SQLException if (1) the given column index is out of bounds,
4647 * (2) the cursor is not on one of this rowset's rows or its
4648 * insert row, (3) the type of the designated column is not
4649 * an SQL <code>TIME</code> or <code>TIMESTAMP</code>, or
4650 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4651 */
4652 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
4653 // sanity check.
4654 checkIndex(columnIndex);
4655 // make sure the cursor is on a valid row
4656 checkCursor();
4657
4658 Object obj = convertTemporal(x,
4659 java.sql.Types.TIME,
4660 RowSetMD.getColumnType(columnIndex));
4661
4662 getCurrentRow().setColumnObject(columnIndex, obj);
4663 }
4664
4665 /**
4666 * Sets the designated column in either the current row or the insert
4667 * row of this <code>CachedRowSetImpl</code> object with the given
4668 * <code>Timestamp</code> object.
4669 *
4670 * This method updates a column value in either the current row or
4671 * the insert row of this rowset, but it does not update the
4672 * database. If the cursor is on a row in the rowset, the
4673 * method {@link #updateRow} must be called to update the database.
4674 * If the cursor is on the insert row, the method {@link #insertRow}
4675 * must be called, which will insert the new row into both this rowset
4676 * and the database. Both of these methods must be called before the
4677 * cursor moves to another row.
4678 *
4679 * @param columnIndex the first column is <code>1</code>, the second
4680 * is <code>2</code>, and so on; must be <code>1</code> or larger
4681 * and equal to or less than the number of columns in this rowset
4682 * @param x the new column value
4683 * @throws SQLException if (1) the given column index is out of bounds,
4684 * (2) the cursor is not on one of this rowset's rows or its
4685 * insert row, (3) the type of the designated column is not
4686 * an SQL <code>DATE</code>, <code>TIME</code>, or
4687 * <code>TIMESTAMP</code>, or (4) this rowset is
4688 * <code>ResultSet.CONCUR_READ_ONLY</code>
4689 */
4690 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
4691 // sanity check.
4692 checkIndex(columnIndex);
4693 // make sure the cursor is on a valid row
4694 checkCursor();
4695
4696 Object obj = convertTemporal(x,
4697 java.sql.Types.TIMESTAMP,
4698 RowSetMD.getColumnType(columnIndex));
4699
4700 getCurrentRow().setColumnObject(columnIndex, obj);
4701 }
4702
4703 /**
4704 * Sets the designated column in either the current row or the insert
4705 * row of this <code>CachedRowSetImpl</code> object with the given
4706 * ASCII stream value.
4707 * <P>
4708 * This method updates a column value in either the current row or
4709 * the insert row of this rowset, but it does not update the
4710 * database. If the cursor is on a row in the rowset, the
4711 * method {@link #updateRow} must be called to update the database.
4712 * If the cursor is on the insert row, the method {@link #insertRow}
4713 * must be called, which will insert the new row into both this rowset
4714 * and the database. Both of these methods must be called before the
4715 * cursor moves to another row.
4716 *
4717 * @param columnIndex the first column is <code>1</code>, the second
4718 * is <code>2</code>, and so on; must be <code>1</code> or larger
4719 * and equal to or less than the number of columns in this rowset
4720 * @param x the new column value
4721 * @param length the number of one-byte ASCII characters in the stream
4722 * @throws SQLException if this method is invoked
4723 */
4724 public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
4725 // sanity Check
4726 checkIndex(columnIndex);
4727 // make sure the cursor is on a valid row
4728 checkCursor();
4729
4730
4731 if (isString(RowSetMD.getColumnType(columnIndex)) == false &&
4732 isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
4733 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4734 }
4735
4736 byte buf[] = new byte[length];
4737 try {
4738 int charsRead = 0;
4739 do {
4740 charsRead += x.read(buf, charsRead, length - charsRead);
4741 } while (charsRead != length);
4742 //Changed the condition check to check for length instead of -1
4743 } catch (java.io.IOException ex) {
4744 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.asciistream").toString());
4745 }
4746 String str = new String(buf);
4747
4748 getCurrentRow().setColumnObject(columnIndex, str);
4749
4750 }
4751
4752 /**
4753 * Sets the designated column in either the current row or the insert
4754 * row of this <code>CachedRowSetImpl</code> object with the given
4755 * <code>java.io.InputStream</code> object.
4756 * <P>
4757 * This method updates a column value in either the current row or
4758 * the insert row of this rowset, but it does not update the
4759 * database. If the cursor is on a row in the rowset, the
4760 * method {@link #updateRow} must be called to update the database.
4761 * If the cursor is on the insert row, the method {@link #insertRow}
4762 * must be called, which will insert the new row into both this rowset
4763 * and the database. Both of these methods must be called before the
4764 * cursor moves to another row.
4765 *
4766 * @param columnIndex the first column is <code>1</code>, the second
4767 * is <code>2</code>, and so on; must be <code>1</code> or larger
4768 * and equal to or less than the number of columns in this rowset
4769 * @param x the new column value; must be a <code>java.io.InputStream</code>
4770 * containing <code>BINARY</code>, <code>VARBINARY</code>, or
4771 * <code>LONGVARBINARY</code> data
4772 * @param length the length of the stream in bytes
4773 * @throws SQLException if (1) the given column index is out of bounds,
4774 * (2) the cursor is not on one of this rowset's rows or its
4775 * insert row, (3) the data in the stream is not binary, or
4776 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4777 */
4778 public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException {
4779 // sanity Check
4780 checkIndex(columnIndex);
4781 // make sure the cursor is on a valid row
4782 checkCursor();
4783
4784 if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
4785 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4786 }
4787
4788 byte buf[] = new byte[length];
4789 try {
4790 int bytesRead = 0;
4791 do {
4792 bytesRead += x.read(buf, bytesRead, length - bytesRead);
4793 } while (bytesRead != -1);
4794 } catch (java.io.IOException ex) {
4795 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.binstream").toString());
4796 }
4797
4798 getCurrentRow().setColumnObject(columnIndex, buf);
4799 }
4800
4801 /**
4802 * Sets the designated column in either the current row or the insert
4803 * row of this <code>CachedRowSetImpl</code> object with the given
4804 * <code>java.io.Reader</code> object.
4805 * <P>
4806 * This method updates a column value in either the current row or
4807 * the insert row of this rowset, but it does not update the
4808 * database. If the cursor is on a row in the rowset, the
4809 * method {@link #updateRow} must be called to update the database.
4810 * If the cursor is on the insert row, the method {@link #insertRow}
4811 * must be called, which will insert the new row into both this rowset
4812 * and the database. Both of these methods must be called before the
4813 * cursor moves to another row.
4814 *
4815 * @param columnIndex the first column is <code>1</code>, the second
4816 * is <code>2</code>, and so on; must be <code>1</code> or larger
4817 * and equal to or less than the number of columns in this rowset
4818 * @param x the new column value; must be a <code>java.io.Reader</code>
4819 * containing <code>BINARY</code>, <code>VARBINARY</code>,
4820 * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
4821 * or <code>LONGVARCHAR</code> data
4822 * @param length the length of the stream in characters
4823 * @throws SQLException if (1) the given column index is out of bounds,
4824 * (2) the cursor is not on one of this rowset's rows or its
4825 * insert row, (3) the data in the stream is not a binary or
4826 * character type, or (4) this rowset is
4827 * <code>ResultSet.CONCUR_READ_ONLY</code>
4828 */
4829 public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
4830 // sanity Check
4831 checkIndex(columnIndex);
4832 // make sure the cursor is on a valid row
4833 checkCursor();
4834
4835 if (isString(RowSetMD.getColumnType(columnIndex)) == false &&
4836 isBinary(RowSetMD.getColumnType(columnIndex)) == false) {
4837 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
4838 }
4839
4840 char buf[] = new char[length];
4841 try {
4842 int charsRead = 0;
4843 do {
4844 charsRead += x.read(buf, charsRead, length - charsRead);
4845 } while (charsRead != length);
4846 //Changed the condition checking to check for length instead of -1
4847 } catch (java.io.IOException ex) {
4848 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.binstream").toString());
4849 }
4850 String str = new String(buf);
4851
4852 getCurrentRow().setColumnObject(columnIndex, str);
4853 }
4854
4855 /**
4856 * Sets the designated column in either the current row or the insert
4857 * row of this <code>CachedRowSetImpl</code> object with the given
4858 * <code>Object</code> value. The <code>scale</code> parameter indicates
4859 * the number of digits to the right of the decimal point and is ignored
4860 * if the new column value is not a type that will be mapped to an SQL
4861 * <code>DECIMAL</code> or <code>NUMERIC</code> value.
4862 * <P>
4863 * This method updates a column value in either the current row or
4864 * the insert row of this rowset, but it does not update the
4865 * database. If the cursor is on a row in the rowset, the
4866 * method {@link #updateRow} must be called to update the database.
4867 * If the cursor is on the insert row, the method {@link #insertRow}
4868 * must be called, which will insert the new row into both this rowset
4869 * and the database. Both of these methods must be called before the
4870 * cursor moves to another row.
4871 *
4872 * @param columnIndex the first column is <code>1</code>, the second
4873 * is <code>2</code>, and so on; must be <code>1</code> or larger
4874 * and equal to or less than the number of columns in this rowset
4875 * @param x the new column value
4876 * @param scale the number of digits to the right of the decimal point (for
4877 * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
4878 * @throws SQLException if (1) the given column index is out of bounds,
4879 * (2) the cursor is not on one of this rowset's rows or its
4880 * insert row, or (3) this rowset is
4881 * <code>ResultSet.CONCUR_READ_ONLY</code>
4882 */
4883 public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
4884 // sanity check.
4885 checkIndex(columnIndex);
4886 // make sure the cursor is on a valid row
4887 checkCursor();
4888
4889 int type = RowSetMD.getColumnType(columnIndex);
4890 if (type == Types.DECIMAL || type == Types.NUMERIC) {
4891 ((java.math.BigDecimal)x).setScale(scale);
4892 }
4893 getCurrentRow().setColumnObject(columnIndex, x);
4894 }
4895
4896 /**
4897 * Sets the designated column in either the current row or the insert
4898 * row of this <code>CachedRowSetImpl</code> object with the given
4899 * <code>Object</code> value.
4900 * <P>
4901 * This method updates a column value in either the current row or
4902 * the insert row of this rowset, but it does not update the
4903 * database. If the cursor is on a row in the rowset, the
4904 * method {@link #updateRow} must be called to update the database.
4905 * If the cursor is on the insert row, the method {@link #insertRow}
4906 * must be called, which will insert the new row into both this rowset
4907 * and the database. Both of these methods must be called before the
4908 * cursor moves to another row.
4909 *
4910 * @param columnIndex the first column is <code>1</code>, the second
4911 * is <code>2</code>, and so on; must be <code>1</code> or larger
4912 * and equal to or less than the number of columns in this rowset
4913 * @param x the new column value
4914 * @throws SQLException if (1) the given column index is out of bounds,
4915 * (2) the cursor is not on one of this rowset's rows or its
4916 * insert row, or (3) this rowset is
4917 * <code>ResultSet.CONCUR_READ_ONLY</code>
4918 */
4919 public void updateObject(int columnIndex, Object x) throws SQLException {
4920 // sanity check.
4921 checkIndex(columnIndex);
4922 // make sure the cursor is on a valid row
4923 checkCursor();
4924
4925 getCurrentRow().setColumnObject(columnIndex, x);
4926 }
4927
4928 /**
4929 * Sets the designated nullable column in the current row or the
4930 * insert row of this <code>CachedRowSetImpl</code> object with
4931 * <code>null</code> value.
4932 * <P>
4933 * This method updates a column value in the current row or the insert
4934 * row of this rowset, but it does not update the database.
4935 * If the cursor is on a row in the rowset, the
4936 * method {@link #updateRow} must be called to update the database.
4937 * If the cursor is on the insert row, the method {@link #insertRow}
4938 * must be called, which will insert the new row into both this rowset
4939 * and the database.
4940 *
4941 * @param columnName a <code>String</code> object that must match the
4942 * SQL name of a column in this rowset, ignoring case
4943 * @throws SQLException if (1) the given column name does not match the
4944 * name of a column in this rowset, (2) the cursor is not on
4945 * one of this rowset's rows or its insert row, or (3) this
4946 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4947 */
4948 public void updateNull(String columnName) throws SQLException {
4949 updateNull(getColIdxByName(columnName));
4950 }
4951
4952 /**
4953 * Sets the designated column in either the current row or the insert
4954 * row of this <code>CachedRowSetImpl</code> object with the given
4955 * <code>boolean</code> value.
4956 * <P>
4957 * This method updates a column value in the current row or the insert
4958 * row of this rowset, but it does not update the database.
4959 * If the cursor is on a row in the rowset, the
4960 * method {@link #updateRow} must be called to update the database.
4961 * If the cursor is on the insert row, the method {@link #insertRow}
4962 * must be called, which will insert the new row into both this rowset
4963 * and the database. Both of these methods must be called before the
4964 * cursor moves to another row.
4965 *
4966 * @param columnName a <code>String</code> object that must match the
4967 * SQL name of a column in this rowset, ignoring case
4968 * @param x the new column value
4969 * @throws SQLException if (1) the given column name does not match the
4970 * name of a column in this rowset, (2) the cursor is not on
4971 * one of this rowset's rows or its insert row, or (3) this
4972 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4973 */
4974 public void updateBoolean(String columnName, boolean x) throws SQLException {
4975 updateBoolean(getColIdxByName(columnName), x);
4976 }
4977
4978 /**
4979 * Sets the designated column in either the current row or the insert
4980 * row of this <code>CachedRowSetImpl</code> object with the given
4981 * <code>byte</code> value.
4982 * <P>
4983 * This method updates a column value in the current row or the insert
4984 * row of this rowset, but it does not update the database.
4985 * If the cursor is on a row in the rowset, the
4986 * method {@link #updateRow} must be called to update the database.
4987 * If the cursor is on the insert row, the method {@link #insertRow}
4988 * must be called, which will insert the new row into both this rowset
4989 * and the database. Both of these methods must be called before the
4990 * cursor moves to another row.
4991 *
4992 * @param columnName a <code>String</code> object that must match the
4993 * SQL name of a column in this rowset, ignoring case
4994 * @param x the new column value
4995 * @throws SQLException if (1) the given column name does not match the
4996 * name of a column in this rowset, (2) the cursor is not on
4997 * one of this rowset's rows or its insert row, or (3) this
4998 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4999 */
5000 public void updateByte(String columnName, byte x) throws SQLException {
5001 updateByte(getColIdxByName(columnName), x);
5002 }
5003
5004 /**
5005 * Sets the designated column in either the current row or the insert
5006 * row of this <code>CachedRowSetImpl</code> object with the given
5007 * <code>short</code> value.
5008 * <P>
5009 * This method updates a column value in the current row or the insert
5010 * row of this rowset, but it does not update the database.
5011 * If the cursor is on a row in the rowset, the
5012 * method {@link #updateRow} must be called to update the database.
5013 * If the cursor is on the insert row, the method {@link #insertRow}
5014 * must be called, which will insert the new row into both this rowset
5015 * and the database. Both of these methods must be called before the
5016 * cursor moves to another row.
5017 *
5018 * @param columnName a <code>String</code> object that must match the
5019 * SQL name of a column in this rowset, ignoring case
5020 * @param x the new column value
5021 * @throws SQLException if (1) the given column name does not match the
5022 * name of a column in this rowset, (2) the cursor is not on
5023 * one of this rowset's rows or its insert row, or (3) this
5024 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5025 */
5026 public void updateShort(String columnName, short x) throws SQLException {
5027 updateShort(getColIdxByName(columnName), x);
5028 }
5029
5030 /**
5031 * Sets the designated column in either the current row or the insert
5032 * row of this <code>CachedRowSetImpl</code> object with the given
5033 * <code>int</code> value.
5034 * <P>
5035 * This method updates a column value in the current row or the insert
5036 * row of this rowset, but it does not update the database.
5037 * If the cursor is on a row in the rowset, the
5038 * method {@link #updateRow} must be called to update the database.
5039 * If the cursor is on the insert row, the method {@link #insertRow}
5040 * must be called, which will insert the new row into both this rowset
5041 * and the database. Both of these methods must be called before the
5042 * cursor moves to another row.
5043 *
5044 * @param columnName a <code>String</code> object that must match the
5045 * SQL name of a column in this rowset, ignoring case
5046 * @param x the new column value
5047 * @throws SQLException if (1) the given column name does not match the
5048 * name of a column in this rowset, (2) the cursor is not on
5049 * one of this rowset's rows or its insert row, or (3) this
5050 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5051 */
5052 public void updateInt(String columnName, int x) throws SQLException {
5053 updateInt(getColIdxByName(columnName), x);
5054 }
5055
5056 /**
5057 * Sets the designated column in either the current row or the insert
5058 * row of this <code>CachedRowSetImpl</code> object with the given
5059 * <code>long</code> value.
5060 * <P>
5061 * This method updates a column value in the current row or the insert
5062 * row of this rowset, but it does not update the database.
5063 * If the cursor is on a row in the rowset, the
5064 * method {@link #updateRow} must be called to update the database.
5065 * If the cursor is on the insert row, the method {@link #insertRow}
5066 * must be called, which will insert the new row into both this rowset
5067 * and the database. Both of these methods must be called before the
5068 * cursor moves to another row.
5069 *
5070 * @param columnName a <code>String</code> object that must match the
5071 * SQL name of a column in this rowset, ignoring case
5072 * @param x the new column value
5073 * @throws SQLException if (1) the given column name does not match the
5074 * name of a column in this rowset, (2) the cursor is not on
5075 * one of this rowset's rows or its insert row, or (3) this
5076 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5077 */
5078 public void updateLong(String columnName, long x) throws SQLException {
5079 updateLong(getColIdxByName(columnName), x);
5080 }
5081
5082 /**
5083 * Sets the designated column in either the current row or the insert
5084 * row of this <code>CachedRowSetImpl</code> object with the given
5085 * <code>float</code> value.
5086 * <P>
5087 * This method updates a column value in the current row or the insert
5088 * row of this rowset, but it does not update the database.
5089 * If the cursor is on a row in the rowset, the
5090 * method {@link #updateRow} must be called to update the database.
5091 * If the cursor is on the insert row, the method {@link #insertRow}
5092 * must be called, which will insert the new row into both this rowset
5093 * and the database. Both of these methods must be called before the
5094 * cursor moves to another row.
5095 *
5096 * @param columnName a <code>String</code> object that must match the
5097 * SQL name of a column in this rowset, ignoring case
5098 * @param x the new column value
5099 * @throws SQLException if (1) the given column name does not match the
5100 * name of a column in this rowset, (2) the cursor is not on
5101 * one of this rowset's rows or its insert row, or (3) this
5102 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5103 */
5104 public void updateFloat(String columnName, float x) throws SQLException {
5105 updateFloat(getColIdxByName(columnName), x);
5106 }
5107
5108 /**
5109 * Sets the designated column in either the current row or the insert
5110 * row of this <code>CachedRowSetImpl</code> object with the given
5111 * <code>double</code> value.
5112 *
5113 * This method updates a column value in either the current row or
5114 * the insert row of this rowset, but it does not update the
5115 * database. If the cursor is on a row in the rowset, the
5116 * method {@link #updateRow} must be called to update the database.
5117 * If the cursor is on the insert row, the method {@link #insertRow}
5118 * must be called, which will insert the new row into both this rowset
5119 * and the database. Both of these methods must be called before the
5120 * cursor moves to another row.
5121 *
5122 * @param columnName a <code>String</code> object that must match the
5123 * SQL name of a column in this rowset, ignoring case
5124 * @param x the new column value
5125 * @throws SQLException if (1) the given column name does not match the
5126 * name of a column in this rowset, (2) the cursor is not on
5127 * one of this rowset's rows or its insert row, or (3) this
5128 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5129 */
5130 public void updateDouble(String columnName, double x) throws SQLException {
5131 updateDouble(getColIdxByName(columnName), x);
5132 }
5133
5134 /**
5135 * Sets the designated column in either the current row or the insert
5136 * row of this <code>CachedRowSetImpl</code> object with the given
5137 * <code>java.math.BigDecimal</code> object.
5138 * <P>
5139 * This method updates a column value in the current row or the insert
5140 * row of this rowset, but it does not update the database.
5141 * If the cursor is on a row in the rowset, the
5142 * method {@link #updateRow} must be called to update the database.
5143 * If the cursor is on the insert row, the method {@link #insertRow}
5144 * must be called, which will insert the new row into both this rowset
5145 * and the database. Both of these methods must be called before the
5146 * cursor moves to another row.
5147 *
5148 * @param columnName a <code>String</code> object that must match the
5149 * SQL name of a column in this rowset, ignoring case
5150 * @param x the new column value
5151 * @throws SQLException if (1) the given column name does not match the
5152 * name of a column in this rowset, (2) the cursor is not on
5153 * one of this rowset's rows or its insert row, or (3) this
5154 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5155 */
5156 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
5157 updateBigDecimal(getColIdxByName(columnName), x);
5158 }
5159
5160 /**
5161 * Sets the designated column in either the current row or the insert
5162 * row of this <code>CachedRowSetImpl</code> object with the given
5163 * <code>String</code> object.
5164 *
5165 * This method updates a column value in either the current row or
5166 * the insert row of this rowset, but it does not update the
5167 * database. If the cursor is on a row in the rowset, the
5168 * method {@link #updateRow} must be called to update the database.
5169 * If the cursor is on the insert row, the method {@link #insertRow}
5170 * must be called, which will insert the new row into both this rowset
5171 * and the database. Both of these methods must be called before the
5172 * cursor moves to another row.
5173 *
5174 * @param columnName a <code>String</code> object that must match the
5175 * SQL name of a column in this rowset, ignoring case
5176 * @param x the new column value
5177 * @throws SQLException if (1) the given column name does not match the
5178 * name of a column in this rowset, (2) the cursor is not on
5179 * one of this rowset's rows or its insert row, or (3) this
5180 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5181 */
5182 public void updateString(String columnName, String x) throws SQLException {
5183 updateString(getColIdxByName(columnName), x);
5184 }
5185
5186 /**
5187 * Sets the designated column in either the current row or the insert
5188 * row of this <code>CachedRowSetImpl</code> object with the given
5189 * <code>byte</code> array.
5190 *
5191 * This method updates a column value in either the current row or
5192 * the insert row of this rowset, but it does not update the
5193 * database. If the cursor is on a row in the rowset, the
5194 * method {@link #updateRow} must be called to update the database.
5195 * If the cursor is on the insert row, the method {@link #insertRow}
5196 * must be called, which will insert the new row into both this rowset
5197 * and the database. Both of these methods must be called before the
5198 * cursor moves to another row.
5199 *
5200 * @param columnName a <code>String</code> object that must match the
5201 * SQL name of a column in this rowset, ignoring case
5202 * @param x the new column value
5203 * @throws SQLException if (1) the given column name does not match the
5204 * name of a column in this rowset, (2) the cursor is not on
5205 * one of this rowset's rows or its insert row, or (3) this
5206 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5207 */
5208 public void updateBytes(String columnName, byte x[]) throws SQLException {
5209 updateBytes(getColIdxByName(columnName), x);
5210 }
5211
5212 /**
5213 * Sets the designated column in either the current row or the insert
5214 * row of this <code>CachedRowSetImpl</code> object with the given
5215 * <code>Date</code> object.
5216 *
5217 * This method updates a column value in either the current row or
5218 * the insert row of this rowset, but it does not update the
5219 * database. If the cursor is on a row in the rowset, the
5220 * method {@link #updateRow} must be called to update the database.
5221 * If the cursor is on the insert row, the method {@link #insertRow}
5222 * must be called, which will insert the new row into both this rowset
5223 * and the database. Both of these methods must be called before the
5224 * cursor moves to another row.
5225 *
5226 * @param columnName a <code>String</code> object that must match the
5227 * SQL name of a column in this rowset, ignoring case
5228 * @param x the new column value
5229 * @throws SQLException if (1) the given column name does not match the
5230 * name of a column in this rowset, (2) the cursor is not on
5231 * one of this rowset's rows or its insert row, (3) the type
5232 * of the designated column is not an SQL <code>DATE</code> or
5233 * <code>TIMESTAMP</code>, or (4) this rowset is
5234 * <code>ResultSet.CONCUR_READ_ONLY</code>
5235 */
5236 public void updateDate(String columnName, java.sql.Date x) throws SQLException {
5237 updateDate(getColIdxByName(columnName), x);
5238 }
5239
5240 /**
5241 * Sets the designated column in either the current row or the insert
5242 * row of this <code>CachedRowSetImpl</code> object with the given
5243 * <code>Time</code> object.
5244 *
5245 * This method updates a column value in either the current row or
5246 * the insert row of this rowset, but it does not update the
5247 * database. If the cursor is on a row in the rowset, the
5248 * method {@link #updateRow} must be called to update the database.
5249 * If the cursor is on the insert row, the method {@link #insertRow}
5250 * must be called, which will insert the new row into both this rowset
5251 * and the database. Both of these methods must be called before the
5252 * cursor moves to another row.
5253 *
5254 * @param columnName a <code>String</code> object that must match the
5255 * SQL name of a column in this rowset, ignoring case
5256 * @param x the new column value
5257 * @throws SQLException if (1) the given column name does not match the
5258 * name of a column in this rowset, (2) the cursor is not on
5259 * one of this rowset's rows or its insert row, (3) the type
5260 * of the designated column is not an SQL <code>TIME</code> or
5261 * <code>TIMESTAMP</code>, or (4) this rowset is
5262 * <code>ResultSet.CONCUR_READ_ONLY</code>
5263 */
5264 public void updateTime(String columnName, java.sql.Time x) throws SQLException {
5265 updateTime(getColIdxByName(columnName), x);
5266 }
5267
5268 /**
5269 * Sets the designated column in either the current row or the insert
5270 * row of this <code>CachedRowSetImpl</code> object with the given
5271 * <code>Timestamp</code> object.
5272 *
5273 * This method updates a column value in either the current row or
5274 * the insert row of this rowset, but it does not update the
5275 * database. If the cursor is on a row in the rowset, the
5276 * method {@link #updateRow} must be called to update the database.
5277 * If the cursor is on the insert row, the method {@link #insertRow}
5278 * must be called, which will insert the new row into both this rowset
5279 * and the database. Both of these methods must be called before the
5280 * cursor moves to another row.
5281 *
5282 * @param columnName a <code>String</code> object that must match the
5283 * SQL name of a column in this rowset, ignoring case
5284 * @param x the new column value
5285 * @throws SQLException if the given column index is out of bounds or
5286 * the cursor is not on one of this rowset's rows or its
5287 * insert row
5288 * @throws SQLException if (1) the given column name does not match the
5289 * name of a column in this rowset, (2) the cursor is not on
5290 * one of this rowset's rows or its insert row, (3) the type
5291 * of the designated column is not an SQL <code>DATE</code>,
5292 * <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this
5293 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5294 */
5295 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
5296 updateTimestamp(getColIdxByName(columnName), x);
5297 }
5298
5299 /**
5300 * Sets the designated column in either the current row or the insert
5301 * row of this <code>CachedRowSetImpl</code> object with the given
5302 * ASCII stream value.
5303 * <P>
5304 * This method updates a column value in either the current row or
5305 * the insert row of this rowset, but it does not update the
5306 * database. If the cursor is on a row in the rowset, the
5307 * method {@link #updateRow} must be called to update the database.
5308 * If the cursor is on the insert row, the method {@link #insertRow}
5309 * must be called, which will insert the new row into both this rowset
5310 * and the database. Both of these methods must be called before the
5311 * cursor moves to another row.
5312 *
5313 * @param columnName a <code>String</code> object that must match the
5314 * SQL name of a column in this rowset, ignoring case
5315 * @param x the new column value
5316 * @param length the number of one-byte ASCII characters in the stream
5317 */
5318 public void updateAsciiStream(String columnName,
5319 java.io.InputStream x,
5320 int length) throws SQLException {
5321 updateAsciiStream(getColIdxByName(columnName), x, length);
5322 }
5323
5324 /**
5325 * Sets the designated column in either the current row or the insert
5326 * row of this <code>CachedRowSetImpl</code> object with the given
5327 * <code>java.io.InputStream</code> object.
5328 * <P>
5329 * This method updates a column value in either the current row or
5330 * the insert row of this rowset, but it does not update the
5331 * database. If the cursor is on a row in the rowset, the
5332 * method {@link #updateRow} must be called to update the database.
5333 * If the cursor is on the insert row, the method {@link #insertRow}
5334 * must be called, which will insert the new row into both this rowset
5335 * and the database. Both of these methods must be called before the
5336 * cursor moves to another row.
5337 *
5338 * @param columnName a <code>String</code> object that must match the
5339 * SQL name of a column in this rowset, ignoring case
5340 * @param x the new column value; must be a <code>java.io.InputStream</code>
5341 * containing <code>BINARY</code>, <code>VARBINARY</code>, or
5342 * <code>LONGVARBINARY</code> data
5343 * @param length the length of the stream in bytes
5344 * @throws SQLException if (1) the given column name does not match the
5345 * name of a column in this rowset, (2) the cursor is not on
5346 * one of this rowset's rows or its insert row, (3) the data
5347 * in the stream is not binary, or (4) this rowset is
5348 * <code>ResultSet.CONCUR_READ_ONLY</code>
5349 */
5350 public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
5351 updateBinaryStream(getColIdxByName(columnName), x, length);
5352 }
5353
5354 /**
5355 * Sets the designated column in either the current row or the insert
5356 * row of this <code>CachedRowSetImpl</code> object with the given
5357 * <code>java.io.Reader</code> object.
5358 * <P>
5359 * This method updates a column value in either the current row or
5360 * the insert row of this rowset, but it does not update the
5361 * database. If the cursor is on a row in the rowset, the
5362 * method {@link #updateRow} must be called to update the database.
5363 * If the cursor is on the insert row, the method {@link #insertRow}
5364 * must be called, which will insert the new row into both this rowset
5365 * and the database. Both of these methods must be called before the
5366 * cursor moves to another row.
5367 *
5368 * @param columnName a <code>String</code> object that must match the
5369 * SQL name of a column in this rowset, ignoring case
5370 * @param reader the new column value; must be a
5371 * <code>java.io.Reader</code> containing <code>BINARY</code>,
5372 * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>,
5373 * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> data
5374 * @param length the length of the stream in characters
5375 * @throws SQLException if (1) the given column name does not match the
5376 * name of a column in this rowset, (2) the cursor is not on
5377 * one of this rowset's rows or its insert row, (3) the data
5378 * in the stream is not a binary or character type, or (4) this
5379 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5380 */
5381 public void updateCharacterStream(String columnName,
5382 java.io.Reader reader,
5383 int length) throws SQLException {
5384 updateCharacterStream(getColIdxByName(columnName), reader, length);
5385 }
5386
5387 /**
5388 * Sets the designated column in either the current row or the insert
5389 * row of this <code>CachedRowSetImpl</code> object with the given
5390 * <code>Object</code> value. The <code>scale</code> parameter
5391 * indicates the number of digits to the right of the decimal point
5392 * and is ignored if the new column value is not a type that will be
5393 * mapped to an SQL <code>DECIMAL</code> or <code>NUMERIC</code> value.
5394 * <P>
5395 * This method updates a column value in either the current row or
5396 * the insert row of this rowset, but it does not update the
5397 * database. If the cursor is on a row in the rowset, the
5398 * method {@link #updateRow} must be called to update the database.
5399 * If the cursor is on the insert row, the method {@link #insertRow}
5400 * must be called, which will insert the new row into both this rowset
5401 * and the database. Both of these methods must be called before the
5402 * cursor moves to another row.
5403 *
5404 * @param columnName a <code>String</code> object that must match the
5405 * SQL name of a column in this rowset, ignoring case
5406 * @param x the new column value
5407 * @param scale the number of digits to the right of the decimal point (for
5408 * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
5409 * @throws SQLException if (1) the given column name does not match the
5410 * name of a column in this rowset, (2) the cursor is not on
5411 * one of this rowset's rows or its insert row, or (3) this
5412 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5413 */
5414 public void updateObject(String columnName, Object x, int scale) throws SQLException {
5415 updateObject(getColIdxByName(columnName), x, scale);
5416 }
5417
5418 /**
5419 * Sets the designated column in either the current row or the insert
5420 * row of this <code>CachedRowSetImpl</code> object with the given
5421 * <code>Object</code> value.
5422 * <P>
5423 * This method updates a column value in either the current row or
5424 * the insert row of this rowset, but it does not update the
5425 * database. If the cursor is on a row in the rowset, the
5426 * method {@link #updateRow} must be called to update the database.
5427 * If the cursor is on the insert row, the method {@link #insertRow}
5428 * must be called, which will insert the new row into both this rowset
5429 * and the database. Both of these methods must be called before the
5430 * cursor moves to another row.
5431 *
5432 * @param columnName a <code>String</code> object that must match the
5433 * SQL name of a column in this rowset, ignoring case
5434 * @param x the new column value
5435 * @throws SQLException if (1) the given column name does not match the
5436 * name of a column in this rowset, (2) the cursor is not on
5437 * one of this rowset's rows or its insert row, or (3) this
5438 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5439 */
5440 public void updateObject(String columnName, Object x) throws SQLException {
5441 updateObject(getColIdxByName(columnName), x);
5442 }
5443
5444 /**
5445 * Inserts the contents of this <code>CachedRowSetImpl</code> object's insert
5446 * row into this rowset immediately following the current row.
5447 * If the current row is the
5448 * position after the last row or before the first row, the new row will
5449 * be inserted at the end of the rowset. This method also notifies
5450 * listeners registered with this rowset that the row has changed.
5451 * <P>
5452 * The cursor must be on the insert row when this method is called.
5453 *
5454 * @throws SQLException if (1) the cursor is not on the insert row,
5455 * (2) one or more of the non-nullable columns in the insert
5456 * row has not been given a value, or (3) this rowset is
5457 * <code>ResultSet.CONCUR_READ_ONLY</code>
5458 */
5459 public void insertRow() throws SQLException {
5460 int pos;
5461
5462 if (onInsertRow == false ||
5463 insertRow.isCompleteRow(RowSetMD) == false) {
5464 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.failedins").toString());
5465 }
5466 // Added the setting of parameters that are passed
5467 // to setXXX methods after an empty CRS Object is
5468 // created through RowSetMetaData object
5469 Object [] toInsert = getParams();
5470
5471 for(int i = 0;i < toInsert.length; i++) {
5472 insertRow.setColumnObject(i+1,toInsert[i]);
5473 }
5474
5475 Row insRow = new Row(RowSetMD.getColumnCount(),
5476 insertRow.getOrigRow());
5477 insRow.setInserted();
5478 /*
5479 * The new row is inserted into the RowSet
5480 * immediately following the current row.
5481 *
5482 * If we are afterlast then the rows are
5483 * inserted at the end.
5484 */
5485 if (currentRow >= numRows || currentRow < 0) {
5486 pos = numRows;
5487 } else {
5488 pos = currentRow;
5489 }
5490
5491 rvh.add(pos, insRow);
5492 ++numRows;
5493 // notify the listeners that the row changed.
5494 notifyRowChanged();
5495 }
5496
5497 /**
5498 * Marks the current row of this <code>CachedRowSetImpl</code> object as
5499 * updated and notifies listeners registered with this rowset that the
5500 * row has changed.
5501 * <P>
5502 * This method cannot be called when the cursor is on the insert row, and
5503 * it should be called before the cursor moves to another row. If it is
5504 * called after the cursor moves to another row, this method has no effect,
5505 * and the updates made before the cursor moved will be lost.
5506 *
5507 * @throws SQLException if the cursor is on the insert row or this
5508 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
5509 */
5510 public void updateRow() throws SQLException {
5511 // make sure we aren't on the insert row
5512 if (onInsertRow == true) {
5513 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.updateins").toString());
5514 }
5515
5516 ((Row)getCurrentRow()).setUpdated();
5517
5518 // notify the listeners that the row changed.
5519 notifyRowChanged();
5520 }
5521
5522 /**
5523 * Deletes the current row from this <code>CachedRowSetImpl</code> object and
5524 * notifies listeners registered with this rowset that a row has changed.
5525 * This method cannot be called when the cursor is on the insert row.
5526 * <P>
5527 * This method marks the current row as deleted, but it does not delete
5528 * the row from the underlying data source. The method
5529 * <code>acceptChanges</code> must be called to delete the row in
5530 * the data source.
5531 *
5532 * @throws SQLException if (1) this method is called when the cursor
5533 * is on the insert row, before the first row, or after the
5534 * last row or (2) this rowset is
5535 * <code>ResultSet.CONCUR_READ_ONLY</code>
5536 */
5537 public void deleteRow() throws SQLException {
5538 // make sure the cursor is on a valid row
5539 checkCursor();
5540
5541 ((Row)getCurrentRow()).setDeleted();
5542 ++numDeleted;
5543
5544 // notify the listeners that the row changed.
5545 notifyRowChanged();
5546 }
5547
5548 /**
5549 * Sets the current row with its original value and marks the row as
5550 * not updated, thus undoing any changes made to the row since the
5551 * last call to the methods <code>updateRow</code> or <code>deleteRow</code>.
5552 * This method should be called only when the cursor is on a row in
5553 * this rowset.
5554 *
5555 * @throws SQLException if the cursor is on the insert row, before the
5556 * first row, or after the last row
5557 */
5558 public void refreshRow() throws SQLException {
5559 // make sure we are on a row
5560 checkCursor();
5561
5562 // don't want this to happen...
5563 if (onInsertRow == true) {
5564 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
5565 }
5566
5567 Row currentRow = (Row)getCurrentRow();
5568 // just undo any changes made to this row.
5569 currentRow.clearUpdated();
5570
5571 }
5572
5573 /**
5574 * Rolls back any updates made to the current row of this
5575 * <code>CachedRowSetImpl</code> object and notifies listeners that
5576 * a row has changed. To have an effect, this method
5577 * must be called after an <code>updateXXX</code> method has been
5578 * called and before the method <code>updateRow</code> has been called.
5579 * If no updates have been made or the method <code>updateRow</code>
5580 * has already been called, this method has no effect.
5581 *
5582 * @throws SQLException if the cursor is on the insert row, before the
5583 * first row, or after the last row
5584 */
5585 public void cancelRowUpdates() throws SQLException {
5586 // make sure we are on a row
5587 checkCursor();
5588
5589 // don't want this to happen...
5590 if (onInsertRow == true) {
5591 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString());
5592 }
5593
5594 Row currentRow = (Row)getCurrentRow();
5595 if (currentRow.getUpdated() == true) {
5596 currentRow.clearUpdated();
5597 notifyRowChanged();
5598 }
5599 }
5600
5601 /**
5602 * Moves the cursor for this <code>CachedRowSetImpl</code> object
5603 * to the insert row. The current row in the rowset is remembered
5604 * while the cursor is on the insert row.
5605 * <P>
5606 * The insert row is a special row associated with an updatable
5607 * rowset. It is essentially a buffer where a new row may
5608 * be constructed by calling the appropriate <code>updateXXX</code>
5609 * methods to assign a value to each column in the row. A complete
5610 * row must be constructed; that is, every column that is not nullable
5611 * must be assigned a value. In order for the new row to become part
5612 * of this rowset, the method <code>insertRow</code> must be called
5613 * before the cursor is moved back to the rowset.
5614 * <P>
5615 * Only certain methods may be invoked while the cursor is on the insert
5616 * row; many methods throw an exception if they are called while the
5617 * cursor is there. In addition to the <code>updateXXX</code>
5618 * and <code>insertRow</code> methods, only the <code>getXXX</code> methods
5619 * may be called when the cursor is on the insert row. A <code>getXXX</code>
5620 * method should be called on a column only after an <code>updateXXX</code>
5621 * method has been called on that column; otherwise, the value returned is
5622 * undetermined.
5623 *
5624 * @throws SQLException if this <code>CachedRowSetImpl</code> object is
5625 * <code>ResultSet.CONCUR_READ_ONLY</code>
5626 */
5627 public void moveToInsertRow() throws SQLException {
5628 if (getConcurrency() == ResultSet.CONCUR_READ_ONLY) {
5629 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins").toString());
5630 }
5631 if (insertRow == null) {
5632 if (RowSetMD == null)
5633 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins1").toString());
5634 int numCols = RowSetMD.getColumnCount();
5635 if (numCols > 0) {
5636 insertRow = new InsertRow(numCols);
5637 } else {
5638 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins2").toString());
5639 }
5640 }
5641 onInsertRow = true;
5642 // %%% setCurrentRow called in BaseRow
5643
5644 currentRow = cursorPos;
5645 cursorPos = -1;
5646
5647 insertRow.initInsertRow();
5648 }
5649
5650 /**
5651 * Moves the cursor for this <code>CachedRowSetImpl</code> object to
5652 * the current row. The current row is the row the cursor was on
5653 * when the method <code>moveToInsertRow</code> was called.
5654 * <P>
5655 * Calling this method has no effect unless it is called while the
5656 * cursor is on the insert row.
5657 *
5658 * @throws SQLException if an error occurs
5659 */
5660 public void moveToCurrentRow() throws SQLException {
5661 if (onInsertRow == false) {
5662 return;
5663 } else {
5664 cursorPos = currentRow;
5665 onInsertRow = false;
5666 }
5667 }
5668
5669 /**
5670 * Returns <code>null</code>.
5671 *
5672 * @return <code>null</code>
5673 * @throws SQLException if an error occurs
5674 */
5675 public Statement getStatement() throws SQLException {
5676 return null;
5677 }
5678
5679 /**
5680 * Retrieves the value of the designated column in this
5681 * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
5682 * the Java programming language, using the given
5683 * <code>java.util.Map</code> object to custom map the value if
5684 * appropriate.
5685 *
5686 * @param columnIndex the first column is <code>1</code>, the second
5687 * is <code>2</code>, and so on; must be <code>1</code> or larger
5688 * and equal to or less than the number of columns in this rowset
5689 * @param map a <code>java.util.Map</code> object showing the mapping
5690 * from SQL type names to classes in the Java programming
5691 * language
5692 * @return an <code>Object</code> representing the SQL value
5693 * @throws SQLException if the given column index is out of bounds or
5694 * the cursor is not on one of this rowset's rows or its
5695 * insert row
5696 */
5697 public Object getObject(int columnIndex,
5698 java.util.Map<String,Class<?>> map)
5699 throws SQLException
5700 {
5701 Object value;
5702
5703 // sanity check.
5704 checkIndex(columnIndex);
5705 // make sure the cursor is on a valid row
5706 checkCursor();
5707
5708 setLastValueNull(false);
5709 value = getCurrentRow().getColumnObject(columnIndex);
5710
5711 // check for SQL NULL
5712 if (value == null) {
5713 setLastValueNull(true);
5714 return null;
5715 }
5716 if (value instanceof Struct) {
5717 Struct s = (Struct)value;
5718
5719 // look up the class in the map
5720 Class<?> c = map.get(s.getSQLTypeName());
5721 if (c != null) {
5722 // create new instance of the class
5723 SQLData obj = null;
5724 try {
5725 ReflectUtil.checkPackageAccess(c);
5726 @SuppressWarnings("deprecation")
5727 Object tmp = c.newInstance();
5728 obj = (SQLData) tmp;
5729 } catch(Exception ex) {
5730 throw new SQLException("Unable to Instantiate: ", ex);
5731 }
5732 // get the attributes from the struct
5733 Object attribs[] = s.getAttributes(map);
5734 // create the SQLInput "stream"
5735 SQLInputImpl sqlInput = new SQLInputImpl(attribs, map);
5736 // read the values...
5737 obj.readSQL(sqlInput, s.getSQLTypeName());
5738 return (Object)obj;
5739 }
5740 }
5741 return value;
5742 }
5743
5744 /**
5745 * Retrieves the value of the designated column in this
5746 * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
5747 * in the Java programming language.
5748 *
5749 * @param columnIndex the first column is <code>1</code>, the second
5750 * is <code>2</code>, and so on; must be <code>1</code> or larger
5751 * and equal to or less than the number of columns in this rowset
5752 * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
5753 * @throws SQLException if (1) the given column index is out of bounds,
5754 * (2) the cursor is not on one of this rowset's rows or its
5755 * insert row, or (3) the designated column does not store an
5756 * SQL <code>REF</code> value
5757 * @see #getRef(String)
5758 */
5759 public Ref getRef(int columnIndex) throws SQLException {
5760 Ref value;
5761
5762 // sanity check.
5763 checkIndex(columnIndex);
5764 // make sure the cursor is on a valid row
5765 checkCursor();
5766
5767 if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.REF) {
5768 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
5769 }
5770
5771 setLastValueNull(false);
5772 value = (Ref)(getCurrentRow().getColumnObject(columnIndex));
5773
5774 // check for SQL NULL
5775 if (value == null) {
5776 setLastValueNull(true);
5777 return null;
5778 }
5779
5780 return value;
5781 }
5782
5783 /**
5784 * Retrieves the value of the designated column in this
5785 * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
5786 * in the Java programming language.
5787 *
5788 * @param columnIndex the first column is <code>1</code>, the second
5789 * is <code>2</code>, and so on; must be <code>1</code> or larger
5790 * and equal to or less than the number of columns in this rowset
5791 * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
5792 * @throws SQLException if (1) the given column index is out of bounds,
5793 * (2) the cursor is not on one of this rowset's rows or its
5794 * insert row, or (3) the designated column does not store an
5795 * SQL <code>BLOB</code> value
5796 * @see #getBlob(String)
5797 */
5798 public Blob getBlob(int columnIndex) throws SQLException {
5799 Blob value;
5800
5801 // sanity check.
5802 checkIndex(columnIndex);
5803 // make sure the cursor is on a valid row
5804 checkCursor();
5805
5806 if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.BLOB) {
5807 System.out.println(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.type").toString(), RowSetMD.getColumnType(columnIndex)));
5808 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
5809 }
5810
5811 setLastValueNull(false);
5812 value = (Blob)(getCurrentRow().getColumnObject(columnIndex));
5813
5814 // check for SQL NULL
5815 if (value == null) {
5816 setLastValueNull(true);
5817 return null;
5818 }
5819
5820 return value;
5821 }
5822
5823 /**
5824 * Retrieves the value of the designated column in this
5825 * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
5826 * in the Java programming language.
5827 *
5828 * @param columnIndex the first column is <code>1</code>, the second
5829 * is <code>2</code>, and so on; must be <code>1</code> or larger
5830 * and equal to or less than the number of columns in this rowset
5831 * @return a <code>Clob</code> object representing an SQL <code>CLOB</code> value
5832 * @throws SQLException if (1) the given column index is out of bounds,
5833 * (2) the cursor is not on one of this rowset's rows or its
5834 * insert row, or (3) the designated column does not store an
5835 * SQL <code>CLOB</code> value
5836 * @see #getClob(String)
5837 */
5838 public Clob getClob(int columnIndex) throws SQLException {
5839 Clob value;
5840
5841 // sanity check.
5842 checkIndex(columnIndex);
5843 // make sure the cursor is on a valid row
5844 checkCursor();
5845
5846 if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.CLOB) {
5847 System.out.println(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.type").toString(), RowSetMD.getColumnType(columnIndex)));
5848 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
5849 }
5850
5851 setLastValueNull(false);
5852 value = (Clob)(getCurrentRow().getColumnObject(columnIndex));
5853
5854 // check for SQL NULL
5855 if (value == null) {
5856 setLastValueNull(true);
5857 return null;
5858 }
5859
5860 return value;
5861 }
5862
5863 /**
5864 * Retrieves the value of the designated column in this
5865 * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
5866 * in the Java programming language.
5867 *
5868 * @param columnIndex the first column is <code>1</code>, the second
5869 * is <code>2</code>, and so on; must be <code>1</code> or larger
5870 * and equal to or less than the number of columns in this rowset
5871 * @return an <code>Array</code> object representing an SQL
5872 * <code>ARRAY</code> value
5873 * @throws SQLException if (1) the given column index is out of bounds,
5874 * (2) the cursor is not on one of this rowset's rows or its
5875 * insert row, or (3) the designated column does not store an
5876 * SQL <code>ARRAY</code> value
5877 * @see #getArray(String)
5878 */
5879 public Array getArray(int columnIndex) throws SQLException {
5880 java.sql.Array value;
5881
5882 // sanity check.
5883 checkIndex(columnIndex);
5884 // make sure the cursor is on a valid row
5885 checkCursor();
5886
5887 if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.ARRAY) {
5888 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
5889 }
5890
5891 setLastValueNull(false);
5892 value = (java.sql.Array)(getCurrentRow().getColumnObject(columnIndex));
5893
5894 // check for SQL NULL
5895 if (value == null) {
5896 setLastValueNull(true);
5897 return null;
5898 }
5899
5900 return value;
5901 }
5902
5903 /**
5904 * Retrieves the value of the designated column in this
5905 * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
5906 * the Java programming language, using the given
5907 * <code>java.util.Map</code> object to custom map the value if
5908 * appropriate.
5909 *
5910 * @param columnName a <code>String</code> object that must match the
5911 * SQL name of a column in this rowset, ignoring case
5912 * @param map a <code>java.util.Map</code> object showing the mapping
5913 * from SQL type names to classes in the Java programming
5914 * language
5915 * @return an <code>Object</code> representing the SQL value
5916 * @throws SQLException if the given column name is not the name of
5917 * a column in this rowset or the cursor is not on one of
5918 * this rowset's rows or its insert row
5919 */
5920 public Object getObject(String columnName,
5921 java.util.Map<String,Class<?>> map)
5922 throws SQLException {
5923 return getObject(getColIdxByName(columnName), map);
5924 }
5925
5926 /**
5927 * Retrieves the value of the designated column in this
5928 * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
5929 * in the Java programming language.
5930 *
5931 * @param colName a <code>String</code> object that must match the
5932 * SQL name of a column in this rowset, ignoring case
5933 * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
5934 * @throws SQLException if (1) the given column name is not the name of
5935 * a column in this rowset, (2) the cursor is not on one of
5936 * this rowset's rows or its insert row, or (3) the column value
5937 * is not an SQL <code>REF</code> value
5938 * @see #getRef(int)
5939 */
5940 public Ref getRef(String colName) throws SQLException {
5941 return getRef(getColIdxByName(colName));
5942 }
5943
5944 /**
5945 * Retrieves the value of the designated column in this
5946 * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
5947 * in the Java programming language.
5948 *
5949 * @param colName a <code>String</code> object that must match the
5950 * SQL name of a column in this rowset, ignoring case
5951 * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
5952 * @throws SQLException if (1) the given column name is not the name of
5953 * a column in this rowset, (2) the cursor is not on one of
5954 * this rowset's rows or its insert row, or (3) the designated
5955 * column does not store an SQL <code>BLOB</code> value
5956 * @see #getBlob(int)
5957 */
5958 public Blob getBlob(String colName) throws SQLException {
5959 return getBlob(getColIdxByName(colName));
5960 }
5961
5962 /**
5963 * Retrieves the value of the designated column in this
5964 * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
5965 * in the Java programming language.
5966 *
5967 * @param colName a <code>String</code> object that must match the
5968 * SQL name of a column in this rowset, ignoring case
5969 * @return a <code>Clob</code> object representing an SQL
5970 * <code>CLOB</code> value
5971 * @throws SQLException if (1) the given column name is not the name of
5972 * a column in this rowset, (2) the cursor is not on one of
5973 * this rowset's rows or its insert row, or (3) the designated
5974 * column does not store an SQL <code>CLOB</code> value
5975 * @see #getClob(int)
5976 */
5977 public Clob getClob(String colName) throws SQLException {
5978 return getClob(getColIdxByName(colName));
5979 }
5980
5981 /**
5982 * Retrieves the value of the designated column in this
5983 * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
5984 * in the Java programming langugage.
5985 *
5986 * @param colName a <code>String</code> object that must match the
5987 * SQL name of a column in this rowset, ignoring case
5988 * @return an <code>Array</code> object representing an SQL
5989 * <code>ARRAY</code> value
5990 * @throws SQLException if (1) the given column name is not the name of
5991 * a column in this rowset, (2) the cursor is not on one of
5992 * this rowset's rows or its insert row, or (3) the designated
5993 * column does not store an SQL <code>ARRAY</code> value
5994 * @see #getArray(int)
5995 */
5996 public Array getArray(String colName) throws SQLException {
5997 return getArray(getColIdxByName(colName));
5998 }
5999
6000 /**
6001 * Retrieves the value of the designated column in the current row
6002 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
6003 * object, using the given <code>Calendar</code> object to construct an
6004 * appropriate millisecond value for the date.
6005 *
6006 * @param columnIndex the first column is <code>1</code>, the second
6007 * is <code>2</code>, and so on; must be <code>1</code> or larger
6008 * and equal to or less than the number of columns in the rowset
6009 * @param cal the <code>java.util.Calendar</code> object to use in
6010 * constructing the date
6011 * @return the column value; if the value is SQL <code>NULL</code>,
6012 * the result is <code>null</code>
6013 * @throws SQLException if (1) the given column name is not the name of
6014 * a column in this rowset, (2) the cursor is not on one of
6015 * this rowset's rows or its insert row, or (3) the designated
6016 * column does not store an SQL <code>DATE</code> or
6017 * <code>TIMESTAMP</code> value
6018 */
6019 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
6020 Object value;
6021
6022 // sanity check.
6023 checkIndex(columnIndex);
6024 // make sure the cursor is on a valid row
6025 checkCursor();
6026
6027 setLastValueNull(false);
6028 value = getCurrentRow().getColumnObject(columnIndex);
6029
6030 // check for SQL NULL
6031 if (value == null) {
6032 setLastValueNull(true);
6033 return null;
6034 }
6035
6036 value = convertTemporal(value,
6037 RowSetMD.getColumnType(columnIndex),
6038 java.sql.Types.DATE);
6039
6040 // create a default calendar
6041 Calendar defaultCal = Calendar.getInstance();
6042 // set this Calendar to the time we have
6043 defaultCal.setTime((java.util.Date)value);
6044
6045 /*
6046 * Now we can pull the pieces of the date out
6047 * of the default calendar and put them into
6048 * the user provided calendar
6049 */
6050 cal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR));
6051 cal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH));
6052 cal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH));
6053
6054 /*
6055 * This looks a little odd but it is correct -
6056 * Calendar.getTime() returns a Date...
6057 */
6058 return new java.sql.Date(cal.getTime().getTime());
6059 }
6060
6061 /**
6062 * Retrieves the value of the designated column in the current row
6063 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
6064 * object, using the given <code>Calendar</code> object to construct an
6065 * appropriate millisecond value for the date.
6066 *
6067 * @param columnName a <code>String</code> object that must match the
6068 * SQL name of a column in this rowset, ignoring case
6069 * @param cal the <code>java.util.Calendar</code> object to use in
6070 * constructing the date
6071 * @return the column value; if the value is SQL <code>NULL</code>,
6072 * the result is <code>null</code>
6073 * @throws SQLException if (1) the given column name is not the name of
6074 * a column in this rowset, (2) the cursor is not on one of
6075 * this rowset's rows or its insert row, or (3) the designated
6076 * column does not store an SQL <code>DATE</code> or
6077 * <code>TIMESTAMP</code> value
6078 */
6079 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
6080 return getDate(getColIdxByName(columnName), cal);
6081 }
6082
6083 /**
6084 * Retrieves the value of the designated column in the current row
6085 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
6086 * object, using the given <code>Calendar</code> object to construct an
6087 * appropriate millisecond value for the date.
6088 *
6089 * @param columnIndex the first column is <code>1</code>, the second
6090 * is <code>2</code>, and so on; must be <code>1</code> or larger
6091 * and equal to or less than the number of columns in the rowset
6092 * @param cal the <code>java.util.Calendar</code> object to use in
6093 * constructing the date
6094 * @return the column value; if the value is SQL <code>NULL</code>,
6095 * the result is <code>null</code>
6096 * @throws SQLException if (1) the given column name is not the name of
6097 * a column in this rowset, (2) the cursor is not on one of
6098 * this rowset's rows or its insert row, or (3) the designated
6099 * column does not store an SQL <code>TIME</code> or
6100 * <code>TIMESTAMP</code> value
6101 */
6102 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
6103 Object value;
6104
6105 // sanity check.
6106 checkIndex(columnIndex);
6107 // make sure the cursor is on a valid row
6108 checkCursor();
6109
6110 setLastValueNull(false);
6111 value = getCurrentRow().getColumnObject(columnIndex);
6112
6113 // check for SQL NULL
6114 if (value == null) {
6115 setLastValueNull(true);
6116 return null;
6117 }
6118
6119 value = convertTemporal(value,
6120 RowSetMD.getColumnType(columnIndex),
6121 java.sql.Types.TIME);
6122
6123 // create a default calendar
6124 Calendar defaultCal = Calendar.getInstance();
6125 // set the time in the default calendar
6126 defaultCal.setTime((java.util.Date)value);
6127
6128 /*
6129 * Now we can pull the pieces of the date out
6130 * of the default calendar and put them into
6131 * the user provided calendar
6132 */
6133 cal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY));
6134 cal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE));
6135 cal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND));
6136
6137 return new java.sql.Time(cal.getTime().getTime());
6138 }
6139
6140 /**
6141 * Retrieves the value of the designated column in the current row
6142 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
6143 * object, using the given <code>Calendar</code> object to construct an
6144 * appropriate millisecond value for the date.
6145 *
6146 * @param columnName a <code>String</code> object that must match the
6147 * SQL name of a column in this rowset, ignoring case
6148 * @param cal the <code>java.util.Calendar</code> object to use in
6149 * constructing the date
6150 * @return the column value; if the value is SQL <code>NULL</code>,
6151 * the result is <code>null</code>
6152 * @throws SQLException if (1) the given column name is not the name of
6153 * a column in this rowset, (2) the cursor is not on one of
6154 * this rowset's rows or its insert row, or (3) the designated
6155 * column does not store an SQL <code>TIME</code> or
6156 * <code>TIMESTAMP</code> value
6157 */
6158 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
6159 return getTime(getColIdxByName(columnName), cal);
6160 }
6161
6162 /**
6163 * Retrieves the value of the designated column in the current row
6164 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Timestamp</code>
6165 * object, using the given <code>Calendar</code> object to construct an
6166 * appropriate millisecond value for the date.
6167 *
6168 * @param columnIndex the first column is <code>1</code>, the second
6169 * is <code>2</code>, and so on; must be <code>1</code> or larger
6170 * and equal to or less than the number of columns in the rowset
6171 * @param cal the <code>java.util.Calendar</code> object to use in
6172 * constructing the date
6173 * @return the column value; if the value is SQL <code>NULL</code>,
6174 * the result is <code>null</code>
6175 * @throws SQLException if (1) the given column name is not the name of
6176 * a column in this rowset, (2) the cursor is not on one of
6177 * this rowset's rows or its insert row, or (3) the designated
6178 * column does not store an SQL <code>TIME</code> or
6179 * <code>TIMESTAMP</code> value
6180 */
6181 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
6182 Object value;
6183
6184 // sanity check.
6185 checkIndex(columnIndex);
6186 // make sure the cursor is on a valid row
6187 checkCursor();
6188
6189 setLastValueNull(false);
6190 value = getCurrentRow().getColumnObject(columnIndex);
6191
6192 // check for SQL NULL
6193 if (value == null) {
6194 setLastValueNull(true);
6195 return null;
6196 }
6197
6198 value = convertTemporal(value,
6199 RowSetMD.getColumnType(columnIndex),
6200 java.sql.Types.TIMESTAMP);
6201
6202 // create a default calendar
6203 Calendar defaultCal = Calendar.getInstance();
6204 // set the time in the default calendar
6205 defaultCal.setTime((java.util.Date)value);
6206
6207 /*
6208 * Now we can pull the pieces of the date out
6209 * of the default calendar and put them into
6210 * the user provided calendar
6211 */
6212 cal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR));
6213 cal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH));
6214 cal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH));
6215 cal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY));
6216 cal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE));
6217 cal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND));
6218
6219 return new java.sql.Timestamp(cal.getTime().getTime());
6220 }
6221
6222 /**
6223 * Retrieves the value of the designated column in the current row
6224 * of this <code>CachedRowSetImpl</code> object as a
6225 * <code>java.sql.Timestamp</code> object, using the given
6226 * <code>Calendar</code> object to construct an appropriate
6227 * millisecond value for the date.
6228 *
6229 * @param columnName a <code>String</code> object that must match the
6230 * SQL name of a column in this rowset, ignoring case
6231 * @param cal the <code>java.util.Calendar</code> object to use in
6232 * constructing the date
6233 * @return the column value; if the value is SQL <code>NULL</code>,
6234 * the result is <code>null</code>
6235 * @throws SQLException if (1) the given column name is not the name of
6236 * a column in this rowset, (2) the cursor is not on one of
6237 * this rowset's rows or its insert row, or (3) the designated
6238 * column does not store an SQL <code>DATE</code>,
6239 * <code>TIME</code>, or <code>TIMESTAMP</code> value
6240 */
6241 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
6242 return getTimestamp(getColIdxByName(columnName), cal);
6243 }
6244
6245 /*
6246 * RowSetInternal Interface
6247 */
6248
6249 /**
6250 * Retrieves the <code>Connection</code> object passed to this
6251 * <code>CachedRowSetImpl</code> object. This connection may be
6252 * used to populate this rowset with data or to write data back
6253 * to its underlying data source.
6254 *
6255 * @return the <code>Connection</code> object passed to this rowset;
6256 * may be <code>null</code> if there is no connection
6257 * @throws SQLException if an error occurs
6258 */
6259 public Connection getConnection() throws SQLException{
6260 return conn;
6261 }
6262
6263 /**
6264 * Sets the metadata for this <code>CachedRowSetImpl</code> object
6265 * with the given <code>RowSetMetaData</code> object.
6266 *
6267 * @param md a <code>RowSetMetaData</code> object instance containing
6268 * metadata about the columsn in the rowset
6269 * @throws SQLException if invalid meta data is supplied to the
6270 * rowset
6271 */
6272 public void setMetaData(RowSetMetaData md) throws SQLException {
6273 RowSetMD =(RowSetMetaDataImpl) md;
6274 }
6275
6276 /**
6277 * Returns a result set containing the original value of the rowset. The
6278 * original value is the state of the <code>CachedRowSetImpl</code> after the
6279 * last population or synchronization (whichever occurred most recently) with
6280 * the data source.
6281 * <p>
6282 * The cursor is positioned before the first row in the result set.
6283 * Only rows contained in the result set returned by <code>getOriginal()</code>
6284 * are said to have an original value.
6285 *
6286 * @return the original result set of the rowset
6287 * @throws SQLException if an error occurs produce the
6288 * <code>ResultSet</code> object
6289 */
6290 public ResultSet getOriginal() throws SQLException {
6291 CachedRowSetImpl crs = new CachedRowSetImpl();
6292 crs.RowSetMD = RowSetMD;
6293 crs.numRows = numRows;
6294 crs.cursorPos = 0;
6295
6296 // make sure we don't get someone playing with these
6297 // %%% is this now necessary ???
6298 //crs.setReader(null);
6299 //crs.setWriter(null);
6300 int colCount = RowSetMD.getColumnCount();
6301 Row orig;
6302
6303 for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
6304 orig = new Row(colCount, ((Row)i.next()).getOrigRow());
6305 crs.rvh.add(orig);
6306 }
6307 return (ResultSet)crs;
6308 }
6309
6310 /**
6311 * Returns a result set containing the original value of the current
6312 * row only.
6313 * The original value is the state of the <code>CachedRowSetImpl</code> after
6314 * the last population or synchronization (whichever occurred most recently)
6315 * with the data source.
6316 *
6317 * @return the original result set of the row
6318 * @throws SQLException if there is no current row
6319 * @see #setOriginalRow
6320 */
6321 public ResultSet getOriginalRow() throws SQLException {
6322 CachedRowSetImpl crs = new CachedRowSetImpl();
6323 crs.RowSetMD = RowSetMD;
6324 crs.numRows = 1;
6325 crs.cursorPos = 0;
6326 crs.setTypeMap(this.getTypeMap());
6327
6328 // make sure we don't get someone playing with these
6329 // %%% is this now necessary ???
6330 //crs.setReader(null);
6331 //crs.setWriter(null);
6332
6333 Row orig = new Row(RowSetMD.getColumnCount(),
6334 getCurrentRow().getOrigRow());
6335
6336 crs.rvh.add(orig);
6337
6338 return (ResultSet)crs;
6339
6340 }
6341
6342 /**
6343 * Marks the current row in this rowset as being an original row.
6344 *
6345 * @throws SQLException if there is no current row
6346 * @see #getOriginalRow
6347 */
6348 public void setOriginalRow() throws SQLException {
6349 if (onInsertRow == true) {
6350 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
6351 }
6352
6353 Row row = (Row)getCurrentRow();
6354 makeRowOriginal(row);
6355
6356 // this can happen if deleted rows are being shown
6357 if (row.getDeleted() == true) {
6358 removeCurrentRow();
6359 }
6360 }
6361
6362 /**
6363 * Makes the given row of this rowset the original row by clearing any
6364 * settings that mark the row as having been inserted, deleted, or updated.
6365 * This method is called internally by the methods
6366 * <code>setOriginalRow</code>
6367 * and <code>setOriginal</code>.
6368 *
6369 * @param row the row to be made the original row
6370 */
6371 private void makeRowOriginal(Row row) {
6372 if (row.getInserted() == true) {
6373 row.clearInserted();
6374 }
6375
6376 if (row.getUpdated() == true) {
6377 row.moveCurrentToOrig();
6378 }
6379 }
6380
6381 /**
6382 * Marks all rows in this rowset as being original rows. Any updates
6383 * made to the rows become the original values for the rowset.
6384 * Calls to the method <code>setOriginal</code> connot be reversed.
6385 *
6386 * @throws SQLException if an error occurs
6387 */
6388 public void setOriginal() throws SQLException {
6389 for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
6390 Row row = (Row)i.next();
6391 makeRowOriginal(row);
6392 // remove deleted rows from the collection.
6393 if (row.getDeleted() == true) {
6394 i.remove();
6395 --numRows;
6396 }
6397 }
6398 numDeleted = 0;
6399
6400 // notify any listeners that the rowset has changed
6401 notifyRowSetChanged();
6402 }
6403
6404 /**
6405 * Returns an identifier for the object (table) that was used to create this
6406 * rowset.
6407 *
6408 * @return a <code>String</code> object that identifies the table from
6409 * which this <code>CachedRowSetImpl</code> object was derived
6410 * @throws SQLException if an error occurs
6411 */
6412 public String getTableName() throws SQLException {
6413 return tableName;
6414 }
6415
6416 /**
6417 * Sets the identifier for the table from which this rowset was derived
6418 * to the given table name.
6419 *
6420 * @param tabName a <code>String</code> object that identifies the
6421 * table from which this <code>CachedRowSetImpl</code> object
6422 * was derived
6423 * @throws SQLException if an error occurs
6424 */
6425 public void setTableName(String tabName) throws SQLException {
6426 if (tabName == null)
6427 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.tablename").toString());
6428 else
6429 tableName = tabName;
6430 }
6431
6432 /**
6433 * Returns the columns that make a key to uniquely identify a
6434 * row in this <code>CachedRowSetImpl</code> object.
6435 *
6436 * @return an array of column numbers that constitutes a primary
6437 * key for this rowset. This array should be empty
6438 * if no column is representitive of a primary key
6439 * @throws SQLException if the rowset is empty or no columns
6440 * are designated as primary keys
6441 * @see #setKeyColumns
6442 */
6443 public int[] getKeyColumns() throws SQLException {
6444 int[]keyColumns = this.keyCols;
6445 return (keyColumns == null) ? null : Arrays.copyOf(keyColumns, keyColumns.length);
6446 }
6447
6448
6449 /**
6450 * Sets this <code>CachedRowSetImpl</code> object's
6451 * <code>keyCols</code> field with the given array of column
6452 * numbers, which forms a key for uniquely identifying a row
6453 * in this rowset.
6454 *
6455 * @param keys an array of <code>int</code> indicating the
6456 * columns that form a primary key for this
6457 * <code>CachedRowSetImpl</code> object; every
6458 * element in the array must be greater than
6459 * <code>0</code> and less than or equal to the number
6460 * of columns in this rowset
6461 * @throws SQLException if any of the numbers in the
6462 * given array is not valid for this rowset
6463 * @see #getKeyColumns
6464 */
6465 public void setKeyColumns(int [] keys) throws SQLException {
6466 int numCols = 0;
6467 if (RowSetMD != null) {
6468 numCols = RowSetMD.getColumnCount();
6469 if (keys.length > numCols)
6470 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.keycols").toString());
6471 }
6472 keyCols = new int[keys.length];
6473 for (int i = 0; i < keys.length; i++) {
6474 if (RowSetMD != null && (keys[i] <= 0 ||
6475 keys[i] > numCols)) {
6476 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcol").toString() +
6477 keys[i]);
6478 }
6479 keyCols[i] = keys[i];
6480 }
6481 }
6482
6483 /**
6484 * Sets the designated column in either the current row or the insert
6485 * row of this <code>CachedRowSetImpl</code> object with the given
6486 * <code>Ref</code> value.
6487 *
6488 * This method updates a column value in either the current row or
6489 * the insert row of this rowset, but it does not update the
6490 * database. If the cursor is on a row in the rowset, the
6491 * method {@link #updateRow} must be called to update the database.
6492 * If the cursor is on the insert row, the method {@link #insertRow}
6493 * must be called, which will insert the new row into both this rowset
6494 * and the database. Both of these methods must be called before the
6495 * cursor moves to another row.
6496 *
6497 * @param columnIndex the first column is <code>1</code>, the second
6498 * is <code>2</code>, and so on; must be <code>1</code> or larger
6499 * and equal to or less than the number of columns in this rowset
6500 * @param ref the new column <code>java.sql.Ref</code> value
6501 * @throws SQLException if (1) the given column index is out of bounds,
6502 * (2) the cursor is not on one of this rowset's rows or its
6503 * insert row, or (3) this rowset is
6504 * <code>ResultSet.CONCUR_READ_ONLY</code>
6505 */
6506 public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
6507 // sanity check.
6508 checkIndex(columnIndex);
6509 // make sure the cursor is on a valid row
6510 checkCursor();
6511
6512 // SerialClob will help in getting the byte array and storing it.
6513 // We need to be checking DatabaseMetaData.locatorsUpdatorCopy()
6514 // or through RowSetMetaData.locatorsUpdatorCopy()
6515 getCurrentRow().setColumnObject(columnIndex, new SerialRef(ref));
6516 }
6517
6518 /**
6519 * Sets the designated column in either the current row or the insert
6520 * row of this <code>CachedRowSetImpl</code> object with the given
6521 * <code>double</code> value.
6522 *
6523 * This method updates a column value in either the current row or
6524 * the insert row of this rowset, but it does not update the
6525 * database. If the cursor is on a row in the rowset, the
6526 * method {@link #updateRow} must be called to update the database.
6527 * If the cursor is on the insert row, the method {@link #insertRow}
6528 * must be called, which will insert the new row into both this rowset
6529 * and the database. Both of these methods must be called before the
6530 * cursor moves to another row.
6531 *
6532 * @param columnName a <code>String</code> object that must match the
6533 * SQL name of a column in this rowset, ignoring case
6534 * @param ref the new column <code>java.sql.Ref</code> value
6535 * @throws SQLException if (1) the given column name does not match the
6536 * name of a column in this rowset, (2) the cursor is not on
6537 * one of this rowset's rows or its insert row, or (3) this
6538 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
6539 */
6540 public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
6541 updateRef(getColIdxByName(columnName), ref);
6542 }
6543
6544 /**
6545 * Sets the designated column in either the current row or the insert
6546 * row of this <code>CachedRowSetImpl</code> object with the given
6547 * <code>double</code> value.
6548 *
6549 * This method updates a column value in either the current row or
6550 * the insert row of this rowset, but it does not update the
6551 * database. If the cursor is on a row in the rowset, the
6552 * method {@link #updateRow} must be called to update the database.
6553 * If the cursor is on the insert row, the method {@link #insertRow}
6554 * must be called, which will insert the new row into both this rowset
6555 * and the database. Both of these methods must be called before the
6556 * cursor moves to another row.
6557 *
6558 * @param columnIndex the first column is <code>1</code>, the second
6559 * is <code>2</code>, and so on; must be <code>1</code> or larger
6560 * and equal to or less than the number of columns in this rowset
6561 * @param c the new column <code>Clob</code> value
6562 * @throws SQLException if (1) the given column index is out of bounds,
6563 * (2) the cursor is not on one of this rowset's rows or its
6564 * insert row, or (3) this rowset is
6565 * <code>ResultSet.CONCUR_READ_ONLY</code>
6566 */
6567 public void updateClob(int columnIndex, Clob c) throws SQLException {
6568 // sanity check.
6569 checkIndex(columnIndex);
6570 // make sure the cursor is on a valid row
6571 checkCursor();
6572
6573 // SerialClob will help in getting the byte array and storing it.
6574 // We need to be checking DatabaseMetaData.locatorsUpdatorCopy()
6575 // or through RowSetMetaData.locatorsUpdatorCopy()
6576
6577 if(dbmslocatorsUpdateCopy){
6578 getCurrentRow().setColumnObject(columnIndex, new SerialClob(c));
6579 }
6580 else{
6581 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.opnotsupp").toString());
6582 }
6583 }
6584
6585 /**
6586 * Sets the designated column in either the current row or the insert
6587 * row of this <code>CachedRowSetImpl</code> object with the given
6588 * <code>double</code> value.
6589 *
6590 * This method updates a column value in either the current row or
6591 * the insert row of this rowset, but it does not update the
6592 * database. If the cursor is on a row in the rowset, the
6593 * method {@link #updateRow} must be called to update the database.
6594 * If the cursor is on the insert row, the method {@link #insertRow}
6595 * must be called, which will insert the new row into both this rowset
6596 * and the database. Both of these methods must be called before the
6597 * cursor moves to another row.
6598 *
6599 * @param columnName a <code>String</code> object that must match the
6600 * SQL name of a column in this rowset, ignoring case
6601 * @param c the new column <code>Clob</code> value
6602 * @throws SQLException if (1) the given column name does not match the
6603 * name of a column in this rowset, (2) the cursor is not on
6604 * one of this rowset's rows or its insert row, or (3) this
6605 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
6606 */
6607 public void updateClob(String columnName, Clob c) throws SQLException {
6608 updateClob(getColIdxByName(columnName), c);
6609 }
6610
6611 /**
6612 * Sets the designated column in either the current row or the insert
6613 * row of this <code>CachedRowSetImpl</code> object with the given
6614 * <code>java.sql.Blob</code> value.
6615 *
6616 * This method updates a column value in either the current row or
6617 * the insert row of this rowset, but it does not update the
6618 * database. If the cursor is on a row in the rowset, the
6619 * method {@link #updateRow} must be called to update the database.
6620 * If the cursor is on the insert row, the method {@link #insertRow}
6621 * must be called, which will insert the new row into both this rowset
6622 * and the database. Both of these methods must be called before the
6623 * cursor moves to another row.
6624 *
6625 * @param columnIndex the first column is <code>1</code>, the second
6626 * is <code>2</code>, and so on; must be <code>1</code> or larger
6627 * and equal to or less than the number of columns in this rowset
6628 * @param b the new column <code>Blob</code> value
6629 * @throws SQLException if (1) the given column index is out of bounds,
6630 * (2) the cursor is not on one of this rowset's rows or its
6631 * insert row, or (3) this rowset is
6632 * <code>ResultSet.CONCUR_READ_ONLY</code>
6633 */
6634 public void updateBlob(int columnIndex, Blob b) throws SQLException {
6635 // sanity check.
6636 checkIndex(columnIndex);
6637 // make sure the cursor is on a valid row
6638 checkCursor();
6639
6640 // SerialBlob will help in getting the byte array and storing it.
6641 // We need to be checking DatabaseMetaData.locatorsUpdatorCopy()
6642 // or through RowSetMetaData.locatorsUpdatorCopy()
6643
6644 if(dbmslocatorsUpdateCopy){
6645 getCurrentRow().setColumnObject(columnIndex, new SerialBlob(b));
6646 }
6647 else{
6648 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.opnotsupp").toString());
6649 }
6650 }
6651
6652 /**
6653 * Sets the designated column in either the current row or the insert
6654 * row of this <code>CachedRowSetImpl</code> object with the given
6655 * <code>java.sql.Blob </code> value.
6656 *
6657 * This method updates a column value in either the current row or
6658 * the insert row of this rowset, but it does not update the
6659 * database. If the cursor is on a row in the rowset, the
6660 * method {@link #updateRow} must be called to update the database.
6661 * If the cursor is on the insert row, the method {@link #insertRow}
6662 * must be called, which will insert the new row into both this rowset
6663 * and the database. Both of these methods must be called before the
6664 * cursor moves to another row.
6665 *
6666 * @param columnName a <code>String</code> object that must match the
6667 * SQL name of a column in this rowset, ignoring case
6668 * @param b the new column <code>Blob</code> value
6669 * @throws SQLException if (1) the given column name does not match the
6670 * name of a column in this rowset, (2) the cursor is not on
6671 * one of this rowset's rows or its insert row, or (3) this
6672 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
6673 */
6674 public void updateBlob(String columnName, Blob b) throws SQLException {
6675 updateBlob(getColIdxByName(columnName), b);
6676 }
6677
6678 /**
6679 * Sets the designated column in either the current row or the insert
6680 * row of this <code>CachedRowSetImpl</code> object with the given
6681 * <code>java.sql.Array</code> values.
6682 *
6683 * This method updates a column value in either the current row or
6684 * the insert row of this rowset, but it does not update the
6685 * database. If the cursor is on a row in the rowset, the
6686 * method {@link #updateRow} must be called to update the database.
6687 * If the cursor is on the insert row, the method {@link #insertRow}
6688 * must be called, which will insert the new row into both this rowset
6689 * and the database. Both of these methods must be called before the
6690 * cursor moves to another row.
6691 *
6692 * @param columnIndex the first column is <code>1</code>, the second
6693 * is <code>2</code>, and so on; must be <code>1</code> or larger
6694 * and equal to or less than the number of columns in this rowset
6695 * @param a the new column <code>Array</code> value
6696 * @throws SQLException if (1) the given column index is out of bounds,
6697 * (2) the cursor is not on one of this rowset's rows or its
6698 * insert row, or (3) this rowset is
6699 * <code>ResultSet.CONCUR_READ_ONLY</code>
6700 */
6701 public void updateArray(int columnIndex, Array a) throws SQLException {
6702 // sanity check.
6703 checkIndex(columnIndex);
6704 // make sure the cursor is on a valid row
6705 checkCursor();
6706
6707 // SerialArray will help in getting the byte array and storing it.
6708 // We need to be checking DatabaseMetaData.locatorsUpdatorCopy()
6709 // or through RowSetMetaData.locatorsUpdatorCopy()
6710 getCurrentRow().setColumnObject(columnIndex, new SerialArray(a));
6711 }
6712
6713 /**
6714 * Sets the designated column in either the current row or the insert
6715 * row of this <code>CachedRowSetImpl</code> object with the given
6716 * <code>java.sql.Array</code> value.
6717 *
6718 * This method updates a column value in either the current row or
6719 * the insert row of this rowset, but it does not update the
6720 * database. If the cursor is on a row in the rowset, the
6721 * method {@link #updateRow} must be called to update the database.
6722 * If the cursor is on the insert row, the method {@link #insertRow}
6723 * must be called, which will insert the new row into both this rowset
6724 * and the database. Both of these methods must be called before the
6725 * cursor moves to another row.
6726 *
6727 * @param columnName a <code>String</code> object that must match the
6728 * SQL name of a column in this rowset, ignoring case
6729 * @param a the new column <code>Array</code> value
6730 * @throws SQLException if (1) the given column name does not match the
6731 * name of a column in this rowset, (2) the cursor is not on
6732 * one of this rowset's rows or its insert row, or (3) this
6733 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
6734 */
6735 public void updateArray(String columnName, Array a) throws SQLException {
6736 updateArray(getColIdxByName(columnName), a);
6737 }
6738
6739
6740 /**
6741 * Retrieves the value of the designated column in this
6742 * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
6743 * in the Java programming language.
6744 *
6745 * @return a java.net.URL object containing the resource reference described by
6746 * the URL
6747 * @throws SQLException if (1) the given column index is out of bounds,
6748 * (2) the cursor is not on one of this rowset's rows or its
6749 * insert row, or (3) the designated column does not store an
6750 * SQL <code>DATALINK</code> value.
6751 * @see #getURL(String)
6752 */
6753 public java.net.URL getURL(int columnIndex) throws SQLException {
6754 //throw new SQLException("Operation not supported");
6755
6756 java.net.URL value;
6757
6758 // sanity check.
6759 checkIndex(columnIndex);
6760 // make sure the cursor is on a valid row
6761 checkCursor();
6762
6763 if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.DATALINK) {
6764 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
6765 }
6766
6767 setLastValueNull(false);
6768 value = (java.net.URL)(getCurrentRow().getColumnObject(columnIndex));
6769
6770 // check for SQL NULL
6771 if (value == null) {
6772 setLastValueNull(true);
6773 return null;
6774 }
6775
6776 return value;
6777 }
6778
6779 /**
6780 * Retrieves the value of the designated column in this
6781 * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
6782 * in the Java programming language.
6783 *
6784 * @return a java.net.URL object containing the resource reference described by
6785 * the URL
6786 * @throws SQLException if (1) the given column name not the name of a column
6787 * in this rowset, or
6788 * (2) the cursor is not on one of this rowset's rows or its
6789 * insert row, or (3) the designated column does not store an
6790 * SQL <code>DATALINK</code> value.
6791 * @see #getURL(int)
6792 */
6793 public java.net.URL getURL(String columnName) throws SQLException {
6794 return getURL(getColIdxByName(columnName));
6795
6796 }
6797
6798 /**
6799 * The first warning reported by calls on this <code>CachedRowSetImpl</code>
6800 * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
6801 * be chained to this <code>SQLWarning</code>. All <code>RowSetWarnings</code>
6802 * warnings are generated in the disconnected environment and remain a
6803 * seperate warning chain to that provided by the <code>getWarnings</code>
6804 * method.
6805 *
6806 * <P>The warning chain is automatically cleared each time a new
6807 * row is read.
6808 *
6809 * <P><B>Note:</B> This warning chain only covers warnings caused
6810 * by <code>CachedRowSet</code> (and their child interface)
6811 * methods. All <code>SQLWarnings</code> can be obtained using the
6812 * <code>getWarnings</code> method which tracks warnings generated
6813 * by the underlying JDBC driver.
6814 * @return the first SQLWarning or null
6815 *
6816 */
6817 public RowSetWarning getRowSetWarnings() {
6818 try {
6819 notifyCursorMoved();
6820 } catch (SQLException e) {} // mask exception
6821 return rowsetWarning;
6822 }
6823
6824
6825 /**
6826 * The function tries to isolate the tablename when only setCommand
6827 * is set and not setTablename is called provided there is only one table
6828 * name in the query else just leaves the setting of table name as such.
6829 * If setTablename is set later it will over ride this table name
6830 * value so retrieved.
6831 *
6832 * @return the tablename if only one table in query else return ""
6833 */
6834 private String buildTableName(String command) throws SQLException {
6835
6836 // If we have a query from one table,
6837 // we set the table name implicitly
6838 // else user has to explicitly set the table name.
6839
6840 int indexFrom, indexComma;
6841 String strTablename ="";
6842 command = command.trim();
6843
6844 // Query can be a select, insert or update
6845
6846 if(command.toLowerCase().startsWith("select")) {
6847 // look for "from" keyword, after that look for a
6848 // comma after from. If comma is there don't set
6849 // table name else isolate table name.
6850
6851 indexFrom = command.toLowerCase().indexOf("from");
6852 indexComma = command.indexOf(',', indexFrom);
6853
6854 if(indexComma == -1) {
6855 // implies only one table
6856 strTablename = (command.substring(indexFrom+"from".length(),command.length())).trim();
6857
6858 String tabName = strTablename;
6859
6860 int idxWhere = tabName.toLowerCase().indexOf("where");
6861
6862 /**
6863 * Adding the addtional check for conditions following the table name.
6864 * If a condition is found truncate it.
6865 **/
6866
6867 if(idxWhere != -1)
6868 {
6869 tabName = tabName.substring(0,idxWhere).trim();
6870 }
6871
6872 strTablename = tabName;
6873
6874 } else {
6875 //strTablename="";
6876 }
6877
6878 } else if(command.toLowerCase().startsWith("insert")) {
6879 //strTablename="";
6880 } else if(command.toLowerCase().startsWith("update")) {
6881 //strTablename="";
6882 }
6883 return strTablename;
6884 }
6885
6886 /**
6887 * Commits all changes performed by the <code>acceptChanges()</code>
6888 * methods
6889 *
6890 * @see java.sql.Connection#commit
6891 */
6892 public void commit() throws SQLException {
6893 conn.commit();
6894 }
6895
6896 /**
6897 * Rolls back all changes performed by the <code>acceptChanges()</code>
6898 * methods
6899 *
6900 * @see java.sql.Connection#rollback
6901 */
6902 public void rollback() throws SQLException {
6903 conn.rollback();
6904 }
6905
6906 /**
6907 * Rolls back all changes performed by the <code>acceptChanges()</code>
6908 * to the last <code>Savepoint</code> transaction marker.
6909 *
6910 * @see java.sql.Connection#rollback(Savepoint)
6911 */
6912 public void rollback(Savepoint s) throws SQLException {
6913 conn.rollback(s);
6914 }
6915
6916 /**
6917 * Unsets the designated parameter to the given int array.
6918 * This was set using <code>setMatchColumn</code>
6919 * as the column which will form the basis of the join.
6920 * <P>
6921 * The parameter value unset by this method should be same
6922 * as was set.
6923 *
6924 * @param columnIdxes the index into this rowset
6925 * object's internal representation of parameter values
6926 * @throws SQLException if an error occurs or the
6927 * parameter index is out of bounds or if the columnIdx is
6928 * not the same as set using <code>setMatchColumn(int [])</code>
6929 */
6930 public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
6931
6932 int i_val;
6933 for( int j= 0 ;j < columnIdxes.length; j++) {
6934 i_val = (Integer.parseInt(iMatchColumns.get(j).toString()));
6935 if(columnIdxes[j] != i_val) {
6936 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols").toString());
6937 }
6938 }
6939
6940 for( int i = 0;i < columnIdxes.length ;i++) {
6941 iMatchColumns.set(i, -1);
6942 }
6943 }
6944
6945 /**
6946 * Unsets the designated parameter to the given String array.
6947 * This was set using <code>setMatchColumn</code>
6948 * as the column which will form the basis of the join.
6949 * <P>
6950 * The parameter value unset by this method should be same
6951 * as was set.
6952 *
6953 * @param columnIdxes the index into this rowset
6954 * object's internal representation of parameter values
6955 * @throws SQLException if an error occurs or the
6956 * parameter index is out of bounds or if the columnName is
6957 * not the same as set using <code>setMatchColumn(String [])</code>
6958 */
6959 public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
6960
6961 for(int j = 0 ;j < columnIdxes.length; j++) {
6962 if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){
6963 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols").toString());
6964 }
6965 }
6966
6967 for(int i = 0 ; i < columnIdxes.length; i++) {
6968 strMatchColumns.set(i,null);
6969 }
6970 }
6971
6972 /**
6973 * Retrieves the column name as <code>String</code> array
6974 * that was set using <code>setMatchColumn(String [])</code>
6975 * for this rowset.
6976 *
6977 * @return a <code>String</code> array object that contains the column names
6978 * for the rowset which has this the match columns
6979 *
6980 * @throws SQLException if an error occurs or column name is not set
6981 */
6982 public String[] getMatchColumnNames() throws SQLException {
6983
6984 String []str_temp = new String[strMatchColumns.size()];
6985
6986 if( strMatchColumns.get(0) == null) {
6987 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.setmatchcols").toString());
6988 }
6989
6990 strMatchColumns.copyInto(str_temp);
6991 return str_temp;
6992 }
6993
6994 /**
6995 * Retrieves the column id as <code>int</code> array that was set using
6996 * <code>setMatchColumn(int [])</code> for this rowset.
6997 *
6998 * @return a <code>int</code> array object that contains the column ids
6999 * for the rowset which has this as the match columns.
7000 *
7001 * @throws SQLException if an error occurs or column index is not set
7002 */
7003 public int[] getMatchColumnIndexes() throws SQLException {
7004
7005 Integer []int_temp = new Integer[iMatchColumns.size()];
7006 int [] i_temp = new int[iMatchColumns.size()];
7007 int i_val;
7008
7009 i_val = iMatchColumns.get(0);
7010
7011 if( i_val == -1 ) {
7012 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.setmatchcols").toString());
7013 }
7014
7015
7016 iMatchColumns.copyInto(int_temp);
7017
7018 for(int i = 0; i < int_temp.length; i++) {
7019 i_temp[i] = (int_temp[i]).intValue();
7020 }
7021
7022 return i_temp;
7023 }
7024
7025 /**
7026 * Sets the designated parameter to the given int array.
7027 * This forms the basis of the join for the
7028 * <code>JoinRowSet</code> as the column which will form the basis of the
7029 * join.
7030 * <P>
7031 * The parameter value set by this method is stored internally and
7032 * will be supplied as the appropriate parameter in this rowset's
7033 * command when the method <code>getMatchColumnIndexes</code> is called.
7034 *
7035 * @param columnIdxes the indexes into this rowset
7036 * object's internal representation of parameter values; the
7037 * first parameter is 0, the second is 1, and so on; must be
7038 * <code>0</code> or greater
7039 * @throws SQLException if an error occurs or the
7040 * parameter index is out of bounds
7041 */
7042 public void setMatchColumn(int[] columnIdxes) throws SQLException {
7043
7044 for(int j = 0 ; j < columnIdxes.length; j++) {
7045 if( columnIdxes[j] < 0 ) {
7046 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols1").toString());
7047 }
7048 }
7049 for(int i = 0 ;i < columnIdxes.length; i++) {
7050 iMatchColumns.add(i,columnIdxes[i]);
7051 }
7052 }
7053
7054 /**
7055 * Sets the designated parameter to the given String array.
7056 * This forms the basis of the join for the
7057 * <code>JoinRowSet</code> as the column which will form the basis of the
7058 * join.
7059 * <P>
7060 * The parameter value set by this method is stored internally and
7061 * will be supplied as the appropriate parameter in this rowset's
7062 * command when the method <code>getMatchColumn</code> is called.
7063 *
7064 * @param columnNames the name of the column into this rowset
7065 * object's internal representation of parameter values
7066 * @throws SQLException if an error occurs or the
7067 * parameter index is out of bounds
7068 */
7069 public void setMatchColumn(String[] columnNames) throws SQLException {
7070
7071 for(int j = 0; j < columnNames.length; j++) {
7072 if( columnNames[j] == null || columnNames[j].equals("")) {
7073 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols2").toString());
7074 }
7075 }
7076 for( int i = 0; i < columnNames.length; i++) {
7077 strMatchColumns.add(i,columnNames[i]);
7078 }
7079 }
7080
7081
7082 /**
7083 * Sets the designated parameter to the given <code>int</code>
7084 * object. This forms the basis of the join for the
7085 * <code>JoinRowSet</code> as the column which will form the basis of the
7086 * join.
7087 * <P>
7088 * The parameter value set by this method is stored internally and
7089 * will be supplied as the appropriate parameter in this rowset's
7090 * command when the method <code>getMatchColumn</code> is called.
7091 *
7092 * @param columnIdx the index into this rowset
7093 * object's internal representation of parameter values; the
7094 * first parameter is 0, the second is 1, and so on; must be
7095 * <code>0</code> or greater
7096 * @throws SQLException if an error occurs or the
7097 * parameter index is out of bounds
7098 */
7099 public void setMatchColumn(int columnIdx) throws SQLException {
7100 // validate, if col is ok to be set
7101 if(columnIdx < 0) {
7102 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols1").toString());
7103 } else {
7104 // set iMatchColumn
7105 iMatchColumns.set(0, columnIdx);
7106 //strMatchColumn = null;
7107 }
7108 }
7109
7110 /**
7111 * Sets the designated parameter to the given <code>String</code>
7112 * object. This forms the basis of the join for the
7113 * <code>JoinRowSet</code> as the column which will form the basis of the
7114 * join.
7115 * <P>
7116 * The parameter value set by this method is stored internally and
7117 * will be supplied as the appropriate parameter in this rowset's
7118 * command when the method <code>getMatchColumn</code> is called.
7119 *
7120 * @param columnName the name of the column into this rowset
7121 * object's internal representation of parameter values
7122 * @throws SQLException if an error occurs or the
7123 * parameter index is out of bounds
7124 */
7125 public void setMatchColumn(String columnName) throws SQLException {
7126 // validate, if col is ok to be set
7127 if(columnName == null || (columnName= columnName.trim()).equals("") ) {
7128 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols2").toString());
7129 } else {
7130 // set strMatchColumn
7131 strMatchColumns.set(0, columnName);
7132 //iMatchColumn = -1;
7133 }
7134 }
7135
7136 /**
7137 * Unsets the designated parameter to the given <code>int</code>
7138 * object. This was set using <code>setMatchColumn</code>
7139 * as the column which will form the basis of the join.
7140 * <P>
7141 * The parameter value unset by this method should be same
7142 * as was set.
7143 *
7144 * @param columnIdx the index into this rowset
7145 * object's internal representation of parameter values
7146 * @throws SQLException if an error occurs or the
7147 * parameter index is out of bounds or if the columnIdx is
7148 * not the same as set using <code>setMatchColumn(int)</code>
7149 */
7150 public void unsetMatchColumn(int columnIdx) throws SQLException {
7151 // check if we are unsetting the SAME column
7152 if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) ) ) {
7153 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch").toString());
7154 } else if(strMatchColumns.get(0) != null) {
7155 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch1").toString());
7156 } else {
7157 // that is, we are unsetting it.
7158 iMatchColumns.set(0, -1);
7159 }
7160 }
7161
7162 /**
7163 * Unsets the designated parameter to the given <code>String</code>
7164 * object. This was set using <code>setMatchColumn</code>
7165 * as the column which will form the basis of the join.
7166 * <P>
7167 * The parameter value unset by this method should be same
7168 * as was set.
7169 *
7170 * @param columnName the index into this rowset
7171 * object's internal representation of parameter values
7172 * @throws SQLException if an error occurs or the
7173 * parameter index is out of bounds or if the columnName is
7174 * not the same as set using <code>setMatchColumn(String)</code>
7175 */
7176 public void unsetMatchColumn(String columnName) throws SQLException {
7177 // check if we are unsetting the same column
7178 columnName = columnName.trim();
7179
7180 if(!((strMatchColumns.get(0)).equals(columnName))) {
7181 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch").toString());
7182 } else if(iMatchColumns.get(0) > 0) {
7183 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch2").toString());
7184 } else {
7185 strMatchColumns.set(0, null); // that is, we are unsetting it.
7186 }
7187 }
7188
7189 /**
7190 * Notifies registered listeners that a RowSet object in the given RowSetEvent
7191 * object has populated a number of additional rows. The <code>numRows</code> parameter
7192 * ensures that this event will only be fired every <code>numRow</code>.
7193 * <p>
7194 * The source of the event can be retrieved with the method event.getSource.
7195 *
7196 * @param event a <code>RowSetEvent</code> object that contains the
7197 * <code>RowSet</code> object that is the source of the events
7198 * @param numRows when populating, the number of rows interval on which the
7199 * <code>CachedRowSet</code> populated should fire; the default value
7200 * is zero; cannot be less than <code>fetchSize</code> or zero
7201 */
7202 public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
7203
7204 if( numRows < 0 || numRows < getFetchSize()) {
7205 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.numrows").toString());
7206 }
7207
7208 if(size() % numRows == 0) {
7209 RowSetEvent event_temp = new RowSetEvent(this);
7210 event = event_temp;
7211 notifyRowSetChanged();
7212 }
7213 }
7214
7215 /**
7216 * Populates this <code>CachedRowSet</code> object with data from
7217 * the given <code>ResultSet</code> object. While related to the <code>populate(ResultSet)</code>
7218 * method, an additional parameter is provided to allow starting position within
7219 * the <code>ResultSet</code> from where to populate the CachedRowSet
7220 * instance.
7221 *
7222 * This method is an alternative to the method <code>execute</code>
7223 * for filling the rowset with data. The method <code>populate</code>
7224 * does not require that the properties needed by the method
7225 * <code>execute</code>, such as the <code>command</code> property,
7226 * be set. This is true because the method <code>populate</code>
7227 * is given the <code>ResultSet</code> object from
7228 * which to get data and thus does not need to use the properties
7229 * required for setting up a connection and executing this
7230 * <code>CachedRowSetImpl</code> object's command.
7231 * <P>
7232 * After populating this rowset with data, the method
7233 * <code>populate</code> sets the rowset's metadata and
7234 * then sends a <code>RowSetChangedEvent</code> object
7235 * to all registered listeners prior to returning.
7236 *
7237 * @param data the <code>ResultSet</code> object containing the data
7238 * to be read into this <code>CachedRowSetImpl</code> object
7239 * @param start the integer specifing the position in the
7240 * <code>ResultSet</code> object to popultate the
7241 * <code>CachedRowSetImpl</code> object.
7242 * @throws SQLException if an error occurs; or the max row setting is
7243 * violated while populating the RowSet.Also id the start position
7244 * is negative.
7245 * @see #execute
7246 */
7247 public void populate(ResultSet data, int start) throws SQLException{
7248
7249 int rowsFetched;
7250 Row currentRow;
7251 int numCols;
7252 int i;
7253 Map<String, Class<?>> map = getTypeMap();
7254 Object obj;
7255 int mRows;
7256
7257 cursorPos = 0;
7258 if(populatecallcount == 0){
7259 if(start < 0){
7260 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.startpos").toString());
7261 }
7262 if(getMaxRows() == 0){
7263 data.absolute(start);
7264 while(data.next()){
7265 totalRows++;
7266 }
7267 totalRows++;
7268 }
7269 startPos = start;
7270 }
7271 populatecallcount = populatecallcount +1;
7272 resultSet = data;
7273 if((endPos - startPos) >= getMaxRows() && (getMaxRows() > 0)){
7274 endPos = prevEndPos;
7275 pagenotend = false;
7276 return;
7277 }
7278
7279 if((maxRowsreached != getMaxRows() || maxRowsreached != totalRows) && pagenotend) {
7280 startPrev = start - getPageSize();
7281 }
7282
7283 if( pageSize == 0){
7284 prevEndPos = endPos;
7285 endPos = start + getMaxRows() ;
7286 }
7287 else{
7288 prevEndPos = endPos;
7289 endPos = start + getPageSize();
7290 }
7291
7292
7293 if (start == 1){
7294 resultSet.beforeFirst();
7295 }
7296 else {
7297 resultSet.absolute(start -1);
7298 }
7299 if( pageSize == 0) {
7300 rvh = new Vector<Object>(getMaxRows());
7301
7302 }
7303 else{
7304 rvh = new Vector<Object>(getPageSize());
7305 }
7306
7307 if (data == null) {
7308 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.populate").toString());
7309 }
7310
7311 // get the meta data for this ResultSet
7312 RSMD = data.getMetaData();
7313
7314 // set up the metadata
7315 RowSetMD = new RowSetMetaDataImpl();
7316 initMetaData(RowSetMD, RSMD);
7317
7318 // release the meta-data so that aren't tempted to use it.
7319 RSMD = null;
7320 numCols = RowSetMD.getColumnCount();
7321 mRows = this.getMaxRows();
7322 rowsFetched = 0;
7323 currentRow = null;
7324
7325 if(!data.next() && mRows == 0){
7326 endPos = prevEndPos;
7327 pagenotend = false;
7328 return;
7329 }
7330
7331 data.previous();
7332
7333 while ( data.next()) {
7334
7335 currentRow = new Row(numCols);
7336 if(pageSize == 0){
7337 if ( rowsFetched >= mRows && mRows > 0) {
7338 rowsetWarning.setNextException(new SQLException("Populating rows "
7339 + "setting has exceeded max row setting"));
7340 break;
7341 }
7342 }
7343 else {
7344 if ( (rowsFetched >= pageSize) ||( maxRowsreached >= mRows && mRows > 0)) {
7345 rowsetWarning.setNextException(new SQLException("Populating rows "
7346 + "setting has exceeded max row setting"));
7347 break;
7348 }
7349 }
7350
7351 for ( i = 1; i <= numCols; i++) {
7352 /*
7353 * check if the user has set a map. If no map
7354 * is set then use plain getObject. This lets
7355 * us work with drivers that do not support
7356 * getObject with a map in fairly sensible way
7357 */
7358 if (map == null) {
7359 obj = data.getObject(i);
7360 } else {
7361 obj = data.getObject(i, map);
7362 }
7363 /*
7364 * the following block checks for the various
7365 * types that we have to serialize in order to
7366 * store - right now only structs have been tested
7367 */
7368 if (obj instanceof Struct) {
7369 obj = new SerialStruct((Struct)obj, map);
7370 } else if (obj instanceof SQLData) {
7371 obj = new SerialStruct((SQLData)obj, map);
7372 } else if (obj instanceof Blob) {
7373 obj = new SerialBlob((Blob)obj);
7374 } else if (obj instanceof Clob) {
7375 obj = new SerialClob((Clob)obj);
7376 } else if (obj instanceof java.sql.Array) {
7377 obj = new SerialArray((java.sql.Array)obj, map);
7378 }
7379
7380 currentRow.initColumnObject(i, obj);
7381 }
7382 rowsFetched++;
7383 maxRowsreached++;
7384 rvh.add(currentRow);
7385 }
7386 numRows = rowsFetched ;
7387 // Also rowsFetched should be equal to rvh.size()
7388 // notify any listeners that the rowset has changed
7389 notifyRowSetChanged();
7390
7391 }
7392
7393 /**
7394 * The nextPage gets the next page, that is a <code>CachedRowSetImpl</code> object
7395 * containing the number of rows specified by page size.
7396 * @return boolean value true indicating whether there are more pages to come and
7397 * false indicating that this is the last page.
7398 * @throws SQLException if an error occurs or this called before calling populate.
7399 */
7400 public boolean nextPage() throws SQLException {
7401
7402 if (populatecallcount == 0){
7403 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nextpage").toString());
7404 }
7405 // Fix for 6554186
7406 onFirstPage = false;
7407 if(callWithCon){
7408 crsReader.setStartPosition(endPos);
7409 crsReader.readData((RowSetInternal)this);
7410 resultSet = null;
7411 }
7412 else {
7413 populate(resultSet,endPos);
7414 }
7415 return pagenotend;
7416 }
7417
7418 /**
7419 * This is the setter function for setting the size of the page, which specifies
7420 * how many rows have to be retrived at a time.
7421 *
7422 * @param size which is the page size
7423 * @throws SQLException if size is less than zero or greater than max rows.
7424 */
7425 public void setPageSize (int size) throws SQLException {
7426 if (size < 0) {
7427 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.pagesize").toString());
7428 }
7429 if (size > getMaxRows() && getMaxRows() != 0) {
7430 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.pagesize1").toString());
7431 }
7432 pageSize = size;
7433 }
7434
7435 /**
7436 * This is the getter function for the size of the page.
7437 *
7438 * @return an integer that is the page size.
7439 */
7440 public int getPageSize() {
7441 return pageSize;
7442 }
7443
7444
7445 /**
7446 * Retrieves the data present in the page prior to the page from where it is
7447 * called.
7448 * @return boolean value true if it retrieves the previous page, flase if it
7449 * is on the first page.
7450 * @throws SQLException if it is called before populate is called or ResultSet
7451 * is of type <code>ResultSet.TYPE_FORWARD_ONLY</code> or if an error
7452 * occurs.
7453 */
7454 public boolean previousPage() throws SQLException {
7455 int pS;
7456 int mR;
7457 int rem;
7458
7459 pS = getPageSize();
7460 mR = maxRowsreached;
7461
7462 if (populatecallcount == 0){
7463 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nextpage").toString());
7464 }
7465
7466 if( !callWithCon){
7467 if(resultSet.getType() == ResultSet.TYPE_FORWARD_ONLY){
7468 throw new SQLException (resBundle.handleGetObject("cachedrowsetimpl.fwdonly").toString());
7469 }
7470 }
7471
7472 pagenotend = true;
7473
7474 if(startPrev < startPos ){
7475 onFirstPage = true;
7476 return false;
7477 }
7478
7479 if(onFirstPage){
7480 return false;
7481 }
7482
7483 rem = mR % pS;
7484
7485 if(rem == 0){
7486 maxRowsreached -= (2 * pS);
7487 if(callWithCon){
7488 crsReader.setStartPosition(startPrev);
7489 crsReader.readData((RowSetInternal)this);
7490 resultSet = null;
7491 }
7492 else {
7493 populate(resultSet,startPrev);
7494 }
7495 return true;
7496 }
7497 else
7498 {
7499 maxRowsreached -= (pS + rem);
7500 if(callWithCon){
7501 crsReader.setStartPosition(startPrev);
7502 crsReader.readData((RowSetInternal)this);
7503 resultSet = null;
7504 }
7505 else {
7506 populate(resultSet,startPrev);
7507 }
7508 return true;
7509 }
7510 }
7511
7512 /**
7513 * Goes to the page number passed as the parameter
7514 * @param page , the page loaded on a call to this function
7515 * @return true if the page exists false otherwise
7516 * @throws SQLException if an error occurs
7517 */
7518 /*
7519 public boolean absolutePage(int page) throws SQLException{
7520
7521 boolean isAbs = true, retVal = true;
7522 int counter;
7523
7524 if( page <= 0 ){
7525 throw new SQLException("Absolute positoin is invalid");
7526 }
7527 counter = 0;
7528
7529 firstPage();
7530 counter++;
7531 while((counter < page) && isAbs) {
7532 isAbs = nextPage();
7533 counter ++;
7534 }
7535
7536 if( !isAbs && counter < page){
7537 retVal = false;
7538 }
7539 else if(counter == page){
7540 retVal = true;
7541 }
7542
7543 return retVal;
7544 }
7545 */
7546
7547
7548 /**
7549 * Goes to the page number passed as the parameter from the current page.
7550 * The parameter can take postive or negative value accordingly.
7551 * @param page , the page loaded on a call to this function
7552 * @return true if the page exists false otherwise
7553 * @throws SQLException if an error occurs
7554 */
7555 /*
7556 public boolean relativePage(int page) throws SQLException {
7557
7558 boolean isRel = true,retVal = true;
7559 int counter;
7560
7561 if(page > 0){
7562 counter = 0;
7563 while((counter < page) && isRel){
7564 isRel = nextPage();
7565 counter++;
7566 }
7567
7568 if(!isRel && counter < page){
7569 retVal = false;
7570 }
7571 else if( counter == page){
7572 retVal = true;
7573 }
7574 return retVal;
7575 }
7576 else {
7577 counter = page;
7578 isRel = true;
7579 while((counter < 0) && isRel){
7580 isRel = previousPage();
7581 counter++;
7582 }
7583
7584 if( !isRel && counter < 0){
7585 retVal = false;
7586 }
7587 else if(counter == 0){
7588 retVal = true;
7589 }
7590 return retVal;
7591 }
7592 }
7593 */
7594
7595 /**
7596 * Retrieves the first page of data as specified by the page size.
7597 * @return boolean value true if present on first page, false otherwise
7598 * @throws SQLException if it called before populate or ResultSet is of
7599 * type <code>ResultSet.TYPE_FORWARD_ONLY</code> or an error occurs
7600 */
7601 /*
7602 public boolean firstPage() throws SQLException {
7603 if (populatecallcount == 0){
7604 throw new SQLException("Populate the data before calling ");
7605 }
7606 if( !callWithCon){
7607 if(resultSet.getType() == ResultSet.TYPE_FORWARD_ONLY) {
7608 throw new SQLException("Result of type forward only");
7609 }
7610 }
7611 endPos = 0;
7612 maxRowsreached = 0;
7613 pagenotend = true;
7614 if(callWithCon){
7615 crsReader.setStartPosition(startPos);
7616 crsReader.readData((RowSetInternal)this);
7617 resultSet = null;
7618 }
7619 else {
7620 populate(resultSet,startPos);
7621 }
7622 onFirstPage = true;
7623 return onFirstPage;
7624 }
7625 */
7626
7627 /**
7628 * Retrives the last page of data as specified by the page size.
7629 * @return boolean value tur if present on the last page, false otherwise
7630 * @throws SQLException if called before populate or if an error occurs.
7631 */
7632 /*
7633 public boolean lastPage() throws SQLException{
7634 int pS;
7635 int mR;
7636 int quo;
7637 int rem;
7638
7639 pS = getPageSize();
7640 mR = getMaxRows();
7641
7642 if(pS == 0){
7643 onLastPage = true;
7644 return onLastPage;
7645 }
7646
7647 if(getMaxRows() == 0){
7648 mR = totalRows;
7649 }
7650
7651 if (populatecallcount == 0){
7652 throw new SQLException("Populate the data before calling ");
7653 }
7654
7655 onFirstPage = false;
7656
7657 if((mR % pS) == 0){
7658 quo = mR / pS;
7659 int start = startPos + (pS * (quo - 1));
7660 maxRowsreached = mR - pS;
7661 if(callWithCon){
7662 crsReader.setStartPosition(start);
7663 crsReader.readData((RowSetInternal)this);
7664 resultSet = null;
7665 }
7666 else {
7667 populate(resultSet,start);
7668 }
7669 onLastPage = true;
7670 return onLastPage;
7671 }
7672 else {
7673 quo = mR /pS;
7674 rem = mR % pS;
7675 int start = startPos + (pS * quo);
7676 maxRowsreached = mR - (rem);
7677 if(callWithCon){
7678 crsReader.setStartPosition(start);
7679 crsReader.readData((RowSetInternal)this);
7680 resultSet = null;
7681 }
7682 else {
7683 populate(resultSet,start);
7684 }
7685 onLastPage = true;
7686 return onLastPage;
7687 }
7688 }
7689 */
7690
7691 /**
7692 * Sets the status for the row on which the cursor is positioned. The insertFlag is used
7693 * to mention the toggle status for this row
7694 * @param insertFlag if it is true - marks this row as inserted
7695 * if it is false - marks it as not a newly inserted row
7696 * @throws SQLException if an error occurs while doing this operation
7697 */
7698 public void setRowInserted(boolean insertFlag) throws SQLException {
7699
7700 checkCursor();
7701
7702 if(onInsertRow == true)
7703 throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString());
7704
7705 if( insertFlag ) {
7706 ((Row)getCurrentRow()).setInserted();
7707 } else {
7708 ((Row)getCurrentRow()).clearInserted();
7709 }
7710 }
7711
7712 /**
7713 * Retrieves the value of the designated <code>SQL XML</code> parameter as a
7714 * <code>SQLXML</code> object in the Java programming language.
7715 * @param columnIndex the first column is 1, the second is 2, ...
7716 * @return a SQLXML object that maps an SQL XML value
7717 * @throws SQLException if a database access error occurs
7718 * @since 1.6
7719 */
7720 public SQLXML getSQLXML(int columnIndex) throws SQLException {
7721 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7722 }
7723
7724 /**
7725 * Retrieves the value of the designated <code>SQL XML</code> parameter as a
7726 * <code>SQLXML</code> object in the Java programming language.
7727 * @param colName the name of the column from which to retrieve the value
7728 * @return a SQLXML object that maps an SQL XML value
7729 * @throws SQLException if a database access error occurs
7730 */
7731 public SQLXML getSQLXML(String colName) throws SQLException {
7732 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7733 }
7734
7735 /**
7736 * Retrieves the value of the designated column in the current row of this
7737 * <code>ResultSet</code> object as a java.sql.RowId object in the Java
7738 * programming language.
7739 *
7740 * @param columnIndex the first column is 1, the second 2, ...
7741 * @return the column value if the value is a SQL <code>NULL</code> the
7742 * value returned is <code>null</code>
7743 * @throws SQLException if a database access error occurs
7744 * @since 1.6
7745 */
7746 public RowId getRowId(int columnIndex) throws SQLException {
7747 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7748 }
7749
7750 /**
7751 * Retrieves the value of the designated column in the current row of this
7752 * <code>ResultSet</code> object as a java.sql.RowId object in the Java
7753 * programming language.
7754 *
7755 * @param columnName the name of the column
7756 * @return the column value if the value is a SQL <code>NULL</code> the
7757 * value returned is <code>null</code>
7758 * @throws SQLException if a database access error occurs
7759 * @since 1.6
7760 */
7761 public RowId getRowId(String columnName) throws SQLException {
7762 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7763 }
7764
7765 /**
7766 * Updates the designated column with a <code>RowId</code> value. The updater
7767 * methods are used to update column values in the current row or the insert
7768 * row. The updater methods do not update the underlying database; instead
7769 * the {@code updateRow} or {@code insertRow} methods are called
7770 * to update the database.
7771 *
7772 * @param columnIndex the first column is 1, the second 2, ...
7773 * @param x the column value
7774 * @throws SQLException if a database access occurs
7775 * @since 1.6
7776 */
7777 public void updateRowId(int columnIndex, RowId x) throws SQLException {
7778 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7779 }
7780
7781 /**
7782 * Updates the designated column with a <code>RowId</code> value. The updater
7783 * methods are used to update column values in the current row or the insert
7784 * row. The updater methods do not update the underlying database; instead
7785 * the {@code updateRow} or {@code insertRow} methods are called
7786 * to update the database.
7787 *
7788 * @param columnName the name of the column
7789 * @param x the column value
7790 * @throws SQLException if a database access occurs
7791 * @since 1.6
7792 */
7793 public void updateRowId(String columnName, RowId x) throws SQLException {
7794 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7795 }
7796
7797 /**
7798 * Retrieves the holdability of this ResultSet object
7799 * @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
7800 * @throws SQLException if a database error occurs
7801 * @since 1.6
7802 */
7803 public int getHoldability() throws SQLException {
7804 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7805 }
7806
7807 /**
7808 * Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the
7809 * method close has been called on it, or if it is automatically closed.
7810 * @return true if this ResultSet object is closed; false if it is still open
7811 * @throws SQLException if a database access error occurs
7812 * @since 1.6
7813 */
7814 public boolean isClosed() throws SQLException {
7815 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7816 }
7817
7818 /**
7819 * This method is used for updating columns that support National Character sets.
7820 * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
7821 * @param columnIndex the first column is 1, the second 2, ...
7822 * @param nString the value for the column to be updated
7823 * @throws SQLException if a database access error occurs
7824 * @since 1.6
7825 */
7826 public void updateNString(int columnIndex, String nString) throws SQLException {
7827 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7828 }
7829
7830 /**
7831 * This method is used for updating columns that support National Character sets.
7832 * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
7833 * @param columnName name of the Column
7834 * @param nString the value for the column to be updated
7835 * @throws SQLException if a database access error occurs
7836 * @since 1.6
7837 */
7838 public void updateNString(String columnName, String nString) throws SQLException {
7839 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7840 }
7841
7842
7843 /*o
7844 * This method is used for updating SQL <code>NCLOB</code> type that maps
7845 * to <code>java.sql.Types.NCLOB</code>
7846 * @param columnIndex the first column is 1, the second 2, ...
7847 * @param nClob the value for the column to be updated
7848 * @throws SQLException if a database access error occurs
7849 * @since 1.6
7850 */
7851 public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
7852 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7853 }
7854
7855 /**
7856 * This method is used for updating SQL <code>NCLOB</code> type that maps
7857 * to <code>java.sql.Types.NCLOB</code>
7858 * @param columnName name of the column
7859 * @param nClob the value for the column to be updated
7860 * @throws SQLException if a database access error occurs
7861 * @since 1.6
7862 */
7863 public void updateNClob(String columnName, NClob nClob) throws SQLException {
7864 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7865 }
7866
7867 /**
7868 * Retrieves the value of the designated column in the current row
7869 * of this <code>ResultSet</code> object as a <code>NClob</code> object
7870 * in the Java programming language.
7871 *
7872 * @param i the first column is 1, the second is 2, ...
7873 * @return a <code>NClob</code> object representing the SQL
7874 * <code>NCLOB</code> value in the specified column
7875 * @exception SQLException if a database access error occurs
7876 * @since 1.6
7877 */
7878 public NClob getNClob(int i) throws SQLException {
7879 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7880 }
7881
7882
7883 /**
7884 * Retrieves the value of the designated column in the current row
7885 * of this <code>ResultSet</code> object as a <code>NClob</code> object
7886 * in the Java programming language.
7887 *
7888 * @param colName the name of the column from which to retrieve the value
7889 * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
7890 * value in the specified column
7891 * @exception SQLException if a database access error occurs
7892 * @since 1.6
7893 */
7894 public NClob getNClob(String colName) throws SQLException {
7895 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7896 }
7897
7898 public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException {
7899 return null;
7900 }
7901
7902 public boolean isWrapperFor(Class<?> interfaces) throws SQLException {
7903 return false;
7904 }
7905
7906
7907 /**
7908 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
7909 * SQL <code>XML</code> value when it sends it to the database.
7910 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
7911 * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
7912 * @throws SQLException if a database access error occurs
7913 * @since 1.6
7914 */
7915 public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
7916 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7917 }
7918
7919 /**
7920 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
7921 * <code>SQL XML</code> value when it sends it to the database.
7922 * @param parameterName the name of the parameter
7923 * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
7924 * @throws SQLException if a database access error occurs
7925 * @since 1.6
7926 */
7927 public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
7928 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7929 }
7930
7931
7932 /**
7933 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
7934 * driver converts this to a SQL <code>ROWID</code> value when it sends it
7935 * to the database
7936 *
7937 * @param parameterIndex the first parameter is 1, the second is 2, ...
7938 * @param x the parameter value
7939 * @throws SQLException if a database access error occurs
7940 *
7941 * @since 1.6
7942 */
7943 public void setRowId(int parameterIndex, RowId x) throws SQLException {
7944 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7945 }
7946
7947
7948 /**
7949 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
7950 * driver converts this to a SQL <code>ROWID</code> when it sends it to the
7951 * database.
7952 *
7953 * @param parameterName the name of the parameter
7954 * @param x the parameter value
7955 * @throws SQLException if a database access error occurs
7956 * @since 1.6
7957 */
7958 public void setRowId(String parameterName, RowId x) throws SQLException {
7959 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
7960 }
7961
7962
7963 /**
7964 * Sets the designated parameter to a <code>Reader</code> object. The
7965 * <code>Reader</code> reads the data till end-of-file is reached. The
7966 * driver does the necessary conversion from Java character format to
7967 * the national character set in the database.
7968
7969 * <P><B>Note:</B> This stream object can either be a standard
7970 * Java stream object or your own subclass that implements the
7971 * standard interface.
7972 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
7973 * it might be more efficient to use a version of
7974 * <code>setNCharacterStream</code> which takes a length parameter.
7975 *
7976 * @param parameterIndex of the first parameter is 1, the second is 2, ...
7977 * @param value the parameter value
7978 * @throws SQLException if the driver does not support national
7979 * character sets; if the driver can detect that a data conversion
7980 * error could occur ; if a database access error occurs; or
7981 * this method is called on a closed <code>PreparedStatement</code>
7982 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
7983 * @since 1.6
7984 */
7985 public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
7986 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
7987 }
7988
7989
7990 /**
7991 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
7992 * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
7993 * object maps to a SQL <code>NCLOB</code>.
7994 * @param parameterName the name of the column to be set
7995 * @param value the parameter value
7996 * @throws SQLException if the driver does not support national
7997 * character sets; if the driver can detect that a data conversion
7998 * error could occur; or if a database access error occurs
7999 * @since 1.6
8000 */
8001 public void setNClob(String parameterName, NClob value) throws SQLException {
8002 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8003 }
8004
8005
8006 /**
8007 * Retrieves the value of the designated column in the current row
8008 * of this <code>ResultSet</code> object as a
8009 * <code>java.io.Reader</code> object.
8010 * It is intended for use when
8011 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
8012 * and <code>LONGNVARCHAR</code> columns.
8013 *
8014 * @return a <code>java.io.Reader</code> object that contains the column
8015 * value; if the value is SQL <code>NULL</code>, the value returned is
8016 * <code>null</code> in the Java programming language.
8017 * @param columnIndex the first column is 1, the second is 2, ...
8018 * @exception SQLException if a database access error occurs
8019 * @since 1.6
8020 */
8021 public java.io.Reader getNCharacterStream(int columnIndex) throws SQLException {
8022 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8023 }
8024
8025
8026 /**
8027 * Retrieves the value of the designated column in the current row
8028 * of this <code>ResultSet</code> object as a
8029 * <code>java.io.Reader</code> object.
8030 * It is intended for use when
8031 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
8032 * and <code>LONGNVARCHAR</code> columns.
8033 *
8034 * @param columnName the name of the column
8035 * @return a <code>java.io.Reader</code> object that contains the column
8036 * value; if the value is SQL <code>NULL</code>, the value returned is
8037 * <code>null</code> in the Java programming language
8038 * @exception SQLException if a database access error occurs
8039 * @since 1.6
8040 */
8041 public java.io.Reader getNCharacterStream(String columnName) throws SQLException {
8042 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8043 }
8044
8045
8046 /**
8047 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
8048 * The updater
8049 * methods are used to update column values in the current row or the insert
8050 * row. The updater methods do not update the underlying database; instead
8051 * the <code>updateRow</code> or <code>insertRow</code> methods are called
8052 * to update the database.
8053 * @param columnIndex the first column is 1, the second 2, ...
8054 * @param xmlObject the value for the column to be updated
8055 * @throws SQLException if a database access error occurs
8056 * @since 1.6
8057 */
8058 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
8059 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8060 }
8061
8062 /**
8063 * Updates the designated column with a <code>java.sql.SQLXML</code> value.
8064 * The updater
8065 * methods are used to update column values in the current row or the insert
8066 * row. The updater methods do not update the underlying database; instead
8067 * the <code>updateRow</code> or <code>insertRow</code> methods are called
8068 * to update the database.
8069 *
8070 * @param columnName the name of the column
8071 * @param xmlObject the column value
8072 * @throws SQLException if a database access occurs
8073 * @since 1.6
8074 */
8075 public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException {
8076 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8077 }
8078
8079 /**
8080 * Retrieves the value of the designated column in the current row
8081 * of this <code>ResultSet</code> object as
8082 * a <code>String</code> in the Java programming language.
8083 * It is intended for use when
8084 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
8085 * and <code>LONGNVARCHAR</code> columns.
8086 *
8087 * @param columnIndex the first column is 1, the second is 2, ...
8088 * @return the column value; if the value is SQL <code>NULL</code>, the
8089 * value returned is <code>null</code>
8090 * @exception SQLException if a database access error occurs
8091 * @since 1.6
8092 */
8093 public String getNString(int columnIndex) throws SQLException {
8094 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8095 }
8096
8097 /**
8098 * Retrieves the value of the designated column in the current row
8099 * of this <code>ResultSet</code> object as
8100 * a <code>String</code> in the Java programming language.
8101 * It is intended for use when
8102 * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
8103 * and <code>LONGNVARCHAR</code> columns.
8104 *
8105 * @param columnName the SQL name of the column
8106 * @return the column value; if the value is SQL <code>NULL</code>, the
8107 * value returned is <code>null</code>
8108 * @exception SQLException if a database access error occurs
8109 * @since 1.6
8110 */
8111 public String getNString(String columnName) throws SQLException {
8112 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8113 }
8114
8115 /**
8116 * Updates the designated column with a character stream value, which will
8117 * have the specified number of bytes. The driver does the necessary conversion
8118 * from Java character format to the national character set in the database.
8119 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
8120 * The updater methods are used to update column values in the current row or
8121 * the insert row. The updater methods do not update the underlying database;
8122 * instead the updateRow or insertRow methods are called to update the database.
8123 *
8124 * @param columnIndex - the first column is 1, the second is 2, ...
8125 * @param x - the new column value
8126 * @param length - the length of the stream
8127 * @exception SQLException if a database access error occurs
8128 * @since 1.6
8129 */
8130 public void updateNCharacterStream(int columnIndex,
8131 java.io.Reader x,
8132 long length)
8133 throws SQLException {
8134 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8135 }
8136
8137 /**
8138 * Updates the designated column with a character stream value, which will
8139 * have the specified number of bytes. The driver does the necessary conversion
8140 * from Java character format to the national character set in the database.
8141 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
8142 * The updater methods are used to update column values in the current row or
8143 * the insert row. The updater methods do not update the underlying database;
8144 * instead the updateRow or insertRow methods are called to update the database.
8145 *
8146 * @param columnName - name of the Column
8147 * @param x - the new column value
8148 * @param length - the length of the stream
8149 * @exception SQLException if a database access error occurs
8150 * @since 1.6
8151 */
8152 public void updateNCharacterStream(String columnName,
8153 java.io.Reader x,
8154 long length)
8155 throws SQLException {
8156 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString());
8157 }
8158
8159 /**
8160 * Updates the designated column with a character stream value. The
8161 * driver does the necessary conversion from Java character format to
8162 * the national character set in the database.
8163 * It is intended for use when
8164 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
8165 * and <code>LONGNVARCHAR</code> columns.
8166 *
8167 * The updater methods are used to update column values in the
8168 * current row or the insert row. The updater methods do not
8169 * update the underlying database; instead the <code>updateRow</code> or
8170 * <code>insertRow</code> methods are called to update the database.
8171 *
8172 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8173 * it might be more efficient to use a version of
8174 * <code>updateNCharacterStream</code> which takes a length parameter.
8175 *
8176 * @param columnIndex the first column is 1, the second is 2, ...
8177 * @param x the new column value
8178 * @exception SQLException if a database access error occurs,
8179 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
8180 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8181 * this method
8182 * @since 1.6
8183 */
8184 public void updateNCharacterStream(int columnIndex,
8185 java.io.Reader x) throws SQLException {
8186 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8187 }
8188
8189 /**
8190 * Updates the designated column with a character stream value. The
8191 * driver does the necessary conversion from Java character format to
8192 * the national character set in the database.
8193 * It is intended for use when
8194 * updating <code>NCHAR</code>,<code>NVARCHAR</code>
8195 * and <code>LONGNVARCHAR</code> columns.
8196 *
8197 * The updater methods are used to update column values in the
8198 * current row or the insert row. The updater methods do not
8199 * update the underlying database; instead the <code>updateRow</code> or
8200 * <code>insertRow</code> methods are called to update the database.
8201 *
8202 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8203 * it might be more efficient to use a version of
8204 * <code>updateNCharacterStream</code> which takes a length parameter.
8205 *
8206 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8207 bel is the name of the column
8208 * @param reader the <code>java.io.Reader</code> object containing
8209 * the new column value
8210 * @exception SQLException if a database access error occurs,
8211 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
8212 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8213 * this method
8214 * @since 1.6
8215 */
8216 public void updateNCharacterStream(String columnLabel,
8217 java.io.Reader reader) throws SQLException {
8218 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8219 }
8220
8221 //////////////////////////
8222
8223 /**
8224 * Updates the designated column using the given input stream, which
8225 * will have the specified number of bytes.
8226 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
8227 * parameter, it may be more practical to send it via a
8228 * <code>java.io.InputStream</code>. Data will be read from the stream
8229 * as needed until end-of-file is reached. The JDBC driver will
8230 * do any necessary conversion from ASCII to the database char format.
8231 *
8232 * <P><B>Note:</B> This stream object can either be a standard
8233 * Java stream object or your own subclass that implements the
8234 * standard interface.
8235 * <p>
8236 * The updater methods are used to update column values in the
8237 * current row or the insert row. The updater methods do not
8238 * update the underlying database; instead the <code>updateRow</code> or
8239 * <code>insertRow</code> methods are called to update the database.
8240 *
8241 * @param columnIndex the first column is 1, the second is 2, ...
8242 * @param inputStream An object that contains the data to set the parameter
8243 * value to.
8244 * @param length the number of bytes in the parameter data.
8245 * @exception SQLException if a database access error occurs,
8246 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8247 * or this method is called on a closed result set
8248 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8249 * this method
8250 * @since 1.6
8251 */
8252 public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException{
8253 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8254 }
8255
8256 /**
8257 * Updates the designated column using the given input stream, which
8258 * will have the specified number of bytes.
8259 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
8260 * parameter, it may be more practical to send it via a
8261 * <code>java.io.InputStream</code>. Data will be read from the stream
8262 * as needed until end-of-file is reached. The JDBC driver will
8263 * do any necessary conversion from ASCII to the database char format.
8264 *
8265 * <P><B>Note:</B> This stream object can either be a standard
8266 * Java stream object or your own subclass that implements the
8267 * standard interface.
8268 * <p>
8269 * The updater methods are used to update column values in the
8270 * current row or the insert row. The updater methods do not
8271 * update the underlying database; instead the <code>updateRow</code> or
8272 * <code>insertRow</code> methods are called to update the database.
8273 *
8274 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
8275 * @param inputStream An object that contains the data to set the parameter
8276 * value to.
8277 * @param length the number of bytes in the parameter data.
8278 * @exception SQLException if a database access error occurs,
8279 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8280 * or this method is called on a closed result set
8281 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8282 * this method
8283 * @since 1.6
8284 */
8285 public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
8286 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8287 }
8288
8289 /**
8290 * Updates the designated column using the given input stream.
8291 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
8292 * parameter, it may be more practical to send it via a
8293 * <code>java.io.InputStream</code>. Data will be read from the stream
8294 * as needed until end-of-file is reached. The JDBC driver will
8295 * do any necessary conversion from ASCII to the database char format.
8296 *
8297 * <P><B>Note:</B> This stream object can either be a standard
8298 * Java stream object or your own subclass that implements the
8299 * standard interface.
8300 *
8301 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8302 * it might be more efficient to use a version of
8303 * <code>updateBlob</code> which takes a length parameter.
8304 * <p>
8305 * The updater methods are used to update column values in the
8306 * current row or the insert row. The updater methods do not
8307 * update the underlying database; instead the <code>updateRow</code> or
8308 * <code>insertRow</code> methods are called to update the database.
8309 *
8310 * @param columnIndex the first column is 1, the second is 2, ...
8311 * @param inputStream An object that contains the data to set the parameter
8312 * value to.
8313 * @exception SQLException if a database access error occurs,
8314 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8315 * or this method is called on a closed result set
8316 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8317 * this method
8318 * @since 1.6
8319 */
8320 public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
8321 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8322 }
8323
8324 /**
8325 * Updates the designated column using the given input stream.
8326 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
8327 * parameter, it may be more practical to send it via a
8328 * <code>java.io.InputStream</code>. Data will be read from the stream
8329 * as needed until end-of-file is reached. The JDBC driver will
8330 * do any necessary conversion from ASCII to the database char format.
8331 *
8332 * <P><B>Note:</B> This stream object can either be a standard
8333 * Java stream object or your own subclass that implements the
8334 * standard interface.
8335 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8336 * it might be more efficient to use a version of
8337 * <code>updateBlob</code> which takes a length parameter.
8338 * <p>
8339 * The updater methods are used to update column values in the
8340 * current row or the insert row. The updater methods do not
8341 * update the underlying database; instead the <code>updateRow</code> or
8342 * <code>insertRow</code> methods are called to update the database.
8343 *
8344 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8345 bel is the name of the column
8346 * @param inputStream An object that contains the data to set the parameter
8347 * value to.
8348 * @exception SQLException if a database access error occurs,
8349 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8350 * or this method is called on a closed result set
8351 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8352 * this method
8353 * @since 1.6
8354 */
8355 public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
8356 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8357 }
8358
8359 /**
8360 * Updates the designated column using the given <code>Reader</code>
8361 * object, which is the given number of characters long.
8362 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8363 * parameter, it may be more practical to send it via a
8364 * <code>java.io.Reader</code> object. The data will be read from the stream
8365 * as needed until end-of-file is reached. The JDBC driver will
8366 * do any necessary conversion from UNICODE to the database char format.
8367 *
8368 * <P><B>Note:</B> This stream object can either be a standard
8369 * Java stream object or your own subclass that implements the
8370 * standard interface.
8371 * <p>
8372 * The updater methods are used to update column values in the
8373 * current row or the insert row. The updater methods do not
8374 * update the underlying database; instead the <code>updateRow</code> or
8375 * <code>insertRow</code> methods are called to update the database.
8376 *
8377 * @param columnIndex the first column is 1, the second is 2, ...
8378 * @param reader An object that contains the data to set the parameter value to.
8379 * @param length the number of characters in the parameter data.
8380 * @exception SQLException if a database access error occurs,
8381 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8382 * or this method is called on a closed result set
8383 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8384 * this method
8385 * @since 1.6
8386 */
8387 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
8388 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8389 }
8390
8391 /**
8392 * Updates the designated column using the given <code>Reader</code>
8393 * object, which is the given number of characters long.
8394 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8395 * parameter, it may be more practical to send it via a
8396 * <code>java.io.Reader</code> object. The data will be read from the stream
8397 * as needed until end-of-file is reached. The JDBC driver will
8398 * do any necessary conversion from UNICODE to the database char format.
8399 *
8400 * <P><B>Note:</B> This stream object can either be a standard
8401 * Java stream object or your own subclass that implements the
8402 * standard interface.
8403 * <p>
8404 * The updater methods are used to update column values in the
8405 * current row or the insert row. The updater methods do not
8406 * update the underlying database; instead the <code>updateRow</code> or
8407 * <code>insertRow</code> methods are called to update the database.
8408 *
8409 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
8410 * @param reader An object that contains the data to set the parameter value to.
8411 * @param length the number of characters in the parameter data.
8412 * @exception SQLException if a database access error occurs,
8413 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8414 * or this method is called on a closed result set
8415 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8416 * this method
8417 * @since 1.6
8418 */
8419 public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
8420 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8421 }
8422
8423 /**
8424 * Updates the designated column using the given <code>Reader</code>
8425 * object.
8426 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8427 * parameter, it may be more practical to send it via a
8428 * <code>java.io.Reader</code> object. The data will be read from the stream
8429 * as needed until end-of-file is reached. The JDBC driver will
8430 * do any necessary conversion from UNICODE to the database char format.
8431 *
8432 * <P><B>Note:</B> This stream object can either be a standard
8433 * Java stream object or your own subclass that implements the
8434 * standard interface.
8435 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8436 * it might be more efficient to use a version of
8437 * <code>updateClob</code> which takes a length parameter.
8438 * <p>
8439 * The updater methods are used to update column values in the
8440 * current row or the insert row. The updater methods do not
8441 * update the underlying database; instead the <code>updateRow</code> or
8442 * <code>insertRow</code> methods are called to update the database.
8443 *
8444 * @param columnIndex the first column is 1, the second is 2, ...
8445 * @param reader An object that contains the data to set the parameter value to.
8446 * @exception SQLException if a database access error occurs,
8447 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8448 * or this method is called on a closed result set
8449 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8450 * this method
8451 * @since 1.6
8452 */
8453 public void updateClob(int columnIndex, Reader reader) throws SQLException {
8454 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8455 }
8456
8457 /**
8458 * Updates the designated column using the given <code>Reader</code>
8459 * object.
8460 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8461 * parameter, it may be more practical to send it via a
8462 * <code>java.io.Reader</code> object. The data will be read from the stream
8463 * as needed until end-of-file is reached. The JDBC driver will
8464 * do any necessary conversion from UNICODE to the database char format.
8465 *
8466 * <P><B>Note:</B> This stream object can either be a standard
8467 * Java stream object or your own subclass that implements the
8468 * standard interface.
8469 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8470 * it might be more efficient to use a version of
8471 * <code>updateClob</code> which takes a length parameter.
8472 * <p>
8473 * The updater methods are used to update column values in the
8474 * current row or the insert row. The updater methods do not
8475 * update the underlying database; instead the <code>updateRow</code> or
8476 * <code>insertRow</code> methods are called to update the database.
8477 *
8478 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8479 bel is the name of the column
8480 * @param reader An object that contains the data to set the parameter value to.
8481 * @exception SQLException if a database access error occurs,
8482 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8483 * or this method is called on a closed result set
8484 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8485 * this method
8486 * @since 1.6
8487 */
8488 public void updateClob(String columnLabel, Reader reader) throws SQLException {
8489 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8490 }
8491
8492 /**
8493 * Updates the designated column using the given <code>Reader</code>
8494 * object, which is the given number of characters long.
8495 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8496 * parameter, it may be more practical to send it via a
8497 * <code>java.io.Reader</code> object. The data will be read from the stream
8498 * as needed until end-of-file is reached. The JDBC driver will
8499 * do any necessary conversion from UNICODE to the database char format.
8500 *
8501 * <P><B>Note:</B> This stream object can either be a standard
8502 * Java stream object or your own subclass that implements the
8503 * standard interface.
8504 * <p>
8505 * The updater methods are used to update column values in the
8506 * current row or the insert row. The updater methods do not
8507 * update the underlying database; instead the <code>updateRow</code> or
8508 * <code>insertRow</code> methods are called to update the database.
8509 *
8510 * @param columnIndex the first column is 1, the second 2, ...
8511 * @param reader An object that contains the data to set the parameter value to.
8512 * @param length the number of characters in the parameter data.
8513 * @throws SQLException if the driver does not support national
8514 * character sets; if the driver can detect that a data conversion
8515 * error could occur; this method is called on a closed result set,
8516 * if a database access error occurs or
8517 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8518 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8519 * this method
8520 * @since 1.6
8521 */
8522 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
8523 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8524 }
8525
8526 /**
8527 * Updates the designated column using the given <code>Reader</code>
8528 * object, which is the given number of characters long.
8529 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8530 * parameter, it may be more practical to send it via a
8531 * <code>java.io.Reader</code> object. The data will be read from the stream
8532 * as needed until end-of-file is reached. The JDBC driver will
8533 * do any necessary conversion from UNICODE to the database char format.
8534 *
8535 * <P><B>Note:</B> This stream object can either be a standard
8536 * Java stream object or your own subclass that implements the
8537 * standard interface.
8538 * <p>
8539 * The updater methods are used to update column values in the
8540 * current row or the insert row. The updater methods do not
8541 * update the underlying database; instead the <code>updateRow</code> or
8542 * <code>insertRow</code> methods are called to update the database.
8543 *
8544 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
8545 * @param reader An object that contains the data to set the parameter value to.
8546 * @param length the number of characters in the parameter data.
8547 * @throws SQLException if the driver does not support national
8548 * character sets; if the driver can detect that a data conversion
8549 * error could occur; this method is called on a closed result set;
8550 * if a database access error occurs or
8551 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8552 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8553 * this method
8554 * @since 1.6
8555 */
8556 public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
8557 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8558 }
8559
8560 /**
8561 * Updates the designated column using the given <code>Reader</code>
8562 * object.
8563 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8564 * parameter, it may be more practical to send it via a
8565 * <code>java.io.Reader</code> object. The data will be read from the stream
8566 * as needed until end-of-file is reached. The JDBC driver will
8567 * do any necessary conversion from UNICODE to the database char format.
8568 *
8569 * <P><B>Note:</B> This stream object can either be a standard
8570 * Java stream object or your own subclass that implements the
8571 * standard interface.
8572 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8573 * it might be more efficient to use a version of
8574 * <code>updateNClob</code> which takes a length parameter.
8575 * <p>
8576 * The updater methods are used to update column values in the
8577 * current row or the insert row. The updater methods do not
8578 * update the underlying database; instead the <code>updateRow</code> or
8579 * <code>insertRow</code> methods are called to update the database.
8580 *
8581 * @param columnIndex the first column is 1, the second 2, ...
8582 * @param reader An object that contains the data to set the parameter value to.
8583 * @throws SQLException if the driver does not support national
8584 * character sets; if the driver can detect that a data conversion
8585 * error could occur; this method is called on a closed result set,
8586 * if a database access error occurs or
8587 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8588 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8589 * this method
8590 * @since 1.6
8591 */
8592 public void updateNClob(int columnIndex, Reader reader) throws SQLException {
8593 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8594 }
8595
8596 /**
8597 * Updates the designated column using the given <code>Reader</code>
8598 * object.
8599 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
8600 * parameter, it may be more practical to send it via a
8601 * <code>java.io.Reader</code> object. The data will be read from the stream
8602 * as needed until end-of-file is reached. The JDBC driver will
8603 * do any necessary conversion from UNICODE to the database char format.
8604 *
8605 * <P><B>Note:</B> This stream object can either be a standard
8606 * Java stream object or your own subclass that implements the
8607 * standard interface.
8608 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8609 * it might be more efficient to use a version of
8610 * <code>updateNClob</code> which takes a length parameter.
8611 * <p>
8612 * The updater methods are used to update column values in the
8613 * current row or the insert row. The updater methods do not
8614 * update the underlying database; instead the <code>updateRow</code> or
8615 * <code>insertRow</code> methods are called to update the database.
8616 *
8617 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8618 bel is the name of the column
8619 * @param reader An object that contains the data to set the parameter value to.
8620 * @throws SQLException if the driver does not support national
8621 * character sets; if the driver can detect that a data conversion
8622 * error could occur; this method is called on a closed result set;
8623 * if a database access error occurs or
8624 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8625 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8626 * this method
8627 * @since 1.6
8628 */
8629 public void updateNClob(String columnLabel, Reader reader) throws SQLException {
8630 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8631 }
8632
8633 /**
8634 * Updates the designated column with an ascii stream value, which will have
8635 * the specified number of bytes.
8636 * The updater methods are used to update column values in the
8637 * current row or the insert row. The updater methods do not
8638 * update the underlying database; instead the <code>updateRow</code> or
8639 * <code>insertRow</code> methods are called to update the database.
8640 *
8641 * @param columnIndex the first column is 1, the second is 2, ...
8642 * @param x the new column value
8643 * @param length the length of the stream
8644 * @exception SQLException if a database access error occurs,
8645 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8646 * or this method is called on a closed result set
8647 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8648 * this method
8649 * @since 1.6
8650 */
8651 public void updateAsciiStream(int columnIndex,
8652 java.io.InputStream x,
8653 long length) throws SQLException {
8654
8655 }
8656
8657 /**
8658 * Updates the designated column with a binary stream value, which will have
8659 * the specified number of bytes.
8660 * The updater methods are used to update column values in the
8661 * current row or the insert row. The updater methods do not
8662 * update the underlying database; instead the <code>updateRow</code> or
8663 * <code>insertRow</code> methods are called to update the database.
8664 *
8665 * @param columnIndex the first column is 1, the second is 2, ...
8666 * @param x the new column value
8667 * @param length the length of the stream
8668 * @exception SQLException if a database access error occurs,
8669 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8670 * or this method is called on a closed result set
8671 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8672 * this method
8673 * @since 1.6
8674 */
8675 public void updateBinaryStream(int columnIndex,
8676 java.io.InputStream x,
8677 long length) throws SQLException {
8678 }
8679
8680 /**
8681 * Updates the designated column with a character stream value, which will have
8682 * the specified number of bytes.
8683 * The updater methods are used to update column values in the
8684 * current row or the insert row. The updater methods do not
8685 * update the underlying database; instead the <code>updateRow</code> or
8686 * <code>insertRow</code> methods are called to update the database.
8687 *
8688 * @param columnIndex the first column is 1, the second is 2, ...
8689 * @param x the new column value
8690 * @param length the length of the stream
8691 * @exception SQLException if a database access error occurs,
8692 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8693 * or this method is called on a closed result set
8694 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8695 * this method
8696 * @since 1.6
8697 */
8698 public void updateCharacterStream(int columnIndex,
8699 java.io.Reader x,
8700 long length) throws SQLException {
8701 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8702 }
8703
8704 /**
8705 * Updates the designated column with a character stream value, which will have
8706 * the specified number of bytes.
8707 * The updater methods are used to update column values in the
8708 * current row or the insert row. The updater methods do not
8709 * update the underlying database; instead the <code>updateRow</code> or
8710 * <code>insertRow</code> methods are called to update the database.
8711 *
8712 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8713 bel is the name of the column
8714 * @param reader the <code>java.io.Reader</code> object containing
8715 * the new column value
8716 * @param length the length of the stream
8717 * @exception SQLException if a database access error occurs,
8718 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8719 * or this method is called on a closed result set
8720 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8721 * this method
8722 * @since 1.6
8723 */
8724 public void updateCharacterStream(String columnLabel,
8725 java.io.Reader reader,
8726 long length) throws SQLException {
8727 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8728 }
8729 /**
8730 * Updates the designated column with an ascii stream value, which will have
8731 * the specified number of bytes..
8732 * The updater methods are used to update column values in the
8733 * current row or the insert row. The updater methods do not
8734 * update the underlying database; instead the <code>updateRow</code> or
8735 * <code>insertRow</code> methods are called to update the database.
8736 *
8737 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
8738 * @param x the new column value
8739 * @param length the length of the stream
8740 * @exception SQLException if a database access error occurs,
8741 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8742 * or this method is called on a closed result set
8743 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8744 * this method
8745 * @since 1.6
8746 */
8747 public void updateAsciiStream(String columnLabel,
8748 java.io.InputStream x,
8749 long length) throws SQLException {
8750 }
8751
8752 /**
8753 * Updates the designated column with a binary stream value, which will have
8754 * the specified number of bytes.
8755 * The updater methods are used to update column values in the
8756 * current row or the insert row. The updater methods do not
8757 * update the underlying database; instead the <code>updateRow</code> or
8758 * <code>insertRow</code> methods are called to update the database.
8759 *
8760 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
8761 * @param x the new column value
8762 * @param length the length of the stream
8763 * @exception SQLException if a database access error occurs,
8764 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8765 * or this method is called on a closed result set
8766 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8767 * this method
8768 * @since 1.6
8769 */
8770 public void updateBinaryStream(String columnLabel,
8771 java.io.InputStream x,
8772 long length) throws SQLException {
8773 }
8774
8775 /**
8776 * Updates the designated column with a binary stream value.
8777 * The updater methods are used to update column values in the
8778 * current row or the insert row. The updater methods do not
8779 * update the underlying database; instead the <code>updateRow</code> or
8780 * <code>insertRow</code> methods are called to update the database.
8781 *
8782 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8783 * it might be more efficient to use a version of
8784 * <code>updateBinaryStream</code> which takes a length parameter.
8785 *
8786 * @param columnIndex the first column is 1, the second is 2, ...
8787 * @param x the new column value
8788 * @exception SQLException if a database access error occurs,
8789 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8790 * or this method is called on a closed result set
8791 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8792 * this method
8793 * @since 1.6
8794 */
8795 public void updateBinaryStream(int columnIndex,
8796 java.io.InputStream x) throws SQLException {
8797 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8798 }
8799
8800
8801 /**
8802 * Updates the designated column with a binary stream value.
8803 * The updater methods are used to update column values in the
8804 * current row or the insert row. The updater methods do not
8805 * update the underlying database; instead the <code>updateRow</code> or
8806 * <code>insertRow</code> methods are called to update the database.
8807 *
8808 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8809 * it might be more efficient to use a version of
8810 * <code>updateBinaryStream</code> which takes a length parameter.
8811 *
8812 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8813 bel is the name of the column
8814 * @param x the new column value
8815 * @exception SQLException if a database access error occurs,
8816 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8817 * or this method is called on a closed result set
8818 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8819 * this method
8820 * @since 1.6
8821 */
8822 public void updateBinaryStream(String columnLabel,
8823 java.io.InputStream x) throws SQLException {
8824 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8825 }
8826
8827 /**
8828 * Updates the designated column with a character stream value.
8829 * The updater methods are used to update column values in the
8830 * current row or the insert row. The updater methods do not
8831 * update the underlying database; instead the <code>updateRow</code> or
8832 * <code>insertRow</code> methods are called to update the database.
8833 *
8834 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8835 * it might be more efficient to use a version of
8836 * <code>updateCharacterStream</code> which takes a length parameter.
8837 *
8838 * @param columnIndex the first column is 1, the second is 2, ...
8839 * @param x the new column value
8840 * @exception SQLException if a database access error occurs,
8841 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8842 * or this method is called on a closed result set
8843 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8844 * this method
8845 * @since 1.6
8846 */
8847 public void updateCharacterStream(int columnIndex,
8848 java.io.Reader x) throws SQLException {
8849 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8850 }
8851
8852 /**
8853 * Updates the designated column with a character stream value.
8854 * The updater methods are used to update column values in the
8855 * current row or the insert row. The updater methods do not
8856 * update the underlying database; instead the <code>updateRow</code> or
8857 * <code>insertRow</code> methods are called to update the database.
8858 *
8859 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8860 * it might be more efficient to use a version of
8861 * <code>updateCharacterStream</code> which takes a length parameter.
8862 *
8863 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8864 bel is the name of the column
8865 * @param reader the <code>java.io.Reader</code> object containing
8866 * the new column value
8867 * @exception SQLException if a database access error occurs,
8868 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8869 * or this method is called on a closed result set
8870 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8871 * this method
8872 * @since 1.6
8873 */
8874 public void updateCharacterStream(String columnLabel,
8875 java.io.Reader reader) throws SQLException {
8876 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8877 }
8878
8879 /**
8880 * Updates the designated column with an ascii stream value.
8881 * The updater methods are used to update column values in the
8882 * current row or the insert row. The updater methods do not
8883 * update the underlying database; instead the <code>updateRow</code> or
8884 * <code>insertRow</code> methods are called to update the database.
8885 *
8886 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8887 * it might be more efficient to use a version of
8888 * <code>updateAsciiStream</code> which takes a length parameter.
8889 *
8890 * @param columnIndex the first column is 1, the second is 2, ...
8891 * @param x the new column value
8892 * @exception SQLException if a database access error occurs,
8893 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8894 * or this method is called on a closed result set
8895 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8896 * this method
8897 * @since 1.6
8898 */
8899 public void updateAsciiStream(int columnIndex,
8900 java.io.InputStream x) throws SQLException {
8901 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8902 }
8903
8904 /**
8905 * Updates the designated column with an ascii stream value.
8906 * The updater methods are used to update column values in the
8907 * current row or the insert row. The updater methods do not
8908 * update the underlying database; instead the <code>updateRow</code> or
8909 * <code>insertRow</code> methods are called to update the database.
8910 *
8911 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8912 * it might be more efficient to use a version of
8913 * <code>updateAsciiStream</code> which takes a length parameter.
8914 *
8915 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
8916 bel is the name of the column
8917 * @param x the new column value
8918 * @exception SQLException if a database access error occurs,
8919 * the result set concurrency is <code>CONCUR_READ_ONLY</code>
8920 * or this method is called on a closed result set
8921 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8922 * this method
8923 * @since 1.6
8924 */
8925 public void updateAsciiStream(String columnLabel,
8926 java.io.InputStream x) throws SQLException {
8927
8928 }
8929
8930 /**
8931 * Sets the designated parameter to the given <code>java.net.URL</code> value.
8932 * The driver converts this to an SQL <code>DATALINK</code> value
8933 * when it sends it to the database.
8934 *
8935 * @param parameterIndex the first parameter is 1, the second is 2, ...
8936 * @param x the <code>java.net.URL</code> object to be set
8937 * @exception SQLException if a database access error occurs or
8938 * this method is called on a closed <code>PreparedStatement</code>
8939 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
8940 * @since 1.4
8941 */
8942 public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
8943 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8944 }
8945
8946 /**
8947 * Sets the designated parameter to a <code>Reader</code> object.
8948 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
8949 * because it informs the driver that the parameter value should be sent to
8950 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
8951 * driver may have to do extra work to determine whether the parameter
8952 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
8953 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
8954 * it might be more efficient to use a version of
8955 * <code>setNClob</code> which takes a length parameter.
8956 *
8957 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
8958 * @param reader An object that contains the data to set the parameter value to.
8959 * @throws SQLException if parameterIndex does not correspond to a parameter
8960 * marker in the SQL statement;
8961 * if the driver does not support national character sets;
8962 * if the driver can detect that a data conversion
8963 * error could occur; if a database access error occurs or
8964 * this method is called on a closed <code>PreparedStatement</code>
8965 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
8966 *
8967 * @since 1.6
8968 */
8969 public void setNClob(int parameterIndex, Reader reader)
8970 throws SQLException{
8971 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
8972 }
8973
8974 /**
8975 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
8976 * of characters specified by length otherwise a <code>SQLException</code> will be
8977 * generated when the <code>CallableStatement</code> is executed.
8978 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
8979 * because it informs the driver that the parameter value should be sent to
8980 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
8981 * driver may have to do extra work to determine whether the parameter
8982 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
8983 *
8984 * @param parameterName the name of the parameter to be set
8985 * @param reader An object that contains the data to set the parameter value to.
8986 * @param length the number of characters in the parameter data.
8987 * @throws SQLException if parameterIndex does not correspond to a parameter
8988 * marker in the SQL statement; if the length specified is less than zero;
8989 * if the driver does not support national
8990 * character sets; if the driver can detect that a data conversion
8991 * error could occur; if a database access error occurs or
8992 * this method is called on a closed <code>CallableStatement</code>
8993 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
8994 * this method
8995 * @since 1.6
8996 */
8997 public void setNClob(String parameterName, Reader reader, long length)
8998 throws SQLException{
8999 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9000 }
9001
9002
9003 /**
9004 * Sets the designated parameter to a <code>Reader</code> object.
9005 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
9006 * because it informs the driver that the parameter value should be sent to
9007 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
9008 * driver may have to do extra work to determine whether the parameter
9009 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
9010 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9011 * it might be more efficient to use a version of
9012 * <code>setNClob</code> which takes a length parameter.
9013 *
9014 * @param parameterName the name of the parameter
9015 * @param reader An object that contains the data to set the parameter value to.
9016 * @throws SQLException if the driver does not support national character sets;
9017 * if the driver can detect that a data conversion
9018 * error could occur; if a database access error occurs or
9019 * this method is called on a closed <code>CallableStatement</code>
9020 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9021 *
9022 * @since 1.6
9023 */
9024 public void setNClob(String parameterName, Reader reader)
9025 throws SQLException{
9026 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9027 }
9028
9029
9030 /**
9031 * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
9032 * of characters specified by length otherwise a <code>SQLException</code> will be
9033 * generated when the <code>PreparedStatement</code> is executed.
9034 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
9035 * because it informs the driver that the parameter value should be sent to
9036 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
9037 * driver may have to do extra work to determine whether the parameter
9038 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
9039 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
9040 * @param reader An object that contains the data to set the parameter value to.
9041 * @param length the number of characters in the parameter data.
9042 * @throws SQLException if parameterIndex does not correspond to a parameter
9043 * marker in the SQL statement; if the length specified is less than zero;
9044 * if the driver does not support national character sets;
9045 * if the driver can detect that a data conversion
9046 * error could occur; if a database access error occurs or
9047 * this method is called on a closed <code>PreparedStatement</code>
9048 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9049 *
9050 * @since 1.6
9051 */
9052 public void setNClob(int parameterIndex, Reader reader, long length)
9053 throws SQLException{
9054 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9055 }
9056
9057
9058 /**
9059 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to
9060 a
9061 * SQL <code>NCLOB</code> value when it sends it to the database.
9062 * @param parameterIndex of the first parameter is 1, the second is 2, ...
9063 * @param value the parameter value
9064 * @throws SQLException if the driver does not support national
9065 * character sets; if the driver can detect that a data conversion
9066 * error could occur ; or if a database access error occurs
9067 * @since 1.6
9068 */
9069 public void setNClob(int parameterIndex, NClob value) throws SQLException{
9070 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9071 }
9072
9073
9074 /**
9075 * Sets the designated parameter to the given <code>String</code> object.
9076 * The driver converts this to a SQL <code>NCHAR</code> or
9077 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
9078 * (depending on the argument's
9079 * size relative to the driver's limits on <code>NVARCHAR</code> values)
9080 * when it sends it to the database.
9081 *
9082 * @param parameterIndex of the first parameter is 1, the second is 2, ...
9083 * @param value the parameter value
9084 * @throws SQLException if the driver does not support national
9085 * character sets; if the driver can detect that a data conversion
9086 * error could occur ; or if a database access error occurs
9087 * @since 1.6
9088 */
9089 public void setNString(int parameterIndex, String value) throws SQLException{
9090 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9091 }
9092
9093
9094 /**
9095 * Sets the designated parameter to the given <code>String</code> object.
9096 * The driver converts this to a SQL <code>NCHAR</code> or
9097 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
9098 * @param parameterName the name of the column to be set
9099 * @param value the parameter value
9100 * @throws SQLException if the driver does not support national
9101 * character sets; if the driver can detect that a data conversion
9102 * error could occur; or if a database access error occurs
9103 * @since 1.6
9104 */
9105 public void setNString(String parameterName, String value)
9106 throws SQLException{
9107 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9108 }
9109
9110
9111 /**
9112 * Sets the designated parameter to a <code>Reader</code> object. The
9113 * <code>Reader</code> reads the data till end-of-file is reached. The
9114 * driver does the necessary conversion from Java character format to
9115 * the national character set in the database.
9116 * @param parameterIndex of the first parameter is 1, the second is 2, ...
9117 * @param value the parameter value
9118 * @param length the number of characters in the parameter data.
9119 * @throws SQLException if the driver does not support national
9120 * character sets; if the driver can detect that a data conversion
9121 * error could occur ; or if a database access error occurs
9122 * @since 1.6
9123 */
9124 public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{
9125 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9126 }
9127
9128
9129 /**
9130 * Sets the designated parameter to a <code>Reader</code> object. The
9131 * <code>Reader</code> reads the data till end-of-file is reached. The
9132 * driver does the necessary conversion from Java character format to
9133 * the national character set in the database.
9134 * @param parameterName the name of the column to be set
9135 * @param value the parameter value
9136 * @param length the number of characters in the parameter data.
9137 * @throws SQLException if the driver does not support national
9138 * character sets; if the driver can detect that a data conversion
9139 * error could occur; or if a database access error occurs
9140 * @since 1.6
9141 */
9142 public void setNCharacterStream(String parameterName, Reader value, long length)
9143 throws SQLException{
9144 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9145 }
9146
9147 /**
9148 * Sets the designated parameter to a <code>Reader</code> object. The
9149 * <code>Reader</code> reads the data till end-of-file is reached. The
9150 * driver does the necessary conversion from Java character format to
9151 * the national character set in the database.
9152
9153 * <P><B>Note:</B> This stream object can either be a standard
9154 * Java stream object or your own subclass that implements the
9155 * standard interface.
9156 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9157 * it might be more efficient to use a version of
9158 * <code>setNCharacterStream</code> which takes a length parameter.
9159 *
9160 * @param parameterName the name of the parameter
9161 * @param value the parameter value
9162 * @throws SQLException if the driver does not support national
9163 * character sets; if the driver can detect that a data conversion
9164 * error could occur ; if a database access error occurs; or
9165 * this method is called on a closed <code>CallableStatement</code>
9166 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9167 * @since 1.6
9168 */
9169 public void setNCharacterStream(String parameterName, Reader value) throws SQLException{
9170 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9171 }
9172
9173 /**
9174 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
9175 * using the given <code>Calendar</code> object. The driver uses
9176 * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
9177 * which the driver then sends to the database. With a
9178 * a <code>Calendar</code> object, the driver can calculate the timestamp
9179 * taking into account a custom timezone. If no
9180 * <code>Calendar</code> object is specified, the driver uses the default
9181 * timezone, which is that of the virtual machine running the application.
9182 *
9183 * @param parameterName the name of the parameter
9184 * @param x the parameter value
9185 * @param cal the <code>Calendar</code> object the driver will use
9186 * to construct the timestamp
9187 * @exception SQLException if a database access error occurs or
9188 * this method is called on a closed <code>CallableStatement</code>
9189 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9190 * this method
9191 * @see #getTimestamp
9192 * @since 1.4
9193 */
9194 public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
9195 throws SQLException{
9196 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9197 }
9198
9199 /**
9200 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
9201 * of characters specified by length otherwise a <code>SQLException</code> will be
9202 * generated when the <code>CallableStatement</code> is executed.
9203 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
9204 * because it informs the driver that the parameter value should be sent to
9205 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
9206 * driver may have to do extra work to determine whether the parameter
9207 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
9208 * @param parameterName the name of the parameter to be set
9209 * @param reader An object that contains the data to set the parameter value to.
9210 * @param length the number of characters in the parameter data.
9211 * @throws SQLException if parameterIndex does not correspond to a parameter
9212 * marker in the SQL statement; if the length specified is less than zero;
9213 * a database access error occurs or
9214 * this method is called on a closed <code>CallableStatement</code>
9215 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9216 * this method
9217 *
9218 * @since 1.6
9219 */
9220 public void setClob(String parameterName, Reader reader, long length)
9221 throws SQLException{
9222 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9223 }
9224
9225
9226 /**
9227 * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
9228 * The driver converts this to an SQL <code>CLOB</code> value when it
9229 * sends it to the database.
9230 *
9231 * @param parameterName the name of the parameter
9232 * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
9233 * @exception SQLException if a database access error occurs or
9234 * this method is called on a closed <code>CallableStatement</code>
9235 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9236 * this method
9237 * @since 1.6
9238 */
9239 public void setClob (String parameterName, Clob x) throws SQLException{
9240 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9241 }
9242
9243
9244 /**
9245 * Sets the designated parameter to a <code>Reader</code> object.
9246 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
9247 * because it informs the driver that the parameter value should be sent to
9248 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
9249 * driver may have to do extra work to determine whether the parameter
9250 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
9251 *
9252 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9253 * it might be more efficient to use a version of
9254 * <code>setClob</code> which takes a length parameter.
9255 *
9256 * @param parameterName the name of the parameter
9257 * @param reader An object that contains the data to set the parameter value to.
9258 * @throws SQLException if a database access error occurs or this method is called on
9259 * a closed <code>CallableStatement</code>
9260 *
9261 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9262 * @since 1.6
9263 */
9264 public void setClob(String parameterName, Reader reader)
9265 throws SQLException{
9266 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9267 }
9268
9269
9270 /**
9271 * Sets the designated parameter to the given <code>java.sql.Date</code> value
9272 * using the default time zone of the virtual machine that is running
9273 * the application.
9274 * The driver converts this
9275 * to an SQL <code>DATE</code> value when it sends it to the database.
9276 *
9277 * @param parameterName the name of the parameter
9278 * @param x the parameter value
9279 * @exception SQLException if a database access error occurs or
9280 * this method is called on a closed <code>CallableStatement</code>
9281 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9282 * this method
9283 * @see #getDate
9284 * @since 1.4
9285 */
9286 public void setDate(String parameterName, java.sql.Date x)
9287 throws SQLException{
9288 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9289 }
9290
9291
9292 /**
9293 * Sets the designated parameter to the given <code>java.sql.Date</code> value,
9294 * using the given <code>Calendar</code> object. The driver uses
9295 * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
9296 * which the driver then sends to the database. With a
9297 * a <code>Calendar</code> object, the driver can calculate the date
9298 * taking into account a custom timezone. If no
9299 * <code>Calendar</code> object is specified, the driver uses the default
9300 * timezone, which is that of the virtual machine running the application.
9301 *
9302 * @param parameterName the name of the parameter
9303 * @param x the parameter value
9304 * @param cal the <code>Calendar</code> object the driver will use
9305 * to construct the date
9306 * @exception SQLException if a database access error occurs or
9307 * this method is called on a closed <code>CallableStatement</code>
9308 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9309 * this method
9310 * @see #getDate
9311 * @since 1.4
9312 */
9313 public void setDate(String parameterName, java.sql.Date x, Calendar cal)
9314 throws SQLException{
9315 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9316 }
9317
9318
9319 /**
9320 * Sets the designated parameter to the given <code>java.sql.Time</code> value.
9321 * The driver converts this
9322 * to an SQL <code>TIME</code> value when it sends it to the database.
9323 *
9324 * @param parameterName the name of the parameter
9325 * @param x the parameter value
9326 * @exception SQLException if a database access error occurs or
9327 * this method is called on a closed <code>CallableStatement</code>
9328 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9329 * this method
9330 * @see #getTime
9331 * @since 1.4
9332 */
9333 public void setTime(String parameterName, java.sql.Time x)
9334 throws SQLException{
9335 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9336 }
9337
9338
9339 /**
9340 * Sets the designated parameter to the given <code>java.sql.Time</code> value,
9341 * using the given <code>Calendar</code> object. The driver uses
9342 * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
9343 * which the driver then sends to the database. With a
9344 * a <code>Calendar</code> object, the driver can calculate the time
9345 * taking into account a custom timezone. If no
9346 * <code>Calendar</code> object is specified, the driver uses the default
9347 * timezone, which is that of the virtual machine running the application.
9348 *
9349 * @param parameterName the name of the parameter
9350 * @param x the parameter value
9351 * @param cal the <code>Calendar</code> object the driver will use
9352 * to construct the time
9353 * @exception SQLException if a database access error occurs or
9354 * this method is called on a closed <code>CallableStatement</code>
9355 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9356 * this method
9357 * @see #getTime
9358 * @since 1.4
9359 */
9360 public void setTime(String parameterName, java.sql.Time x, Calendar cal)
9361 throws SQLException{
9362 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9363 }
9364
9365 /**
9366 * Sets the designated parameter to a <code>Reader</code> object.
9367 * This method differs from the <code>setCharacterStream (int, Reader)</code> method
9368 * because it informs the driver that the parameter value should be sent to
9369 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
9370 * driver may have to do extra work to determine whether the parameter
9371 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
9372 *
9373 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9374 * it might be more efficient to use a version of
9375 * <code>setClob</code> which takes a length parameter.
9376 *
9377 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
9378 * @param reader An object that contains the data to set the parameter value to.
9379 * @throws SQLException if a database access error occurs, this method is called on
9380 * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
9381 * marker in the SQL statement
9382 *
9383 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9384 * @since 1.6
9385 */
9386 public void setClob(int parameterIndex, Reader reader)
9387 throws SQLException{
9388 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9389 }
9390
9391 /**
9392 * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
9393 * of characters specified by length otherwise a <code>SQLException</code> will be
9394 * generated when the <code>PreparedStatement</code> is executed.
9395 *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
9396 * because it informs the driver that the parameter value should be sent to
9397 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
9398 * driver may have to do extra work to determine whether the parameter
9399 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
9400 * @param parameterIndex index of the first parameter is 1, the second is 2, ...
9401 * @param reader An object that contains the data to set the parameter value to.
9402 * @param length the number of characters in the parameter data.
9403 * @throws SQLException if a database access error occurs, this method is called on
9404 * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
9405 * marker in the SQL statement, or if the length specified is less than zero.
9406 *
9407 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9408 * @since 1.6
9409 */
9410 public void setClob(int parameterIndex, Reader reader, long length)
9411 throws SQLException{
9412 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9413 }
9414
9415
9416 /**
9417 * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number
9418 * of characters specified by length otherwise a <code>SQLException</code> will be
9419 * generated when the <code>PreparedStatement</code> is executed.
9420 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
9421 * method because it informs the driver that the parameter value should be
9422 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
9423 * the driver may have to do extra work to determine whether the parameter
9424 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
9425 * @param parameterIndex index of the first parameter is 1,
9426 * the second is 2, ...
9427 * @param inputStream An object that contains the data to set the parameter
9428 * value to.
9429 * @param length the number of bytes in the parameter data.
9430 * @throws SQLException if a database access error occurs,
9431 * this method is called on a closed <code>PreparedStatement</code>,
9432 * if parameterIndex does not correspond
9433 * to a parameter marker in the SQL statement, if the length specified
9434 * is less than zero or if the number of bytes in the inputstream does not match
9435 * the specified length.
9436 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9437 *
9438 * @since 1.6
9439 */
9440 public void setBlob(int parameterIndex, InputStream inputStream, long length)
9441 throws SQLException{
9442 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9443 }
9444
9445
9446 /**
9447 * Sets the designated parameter to a <code>InputStream</code> object.
9448 * This method differs from the <code>setBinaryStream (int, InputStream)</code>
9449 * method because it informs the driver that the parameter value should be
9450 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
9451 * the driver may have to do extra work to determine whether the parameter
9452 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
9453 *
9454 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9455 * it might be more efficient to use a version of
9456 * <code>setBlob</code> which takes a length parameter.
9457 *
9458 * @param parameterIndex index of the first parameter is 1,
9459 * the second is 2, ...
9460 * @param inputStream An object that contains the data to set the parameter
9461 * value to.
9462 * @throws SQLException if a database access error occurs,
9463 * this method is called on a closed <code>PreparedStatement</code> or
9464 * if parameterIndex does not correspond
9465 * to a parameter marker in the SQL statement,
9466 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9467 *
9468 * @since 1.6
9469 */
9470 public void setBlob(int parameterIndex, InputStream inputStream)
9471 throws SQLException{
9472 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9473 }
9474
9475
9476 /**
9477 * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number
9478 * of characters specified by length, otherwise a <code>SQLException</code> will be
9479 * generated when the <code>CallableStatement</code> is executed.
9480 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
9481 * method because it informs the driver that the parameter value should be
9482 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
9483 * the driver may have to do extra work to determine whether the parameter
9484 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
9485 *
9486 * @param parameterName the name of the parameter to be set
9487 * the second is 2, ...
9488 *
9489 * @param inputStream An object that contains the data to set the parameter
9490 * value to.
9491 * @param length the number of bytes in the parameter data.
9492 * @throws SQLException if parameterIndex does not correspond
9493 * to a parameter marker in the SQL statement, or if the length specified
9494 * is less than zero; if the number of bytes in the inputstream does not match
9495 * the specified length; if a database access error occurs or
9496 * this method is called on a closed <code>CallableStatement</code>
9497 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9498 * this method
9499 *
9500 * @since 1.6
9501 */
9502 public void setBlob(String parameterName, InputStream inputStream, long length)
9503 throws SQLException{
9504 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9505 }
9506
9507
9508 /**
9509 * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
9510 * The driver converts this to an SQL <code>BLOB</code> value when it
9511 * sends it to the database.
9512 *
9513 * @param parameterName the name of the parameter
9514 * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
9515 * @exception SQLException if a database access error occurs or
9516 * this method is called on a closed <code>CallableStatement</code>
9517 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9518 * this method
9519 * @since 1.6
9520 */
9521 public void setBlob (String parameterName, Blob x) throws SQLException{
9522 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9523 }
9524
9525
9526 /**
9527 * Sets the designated parameter to a <code>InputStream</code> object.
9528 * This method differs from the <code>setBinaryStream (int, InputStream)</code>
9529 * method because it informs the driver that the parameter value should be
9530 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
9531 * the driver may have to do extra work to determine whether the parameter
9532 * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
9533 *
9534 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9535 * it might be more efficient to use a version of
9536 * <code>setBlob</code> which takes a length parameter.
9537 *
9538 * @param parameterName the name of the parameter
9539 * @param inputStream An object that contains the data to set the parameter
9540 * value to.
9541 * @throws SQLException if a database access error occurs or
9542 * this method is called on a closed <code>CallableStatement</code>
9543 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9544 *
9545 * @since 1.6
9546 */
9547 public void setBlob(String parameterName, InputStream inputStream)
9548 throws SQLException{
9549 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9550 }
9551
9552 /**
9553 * Sets the value of the designated parameter with the given object. The second
9554 * argument must be an object type; for integral values, the
9555 * <code>java.lang</code> equivalent objects should be used.
9556 *
9557 * <p>The given Java object will be converted to the given targetSqlType
9558 * before being sent to the database.
9559 *
9560 * If the object has a custom mapping (is of a class implementing the
9561 * interface <code>SQLData</code>),
9562 * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
9563 * to the SQL data stream.
9564 * If, on the other hand, the object is of a class implementing
9565 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
9566 * <code>Struct</code>, <code>java.net.URL</code>,
9567 * or <code>Array</code>, the driver should pass it to the database as a
9568 * value of the corresponding SQL type.
9569 * <P>
9570 * Note that this method may be used to pass datatabase-
9571 * specific abstract data types.
9572 *
9573 * @param parameterName the name of the parameter
9574 * @param x the object containing the input parameter value
9575 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
9576 * sent to the database. The scale argument may further qualify this type.
9577 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
9578 * this is the number of digits after the decimal point. For all other
9579 * types, this value will be ignored.
9580 * @exception SQLException if a database access error occurs or
9581 * this method is called on a closed <code>CallableStatement</code>
9582 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
9583 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
9584 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
9585 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
9586 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
9587 * or <code>STRUCT</code> data type and the JDBC driver does not support
9588 * this data type
9589 * @see Types
9590 * @see #getObject
9591 * @since 1.4
9592 */
9593 public void setObject(String parameterName, Object x, int targetSqlType, int scale)
9594 throws SQLException{
9595 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9596 }
9597
9598
9599
9600 /**
9601 * Sets the value of the designated parameter with the given object.
9602 * This method is like the method <code>setObject</code>
9603 * above, except that it assumes a scale of zero.
9604 *
9605 * @param parameterName the name of the parameter
9606 * @param x the object containing the input parameter value
9607 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
9608 * sent to the database
9609 * @exception SQLException if a database access error occurs or
9610 * this method is called on a closed <code>CallableStatement</code>
9611 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
9612 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
9613 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
9614 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
9615 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
9616 * or <code>STRUCT</code> data type and the JDBC driver does not support
9617 * this data type
9618 * @see #getObject
9619 * @since 1.4
9620 */
9621 public void setObject(String parameterName, Object x, int targetSqlType)
9622 throws SQLException{
9623 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9624 }
9625
9626
9627 /**
9628 * Sets the value of the designated parameter with the given object.
9629 * The second parameter must be of type <code>Object</code>; therefore, the
9630 * <code>java.lang</code> equivalent objects should be used for built-in types.
9631 *
9632 * <p>The JDBC specification specifies a standard mapping from
9633 * Java <code>Object</code> types to SQL types. The given argument
9634 * will be converted to the corresponding SQL type before being
9635 * sent to the database.
9636 *
9637 * <p>Note that this method may be used to pass datatabase-
9638 * specific abstract data types, by using a driver-specific Java
9639 * type.
9640 *
9641 * If the object is of a class implementing the interface <code>SQLData</code>,
9642 * the JDBC driver should call the method <code>SQLData.writeSQL</code>
9643 * to write it to the SQL data stream.
9644 * If, on the other hand, the object is of a class implementing
9645 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
9646 * <code>Struct</code>, <code>java.net.URL</code>,
9647 * or <code>Array</code>, the driver should pass it to the database as a
9648 * value of the corresponding SQL type.
9649 * <P>
9650 * This method throws an exception if there is an ambiguity, for example, if the
9651 * object is of a class implementing more than one of the interfaces named above.
9652 *
9653 * @param parameterName the name of the parameter
9654 * @param x the object containing the input parameter value
9655 * @exception SQLException if a database access error occurs,
9656 * this method is called on a closed <code>CallableStatement</code> or if the given
9657 * <code>Object</code> parameter is ambiguous
9658 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9659 * this method
9660 * @see #getObject
9661 * @since 1.4
9662 */
9663 public void setObject(String parameterName, Object x) throws SQLException{
9664 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9665 }
9666
9667 /**
9668 * Sets the designated parameter to the given input stream, which will have
9669 * the specified number of bytes.
9670 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
9671 * parameter, it may be more practical to send it via a
9672 * <code>java.io.InputStream</code>. Data will be read from the stream
9673 * as needed until end-of-file is reached. The JDBC driver will
9674 * do any necessary conversion from ASCII to the database char format.
9675 *
9676 * <P><B>Note:</B> This stream object can either be a standard
9677 * Java stream object or your own subclass that implements the
9678 * standard interface.
9679 *
9680 * @param parameterName the name of the parameter
9681 * @param x the Java input stream that contains the ASCII parameter value
9682 * @param length the number of bytes in the stream
9683 * @exception SQLException if a database access error occurs or
9684 * this method is called on a closed <code>CallableStatement</code>
9685 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9686 * this method
9687 * @since 1.4
9688 */
9689 public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
9690 throws SQLException{
9691 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9692 }
9693
9694
9695 /**
9696 * Sets the designated parameter to the given input stream, which will have
9697 * the specified number of bytes.
9698 * When a very large binary value is input to a <code>LONGVARBINARY</code>
9699 * parameter, it may be more practical to send it via a
9700 * <code>java.io.InputStream</code> object. The data will be read from the stream
9701 * as needed until end-of-file is reached.
9702 *
9703 * <P><B>Note:</B> This stream object can either be a standard
9704 * Java stream object or your own subclass that implements the
9705 * standard interface.
9706 *
9707 * @param parameterName the name of the parameter
9708 * @param x the java input stream which contains the binary parameter value
9709 * @param length the number of bytes in the stream
9710 * @exception SQLException if a database access error occurs or
9711 * this method is called on a closed <code>CallableStatement</code>
9712 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9713 * this method
9714 * @since 1.4
9715 */
9716 public void setBinaryStream(String parameterName, java.io.InputStream x,
9717 int length) throws SQLException{
9718 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9719 }
9720
9721
9722 /**
9723 * Sets the designated parameter to the given <code>Reader</code>
9724 * object, which is the given number of characters long.
9725 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
9726 * parameter, it may be more practical to send it via a
9727 * <code>java.io.Reader</code> object. The data will be read from the stream
9728 * as needed until end-of-file is reached. The JDBC driver will
9729 * do any necessary conversion from UNICODE to the database char format.
9730 *
9731 * <P><B>Note:</B> This stream object can either be a standard
9732 * Java stream object or your own subclass that implements the
9733 * standard interface.
9734 *
9735 * @param parameterName the name of the parameter
9736 * @param reader the <code>java.io.Reader</code> object that
9737 * contains the UNICODE data used as the designated parameter
9738 * @param length the number of characters in the stream
9739 * @exception SQLException if a database access error occurs or
9740 * this method is called on a closed <code>CallableStatement</code>
9741 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9742 * this method
9743 * @since 1.4
9744 */
9745 public void setCharacterStream(String parameterName,
9746 java.io.Reader reader,
9747 int length) throws SQLException{
9748 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9749 }
9750
9751
9752 /**
9753 * Sets the designated parameter to the given input stream.
9754 * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
9755 * parameter, it may be more practical to send it via a
9756 * <code>java.io.InputStream</code>. Data will be read from the stream
9757 * as needed until end-of-file is reached. The JDBC driver will
9758 * do any necessary conversion from ASCII to the database char format.
9759 *
9760 * <P><B>Note:</B> This stream object can either be a standard
9761 * Java stream object or your own subclass that implements the
9762 * standard interface.
9763 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9764 * it might be more efficient to use a version of
9765 * <code>setAsciiStream</code> which takes a length parameter.
9766 *
9767 * @param parameterName the name of the parameter
9768 * @param x the Java input stream that contains the ASCII parameter value
9769 * @exception SQLException if a database access error occurs or
9770 * this method is called on a closed <code>CallableStatement</code>
9771 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9772 * @since 1.6
9773 */
9774 public void setAsciiStream(String parameterName, java.io.InputStream x)
9775 throws SQLException{
9776 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9777 }
9778
9779
9780 /**
9781 * Sets the designated parameter to the given input stream.
9782 * When a very large binary value is input to a <code>LONGVARBINARY</code>
9783 * parameter, it may be more practical to send it via a
9784 * <code>java.io.InputStream</code> object. The data will be read from the
9785 * stream as needed until end-of-file is reached.
9786 *
9787 * <P><B>Note:</B> This stream object can either be a standard
9788 * Java stream object or your own subclass that implements the
9789 * standard interface.
9790 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9791 * it might be more efficient to use a version of
9792 * <code>setBinaryStream</code> which takes a length parameter.
9793 *
9794 * @param parameterName the name of the parameter
9795 * @param x the java input stream which contains the binary parameter value
9796 * @exception SQLException if a database access error occurs or
9797 * this method is called on a closed <code>CallableStatement</code>
9798 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9799 * @since 1.6
9800 */
9801 public void setBinaryStream(String parameterName, java.io.InputStream x)
9802 throws SQLException{
9803 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9804 }
9805
9806
9807
9808 /**
9809 * Sets the designated parameter to the given <code>Reader</code>
9810 * object.
9811 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
9812 * parameter, it may be more practical to send it via a
9813 * <code>java.io.Reader</code> object. The data will be read from the stream
9814 * as needed until end-of-file is reached. The JDBC driver will
9815 * do any necessary conversion from UNICODE to the database char format.
9816 *
9817 * <P><B>Note:</B> This stream object can either be a standard
9818 * Java stream object or your own subclass that implements the
9819 * standard interface.
9820 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
9821 * it might be more efficient to use a version of
9822 * <code>setCharacterStream</code> which takes a length parameter.
9823 *
9824 * @param parameterName the name of the parameter
9825 * @param reader the <code>java.io.Reader</code> object that contains the
9826 * Unicode data
9827 * @exception SQLException if a database access error occurs or
9828 * this method is called on a closed <code>CallableStatement</code>
9829 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
9830 * @since 1.6
9831 */
9832 public void setCharacterStream(String parameterName,
9833 java.io.Reader reader) throws SQLException{
9834 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9835 }
9836
9837 /**
9838 * Sets the designated parameter to the given
9839 * <code>java.math.BigDecimal</code> value.
9840 * The driver converts this to an SQL <code>NUMERIC</code> value when
9841 * it sends it to the database.
9842 *
9843 * @param parameterName the name of the parameter
9844 * @param x the parameter value
9845 * @exception SQLException if a database access error occurs or
9846 * this method is called on a closed <code>CallableStatement</code>
9847 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9848 * this method
9849 * @see #getBigDecimal
9850 * @since 1.4
9851 */
9852 public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
9853 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9854 }
9855
9856
9857
9858 /**
9859 * Sets the designated parameter to the given Java <code>String</code> value.
9860 * The driver converts this
9861 * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
9862 * (depending on the argument's
9863 * size relative to the driver's limits on <code>VARCHAR</code> values)
9864 * when it sends it to the database.
9865 *
9866 * @param parameterName the name of the parameter
9867 * @param x the parameter value
9868 * @exception SQLException if a database access error occurs or
9869 * this method is called on a closed <code>CallableStatement</code>
9870 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9871 * this method
9872 * @see #getString
9873 * @since 1.4
9874 */
9875 public void setString(String parameterName, String x) throws SQLException{
9876 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9877 }
9878
9879
9880
9881 /**
9882 * Sets the designated parameter to the given Java array of bytes.
9883 * The driver converts this to an SQL <code>VARBINARY</code> or
9884 * <code>LONGVARBINARY</code> (depending on the argument's size relative
9885 * to the driver's limits on <code>VARBINARY</code> values) when it sends
9886 * it to the database.
9887 *
9888 * @param parameterName the name of the parameter
9889 * @param x the parameter value
9890 * @exception SQLException if a database access error occurs or
9891 * this method is called on a closed <code>CallableStatement</code>
9892 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9893 * this method
9894 * @see #getBytes
9895 * @since 1.4
9896 */
9897 public void setBytes(String parameterName, byte x[]) throws SQLException{
9898 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9899 }
9900
9901
9902
9903 /**
9904 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
9905 * The driver
9906 * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
9907 * database.
9908 *
9909 * @param parameterName the name of the parameter
9910 * @param x the parameter value
9911 * @exception SQLException if a database access error occurs or
9912 * this method is called on a closed <code>CallableStatement</code>
9913 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9914 * this method
9915 * @see #getTimestamp
9916 * @since 1.4
9917 */
9918 public void setTimestamp(String parameterName, java.sql.Timestamp x)
9919 throws SQLException{
9920 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9921 }
9922
9923 /**
9924 * Sets the designated parameter to SQL <code>NULL</code>.
9925 *
9926 * <P><B>Note:</B> You must specify the parameter's SQL type.
9927 *
9928 * @param parameterName the name of the parameter
9929 * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
9930 * @exception SQLException if a database access error occurs or
9931 * this method is called on a closed <code>CallableStatement</code>
9932 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9933 * this method
9934 * @since 1.4
9935 */
9936 public void setNull(String parameterName, int sqlType) throws SQLException {
9937 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9938 }
9939
9940
9941 /**
9942 * Sets the designated parameter to SQL <code>NULL</code>.
9943 * This version of the method <code>setNull</code> should
9944 * be used for user-defined types and REF type parameters. Examples
9945 * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
9946 * named array types.
9947 *
9948 * <P><B>Note:</B> To be portable, applications must give the
9949 * SQL type code and the fully-qualified SQL type name when specifying
9950 * a NULL user-defined or REF parameter. In the case of a user-defined type
9951 * the name is the type name of the parameter itself. For a REF
9952 * parameter, the name is the type name of the referenced type. If
9953 * a JDBC driver does not need the type code or type name information,
9954 * it may ignore it.
9955 *
9956 * Although it is intended for user-defined and Ref parameters,
9957 * this method may be used to set a null parameter of any JDBC type.
9958 * If the parameter does not have a user-defined or REF type, the given
9959 * typeName is ignored.
9960 *
9961 *
9962 * @param parameterName the name of the parameter
9963 * @param sqlType a value from <code>java.sql.Types</code>
9964 * @param typeName the fully-qualified name of an SQL user-defined type;
9965 * ignored if the parameter is not a user-defined type or
9966 * SQL <code>REF</code> value
9967 * @exception SQLException if a database access error occurs or
9968 * this method is called on a closed <code>CallableStatement</code>
9969 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9970 * this method
9971 * @since 1.4
9972 */
9973 public void setNull (String parameterName, int sqlType, String typeName)
9974 throws SQLException{
9975 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9976 }
9977
9978
9979
9980 /**
9981 * Sets the designated parameter to the given Java <code>boolean</code> value.
9982 * The driver converts this
9983 * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
9984 *
9985 * @param parameterName the name of the parameter
9986 * @param x the parameter value
9987 * @exception SQLException if a database access error occurs or
9988 * this method is called on a closed <code>CallableStatement</code>
9989 * @see #getBoolean
9990 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
9991 * this method
9992 * @since 1.4
9993 */
9994 public void setBoolean(String parameterName, boolean x) throws SQLException{
9995 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
9996 }
9997
9998
9999
10000 /**
10001 * Sets the designated parameter to the given Java <code>byte</code> value.
10002 * The driver converts this
10003 * to an SQL <code>TINYINT</code> value when it sends it to the database.
10004 *
10005 * @param parameterName the name of the parameter
10006 * @param x the parameter value
10007 * @exception SQLException if a database access error occurs or
10008 * this method is called on a closed <code>CallableStatement</code>
10009 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10010 * this method
10011 * @see #getByte
10012 * @since 1.4
10013 */
10014 public void setByte(String parameterName, byte x) throws SQLException{
10015 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10016 }
10017
10018
10019
10020 /**
10021 * Sets the designated parameter to the given Java <code>short</code> value.
10022 * The driver converts this
10023 * to an SQL <code>SMALLINT</code> value when it sends it to the database.
10024 *
10025 * @param parameterName the name of the parameter
10026 * @param x the parameter value
10027 * @exception SQLException if a database access error occurs or
10028 * this method is called on a closed <code>CallableStatement</code>
10029 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10030 * this method
10031 * @see #getShort
10032 * @since 1.4
10033 */
10034 public void setShort(String parameterName, short x) throws SQLException{
10035 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10036 }
10037
10038
10039 /**
10040 * Sets the designated parameter to the given Java <code>int</code> value.
10041 * The driver converts this
10042 * to an SQL <code>INTEGER</code> value when it sends it to the database.
10043 *
10044 * @param parameterName the name of the parameter
10045 * @param x the parameter value
10046 * @exception SQLException if a database access error occurs or
10047 * this method is called on a closed <code>CallableStatement</code>
10048 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10049 * this method
10050 * @see #getInt
10051 * @since 1.4
10052 */
10053 public void setInt(String parameterName, int x) throws SQLException{
10054 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10055 }
10056
10057
10058 /**
10059 * Sets the designated parameter to the given Java <code>long</code> value.
10060 * The driver converts this
10061 * to an SQL <code>BIGINT</code> value when it sends it to the database.
10062 *
10063 * @param parameterName the name of the parameter
10064 * @param x the parameter value
10065 * @exception SQLException if a database access error occurs or
10066 * this method is called on a closed <code>CallableStatement</code>
10067 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10068 * this method
10069 * @see #getLong
10070 * @since 1.4
10071 */
10072 public void setLong(String parameterName, long x) throws SQLException{
10073 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10074 }
10075
10076
10077 /**
10078 * Sets the designated parameter to the given Java <code>float</code> value.
10079 * The driver converts this
10080 * to an SQL <code>FLOAT</code> value when it sends it to the database.
10081 *
10082 * @param parameterName the name of the parameter
10083 * @param x the parameter value
10084 * @exception SQLException if a database access error occurs or
10085 * this method is called on a closed <code>CallableStatement</code>
10086 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10087 * this method
10088 * @see #getFloat
10089 * @since 1.4
10090 */
10091 public void setFloat(String parameterName, float x) throws SQLException{
10092 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10093 }
10094
10095
10096 /**
10097 * Sets the designated parameter to the given Java <code>double</code> value.
10098 * The driver converts this
10099 * to an SQL <code>DOUBLE</code> value when it sends it to the database.
10100 *
10101 * @param parameterName the name of the parameter
10102 * @param x the parameter value
10103 * @exception SQLException if a database access error occurs or
10104 * this method is called on a closed <code>CallableStatement</code>
10105 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
10106 * this method
10107 * @see #getDouble
10108 * @since 1.4
10109 */
10110 public void setDouble(String parameterName, double x) throws SQLException{
10111 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString());
10112 }
10113
10114 /**
10115 * This method re populates the resBundle
10116 * during the deserialization process
10117 *
10118 */
10119 private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
10120 // Default state initialization happens here
10121 ois.defaultReadObject();
10122 // Initialization of transient Res Bundle happens here .
10123 try {
10124 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
10125 } catch(IOException ioe) {
10126 throw new RuntimeException(ioe);
10127 }
10128
10129 }
10130
10131 //------------------------- JDBC 4.1 -----------------------------------
10132 public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
10133 throw new SQLFeatureNotSupportedException("Not supported yet.");
10134 }
10135
10136 public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
10137 throw new SQLFeatureNotSupportedException("Not supported yet.");
10138 }
10139
10140 static final long serialVersionUID =1884577171200622428L;
10141 }