History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/com/sun/rowset/internal/SyncResolverImpl.java (1 of 18352 files). Show all

Unified · Split

java/pkg/com/sun/rowset/internal/SyncResolverImpl.java+4860−0
@@ -0,0 +1,4860 @@
1/*
2 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package com.sun.rowset.internal;
27
28import java.sql.*;
29import javax.sql.*;
30import java.util.*;
31import java.math.BigDecimal;
32
33import javax.sql.rowset.*;
34import javax.sql.rowset.spi.*;
35
36import com.sun.rowset.*;
37import java.io.IOException;
38import java.io.ObjectInputStream;
39
40/**
41 * There will be two sets of data which will be maintained by the rowset at the
42 * time of synchronization. The <code>SyncProvider</code> will utilize the
43 * <code>SyncResolver</code> to synchronize the changes back to database.
44 */
45public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
46 /**
47 * This CachedRowSet object will encapsulate a rowset
48 * which will be sync'ed with the datasource but will
49 * contain values in rows where there is conflict.
50 * For rows other than conflict, it will *not* contain
51 * any data. For rows containing conflict it will
52 * return either of the three values set by SyncResolver.*_CONFLICT
53 * from getStatus()
54 */
55 private CachedRowSetImpl crsRes;
56
57 /**
58 * This is the actual CachedRowSet object
59 * which is being synchronized back to
60 * datasource.
61 */
62 private CachedRowSetImpl crsSync;
63
64 /**
65 * This ArrayList will contain the status of a row
66 * from the SyncResolver.* values else it will be null.
67 */
68 private ArrayList stats;
69
70 /**
71 * The RowSetWriter associated with the original
72 * CachedRowSet object which is being synchronized.
73 */
74 private CachedRowSetWriter crw;
75
76 /**
77 * Row number identifier
78 */
79 private int rowStatus;
80
81 /**
82 * This will contain the size of the <code>CachedRowSet</code> object
83 */
84 private int sz;
85
86 /**
87 * The <code>Connection</code> handle used to synchronize the changes
88 * back to datasource. This is the same connection handle as was passed
89 * to the CachedRowSet while fetching the data.
90 */
91 private transient Connection con;
92
93 /**
94 * The <code>CachedRowSet</code> object which will encapsulate
95 * a row at any time. This will be built from CachedRowSet and
96 * SyncResolver values. Synchronization takes place on a row by
97 * row basis encapsulated as a CahedRowSet.
98 */
99 private CachedRowSet row;
100
101 private JdbcRowSetResourceBundle resBundle;
102
103 /**
104 * Public constructor
105 */
106 public SyncResolverImpl() throws SQLException {
107 try {
108 crsSync = new CachedRowSetImpl();
109 crsRes = new CachedRowSetImpl();
110 crw = new CachedRowSetWriter();
111 row = new CachedRowSetImpl();
112 rowStatus = 1;
113 try {
114 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
115 } catch(IOException ioe) {
116 throw new RuntimeException(ioe);
117 }
118
119 } catch(SQLException sqle) {
120 }
121 }
122
123
124 /**
125 * Retrieves the conflict status of the current row of this
126 * <code>SyncResolver</code>, which indicates the operationthe <code>RowSet</code>
127 * object was attempting when the conflict occurred.
128 *
129 * @return one of the following constants:
130 * <code>SyncResolver.UPDATE_ROW_CONFLICT</code>,
131 * <code>SyncResolver.DELETE_ROW_CONFLICT</code>, or
132 * <code>SyncResolver.INSERT_ROW_CONFLICT</code>
133 */
134 public int getStatus() {
135 return ((Integer)stats.get(rowStatus-1)).intValue();
136 }
137
138 /**
139 * Retrieves the value in the designated column in the current row of this
140 * <code>SyncResolver</code> object, which is the value that caused a conflict.
141 *
142 * @param index <code>int</code> designating the column in this row of this
143 * <code>SyncResolver</code> object from which to retrieve the value
144 * causing a conflict
145 */
146 public Object getConflictValue(int index) throws SQLException {
147 try {
148 return crsRes.getObject(index);
149 } catch(SQLException sqle) {
150 throw new SQLException(sqle.getMessage());
151 }
152 }
153
154 /**
155 * Retrieves the value in the designated column in the current row of this
156 * <code>SyncResolver</code> object, which is the value that caused a conflict.
157 *
158 * @param columnName a <code>String</code> object designating the column in this row of this
159 * <code>SyncResolver</code> object from which to retrieve the value
160 * causing a conflict
161 */
162 public Object getConflictValue(String columnName) throws SQLException {
163 try {
164 return crsRes.getObject(columnName);
165 } catch(SQLException sqle) {
166 throw new SQLException(sqle.getMessage());
167 }
168 }
169
170 /**
171 * Sets <i>obj</i> as the value in column <i>index</i> in the current row of the
172 * <code>RowSet</code> object. This value is the resolved value that is to be
173 * persisted in the data source.
174 *
175 * @param index an <code>int</code> giving the number of the column into which to
176 * set the value to be persisted
177 * @param obj an <code>Object</code> that is the value to be set in the data source
178 */
179 public void setResolvedValue(int index, Object obj) throws SQLException {
180 // modify method to throw SQLException in spec
181
182 /**
183 * When a value is resolved properly make it to null
184 * inside crsRes for that column.
185 *
186 * For more than one conflicts in the row,
187 * check for the last resolved value of the current row
188 * (Note: it can be resolved randomly for same row)
189 * then sync back immediately.
190 **/
191 try {
192 // check whether the index is in range
193 if(index<=0 || index > crsSync.getMetaData().getColumnCount() ) {
194 throw new SQLException(resBundle.handleGetObject("syncrsimpl.indexval").toString()+ index);
195 }
196 // check whether index col is in conflict
197 if(crsRes.getObject(index) == null) {
198 throw new SQLException(resBundle.handleGetObject("syncrsimpl.noconflict").toString());
199 }
200 } catch (SQLException sqle) {
201 // modify method to throw for SQLException
202 throw new SQLException(sqle.getMessage());
203 }
204 try {
205 boolean bool = true;
206 /** Check resolved value to be either of conflict
207 * or in rowset else throw sql exception.
208 * If we allow a value other than that in CachedRowSet or
209 * datasource we will end up in looping the loop of exceptions.
210 **/
211
212 if( ((crsSync.getObject(index)).toString()).equals(obj.toString()) ||
213 ((crsRes.getObject(index)).toString()).equals(obj.toString()) ) {
214
215 /**
216 * Check whether this is the only conflict in the row.
217 * If yes, synchronize this row back
218 * which has been resolved, else wait
219 * for all conflicts of current row to be resolved
220 *
221 * Step 1: Update crsRes and make the index col as null
222 * i.e. resolved
223 * crsRes.updateObject(index, obj);
224 **/
225 crsRes.updateNull(index);
226 crsRes.updateRow();
227
228 /**
229 * Step 2: Change the value in the CachedRowSetImpl object
230 * crsSync.updateObject(index, obj);
231 * crsSync.updateRow();
232 **/
233 if(row.size() != 1) {
234 row = buildCachedRow();
235 }
236
237 row.updateObject(index, obj);
238 row.updateRow();
239
240 for(int j=1; j < crsRes.getMetaData().getColumnCount(); j++) {
241 if(crsRes.getObject(j) != null) {
242 bool = false;
243 break;
244 // break out of loop and wait for other cols
245 // in same row to get resolved
246 } //end if
247
248 } //end for
249
250 if(bool) {
251 /**
252 * sync data back using CachedRowSetWriter
253 * construct the present row and pass it to the writer
254 * to write back to db.
255 **/
256 try {
257 /**
258 * Note : The use of CachedRowSetWriter to get *same* Connection handle.
259 * The CachedRowSetWriter uses the connection handle
260 * from the reader, Hence will use the same connection handle
261 * as of original CachedRowSetImpl
262 **/
263
264 writeData(row);
265
266 //crw.writeData( (RowSetInternal)crsRow);
267 //System.out.printlnt.println("12");
268
269 } catch(SyncProviderException spe) {
270 /**
271 * This will occur if db is not allowing
272 * even after resolving the conflicts
273 * due to some reasons.
274 * Also will prevent from going into a loop of SPE's
275 **/
276 throw new SQLException(resBundle.handleGetObject("syncrsimpl.syncnotpos").toString());
277 }
278 } //end if(bool)
279
280 } else {
281 throw new SQLException(resBundle.handleGetObject("syncrsimpl.valtores").toString());
282 } //end if (crs.getObject ...) block
283
284
285 } catch(SQLException sqle) {
286 throw new SQLException(sqle.getMessage());
287 }
288 }
289
290 /**
291 * This passes a CachedRowSet as a row the the CachedRowSetWriter
292 * after the values have been resolved, back to the datasource.
293 *
294 * @param row a <code>CachedRowSet</code> object which will hold the
295 * values of a particular row after they have been resolved by
296 * the user to synchronize back to datasource.
297 * @throws SQLException if synchronization does not happen properly
298 * maybe beacuse <code>Connection</code> has timed out.
299 **/
300 private void writeData(CachedRowSet row) throws SQLException {
301 crw.updateResolvedConflictToDB(row, crw.getReader().connect((RowSetInternal)crsSync));
302 }
303
304 /**
305 * This function builds a row as a <code>CachedRowSet</code> object
306 * which has been resolved and is ready to be synchrinized to the datasource
307 *
308 * @throws SQLException if there is problem in building
309 * the metadata of the row.
310 **/
311 private CachedRowSet buildCachedRow() throws SQLException {
312 int iColCount;
313 CachedRowSetImpl crsRow = new CachedRowSetImpl();
314
315 RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
316 RowSetMetaDataImpl rsmdWrite = (RowSetMetaDataImpl)crsSync.getMetaData();
317 RowSetMetaDataImpl rsmdRow = new RowSetMetaDataImpl();
318
319 iColCount = rsmdWrite.getColumnCount();
320 rsmdRow.setColumnCount(iColCount);
321
322 for(int i =1;i<=iColCount;i++) {
323 rsmdRow.setColumnType(i,rsmdWrite.getColumnType(i));
324 rsmdRow.setColumnName(i,rsmdWrite.getColumnName(i));
325 rsmdRow.setNullable(i,ResultSetMetaData.columnNullableUnknown);
326
327 try {
328 rsmdRow.setCatalogName(i, rsmdWrite.getCatalogName(i));
329 rsmdRow.setSchemaName(i, rsmdWrite.getSchemaName(i));
330 } catch(SQLException e) {
331 e.printStackTrace();
332 }
333 } //end for
334
335 crsRow.setMetaData(rsmdRow);
336
337 crsRow.moveToInsertRow();
338
339 for(int col=1;col<=crsSync.getMetaData().getColumnCount();col++) {
340 crsRow.updateObject(col, crsSync.getObject(col));
341 }
342
343 crsRow.insertRow();
344 crsRow.moveToCurrentRow();
345
346 crsRow.absolute(1);
347 crsRow.setOriginalRow();
348
349 try {
350 crsRow.setUrl(crsSync.getUrl());
351 } catch(SQLException sqle) {
352
353 }
354
355 try {
356 crsRow.setDataSourceName(crsSync.getCommand());
357 } catch(SQLException sqle) {
358
359 }
360
361 try {
362 if(crsSync.getTableName()!= null){
363 crsRow.setTableName(crsSync.getTableName());
364 }
365 } catch(SQLException sqle) {
366
367 }
368
369 try {
370 if(crsSync.getCommand() != null)
371 crsRow.setCommand(crsSync.getCommand());
372 } catch(SQLException sqle) {
373
374 }
375
376 try {
377 crsRow.setKeyColumns(crsSync.getKeyColumns());
378 } catch(SQLException sqle) {
379
380 }
381 return crsRow;
382 }
383
384
385
386 /**
387 * Sets <i>obj</i> as the value in column <i>columnName</i> in the current row of the
388 * <code>RowSet</code> object. This value is the resolved value that is to be
389 * persisted in the data source.
390 *
391 * @param columnName a <code>String</code> object giving the name of the column
392 * into which to set the value to be persisted
393 * @param obj an <code>Object</code> that is the value to be set in the data source
394 */
395 public void setResolvedValue(String columnName, Object obj) throws SQLException {
396 // modify method to throw SQLException in spec
397 // %%% Missing implementation!
398 }
399
400 /**
401 * This function is package private,
402 * i.e. cannot be accesses outside this package.
403 * This is used to set the actual CachedRowSet
404 * which is being synchronized to the database
405 **/
406 void setCachedRowSet(CachedRowSet crs) {
407 crsSync = (CachedRowSetImpl)crs;
408 }
409
410 /**
411 * This function is package private,
412 * i.e. cannot be accesses outside this package.
413 * This is used to set the CachedRowSet formed
414 * with conflict values.
415 **/
416 void setCachedRowSetResolver(CachedRowSet crs){
417 try {
418 crsRes = (CachedRowSetImpl)crs;
419 crsRes.afterLast();
420 sz = crsRes.size();
421 } catch (SQLException sqle) {
422 // do nothing
423 }
424 }
425
426 /**
427 * This function is package private,
428 * i.e. cannot be accesses outside this package.
429 * This is used to set the status of each row
430 * to either of the values SyncResolver.*_CONFLICT
431 **/
432 void setStatus(ArrayList status){
433 stats = status;
434 }
435
436 /**
437 * This function is package private,
438 * i.e. cannot be accesses outside this package.
439 * This is used to set the handle to the writer object
440 * which will write the resolved values back to datasource
441 **/
442 void setCachedRowSetWriter(CachedRowSetWriter CRWriter) {
443 crw = CRWriter;
444 }
445
446 /**
447 * Moves the cursor down one row from its current position. A <code>SyncResolver</code>
448 * cursor is initially positioned before the first conflict row; the first call to the
449 * method <code>nextConflict()</code> makes the first conflict row the current row;
450 * the second call makes the second conflict row the current row, and so on.
451 * <p>
452 * If an input stream is open for the current row, a call to the method next will
453 * implicitly close it. A <code>SyncResolver</code> object's warning chain is cleared
454 * when a new row
455 *
456 * @return true if the new current row is valid; false if there are no more rows
457 * @throws SQLException if a database access occurs
458 *
459 */
460 public boolean nextConflict() throws SQLException {
461 /**
462 * The next() method will hop from
463 * one conflict to another
464 *
465 * Internally do a crs.next() until
466 * next conflict.
467 **/
468 boolean bool = false;
469
470 crsSync.setShowDeleted(true);
471 while(crsSync.next()) {
472 crsRes.previous();
473 rowStatus++; //sz--;
474
475 if((rowStatus-1) >= stats.size()) {
476 bool = false;
477 break;
478 }
479
480 if(((Integer)stats.get(rowStatus-1)).intValue() == SyncResolver.NO_ROW_CONFLICT) {
481 // do nothing
482 // bool remains as false
483 ;
484 } else {
485 bool = true;
486 break;
487 } //end if
488
489 } //end while
490
491 crsSync.setShowDeleted(false);
492 return bool;
493 } // end next() method
494
495
496 /**
497 * Moves the cursor to the previous conflict row in this <code>SyncResolver</code> object.
498 *
499 * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
500 * if it is off the result set
501 * @throws SQLException if a database access error occurs or the result set type
502 * is TYPE_FORWARD_ONLY
503 */
504 public boolean previousConflict() throws SQLException {
505 throw new UnsupportedOperationException();
506 }
507
508 //-----------------------------------------------------------------------
509 // Properties
510 //-----------------------------------------------------------------------
511
512 /**
513 * Sets this <code>CachedRowSetImpl</code> object's command property
514 * to the given <code>String</code> object and clears the parameters,
515 * if any, that were set for the previous command.
516 * <P>
517 * The command property may not be needed
518 * if the rowset is produced by a data source, such as a spreadsheet,
519 * that does not support commands. Thus, this property is optional
520 * and may be <code>null</code>.
521 *
522 * @param cmd a <code>String</code> object containing an SQL query
523 * that will be set as the command; may be <code>null</code>
524 * @throws SQLException if an error occurs
525 */
526 public void setCommand(String cmd) throws SQLException {
527 throw new UnsupportedOperationException();
528 }
529
530
531 //---------------------------------------------------------------------
532 // Reading and writing data
533 //---------------------------------------------------------------------
534
535 /**
536 * Populates this <code>CachedRowSetImpl</code> object with data from
537 * the given <code>ResultSet</code> object. This
538 * method is an alternative to the method <code>execute</code>
539 * for filling the rowset with data. The method <code>populate</code>
540 * does not require that the properties needed by the method
541 * <code>execute</code>, such as the <code>command</code> property,
542 * be set. This is true because the method <code>populate</code>
543 * is given the <code>ResultSet</code> object from
544 * which to get data and thus does not need to use the properties
545 * required for setting up a connection and executing this
546 * <code>CachedRowSetImpl</code> object's command.
547 * <P>
548 * After populating this rowset with data, the method
549 * <code>populate</code> sets the rowset's metadata and
550 * then sends a <code>RowSetChangedEvent</code> object
551 * to all registered listeners prior to returning.
552 *
553 * @param data the <code>ResultSet</code> object containing the data
554 * to be read into this <code>CachedRowSetImpl</code> object
555 * @throws SQLException if an error occurs; or the max row setting is
556 * violated while populating the RowSet
557 * @see #execute
558 */
559 public void populate(ResultSet data) throws SQLException {
560 throw new UnsupportedOperationException();
561 }
562
563 /**
564 * Populates this <code>CachedRowSetImpl</code> object with data,
565 * using the given connection to produce the result set from
566 * which data will be read. A second form of this method,
567 * which takes no arguments, uses the values from this rowset's
568 * user, password, and either url or data source properties to
569 * create a new database connection. The form of <code>execute</code>
570 * that is given a connection ignores these properties.
571 *
572 * @param conn A standard JDBC <code>Connection</code> object that this
573 * <code>CachedRowSet</code> object can pass to a synchronization provider
574 * to establish a connection to the data source
575 * @throws SQLException if an invalid <code>Connection</code> is supplied
576 * or an error occurs in establishing the connection to the
577 * data source
578 * @see #populate
579 * @see java.sql.Connection
580 */
581 public void execute(Connection conn) throws SQLException {
582 throw new UnsupportedOperationException();
583 }
584
585 /**
586 * Propagates all row update, insert, and delete changes to the
587 * underlying data source backing this <code>CachedRowSetImpl</code>
588 * object.
589 * <P>
590 * <b>Note</b>In the reference implementation an optimistic concurrency implementation
591 * is provided as a sample implementation of a the <code>SyncProvider</code>
592 * abstract class.
593 * <P>
594 * This method fails if any of the updates cannot be propagated back
595 * to the data source. When it fails, the caller can assume that
596 * none of the updates are reflected in the data source.
597 * When an exception is thrown, the current row
598 * is set to the first "updated" row that resulted in an exception
599 * unless the row that caused the exception is a "deleted" row.
600 * In that case, when deleted rows are not shown, which is usually true,
601 * the current row is not affected.
602 * <P>
603 * If no <code>SyncProvider</code> is configured, the reference implementation
604 * leverages the <code>RIOptimisticProvider</code> available which provides the
605 * default and reference synchronization capabilities for disconnected
606 * <code>RowSets</code>.
607 *
608 * @throws SQLException if the cursor is on the insert row or the underlying
609 * reference synchronization provider fails to commit the updates
610 * to the datasource
611 * @throws SyncProviderException if an internal error occurs within the
612 * <code>SyncProvider</code> instance during either during the
613 * process or at any time when the <code>SyncProvider</code>
614 * instance touches the data source.
615 * @see #acceptChanges(java.sql.Connection)
616 * @see javax.sql.RowSetWriter
617 * @see javax.sql.rowset.spi.SyncProvider
618 */
619 public void acceptChanges() throws SyncProviderException {
620 throw new UnsupportedOperationException();
621 }
622
623 /**
624 * Propagates all row update, insert, and delete changes to the
625 * data source backing this <code>CachedRowSetImpl</code> object
626 * using the given <code>Connection</code> object.
627 * <P>
628 * The reference implementation <code>RIOptimisticProvider</code>
629 * modifies its synchronization to a write back function given
630 * the updated connection
631 * The reference implementation modifies its synchronization behaviour
632 * via the <code>SyncProvider</code> to ensure the synchronization
633 * occurs according to the updated JDBC <code>Connection</code>
634 * properties.
635 *
636 * @param con a standard JDBC <code>Connection</code> object
637 * @throws SQLException if the cursor is on the insert row or the underlying
638 * synchronization provider fails to commit the updates
639 * back to the data source
640 * @see #acceptChanges
641 * @see javax.sql.RowSetWriter
642 * @see javax.sql.rowset.spi.SyncFactory
643 * @see javax.sql.rowset.spi.SyncProvider
644 */
645 public void acceptChanges(Connection con) throws SyncProviderException{
646 throw new UnsupportedOperationException();
647 }
648
649 /**
650 * Restores this <code>CachedRowSetImpl</code> object to its original state,
651 * that is, its state before the last set of changes.
652 * <P>
653 * Before returning, this method moves the cursor before the first row
654 * and sends a <code>rowSetChanged</code> event to all registered
655 * listeners.
656 * @throws SQLException if an error is occurs rolling back the RowSet
657 * state to the definied original value.
658 * @see javax.sql.RowSetListener#rowSetChanged
659 */
660 public void restoreOriginal() throws SQLException {
661 throw new UnsupportedOperationException();
662 }
663
664 /**
665 * Releases the current contents of this <code>CachedRowSetImpl</code>
666 * object and sends a <code>rowSetChanged</code> event object to all
667 * registered listeners.
668 *
669 * @throws SQLException if an error occurs flushing the contents of
670 * RowSet.
671 * @see javax.sql.RowSetListener#rowSetChanged
672 */
673 public void release() throws SQLException {
674 throw new UnsupportedOperationException();
675 }
676
677 /**
678 * Cancels deletion of the current row and notifies listeners that
679 * a row has changed.
680 * <P>
681 * Note: This method can be ignored if deleted rows are not being shown,
682 * which is the normal case.
683 *
684 * @throws SQLException if the cursor is not on a valid row
685 */
686 public void undoDelete() throws SQLException {
687 throw new UnsupportedOperationException();
688 }
689
690 /**
691 * Immediately removes the current row from this
692 * <code>CachedRowSetImpl</code> object if the row has been inserted, and
693 * also notifies listeners the a row has changed. An exception is thrown
694 * if the row is not a row that has been inserted or the cursor is before
695 * the first row, after the last row, or on the insert row.
696 * <P>
697 * This operation cannot be undone.
698 *
699 * @throws SQLException if an error occurs,
700 * the cursor is not on a valid row,
701 * or the row has not been inserted
702 */
703 public void undoInsert() throws SQLException {
704 throw new UnsupportedOperationException();
705 }
706
707 /**
708 * Immediately reverses the last update operation if the
709 * row has been modified. This method can be
710 * called to reverse updates on a all columns until all updates in a row have
711 * been rolled back to their originating state since the last synchronization
712 * (<code>acceptChanges</code>) or population. This method may also be called
713 * while performing updates to the insert row.
714 * <P>
715 * <code>undoUpdate</code may be called at any time during the life-time of a
716 * rowset, however after a synchronization has occurs this method has no
717 * affect until further modification to the RowSet data occurs.
718 *
719 * @throws SQLException if cursor is before the first row, after the last
720 * row in rowset.
721 * @see #undoDelete
722 * @see #undoInsert
723 * @see java.sql.ResultSet#cancelRowUpdates
724 */
725 public void undoUpdate() throws SQLException {
726 throw new UnsupportedOperationException();
727
728 }
729
730 //--------------------------------------------------------------------
731 // Views
732 //--------------------------------------------------------------------
733
734 /**
735 * Returns a new <code>RowSet</code> object backed by the same data as
736 * that of this <code>CachedRowSetImpl</code> object and sharing a set of cursors
737 * with it. This allows cursors to interate over a shared set of rows, providing
738 * multiple views of the underlying data.
739 *
740 * @return a <code>RowSet</code> object that is a copy of this <code>CachedRowSetImpl</code>
741 * object and shares a set of cursors with it
742 * @throws SQLException if an error occurs or cloning is
743 * not supported
744 * @see javax.sql.RowSetEvent
745 * @see javax.sql.RowSetListener
746 */
747 public RowSet createShared() throws SQLException {
748 throw new UnsupportedOperationException();
749 }
750
751 /**
752 * Returns a new <code>RowSet</code> object containing by the same data
753 * as this <code>CachedRowSetImpl</code> object. This method
754 * differs from the method <code>createCopy</code> in that it throws a
755 * <code>CloneNotSupportedException</code> object instead of an
756 * <code>SQLException</code> object, as the method <code>createShared</code>
757 * does. This <code>clone</code>
758 * method is called internally by the method <code>createShared</code>,
759 * which catches the <code>CloneNotSupportedException</code> object
760 * and in turn throws a new <code>SQLException</code> object.
761 *
762 * @return a copy of this <code>CachedRowSetImpl</code> object
763 * @throws CloneNotSupportedException if an error occurs when
764 * attempting to clone this <code>CachedRowSetImpl</code> object
765 * @see #createShared
766 */
767 protected Object clone() throws CloneNotSupportedException {
768 throw new UnsupportedOperationException();
769 }
770
771 /**
772 * Creates a <code>RowSet</code> object that is a deep copy of
773 * this <code>CachedRowSetImpl</code> object's data, including
774 * constraints. Updates made
775 * on a copy are not visible to the original rowset;
776 * a copy of a rowset is completely independent from the original.
777 * <P>
778 * Making a copy saves the cost of creating an identical rowset
779 * from first principles, which can be quite expensive.
780 * For example, it can eliminate the need to query a
781 * remote database server.
782 * @return a new <code>CachedRowSet</code> object that is a deep copy
783 * of this <code>CachedRowSet</code> object and is
784 * completely independent from this <code>CachedRowSetImpl</code>
785 * object.
786 * @throws SQLException if an error occurs in generating the copy of this
787 * of the <code>CachedRowSetImpl</code>
788 * @see #createShared
789 * @see javax.sql.RowSetEvent
790 * @see javax.sql.RowSetListener
791 */
792 public CachedRowSet createCopy() throws SQLException {
793 throw new UnsupportedOperationException();
794 }
795
796 /**
797 * Creates a <code>RowSet</code> object that is a copy of
798 * this <code>CachedRowSetImpl</code> object's table structure
799 * and the constraints only.
800 * There will be no data in the object being returned.
801 * Updates made on a copy are not visible to the original rowset.
802 * <P>
803 * This helps in getting the underlying XML schema which can
804 * be used as the basis for populating a <code>WebRowSet</code>.
805 *
806 * @return a new <code>CachedRowSet</code> object that is a copy
807 * of this <code>CachedRowSetImpl</code> object's schema and
808 * retains all the constraints on the original rowset but contains
809 * no data
810 * @throws SQLException if an error occurs in generating the copy
811 * of the <code>CachedRowSet</code> object
812 * @see #createShared
813 * @see #createCopy
814 * @see #createCopyNoConstraints
815 * @see javax.sql.RowSetEvent
816 * @see javax.sql.RowSetListener
817 */
818 public CachedRowSet createCopySchema() throws SQLException {
819 throw new UnsupportedOperationException();
820 }
821
822 /**
823 * Creates a <code>CachedRowSet</code> object that is a copy of
824 * this <code>CachedRowSetImpl</code> object's data only.
825 * All constraints set in this object will not be there
826 * in the returning object. Updates made
827 * on a copy are not visible to the original rowset.
828 *
829 * @return a new <code>CachedRowSet</code> object that is a deep copy
830 * of this <code>CachedRowSetImpl</code> object and is
831 * completely independent from this <code>CachedRowSetImpl</code> object
832 * @throws SQLException if an error occurs in generating the copy of the
833 * of the <code>CachedRowSet</code>
834 * @see #createShared
835 * @see #createCopy
836 * @see #createCopySchema
837 * @see javax.sql.RowSetEvent
838 * @see javax.sql.RowSetListener
839 */
840 public CachedRowSet createCopyNoConstraints() throws SQLException {
841 throw new UnsupportedOperationException();
842 }
843
844 /**
845 * Converts this <code>CachedRowSetImpl</code> object to a collection
846 * of tables. The sample implementation utilitizes the <code>TreeMap</code>
847 * collection type.
848 * This class guarantees that the map will be in ascending key order,
849 * sorted according to the natural order for the key's class.
850 *
851 * @return a <code>Collection</code> object consisting of tables,
852 * each of which is a copy of a row in this
853 * <code>CachedRowSetImpl</code> object
854 * @throws SQLException if an error occurs in generating the collection
855 * @see #toCollection(int)
856 * @see #toCollection(String)
857 * @see java.util.TreeMap
858 */
859 public Collection toCollection() throws SQLException {
860 throw new UnsupportedOperationException();
861 }
862
863 /**
864 * Returns the specified column of this <code>CachedRowSetImpl</code> object
865 * as a <code>Collection</code> object. This method makes a copy of the
866 * column's data and utilitizes the <code>Vector</code> to establish the
867 * collection. The <code>Vector</code> class implements a growable array
868 * objects allowing the individual components to be accessed using an
869 * an integer index similar to that of an array.
870 *
871 * @return a <code>Collection</code> object that contains the value(s)
872 * stored in the specified column of this
873 * <code>CachedRowSetImpl</code>
874 * object
875 * @throws SQLException if an error occurs generated the collection; or
876 * an invalid column is provided.
877 * @see #toCollection()
878 * @see #toCollection(String)
879 * @see java.util.Vector
880 */
881 public Collection toCollection(int column) throws SQLException {
882 throw new UnsupportedOperationException();
883 }
884
885 /**
886 * Returns the specified column of this <code>CachedRowSetImpl</code> object
887 * as a <code>Collection</code> object. This method makes a copy of the
888 * column's data and utilitizes the <code>Vector</code> to establish the
889 * collection. The <code>Vector</code> class implements a growable array
890 * objects allowing the individual components to be accessed using an
891 * an integer index similar to that of an array.
892 *
893 * @return a <code>Collection</code> object that contains the value(s)
894 * stored in the specified column of this
895 * <code>CachedRowSetImpl</code>
896 * object
897 * @throws SQLException if an error occurs generated the collection; or
898 * an invalid column is provided.
899 * @see #toCollection()
900 * @see #toCollection(int)
901 * @see java.util.Vector
902 */
903 public Collection toCollection(String column) throws SQLException {
904 throw new UnsupportedOperationException();
905 }
906
907 //--------------------------------------------------------------------
908 // Advanced features
909 //--------------------------------------------------------------------
910
911
912 /**
913 * Returns the <code>SyncProvider</code> implementation being used
914 * with this <code>CachedRowSetImpl</code> implementation rowset.
915 *
916 * @return the SyncProvider used by the rowset. If not provider was
917 * set when the rowset was instantiated, the reference
918 * implementation (default) provider is returned.
919 * @throws SQLException if error occurs while return the
920 * <code>SyncProvider</code> instance.
921 */
922 public SyncProvider getSyncProvider() throws SQLException {
923 throw new UnsupportedOperationException();
924 }
925
926 /**
927 * Sets the active <code>SyncProvider</code> and attempts to load
928 * load the new provider using the <code>SyncFactory</code> SPI.
929 *
930 * @throws SQLException if an error occurs while resetting the
931 * <code>SyncProvider</code>.
932 */
933 public void setSyncProvider(String providerStr) throws SQLException {
934 throw new UnsupportedOperationException();
935 }
936
937
938 //-----------------
939 // methods inherited from RowSet
940 //-----------------
941
942
943
944
945
946
947 //---------------------------------------------------------------------
948 // Reading and writing data
949 //---------------------------------------------------------------------
950
951 /**
952 * Populates this <code>CachedRowSetImpl</code> object with data.
953 * This form of the method uses the rowset's user, password, and url or
954 * data source name properties to create a database
955 * connection. If properties that are needed
956 * have not been set, this method will throw an exception.
957 * <P>
958 * Another form of this method uses an existing JDBC <code>Connection</code>
959 * object instead of creating a new one; therefore, it ignores the
960 * properties used for establishing a new connection.
961 * <P>
962 * The query specified by the command property is executed to create a
963 * <code>ResultSet</code> object from which to retrieve data.
964 * The current contents of the rowset are discarded, and the
965 * rowset's metadata is also (re)set. If there are outstanding updates,
966 * they are also ignored.
967 * <P>
968 * The method <code>execute</code> closes any database connections that it
969 * creates.
970 *
971 * @throws SQLException if an error occurs or the
972 * necessary properties have not been set
973 */
974 public void execute() throws SQLException {
975 throw new UnsupportedOperationException();
976 }
977
978
979
980 //-----------------------------------
981 // Methods inherited from ResultSet
982 //-----------------------------------
983
984 /**
985 * Moves the cursor down one row from its current position and
986 * returns <code>true</code> if the new cursor position is a
987 * valid row.
988 * The cursor for a new <code>ResultSet</code> object is initially
989 * positioned before the first row. The first call to the method
990 * <code>next</code> moves the cursor to the first row, making it
991 * the current row; the second call makes the second row the
992 * current row, and so on.
993 *
994 * <P>If an input stream from the previous row is open, it is
995 * implicitly closed. The <code>ResultSet</code> object's warning
996 * chain is cleared when a new row is read.
997 *
998 * @return <code>true</code> if the new current row is valid;
999 * <code>false</code> if there are no more rows
1000 * @throws SQLException if an error occurs or
1001 * the cursor is not positioned in the rowset, before
1002 * the first row, or after the last row
1003 */
1004 public boolean next() throws SQLException {
1005 throw new UnsupportedOperationException();
1006 }
1007
1008 /**
1009 * Moves this <code>CachedRowSetImpl</code> object's cursor to the next
1010 * row and returns <code>true</code> if the cursor is still in the rowset;
1011 * returns <code>false</code> if the cursor has moved to the position after
1012 * the last row.
1013 * <P>
1014 * This method handles the cases where the cursor moves to a row that
1015 * has been deleted.
1016 * If this rowset shows deleted rows and the cursor moves to a row
1017 * that has been deleted, this method moves the cursor to the next
1018 * row until the cursor is on a row that has not been deleted.
1019 * <P>
1020 * The method <code>internalNext</code> is called by methods such as
1021 * <code>next</code>, <code>absolute</code>, and <code>relative</code>,
1022 * and, as its name implies, is only called internally.
1023 * <p>
1024 * This is a implementation only method and is not required as a standard
1025 * implementation of the <code>CachedRowSet</code> interface.
1026 *
1027 * @return <code>true</code> if the cursor is on a valid row in this
1028 * rowset; <code>false</code> if it is after the last row
1029 * @throws SQLException if an error occurs
1030 */
1031 protected boolean internalNext() throws SQLException {
1032 throw new UnsupportedOperationException();
1033 }
1034
1035 /**
1036 * Closes this <code>CachedRowSetImpl</code> objecy and releases any resources
1037 * it was using.
1038 *
1039 * @throws SQLException if an error occurs when releasing any resources in use
1040 * by this <code>CachedRowSetImpl</code> object
1041 */
1042 public void close() throws SQLException {
1043 throw new UnsupportedOperationException();
1044 }
1045
1046 /**
1047 * Reports whether the last column read was SQL <code>NULL</code>.
1048 * Note that you must first call the method <code>getXXX</code>
1049 * on a column to try to read its value and then call the method
1050 * <code>wasNull</code> to determine whether the value was
1051 * SQL <code>NULL</code>.
1052 *
1053 * @return <code>true</code> if the value in the last column read
1054 * was SQL <code>NULL</code>; <code>false</code> otherwise
1055 * @throws SQLException if an error occurs
1056 */
1057 public boolean wasNull() throws SQLException {
1058 throw new UnsupportedOperationException();
1059 }
1060
1061 /**
1062 * Returns the insert row or the current row of this
1063 * <code>CachedRowSetImpl</code>object.
1064 *
1065 * @return the <code>Row</code> object on which this <code>CachedRowSetImpl</code>
1066 * objects's cursor is positioned
1067 */
1068 protected BaseRow getCurrentRow() {
1069 throw new UnsupportedOperationException();
1070 }
1071
1072 /**
1073 * Removes the row on which the cursor is positioned.
1074 * <p>
1075 * This is a implementation only method and is not required as a standard
1076 * implementation of the <code>CachedRowSet</code> interface.
1077 *
1078 * @throws SQLException if the cursor is positioned on the insert
1079 * row
1080 */
1081 protected void removeCurrentRow() {
1082 throw new UnsupportedOperationException();
1083 }
1084
1085
1086 /**
1087 * Retrieves the value of the designated column in the current row
1088 * of this <code>CachedRowSetImpl</code> object as a
1089 * <code>String</code> object.
1090 *
1091 * @param columnIndex the first column is <code>1</code>, the second
1092 * is <code>2</code>, and so on; must be <code>1</code> or larger
1093 * and equal to or less than the number of columns in the rowset
1094 * @return the column value; if the value is SQL <code>NULL</code>, the
1095 * result is <code>null</code>
1096 * @throws SQLException if (1) the given column index is out of bounds,
1097 * (2) the cursor is not on one of this rowset's rows or its
1098 * insert row, or (3) the designated column does not store an
1099 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1100 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>, <b>VARCHAR</b></code>
1101 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1102 * recommended return type.
1103 */
1104 public String getString(int columnIndex) throws SQLException {
1105 throw new UnsupportedOperationException();
1106 }
1107
1108 /**
1109 * Retrieves the value of the designated column in the current row
1110 * of this <code>CachedRowSetImpl</code> object as a
1111 * <code>boolean</code> value.
1112 *
1113 * @param columnIndex the first column is <code>1</code>, the second
1114 * is <code>2</code>, and so on; must be <code>1</code> or larger
1115 * and equal to or less than the number of columns in the rowset
1116 * @return the column value as a <code>boolean</code> in the Java progamming language;
1117 * if the value is SQL <code>NULL</code>, the result is <code>false</code>
1118 * @throws SQLException if (1) the given column index is out of bounds,
1119 * (2) the cursor is not on one of this rowset's rows or its
1120 * insert row, or (3) the designated column does not store an
1121 * SQL <code>BOOLEAN</code> value
1122 * @see #getBoolean(String)
1123 */
1124 public boolean getBoolean(int columnIndex) throws SQLException {
1125 throw new UnsupportedOperationException();
1126 }
1127
1128 /**
1129 * Retrieves the value of the designated column in the current row
1130 * of this <code>CachedRowSetImpl</code> object as a
1131 * <code>byte</code> value.
1132 *
1133 * @param columnIndex the first column is <code>1</code>, the second
1134 * is <code>2</code>, and so on; must be <code>1</code> or larger
1135 * and equal to or less than the number of columns in the rowset
1136 * @return the column value as a <code>byte</code> in the Java programming
1137 * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1138 * @throws SQLException if (1) the given column index is out of bounds,
1139 * (2) the cursor is not on one of this rowset's rows or its
1140 * insert row, or (3) the designated column does not store an
1141 * SQL <code><b>TINYINT</b>, SMALLINT, INTEGER, BIGINT, REAL,
1142 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1143 * or <code>LONGVARCHAR</code> value. The bold SQL type
1144 * designates the recommended return type.
1145 * @see #getByte(String)
1146 */
1147 public byte getByte(int columnIndex) throws SQLException {
1148 throw new UnsupportedOperationException();
1149 }
1150
1151 /**
1152 * Retrieves the value of the designated column in the current row
1153 * of this <code>CachedRowSetImpl</code> object as a
1154 * <code>short</code> value.
1155 *
1156 * @param columnIndex the first column is <code>1</code>, the second
1157 * is <code>2</code>, and so on; must be <code>1</code> or larger
1158 * and equal to or less than the number of columns in the rowset
1159 * @return the column value; if the value is SQL <code>NULL</code>, the
1160 * result is <code>0</code>
1161 * @throws SQLException if (1) the given column index is out of bounds,
1162 * (2) the cursor is not on one of this rowset's rows or its
1163 * insert row, or (3) the designated column does not store an
1164 * SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER, BIGINT, REAL
1165 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1166 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1167 * recommended return type.
1168 * @see #getShort(String)
1169 */
1170 public short getShort(int columnIndex) throws SQLException {
1171 throw new UnsupportedOperationException();
1172 }
1173
1174 /**
1175 * Retrieves the value of the designated column in the current row
1176 * of this <code>CachedRowSetImpl</code> object as an
1177 * <code>int</code> value.
1178 *
1179 * @param columnIndex the first column is <code>1</code>, the second
1180 * is <code>2</code>, and so on; must be <code>1</code> or larger
1181 * and equal to or less than the number of columns in the rowset
1182 * @return the column value; if the value is SQL <code>NULL</code>, the
1183 * result is <code>0</code>
1184 * @throws SQLException if (1) the given column index is out of bounds,
1185 * (2) the cursor is not on one of this rowset's rows or its
1186 * insert row, or (3) the designated column does not store an
1187 * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1188 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1189 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1190 * recommended return type.
1191 */
1192 public int getInt(int columnIndex) throws SQLException {
1193 throw new UnsupportedOperationException();
1194 }
1195
1196 /**
1197 * Retrieves the value of the designated column in the current row
1198 * of this <code>CachedRowSetImpl</code> object as a
1199 * <code>long</code> value.
1200 *
1201 * @param columnIndex the first column is <code>1</code>, the second
1202 * is <code>2</code>, and so on; must be <code>1</code> or larger
1203 * and equal to or less than the number of columns in the rowset
1204 * @return the column value; if the value is SQL <code>NULL</code>, the
1205 * result is <code>0</code>
1206 * @throws SQLException if (1) the given column index is out of bounds,
1207 * (2) the cursor is not on one of this rowset's rows or its
1208 * insert row, or (3) the designated column does not store an
1209 * SQL <code>TINYINT, SMALLINT, INTEGER, <b>BIGINT</b>, REAL
1210 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1211 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1212 * recommended return type.
1213 * @see #getLong(String)
1214 */
1215 public long getLong(int columnIndex) throws SQLException {
1216 throw new UnsupportedOperationException();
1217 }
1218
1219 /**
1220 * Retrieves the value of the designated column in the current row
1221 * of this <code>CachedRowSetImpl</code> object as a
1222 * <code>float</code> value.
1223 *
1224 * @param columnIndex the first column is <code>1</code>, the second
1225 * is <code>2</code>, and so on; must be <code>1</code> or larger
1226 * and equal to or less than the number of columns in the rowset
1227 * @return the column value; if the value is SQL <code>NULL</code>, the
1228 * result is <code>0</code>
1229 * @throws SQLException if (1) the given column index is out of bounds,
1230 * (2) the cursor is not on one of this rowset's rows or its
1231 * insert row, or (3) the designated column does not store an
1232 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, <b>REAL</b>,
1233 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1234 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1235 * recommended return type.
1236 * @see #getFloat(String)
1237 */
1238 public float getFloat(int columnIndex) throws SQLException {
1239 throw new UnsupportedOperationException();
1240 }
1241
1242 /**
1243 * Retrieves the value of the designated column in the current row
1244 * of this <code>CachedRowSetImpl</code> object as a
1245 * <code>double</code> value.
1246 *
1247 * @param columnIndex the first column is <code>1</code>, the second
1248 * is <code>2</code>, and so on; must be <code>1</code> or larger
1249 * and equal to or less than the number of columns in the rowset
1250 * @return the column value; if the value is SQL <code>NULL</code>, the
1251 * result is <code>0</code>
1252 * @throws SQLException if (1) the given column index is out of bounds,
1253 * (2) the cursor is not on one of this rowset's rows or its
1254 * insert row, or (3) the designated column does not store an
1255 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1256 * <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1257 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1258 * recommended return type.
1259 * @see #getDouble(String)
1260 *
1261 */
1262 public double getDouble(int columnIndex) throws SQLException {
1263 throw new UnsupportedOperationException();
1264 }
1265
1266 /**
1267 * Retrieves the value of the designated column in the current row
1268 * of this <code>CachedRowSetImpl</code> object as a
1269 * <code>java.math.BigDecimal</code> object.
1270 * <P>
1271 * This method is deprecated; use the version of <code>getBigDecimal</code>
1272 * that does not take a scale parameter and returns a value with full
1273 * precision.
1274 *
1275 * @param columnIndex the first column is <code>1</code>, the second
1276 * is <code>2</code>, and so on; must be <code>1</code> or larger
1277 * and equal to or less than the number of columns in the rowset
1278 * @param scale the number of digits to the right of the decimal point in the
1279 * value returned
1280 * @return the column value with the specified number of digits to the right
1281 * of the decimal point; if the value is SQL <code>NULL</code>, the
1282 * result is <code>null</code>
1283 * @throws SQLException if the given column index is out of bounds,
1284 * the cursor is not on a valid row, or this method fails
1285 * @deprecated
1286 */
1287 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
1288 throw new UnsupportedOperationException();
1289 }
1290
1291 /**
1292 * Retrieves the value of the designated column in the current row
1293 * of this <code>CachedRowSetImpl</code> object as a
1294 * <code>byte</code> array value.
1295 *
1296 * @param columnIndex the first column is <code>1</code>, the second
1297 * is <code>2</code>, and so on; must be <code>1</code> or larger
1298 * and equal to or less than the number of columns in the rowset
1299 * @return the column value as a <code>byte</code> array in the Java programming
1300 * language; if the value is SQL <code>NULL</code>, the
1301 * result is <code>null</code>
1302 *
1303 * @throws SQLException if (1) the given column index is out of bounds,
1304 * (2) the cursor is not on one of this rowset's rows or its
1305 * insert row, or (3) the designated column does not store an
1306 * SQL <code><b>BINARY</b>, <b>VARBINARY</b> or
1307 * LONGVARBINARY</code> value.
1308 * The bold SQL type designates the recommended return type.
1309 * @see #getBytes(String)
1310 */
1311 public byte[] getBytes(int columnIndex) throws SQLException {
1312 throw new UnsupportedOperationException();
1313 }
1314
1315 /**
1316 * Retrieves the value of the designated column in the current row
1317 * of this <code>CachedRowSetImpl</code> object as a
1318 * <code>java.sql.Date</code> object.
1319 *
1320 * @param columnIndex the first column is <code>1</code>, the second
1321 * is <code>2</code>, and so on; must be <code>1</code> or larger
1322 * and equal to or less than the number of columns in the rowset
1323 * @return the column value as a <code>java.sql.Data</code> object; if
1324 * the value is SQL <code>NULL</code>, the
1325 * result is <code>null</code>
1326 * @throws SQLException if the given column index is out of bounds,
1327 * the cursor is not on a valid row, or this method fails
1328 */
1329 public java.sql.Date getDate(int columnIndex) throws SQLException {
1330 throw new UnsupportedOperationException();
1331 }
1332
1333 /**
1334 * Retrieves the value of the designated column in the current row
1335 * of this <code>CachedRowSetImpl</code> object as a
1336 * <code>java.sql.Time</code> object.
1337 *
1338 * @param columnIndex the first column is <code>1</code>, the second
1339 * is <code>2</code>, and so on; must be <code>1</code> or larger
1340 * and equal to or less than the number of columns in the rowset
1341 * @return the column value; if the value is SQL <code>NULL</code>, the
1342 * result is <code>null</code>
1343 * @throws SQLException if the given column index is out of bounds,
1344 * the cursor is not on a valid row, or this method fails
1345 */
1346 public java.sql.Time getTime(int columnIndex) throws SQLException {
1347 throw new UnsupportedOperationException();
1348 }
1349
1350 /**
1351 * Retrieves the value of the designated column in the current row
1352 * of this <code>CachedRowSetImpl</code> object as a
1353 * <code>java.sql.Timestamp</code> object.
1354 *
1355 * @param columnIndex the first column is <code>1</code>, the second
1356 * is <code>2</code>, and so on; must be <code>1</code> or larger
1357 * and equal to or less than the number of columns in the rowset
1358 * @return the column value; if the value is SQL <code>NULL</code>, the
1359 * result is <code>null</code>
1360 * @throws SQLException if the given column index is out of bounds,
1361 * the cursor is not on a valid row, or this method fails
1362 */
1363 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
1364 throw new UnsupportedOperationException();
1365 }
1366
1367 /**
1368 * Retrieves the value of the designated column in the current row of this
1369 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1370 * object.
1371 *
1372 * A column value can be retrieved as a stream of ASCII characters
1373 * and then read in chunks from the stream. This method is particularly
1374 * suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC
1375 * driver will do any necessary conversion from the database format into ASCII.
1376 *
1377 * <P><B>Note:</B> All the data in the returned stream must be
1378 * read prior to getting the value of any other column. The next
1379 * call to a get method implicitly closes the stream. . Also, a
1380 * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
1381 * whether there is data available or not.
1382 *
1383 * @param columnIndex the first column is <code>1</code>, the second
1384 * is <code>2</code>, and so on; must be <code>1</code> or larger
1385 * and equal to or less than the number of columns in this rowset
1386 * @return a Java input stream that delivers the database column value
1387 * as a stream of one-byte ASCII characters. If the value is SQL
1388 * <code>NULL</code>, the result is <code>null</code>.
1389 * @throws SQLException if (1) the given column index is out of bounds,
1390 * (2) the cursor is not on one of this rowset's rows or its
1391 * insert row, or (3) the designated column does not store an
1392 * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1393 * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1394 * bold SQL type designates the recommended return types that this method is
1395 * used to retrieve.
1396 * @see #getAsciiStream(String)
1397 */
1398 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
1399 throw new UnsupportedOperationException();
1400 }
1401
1402 /**
1403 * A column value can be retrieved as a stream of Unicode characters
1404 * and then read in chunks from the stream. This method is particularly
1405 * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
1406 * do any necessary conversion from the database format into Unicode.
1407 *
1408 * <P><B>Note:</B> All the data in the returned stream must be
1409 * read prior to getting the value of any other column. The next
1410 * call to a get method implicitly closes the stream. . Also, a
1411 * stream may return 0 for available() whether there is data
1412 * available or not.
1413 *
1414 * @param columnIndex the first column is <code>1</code>, the second
1415 * is <code>2</code>, and so on; must be <code>1</code> or larger
1416 * and equal to or less than the number of columns in this rowset
1417 * @return a Java input stream that delivers the database column value
1418 * as a stream of two byte Unicode characters. If the value is SQL NULL
1419 * then the result is null.
1420 * @throws SQLException if an error occurs
1421 * @deprecated
1422 */
1423 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
1424 throw new UnsupportedOperationException();
1425 }
1426
1427 /**
1428 * Retrieves the value of the designated column in the current row of this
1429 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1430 * object.
1431 * <P>
1432 * A column value can be retrieved as a stream of uninterpreted bytes
1433 * and then read in chunks from the stream. This method is particularly
1434 * suitable for retrieving large <code>LONGVARBINARY</code> values.
1435 *
1436 * <P><B>Note:</B> All the data in the returned stream must be
1437 * read prior to getting the value of any other column. The next
1438 * call to a get method implicitly closes the stream. Also, a
1439 * stream may return <code>0</code> for
1440 * <code>CachedRowSetImpl.available()</code> whether there is data
1441 * available or not.
1442 *
1443 * @param columnIndex the first column is <code>1</code>, the second
1444 * is <code>2</code>, and so on; must be <code>1</code> or larger
1445 * and equal to or less than the number of columns in the rowset
1446 * @return a Java input stream that delivers the database column value
1447 * as a stream of uninterpreted bytes. If the value is SQL <code>NULL</code>
1448 * then the result is <code>null</code>.
1449 * @throws SQLException if (1) the given column index is out of bounds,
1450 * (2) the cursor is not on one of this rowset's rows or its
1451 * insert row, or (3) the designated column does not store an
1452 * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1453 * The bold type indicates the SQL type that this method is recommened
1454 * to retrieve.
1455 * @see #getBinaryStream(String)
1456 */
1457 public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
1458 throw new UnsupportedOperationException();
1459
1460 }
1461
1462
1463 //======================================================================
1464 // Methods for accessing results by column name
1465 //======================================================================
1466
1467 /**
1468 * Retrieves the value stored in the designated column
1469 * of the current row as a <code>String</code> object.
1470 *
1471 * @param columnName a <code>String</code> object giving the SQL name of
1472 * a column in this <code>CachedRowSetImpl</code> object
1473 * @return the column value; if the value is SQL <code>NULL</code>,
1474 * the result is <code>null</code>
1475 * @throws SQLException if (1) the given column name is not the name of
1476 * a column in this rowset, (2) the cursor is not on one of
1477 * this rowset's rows or its insert row, or (3) the designated
1478 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1479 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>,
1480 * <b>VARCHAR</b></code> or <code>LONGVARCHAR<</code> value. The bold SQL type
1481 * designates the recommended return type.
1482 */
1483 public String getString(String columnName) throws SQLException {
1484 throw new UnsupportedOperationException();
1485 }
1486
1487 /**
1488 * Retrieves the value stored in the designated column
1489 * of the current row as a <code>boolean</code> value.
1490 *
1491 * @param columnName a <code>String</code> object giving the SQL name of
1492 * a column in this <code>CachedRowSetImpl</code> object
1493 * @return the column value as a <code>boolean</code> in the Java programming
1494 * language; if the value is SQL <code>NULL</code>,
1495 * the result is <code>false</code>
1496 * @throws SQLException if (1) the given column name is not the name of
1497 * a column in this rowset, (2) the cursor is not on one of
1498 * this rowset's rows or its insert row, or (3) the designated
1499 * column does not store an SQL <code>BOOLEAN</code> value
1500 * @see #getBoolean(int)
1501 */
1502 public boolean getBoolean(String columnName) throws SQLException {
1503 throw new UnsupportedOperationException();
1504 }
1505
1506 /**
1507 * Retrieves the value stored in the designated column
1508 * of the current row as a <code>byte</code> value.
1509 *
1510 * @param columnName a <code>String</code> object giving the SQL name of
1511 * a column in this <code>CachedRowSetImpl</code> object
1512 * @return the column value as a <code>byte</code> in the Java programming
1513 * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1514 * @throws SQLException if (1) the given column name is not the name of
1515 * a column in this rowset, (2) the cursor is not on one of
1516 * this rowset's rows or its insert row, or (3) the designated
1517 * column does not store an SQL <code><B>TINYINT</B>, SMALLINT, INTEGER,
1518 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1519 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The
1520 * bold type designates the recommended return type
1521 */
1522 public byte getByte(String columnName) throws SQLException {
1523 throw new UnsupportedOperationException();
1524 }
1525
1526 /**
1527 * Retrieves the value stored in the designated column
1528 * of the current row as a <code>short</code> value.
1529 *
1530 * @param columnName a <code>String</code> object giving the SQL name of
1531 * a column in this <code>CachedRowSetImpl</code> object
1532 * @return the column value; if the value is SQL <code>NULL</code>,
1533 * the result is <code>0</code>
1534 * @throws SQLException if (1) the given column name is not the name of
1535 * a column in this rowset, (2) the cursor is not on one of
1536 * this rowset's rows or its insert row, or (3) the designated
1537 * column does not store an SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER
1538 * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1539 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1540 * designates the recommended return type.
1541 * @see #getShort(int)
1542 */
1543 public short getShort(String columnName) throws SQLException {
1544 throw new UnsupportedOperationException();
1545 }
1546
1547 /**
1548 * Retrieves the value stored in the designated column
1549 * of the current row as an <code>int</code> value.
1550 *
1551 * @param columnName a <code>String</code> object giving the SQL name of
1552 * a column in this <code>CachedRowSetImpl</code> object
1553 * @return the column value; if the value is SQL <code>NULL</code>,
1554 * the result is <code>0</code>
1555 * @throws SQLException if (1) the given column name is not the name
1556 * of a column in this rowset,
1557 * (2) the cursor is not on one of this rowset's rows or its
1558 * insert row, or (3) the designated column does not store an
1559 * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1560 * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1561 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1562 * recommended return type.
1563 */
1564 public int getInt(String columnName) throws SQLException {
1565 throw new UnsupportedOperationException();
1566 }
1567
1568 /**
1569 * Retrieves the value stored in the designated column
1570 * of the current row as a <code>long</code> value.
1571 *
1572 * @param columnName a <code>String</code> object giving the SQL name of
1573 * a column in this <code>CachedRowSetImpl</code> object
1574 * @return the column value; if the value is SQL <code>NULL</code>,
1575 * the result is <code>0</code>
1576 * @throws SQLException if (1) the given column name is not the name of
1577 * a column in this rowset, (2) the cursor is not on one of
1578 * this rowset's rows or its insert row, or (3) the designated
1579 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1580 * <b>BIGINT</b>, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1581 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1582 * designates the recommended return type.
1583 * @see #getLong(int)
1584 */
1585 public long getLong(String columnName) throws SQLException {
1586 throw new UnsupportedOperationException();
1587 }
1588
1589 /**
1590 * Retrieves the value stored in the designated column
1591 * of the current row as a <code>float</code> value.
1592 *
1593 * @param columnName a <code>String</code> object giving the SQL name of
1594 * a column in this <code>CachedRowSetImpl</code> object
1595 * @return the column value; if the value is SQL <code>NULL</code>,
1596 * the result is <code>0</code>
1597 * @throws SQLException if (1) the given column name is not the name of
1598 * a column in this rowset, (2) the cursor is not on one of
1599 * this rowset's rows or its insert row, or (3) the designated
1600 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1601 * BIGINT, <b>REAL</b>, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1602 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1603 * designates the recommended return type.
1604 * @see #getFloat(String)
1605 */
1606 public float getFloat(String columnName) throws SQLException {
1607 throw new UnsupportedOperationException();
1608 }
1609
1610 /**
1611 * Retrieves the value stored in the designated column
1612 * of the current row of this <code>CachedRowSetImpl</code> object
1613 * as a <code>double</code> value.
1614 *
1615 * @param columnName a <code>String</code> object giving the SQL name of
1616 * a column in this <code>CachedRowSetImpl</code> object
1617 * @return the column value; if the value is SQL <code>NULL</code>,
1618 * the result is <code>0</code>
1619 * @throws SQLException if (1) the given column name is not the name of
1620 * a column in this rowset, (2) the cursor is not on one of
1621 * this rowset's rows or its insert row, or (3) the designated
1622 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1623 * BIGINT, REAL, <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR,
1624 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1625 * designates the recommended return types.
1626 * @see #getDouble(int)
1627 */
1628 public double getDouble(String columnName) throws SQLException {
1629 throw new UnsupportedOperationException();
1630 }
1631
1632 /**
1633 * Retrieves the value stored in the designated column
1634 * of the current row as a <code>java.math.BigDecimal</code> object.
1635 *
1636 * @param columnName a <code>String</code> object giving the SQL name of
1637 * a column in this <code>CachedRowSetImpl</code> object
1638 * @param scale the number of digits to the right of the decimal point
1639 * @return a java.math.BugDecimal object with <code><i>scale</i></code>
1640 * number of digits to the right of the decimal point.
1641 * @throws SQLException if (1) the given column name is not the name of
1642 * a column in this rowset, (2) the cursor is not on one of
1643 * this rowset's rows or its insert row, or (3) the designated
1644 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1645 * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
1646 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1647 * designates the recommended return type that this method is used to
1648 * retrieve.
1649 * @deprecated Use the <code>getBigDecimal(String columnName)</code>
1650 * method instead
1651 */
1652 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
1653 throw new UnsupportedOperationException();
1654 }
1655
1656 /**
1657 * Retrieves the value stored in the designated column
1658 * of the current row as a <code>byte</code> array.
1659 * The bytes represent the raw values returned by the driver.
1660 *
1661 * @param columnName a <code>String</code> object giving the SQL name of
1662 * a column in this <code>CachedRowSetImpl</code> object
1663 * @return the column value as a <code>byte</code> array in the Java programming
1664 * language; if the value is SQL <code>NULL</code>, the result is <code>null</code>
1665 * @throws SQLException if (1) the given column name is not the name of
1666 * a column in this rowset, (2) the cursor is not on one of
1667 * this rowset's rows or its insert row, or (3) the designated
1668 * column does not store an SQL <code><b>BINARY</b>, <b>VARBINARY</b>
1669 * </code> or <code>LONGVARBINARY</code> values
1670 * The bold SQL type designates the recommended return type.
1671 * @see #getBytes(int)
1672 */
1673 public byte[] getBytes(String columnName) throws SQLException {
1674 throw new UnsupportedOperationException();
1675 }
1676
1677 /**
1678 * Retrieves the value stored in the designated column
1679 * of the current row as a <code>java.sql.Date</code> object.
1680 *
1681 * @param columnName a <code>String</code> object giving the SQL name of
1682 * a column in this <code>CachedRowSetImpl</code> object
1683 * @return the column value; if the value is SQL <code>NULL</code>,
1684 * the result is <code>null</code>
1685 * @throws SQLException if (1) the given column name is not the name of
1686 * a column in this rowset, (2) the cursor is not on one of
1687 * this rowset's rows or its insert row, or (3) the designated
1688 * column does not store an SQL <code>DATE</code> or
1689 * <code>TIMESTAMP</code> value
1690 */
1691 public java.sql.Date getDate(String columnName) throws SQLException {
1692 throw new UnsupportedOperationException();
1693 }
1694
1695 /**
1696 * Retrieves the value stored in the designated column
1697 * of the current row as a <code>java.sql.Time</code> object.
1698 *
1699 * @param columnName a <code>String</code> object giving the SQL name of
1700 * a column in this <code>CachedRowSetImpl</code> object
1701 * @return the column value; if the value is SQL <code>NULL</code>,
1702 * the result is <code>null</code>
1703 * @throws SQLException if the given column name does not match one of
1704 * this rowset's column names or the cursor is not on one of
1705 * this rowset's rows or its insert row
1706 */
1707 public java.sql.Time getTime(String columnName) throws SQLException {
1708 throw new UnsupportedOperationException();
1709 }
1710
1711 /**
1712 * Retrieves the value stored in the designated column
1713 * of the current row as a <code>java.sql.Timestamp</code> object.
1714 *
1715 * @param columnName a <code>String</code> object giving the SQL name of
1716 * a column in this <code>CachedRowSetImpl</code> object
1717 * @return the column value; if the value is SQL <code>NULL</code>,
1718 * the result is <code>null</code>
1719 * @throws SQLException if the given column name does not match one of
1720 * this rowset's column names or the cursor is not on one of
1721 * this rowset's rows or its insert row
1722 */
1723 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
1724 throw new UnsupportedOperationException();
1725 }
1726
1727 /**
1728 * Retrieves the value of the designated column in the current row of this
1729 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1730 * object.
1731 *
1732 * A column value can be retrieved as a stream of ASCII characters
1733 * and then read in chunks from the stream. This method is particularly
1734 * suitable for retrieving large <code>LONGVARCHAR</code> values. The
1735 * <code>SyncProvider</code> will rely on the JDBC driver to do any necessary
1736 * conversion from the database format into ASCII format.
1737 *
1738 * <P><B>Note:</B> All the data in the returned stream must
1739 * be read prior to getting the value of any other column. The
1740 * next call to a <code>getXXX</code> method implicitly closes the stream.
1741 *
1742 * @param columnName a <code>String</code> object giving the SQL name of
1743 * a column in this <code>CachedRowSetImpl</code> object
1744 * @return a Java input stream that delivers the database column value
1745 * as a stream of one-byte ASCII characters. If the value is SQL
1746 * <code>NULL</code>, the result is <code>null</code>.
1747 * @throws SQLException if (1) the given column name is not the name of
1748 * a column in this rowset
1749 * (2) the cursor is not on one of this rowset's rows or its
1750 * insert row, or (3) the designated column does not store an
1751 * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1752 * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1753 * bold SQL type designates the recommended return types that this method is
1754 * used to retrieve.
1755 * @see #getAsciiStream(int)
1756 */
1757 public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
1758 throw new UnsupportedOperationException();
1759
1760 }
1761
1762 /**
1763 * A column value can be retrieved as a stream of Unicode characters
1764 * and then read in chunks from the stream. This method is particularly
1765 * suitable for retrieving large <code>LONGVARCHAR</code> values.
1766 * The JDBC driver will do any necessary conversion from the database
1767 * format into Unicode.
1768 *
1769 * <P><B>Note:</B> All the data in the returned stream must
1770 * be read prior to getting the value of any other column. The
1771 * next call to a <code>getXXX</code> method implicitly closes the stream.
1772 *
1773 * @param columnName a <code>String</code> object giving the SQL name of
1774 * a column in this <code>CachedRowSetImpl</code> object
1775 * @return a Java input stream that delivers the database column value
1776 * as a stream of two-byte Unicode characters. If the value is
1777 * SQL <code>NULL</code>, the result is <code>null</code>.
1778 * @throws SQLException if the given column name does not match one of
1779 * this rowset's column names or the cursor is not on one of
1780 * this rowset's rows or its insert row
1781 * @deprecated use the method <code>getCharacterStream</code> instead
1782 */
1783 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
1784 throw new UnsupportedOperationException();
1785 }
1786
1787 /**
1788 * Retrieves the value of the designated column in the current row of this
1789 * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1790 * object.
1791 * <P>
1792 * A column value can be retrieved as a stream of uninterpreted bytes
1793 * and then read in chunks from the stream. This method is particularly
1794 * suitable for retrieving large <code>LONGVARBINARY</code> values.
1795 *
1796 * <P><B>Note:</B> All the data in the returned stream must be
1797 * read prior to getting the value of any other column. The next
1798 * call to a get method implicitly closes the stream. Also, a
1799 * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
1800 * whether there is data available or not.
1801 *
1802 * @param columnName a <code>String</code> object giving the SQL name of
1803 * a column in this <code>CachedRowSetImpl</code> object
1804 * @return a Java input stream that delivers the database column value
1805 * as a stream of uninterpreted bytes. If the value is SQL
1806 * <code>NULL</code>, the result is <code>null</code>.
1807 * @throws SQLException if (1) the given column name is unknown,
1808 * (2) the cursor is not on one of this rowset's rows or its
1809 * insert row, or (3) the designated column does not store an
1810 * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1811 * The bold type indicates the SQL type that this method is recommened
1812 * to retrieve.
1813 * @see #getBinaryStream(int)
1814 *
1815 */
1816 public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
1817 throw new UnsupportedOperationException();
1818 }
1819
1820
1821 //=====================================================================
1822 // Advanced features:
1823 //=====================================================================
1824
1825 /**
1826 * The first warning reported by calls on this <code>CachedRowSetImpl</code>
1827 * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
1828 * be chained to this <code>SQLWarning</code>.
1829 *
1830 * <P>The warning chain is automatically cleared each time a new
1831 * row is read.
1832 *
1833 * <P><B>Note:</B> This warning chain only covers warnings caused
1834 * by <code>ResultSet</code> methods. Any warning caused by statement
1835 * methods (such as reading OUT parameters) will be chained on the
1836 * <code>Statement</code> object.
1837 *
1838 * @return the first SQLWarning or null
1839 */
1840 public SQLWarning getWarnings() {
1841 throw new UnsupportedOperationException();
1842 }
1843
1844 /**
1845 * Clears all the warnings reporeted for the <code>CachedRowSetImpl</code>
1846 * object. After a call to this method, the <code>getWarnings</code> method
1847 * returns <code>null</code> until a new warning is reported for this
1848 * <code>CachedRowSetImpl</code> object.
1849 */
1850 public void clearWarnings() {
1851 throw new UnsupportedOperationException();
1852 }
1853
1854 /**
1855 * Retrieves the name of the SQL cursor used by this
1856 * <code>CachedRowSetImpl</code> object.
1857 *
1858 * <P>In SQL, a result table is retrieved through a cursor that is
1859 * named. The current row of a <code>ResultSet</code> can be updated or deleted
1860 * using a positioned update/delete statement that references the
1861 * cursor name. To ensure that the cursor has the proper isolation
1862 * level to support an update operation, the cursor's <code>SELECT</code>
1863 * statement should be of the form <code>select for update</code>.
1864 * If the <code>for update</code> clause
1865 * is omitted, positioned updates may fail.
1866 *
1867 * <P>JDBC supports this SQL feature by providing the name of the
1868 * SQL cursor used by a <code>ResultSet</code> object. The current row
1869 * of a result set is also the current row of this SQL cursor.
1870 *
1871 * <P><B>Note:</B> If positioned updates are not supported, an
1872 * <code>SQLException</code> is thrown.
1873 *
1874 * @return the SQL cursor name for this <code>CachedRowSetImpl</code> object's
1875 * cursor
1876 * @throws SQLException if an error occurs
1877 */
1878 public String getCursorName() throws SQLException {
1879 throw new UnsupportedOperationException();
1880 }
1881
1882 /**
1883 * Retrieves a <code>ResultSetMetaData</code> object instance that
1884 * contains information about the <code>CachedRowSet</code> object.
1885 * However, applications should cast the returned object to a
1886 * <code>RowSetMetaData</code> interface implementation. In the
1887 * reference implementation, this cast can be done on the
1888 * <code>RowSetMetaDataImpl</code> class.
1889 * <P>
1890 * For example:
1891 * <pre>
1892 * CachedRowSet crs = new CachedRowSetImpl();
1893 * RowSetMetaDataImpl metaData =
1894 * (RowSetMetaDataImpl)crs.getMetaData();
1895 * // Set the number of columns in the RowSet object for
1896 * // which this RowSetMetaDataImpl object was created to the
1897 * // given number.
1898 * metaData.setColumnCount(3);
1899 * crs.setMetaData(metaData);
1900 * </pre>
1901 *
1902 * @return the <code>ResultSetMetaData</code> object that describes this
1903 * <code>CachedRowSetImpl</code> object's columns
1904 * @throws SQLException if an error occurs in generating the RowSet
1905 * meta data; or if the <code>CachedRowSetImpl</code> is empty.
1906 * @see javax.sql.RowSetMetaData
1907 */
1908 public ResultSetMetaData getMetaData() throws SQLException {
1909 throw new UnsupportedOperationException();
1910 }
1911
1912
1913 /**
1914 * Retrieves the value of the designated column in the current row
1915 * of this <code>CachedRowSetImpl</code> object as an
1916 * <code>Object</code> value.
1917 * <P>
1918 * The type of the <code>Object</code> will be the default
1919 * Java object type corresponding to the column's SQL type,
1920 * following the mapping for built-in types specified in the JDBC 3.0
1921 * specification.
1922 * <P>
1923 * This method may also be used to read datatabase-specific
1924 * abstract data types.
1925 * <P>
1926 * This implementation of the method <code>getObject</code> extends its
1927 * behavior so that it gets the attributes of an SQL structured type
1928 * as an array of <code>Object</code> values. This method also custom
1929 * maps SQL user-defined types to classes in the Java programming language.
1930 * When the specified column contains
1931 * a structured or distinct value, the behavior of this method is as
1932 * if it were a call to the method <code>getObject(columnIndex,
1933 * this.getStatement().getConnection().getTypeMap())</code>.
1934 *
1935 * @param columnIndex the first column is <code>1</code>, the second
1936 * is <code>2</code>, and so on; must be <code>1</code> or larger
1937 * and equal to or less than the number of columns in the rowset
1938 * @return a <code>java.lang.Object</code> holding the column value;
1939 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1940 * @throws SQLException if the given column index is out of bounds,
1941 * the cursor is not on a valid row, or there is a problem getting
1942 * the <code>Class</code> object for a custom mapping
1943 * @see #getObject(String)
1944 */
1945 public Object getObject(int columnIndex) throws SQLException {
1946 throw new UnsupportedOperationException();
1947 }
1948
1949 /**
1950 * Retrieves the value of the designated column in the current row
1951 * of this <code>CachedRowSetImpl</code> object as an
1952 * <code>Object</code> value.
1953 * <P>
1954 * The type of the <code>Object</code> will be the default
1955 * Java object type corresponding to the column's SQL type,
1956 * following the mapping for built-in types specified in the JDBC 3.0
1957 * specification.
1958 * <P>
1959 * This method may also be used to read datatabase-specific
1960 * abstract data types.
1961 * <P>
1962 * This implementation of the method <code>getObject</code> extends its
1963 * behavior so that it gets the attributes of an SQL structured type
1964 * as an array of <code>Object</code> values. This method also custom
1965 * maps SQL user-defined types to classes
1966 * in the Java programming language. When the specified column contains
1967 * a structured or distinct value, the behavior of this method is as
1968 * if it were a call to the method <code>getObject(columnIndex,
1969 * this.getStatement().getConnection().getTypeMap())</code>.
1970 *
1971 * @param columnName a <code>String</code> object that must match the
1972 * SQL name of a column in this rowset, ignoring case
1973 * @return a <code>java.lang.Object</code> holding the column value;
1974 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1975 * @throws SQLException if (1) the given column name does not match one of
1976 * this rowset's column names, (2) the cursor is not
1977 * on a valid row, or (3) there is a problem getting
1978 * the <code>Class</code> object for a custom mapping
1979 * @see #getObject(int)
1980 */
1981 public Object getObject(String columnName) throws SQLException {
1982 throw new UnsupportedOperationException();
1983 }
1984
1985 //----------------------------------------------------------------
1986
1987 /**
1988 * Maps the given column name for one of this <code>CachedRowSetImpl</code>
1989 * object's columns to its column number.
1990 *
1991 * @param columnName a <code>String</code> object that must match the
1992 * SQL name of a column in this rowset, ignoring case
1993 * @return the column index of the given column name
1994 * @throws SQLException if the given column name does not match one
1995 * of this rowset's column names
1996 */
1997 public int findColumn(String columnName) throws SQLException {
1998 throw new UnsupportedOperationException();
1999 }
2000
2001 //--------------------------JDBC 2.0-----------------------------------
2002
2003 //---------------------------------------------------------------------
2004 // Getter's and Setter's
2005 //---------------------------------------------------------------------
2006
2007 /**
2008 * Retrieves the value stored in the designated column
2009 * of the current row as a <code>java.io.Reader</code> object.
2010 *
2011 * <P><B>Note:</B> All the data in the returned stream must
2012 * be read prior to getting the value of any other column. The
2013 * next call to a <code>getXXX</code> method implicitly closes the stream.
2014 *
2015 * @param columnIndex the first column is <code>1</code>, the second
2016 * is <code>2</code>, and so on; must be <code>1</code> or larger
2017 * and equal to or less than the number of columns in the rowset
2018 * @return a Java character stream that delivers the database column value
2019 * as a stream of two-byte unicode characters in a
2020 * <code>java.io.Reader</code> object. If the value is
2021 * SQL <code>NULL</code>, the result is <code>null</code>.
2022 * @throws SQLException if (1) the given column index is out of bounds,
2023 * (2) the cursor is not on one of this rowset's rows or its
2024 * insert row, or (3) the designated column does not store an
2025 * SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, BINARY, VARBINARY</code> or
2026 * <code>LONGVARBINARY</code> value.
2027 * The bold SQL type designates the recommended return type.
2028 * @see #getCharacterStream(String)
2029 */
2030 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException{
2031 throw new UnsupportedOperationException();
2032 }
2033
2034 /**
2035 * Retrieves the value stored in the designated column
2036 * of the current row as a <code>java.io.Reader</code> object.
2037 *
2038 * <P><B>Note:</B> All the data in the returned stream must
2039 * be read prior to getting the value of any other column. The
2040 * next call to a <code>getXXX</code> method implicitly closes the stream.
2041 *
2042 * @param columnName a <code>String</code> object giving the SQL name of
2043 * a column in this <code>CachedRowSetImpl</code> object
2044 * @return a Java input stream that delivers the database column value
2045 * as a stream of two-byte Unicode characters. If the value is
2046 * SQL <code>NULL</code>, the result is <code>null</code>.
2047 * @throws SQLException if (1) the given column name is not the name of
2048 * a column in this rowset, (2) the cursor is not on one of
2049 * this rowset's rows or its insert row, or (3) the designated
2050 * column does not store an SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>,
2051 * BINARY, VARYBINARY</code> or <code>LONGVARBINARY</code> value.
2052 * The bold SQL type designates the recommended return type.
2053 */
2054 public java.io.Reader getCharacterStream(String columnName) throws SQLException {
2055 throw new UnsupportedOperationException();
2056 }
2057
2058 /**
2059 * Retrieves the value of the designated column in the current row
2060 * of this <code>CachedRowSetImpl</code> object as a
2061 * <code>java.math.BigDecimal</code> object.
2062 *
2063 * @param columnIndex the first column is <code>1</code>, the second
2064 * is <code>2</code>, and so on; must be <code>1</code> or larger
2065 * and equal to or less than the number of columns in the rowset
2066 * @return a <code>java.math.BigDecimal</code> value with full precision;
2067 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2068 * @throws SQLException if (1) the given column index is out of bounds,
2069 * (2) the cursor is not on one of this rowset's rows or its
2070 * insert row, or (3) the designated column does not store an
2071 * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
2072 * FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT, CHAR, VARCHAR</code>
2073 * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
2074 * recommended return types that this method is used to retrieve.
2075 * @see #getBigDecimal(String)
2076 */
2077 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
2078 throw new UnsupportedOperationException();
2079 }
2080
2081 /**
2082 * Retrieves the value of the designated column in the current row
2083 * of this <code>CachedRowSetImpl</code> object as a
2084 * <code>java.math.BigDecimal</code> object.
2085 *
2086 * @param columnName a <code>String</code> object that must match the
2087 * SQL name of a column in this rowset, ignoring case
2088 * @return a <code>java.math.BigDecimal</code> value with full precision;
2089 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2090 * @throws SQLException if (1) the given column name is not the name of
2091 * a column in this rowset, (2) the cursor is not on one of
2092 * this rowset's rows or its insert row, or (3) the designated
2093 * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2094 * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
2095 * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2096 * designates the recommended return type that this method is used to
2097 * retrieve
2098 * @see #getBigDecimal(int)
2099 */
2100 public BigDecimal getBigDecimal(String columnName) throws SQLException {
2101 throw new UnsupportedOperationException();
2102 }
2103
2104 //---------------------------------------------------------------------
2105 // Traversal/Positioning
2106 //---------------------------------------------------------------------
2107
2108 /**
2109 * Returns the number of rows in this <code>CachedRowSetImpl</code> object.
2110 *
2111 * @return number of rows in the rowset
2112 */
2113 public int size() {
2114 throw new UnsupportedOperationException();
2115 }
2116
2117 /**
2118 * Indicates whether the cursor is before the first row in this
2119 * <code>CachedRowSetImpl</code> object.
2120 *
2121 * @return <code>true</code> if the cursor is before the first row;
2122 * <code>false</code> otherwise or if the rowset contains no rows
2123 * @throws SQLException if an error occurs
2124 */
2125 public boolean isBeforeFirst() throws SQLException {
2126 throw new UnsupportedOperationException();
2127 }
2128
2129 /**
2130 * Indicates whether the cursor is after the last row in this
2131 * <code>CachedRowSetImpl</code> object.
2132 *
2133 * @return <code>true</code> if the cursor is after the last row;
2134 * <code>false</code> otherwise or if the rowset contains no rows
2135 * @throws SQLException if an error occurs
2136 */
2137 public boolean isAfterLast() throws SQLException {
2138 throw new UnsupportedOperationException();
2139 }
2140
2141 /**
2142 * Indicates whether the cursor is on the first row in this
2143 * <code>CachedRowSetImpl</code> object.
2144 *
2145 * @return <code>true</code> if the cursor is on the first row;
2146 * <code>false</code> otherwise or if the rowset contains no rows
2147 * @throws SQLException if an error occurs
2148 */
2149 public boolean isFirst() throws SQLException {
2150 throw new UnsupportedOperationException();
2151 }
2152
2153 /**
2154 * Indicates whether the cursor is on the last row in this
2155 * <code>CachedRowSetImpl</code> object.
2156 * <P>
2157 * Note: Calling the method <code>isLast</code> may be expensive
2158 * because the JDBC driver might need to fetch ahead one row in order
2159 * to determine whether the current row is the last row in this rowset.
2160 *
2161 * @return <code>true</code> if the cursor is on the last row;
2162 * <code>false</code> otherwise or if this rowset contains no rows
2163 * @throws SQLException if an error occurs
2164 */
2165 public boolean isLast() throws SQLException {
2166 throw new UnsupportedOperationException();
2167 }
2168
2169 /**
2170 * Moves this <code>CachedRowSetImpl</code> object's cursor to the front of
2171 * the rowset, just before the first row. This method has no effect if
2172 * this rowset contains no rows.
2173 *
2174 * @throws SQLException if an error occurs or the type of this rowset
2175 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2176 */
2177 public void beforeFirst() throws SQLException {
2178 throw new UnsupportedOperationException();
2179 }
2180
2181 /**
2182 * Moves this <code>CachedRowSetImpl</code> object's cursor to the end of
2183 * the rowset, just after the last row. This method has no effect if
2184 * this rowset contains no rows.
2185 *
2186 * @throws SQLException if an error occurs
2187 */
2188 public void afterLast() throws SQLException {
2189 throw new UnsupportedOperationException();
2190 }
2191
2192 /**
2193 * Moves this <code>CachedRowSetImpl</code> object's cursor to the first row
2194 * and returns <code>true</code> if the operation was successful. This
2195 * method also notifies registered listeners that the cursor has moved.
2196 *
2197 * @return <code>true</code> if the cursor is on a valid row;
2198 * <code>false</code> otherwise or if there are no rows in this
2199 * <code>CachedRowSetImpl</code> object
2200 * @throws SQLException if the type of this rowset
2201 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2202 */
2203 public boolean first() throws SQLException {
2204 throw new UnsupportedOperationException();
2205 }
2206
2207 /**
2208 * Moves this <code>CachedRowSetImpl</code> object's cursor to the first
2209 * row and returns <code>true</code> if the operation is successful.
2210 * <P>
2211 * This method is called internally by the methods <code>first</code>,
2212 * <code>isFirst</code>, and <code>absolute</code>.
2213 * It in turn calls the method <code>internalNext</code> in order to
2214 * handle the case where the first row is a deleted row that is not visible.
2215 * <p>
2216 * This is a implementation only method and is not required as a standard
2217 * implementation of the <code>CachedRowSet</code> interface.
2218 *
2219 * @return <code>true</code> if the cursor moved to the first row;
2220 * <code>false</code> otherwise
2221 * @throws SQLException if an error occurs
2222 */
2223 protected boolean internalFirst() throws SQLException {
2224 throw new UnsupportedOperationException();
2225 }
2226
2227 /**
2228 * Moves this <code>CachedRowSetImpl</code> object's cursor to the last row
2229 * and returns <code>true</code> if the operation was successful. This
2230 * method also notifies registered listeners that the cursor has moved.
2231 *
2232 * @return <code>true</code> if the cursor is on a valid row;
2233 * <code>false</code> otherwise or if there are no rows in this
2234 * <code>CachedRowSetImpl</code> object
2235 * @throws SQLException if the type of this rowset
2236 * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2237 */
2238 public boolean last() throws SQLException {
2239 throw new UnsupportedOperationException();
2240 }
2241
2242 /**
2243 * Moves this <code>CachedRowSetImpl</code> object's cursor to the last
2244 * row and returns <code>true</code> if the operation is successful.
2245 * <P>
2246 * This method is called internally by the method <code>last</code>
2247 * when rows have been deleted and the deletions are not visible.
2248 * The method <code>internalLast</code> handles the case where the
2249 * last row is a deleted row that is not visible by in turn calling
2250 * the method <code>internalPrevious</code>.
2251 * <p>
2252 * This is a implementation only method and is not required as a standard
2253 * implementation of the <code>CachedRowSet</code> interface.
2254 *
2255 * @return <code>true</code> if the cursor moved to the last row;
2256 * <code>false</code> otherwise
2257 * @throws SQLException if an error occurs
2258 */
2259 protected boolean internalLast() throws SQLException {
2260 throw new UnsupportedOperationException();
2261 }
2262
2263 /**
2264 * Returns the number of the current row in this <code>CachedRowSetImpl</code>
2265 * object. The first row is number 1, the second number 2, and so on.
2266 *
2267 * @return the number of the current row; <code>0</code> if there is no
2268 * current row
2269 * @throws SQLException if an error occurs; or if the <code>CacheRowSetImpl</code>
2270 * is empty
2271 */
2272 public int getRow() throws SQLException {
2273 return crsSync.getRow();
2274 }
2275
2276 /**
2277 * Moves this <code>CachedRowSetImpl</code> object's cursor to the row number
2278 * specified.
2279 *
2280 * <p>If the number is positive, the cursor moves to an absolute row with
2281 * respect to the beginning of the rowset. The first row is row 1, the second
2282 * is row 2, and so on. For example, the following command, in which
2283 * <code>crs</code> is a <code>CachedRowSetImpl</code> object, moves the cursor
2284 * to the fourth row, starting from the beginning of the rowset.
2285 * <PRE><code>
2286 *
2287 * crs.absolute(4);
2288 *
2289 * </code> </PRE>
2290 * <P>
2291 * If the number is negative, the cursor moves to an absolute row position
2292 * with respect to the end of the rowset. For example, calling
2293 * <code>absolute(-1)</code> positions the cursor on the last row,
2294 * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2295 * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
2296 * the following command moves the cursor to the fourth-to-last row, which
2297 * in the case of a rowset with five rows, is also the second row, counting
2298 * from the beginning.
2299 * <PRE><code>
2300 *
2301 * crs.absolute(-4);
2302 *
2303 * </code> </PRE>
2304 *
2305 * If the number specified is larger than the number of rows, the cursor
2306 * will move to the position after the last row. If the number specified
2307 * would move the cursor one or more rows before the first row, the cursor
2308 * moves to the position before the first row.
2309 * <P>
2310 * Note: Calling <code>absolute(1)</code> is the same as calling the
2311 * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2312 * same as calling <code>last()</code>.
2313 *
2314 * @param row a positive number to indicate the row, starting row numbering from
2315 * the first row, which is <code>1</code>; a negative number to indicate
2316 * the row, starting row numbering from the last row, which is
2317 * <code>-1</code>; it must not be <code>0</code>
2318 * @return <code>true</code> if the cursor is on the rowset; <code>false</code>
2319 * otherwise
2320 * @throws SQLException if the given cursor position is <code>0</code> or the
2321 * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2322 */
2323 public boolean absolute( int row ) throws SQLException {
2324 throw new UnsupportedOperationException();
2325 }
2326
2327 /**
2328 * Moves the cursor the specified number of rows from the current
2329 * position, with a positive number moving it forward and a
2330 * negative number moving it backward.
2331 * <P>
2332 * If the number is positive, the cursor moves the specified number of
2333 * rows toward the end of the rowset, starting at the current row.
2334 * For example, the following command, in which
2335 * <code>crs</code> is a <code>CachedRowSetImpl</code> object with 100 rows,
2336 * moves the cursor forward four rows from the current row. If the
2337 * current row is 50, the cursor would move to row 54.
2338 * <PRE><code>
2339 *
2340 * crs.relative(4);
2341 *
2342 * </code> </PRE>
2343 * <P>
2344 * If the number is negative, the cursor moves back toward the beginning
2345 * the specified number of rows, starting at the current row.
2346 * For example, calling the method
2347 * <code>absolute(-1)</code> positions the cursor on the last row,
2348 * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2349 * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
2350 * the following command moves the cursor to the fourth-to-last row, which
2351 * in the case of a rowset with five rows, is also the second row
2352 * from the beginning.
2353 * <PRE><code>
2354 *
2355 * crs.absolute(-4);
2356 *
2357 * </code> </PRE>
2358 *
2359 * If the number specified is larger than the number of rows, the cursor
2360 * will move to the position after the last row. If the number specified
2361 * would move the cursor one or more rows before the first row, the cursor
2362 * moves to the position before the first row. In both cases, this method
2363 * throws an <code>SQLException</code>.
2364 * <P>
2365 * Note: Calling <code>absolute(1)</code> is the same as calling the
2366 * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2367 * same as calling <code>last()</code>. Calling <code>relative(0)</code>
2368 * is valid, but it does not change the cursor position.
2369 *
2370 * @param rows an <code>int</code> indicating the number of rows to move
2371 * the cursor, starting at the current row; a positive number
2372 * moves the cursor forward; a negative number moves the cursor
2373 * backward; must not move the cursor past the valid
2374 * rows
2375 * @return <code>true</code> if the cursor is on a row in this
2376 * <code>CachedRowSetImpl</code> object; <code>false</code>
2377 * otherwise
2378 * @throws SQLException if there are no rows in this rowset, the cursor is
2379 * positioned either before the first row or after the last row, or
2380 * the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code>
2381 */
2382 public boolean relative(int rows) throws SQLException {
2383 throw new UnsupportedOperationException();
2384 }
2385
2386 /**
2387 * Moves this <code>CachedRowSetImpl</code> object's cursor to the
2388 * previous row and returns <code>true</code> if the cursor is on
2389 * a valid row or <code>false</code> if it is not.
2390 * This method also notifies all listeners registered with this
2391 * <code>CachedRowSetImpl</code> object that its cursor has moved.
2392 * <P>
2393 * Note: calling the method <code>previous()</code> is not the same
2394 * as calling the method <code>relative(-1)</code>. This is true
2395 * because it is possible to call <code>previous()</code> from the insert
2396 * row, from after the last row, or from the current row, whereas
2397 * <code>relative</code> may only be called from the current row.
2398 * <P>
2399 * The method <code>previous</code> may used in a <code>while</code>
2400 * loop to iterate through a rowset starting after the last row
2401 * and moving toward the beginning. The loop ends when <code>previous</code>
2402 * returns <code>false</code>, meaning that there are no more rows.
2403 * For example, the following code fragment retrieves all the data in
2404 * the <code>CachedRowSetImpl</code> object <code>crs</code>, which has
2405 * three columns. Note that the cursor must initially be positioned
2406 * after the last row so that the first call to the method
2407 * <code>previous</code> places the cursor on the last line.
2408 * <PRE> <code>
2409 *
2410 * crs.afterLast();
2411 * while (previous()) {
2412 * String name = crs.getString(1);
2413 * int age = crs.getInt(2);
2414 * short ssn = crs.getShort(3);
2415 * System.out.println(name + " " + age + " " + ssn);
2416 * }
2417 *
2418 * </code> </PRE>
2419 * This method throws an <code>SQLException</code> if the cursor is not
2420 * on a row in the rowset, before the first row, or after the last row.
2421 *
2422 * @return <code>true</code> if the cursor is on a valid row;
2423 * <code>false</code> if it is before the first row or after the
2424 * last row
2425 * @throws SQLException if the cursor is not on a valid position or the
2426 * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2427 */
2428 public boolean previous() throws SQLException {
2429 throw new UnsupportedOperationException();
2430 }
2431
2432 /**
2433 * Moves the cursor to the previous row in this <code>CachedRowSetImpl</code>
2434 * object, skipping past deleted rows that are not visible; returns
2435 * <code>true</code> if the cursor is on a row in this rowset and
2436 * <code>false</code> when the cursor goes before the first row.
2437 * <P>
2438 * This method is called internally by the method <code>previous</code>.
2439 * <P>
2440 * This is a implementation only method and is not required as a standard
2441 * implementation of the <code>CachedRowSet</code> interface.
2442 *
2443 * @return <code>true</code> if the cursor is on a row in this rowset;
2444 * <code>false</code> when the cursor reaches the position before
2445 * the first row
2446 * @throws SQLException if an error occurs
2447 */
2448 protected boolean internalPrevious() throws SQLException {
2449 throw new UnsupportedOperationException();
2450 }
2451
2452
2453 //---------------------------------------------------------------------
2454 // Updates
2455 //---------------------------------------------------------------------
2456
2457 /**
2458 * Indicates whether the current row of this <code>CachedRowSetImpl</code>
2459 * object has been updated. The value returned
2460 * depends on whether this rowset can detect updates: <code>false</code>
2461 * will always be returned if it does not detect updates.
2462 *
2463 * @return <code>true</code> if the row has been visibly updated
2464 * by the owner or another and updates are detected;
2465 * <code>false</code> otherwise
2466 * @throws SQLException if the cursor is on the insert row or not
2467 * not on a valid row
2468 *
2469 * @see DatabaseMetaData#updatesAreDetected
2470 */
2471 public boolean rowUpdated() throws SQLException {
2472 throw new UnsupportedOperationException();
2473 }
2474
2475 /**
2476 * Indicates whether the designated column of the current row of
2477 * this <code>CachedRowSetImpl</code> object has been updated. The
2478 * value returned depends on whether this rowset can detcted updates:
2479 * <code>false</code> will always be returned if it does not detect updates.
2480 *
2481 * @param idx the index identifier of the column that may be have been updated.
2482 * @return <code>true</code> is the designated column has been updated
2483 * and the rowset detects updates; <code>false</code> if the rowset has not
2484 * been updated or the rowset does not detect updates
2485 * @throws SQLException if the cursor is on the insert row or not
2486 * on a valid row
2487 * @see DatabaseMetaData#updatesAreDetected
2488 */
2489 public boolean columnUpdated(int idx) throws SQLException {
2490 throw new UnsupportedOperationException();
2491 }
2492
2493 /**
2494 * Indicates whether the designated column of the current row of
2495 * this <code>CachedRowSetImpl</code> object has been updated. The
2496 * value returned depends on whether this rowset can detcted updates:
2497 * <code>false</code> will always be returned if it does not detect updates.
2498 *
2499 * @param columnName the <code>String</code> column name column that may be have
2500 * been updated.
2501 * @return <code>true</code> is the designated column has been updated
2502 * and the rowset detects updates; <code>false</code> if the rowset has not
2503 * been updated or the rowset does not detect updates
2504 * @throws SQLException if the cursor is on the insert row or not
2505 * on a valid row
2506 * @see DatabaseMetaData#updatesAreDetected
2507 */
2508 public boolean columnUpdated(String columnName) throws SQLException {
2509 throw new UnsupportedOperationException();
2510 }
2511
2512 /**
2513 * Indicates whether the current row has been inserted. The value returned
2514 * depends on whether or not the rowset can detect visible inserts.
2515 *
2516 * @return <code>true</code> if a row has been inserted and inserts are detected;
2517 * <code>false</code> otherwise
2518 * @throws SQLException if the cursor is on the insert row or not
2519 * not on a valid row
2520 *
2521 * @see DatabaseMetaData#insertsAreDetected
2522 */
2523 public boolean rowInserted() throws SQLException {
2524 throw new UnsupportedOperationException();
2525 }
2526
2527 /**
2528 * Indicates whether the current row has been deleted. A deleted row
2529 * may leave a visible "hole" in a rowset. This method can be used to
2530 * detect such holes if the rowset can detect deletions. This method
2531 * will always return <code>false</code> if this rowset cannot detect
2532 * deletions.
2533 *
2534 * @return <code>true</code> if (1)the current row is blank, indicating that
2535 * the row has been deleted, and (2)deletions are detected;
2536 * <code>false</code> otherwise
2537 * @throws SQLException if the cursor is on a valid row in this rowset
2538 * @see DatabaseMetaData#deletesAreDetected
2539 */
2540 public boolean rowDeleted() throws SQLException {
2541 throw new UnsupportedOperationException();
2542 }
2543
2544 /**
2545 * Sets the designated nullable column in the current row or the
2546 * insert row of this <code>CachedRowSetImpl</code> object with
2547 * <code>null</code> value.
2548 * <P>
2549 * This method updates a column value in the current row or the insert
2550 * row of this rowset; however, another method must be called to complete
2551 * the update process. If the cursor is on a row in the rowset, the
2552 * method {@link #updateRow} must be called to mark the row as updated
2553 * and to notify listeners that the row has changed.
2554 * If the cursor is on the insert row, the method {@link #insertRow}
2555 * must be called to insert the new row into this rowset and to notify
2556 * listeners that a row has changed.
2557 * <P>
2558 * In order to propagate updates in this rowset to the underlying
2559 * data source, an application must call the method {@link #acceptChanges}
2560 * after it calls either <code>updateRow</code> or <code>insertRow</code>.
2561 *
2562 * @param columnIndex the first column is <code>1</code>, the second
2563 * is <code>2</code>, and so on; must be <code>1</code> or larger
2564 * and equal to or less than the number of columns in this rowset
2565 * @throws SQLException if (1) the given column index is out of bounds,
2566 * (2) the cursor is not on one of this rowset's rows or its
2567 * insert row, or (3) this rowset is
2568 * <code>ResultSet.CONCUR_READ_ONLY</code>
2569 */
2570 public void updateNull(int columnIndex) throws SQLException {
2571 throw new UnsupportedOperationException();
2572 }
2573
2574 /**
2575 * Sets the designated column in either the current row or the insert
2576 * row of this <code>CachedRowSetImpl</code> object with the given
2577 * <code>boolean</code> value.
2578 * <P>
2579 * This method updates a column value in the current row or the insert
2580 * row of this rowset, but it does not update the database.
2581 * If the cursor is on a row in the rowset, the
2582 * method {@link #updateRow} must be called to update the database.
2583 * If the cursor is on the insert row, the method {@link #insertRow}
2584 * must be called, which will insert the new row into both this rowset
2585 * and the database. Both of these methods must be called before the
2586 * cursor moves to another row.
2587 *
2588 * @param columnIndex the first column is <code>1</code>, the second
2589 * is <code>2</code>, and so on; must be <code>1</code> or larger
2590 * and equal to or less than the number of columns in this rowset
2591 * @param x the new column value
2592 * @throws SQLException if (1) the given column index is out of bounds,
2593 * (2) the cursor is not on one of this rowset's rows or its
2594 * insert row, or (3) this rowset is
2595 * <code>ResultSet.CONCUR_READ_ONLY</code>
2596 */
2597 public void updateBoolean(int columnIndex, boolean x) throws SQLException {
2598 throw new UnsupportedOperationException();
2599 }
2600
2601 /**
2602 * Sets the designated column in either the current row or the insert
2603 * row of this <code>CachedRowSetImpl</code> object with the given
2604 * <code>byte</code> value.
2605 * <P>
2606 * This method updates a column value in the current row or the insert
2607 * row of this rowset, but it does not update the database.
2608 * If the cursor is on a row in the rowset, the
2609 * method {@link #updateRow} must be called to update the database.
2610 * If the cursor is on the insert row, the method {@link #insertRow}
2611 * must be called, which will insert the new row into both this rowset
2612 * and the database. Both of these methods must be called before the
2613 * cursor moves to another row.
2614 *
2615 * @param columnIndex the first column is <code>1</code>, the second
2616 * is <code>2</code>, and so on; must be <code>1</code> or larger
2617 * and equal to or less than the number of columns in this rowset
2618 * @param x the new column value
2619 * @throws SQLException if (1) the given column index is out of bounds,
2620 * (2) the cursor is not on one of this rowset's rows or its
2621 * insert row, or (3) this rowset is
2622 * <code>ResultSet.CONCUR_READ_ONLY</code>
2623 */
2624 public void updateByte(int columnIndex, byte x) throws SQLException {
2625 throw new UnsupportedOperationException();
2626 }
2627
2628 /**
2629 * Sets the designated column in either the current row or the insert
2630 * row of this <code>CachedRowSetImpl</code> object with the given
2631 * <code>short</code> value.
2632 * <P>
2633 * This method updates a column value in the current row or the insert
2634 * row of this rowset, but it does not update the database.
2635 * If the cursor is on a row in the rowset, the
2636 * method {@link #updateRow} must be called to update the database.
2637 * If the cursor is on the insert row, the method {@link #insertRow}
2638 * must be called, which will insert the new row into both this rowset
2639 * and the database. Both of these methods must be called before the
2640 * cursor moves to another row.
2641 *
2642 * @param columnIndex the first column is <code>1</code>, the second
2643 * is <code>2</code>, and so on; must be <code>1</code> or larger
2644 * and equal to or less than the number of columns in this rowset
2645 * @param x the new column value
2646 * @throws SQLException if (1) the given column index is out of bounds,
2647 * (2) the cursor is not on one of this rowset's rows or its
2648 * insert row, or (3) this rowset is
2649 * <code>ResultSet.CONCUR_READ_ONLY</code>
2650 */
2651 public void updateShort(int columnIndex, short x) throws SQLException {
2652 throw new UnsupportedOperationException();
2653 }
2654
2655 /**
2656 * Sets the designated column in either the current row or the insert
2657 * row of this <code>CachedRowSetImpl</code> object with the given
2658 * <code>int</code> value.
2659 * <P>
2660 * This method updates a column value in the current row or the insert
2661 * row of this rowset, but it does not update the database.
2662 * If the cursor is on a row in the rowset, the
2663 * method {@link #updateRow} must be called to update the database.
2664 * If the cursor is on the insert row, the method {@link #insertRow}
2665 * must be called, which will insert the new row into both this rowset
2666 * and the database. Both of these methods must be called before the
2667 * cursor moves to another row.
2668 *
2669 * @param columnIndex the first column is <code>1</code>, the second
2670 * is <code>2</code>, and so on; must be <code>1</code> or larger
2671 * and equal to or less than the number of columns in this rowset
2672 * @param x the new column value
2673 * @throws SQLException if (1) the given column index is out of bounds,
2674 * (2) the cursor is not on one of this rowset's rows or its
2675 * insert row, or (3) this rowset is
2676 * <code>ResultSet.CONCUR_READ_ONLY</code>
2677 */
2678 public void updateInt(int columnIndex, int x) throws SQLException {
2679 throw new UnsupportedOperationException();
2680 }
2681
2682 /**
2683 * Sets the designated column in either the current row or the insert
2684 * row of this <code>CachedRowSetImpl</code> object with the given
2685 * <code>long</code> value.
2686 * <P>
2687 * This method updates a column value in the current row or the insert
2688 * row of this rowset, but it does not update the database.
2689 * If the cursor is on a row in the rowset, the
2690 * method {@link #updateRow} must be called to update the database.
2691 * If the cursor is on the insert row, the method {@link #insertRow}
2692 * must be called, which will insert the new row into both this rowset
2693 * and the database. Both of these methods must be called before the
2694 * cursor moves to another row.
2695 *
2696 * @param columnIndex the first column is <code>1</code>, the second
2697 * is <code>2</code>, and so on; must be <code>1</code> or larger
2698 * and equal to or less than the number of columns in this rowset
2699 * @param x the new column value
2700 * @throws SQLException if (1) the given column index is out of bounds,
2701 * (2) the cursor is not on one of this rowset's rows or its
2702 * insert row, or (3) this rowset is
2703 * <code>ResultSet.CONCUR_READ_ONLY</code>
2704 */
2705 public void updateLong(int columnIndex, long x) throws SQLException {
2706 throw new UnsupportedOperationException();
2707
2708 }
2709
2710 /**
2711 * Sets the designated column in either the current row or the insert
2712 * row of this <code>CachedRowSetImpl</code> object with the given
2713 * <code>float</code> value.
2714 * <P>
2715 * This method updates a column value in the current row or the insert
2716 * row of this rowset, but it does not update the database.
2717 * If the cursor is on a row in the rowset, the
2718 * method {@link #updateRow} must be called to update the database.
2719 * If the cursor is on the insert row, the method {@link #insertRow}
2720 * must be called, which will insert the new row into both this rowset
2721 * and the database. Both of these methods must be called before the
2722 * cursor moves to another row.
2723 *
2724 * @param columnIndex the first column is <code>1</code>, the second
2725 * is <code>2</code>, and so on; must be <code>1</code> or larger
2726 * and equal to or less than the number of columns in this rowset
2727 * @param x the new column value
2728 * @throws SQLException if (1) the given column index is out of bounds,
2729 * (2) the cursor is not on one of this rowset's rows or its
2730 * insert row, or (3) this rowset is
2731 * <code>ResultSet.CONCUR_READ_ONLY</code>
2732 */
2733 public void updateFloat(int columnIndex, float x) throws SQLException {
2734 throw new UnsupportedOperationException();
2735 }
2736
2737 /**
2738 * Sets the designated column in either the current row or the insert
2739 * row of this <code>CachedRowSetImpl</code> object with the given
2740 * <code>double</code> value.
2741 *
2742 * This method updates a column value in either the current row or
2743 * the insert row of this rowset, but it does not update the
2744 * database. If the cursor is on a row in the rowset, the
2745 * method {@link #updateRow} must be called to update the database.
2746 * If the cursor is on the insert row, the method {@link #insertRow}
2747 * must be called, which will insert the new row into both this rowset
2748 * and the database. Both of these methods must be called before the
2749 * cursor moves to another row.
2750 *
2751 * @param columnIndex the first column is <code>1</code>, the second
2752 * is <code>2</code>, and so on; must be <code>1</code> or larger
2753 * and equal to or less than the number of columns in this rowset
2754 * @param x the new column value
2755 * @throws SQLException if (1) the given column index is out of bounds,
2756 * (2) the cursor is not on one of this rowset's rows or its
2757 * insert row, or (3) this rowset is
2758 * <code>ResultSet.CONCUR_READ_ONLY</code>
2759 */
2760 public void updateDouble(int columnIndex, double x) throws SQLException {
2761 throw new UnsupportedOperationException();
2762 }
2763
2764 /**
2765 * Sets the designated column in either the current row or the insert
2766 * row of this <code>CachedRowSetImpl</code> object with the given
2767 * <code>java.math.BigDecimal</code> object.
2768 * <P>
2769 * This method updates a column value in the current row or the insert
2770 * row of this rowset, but it does not update the database.
2771 * If the cursor is on a row in the rowset, the
2772 * method {@link #updateRow} must be called to update the database.
2773 * If the cursor is on the insert row, the method {@link #insertRow}
2774 * must be called, which will insert the new row into both this rowset
2775 * and the database. Both of these methods must be called before the
2776 * cursor moves to another row.
2777 *
2778 * @param columnIndex the first column is <code>1</code>, the second
2779 * is <code>2</code>, and so on; must be <code>1</code> or larger
2780 * and equal to or less than the number of columns in this rowset
2781 * @param x the new column value
2782 * @throws SQLException if (1) the given column index is out of bounds,
2783 * (2) the cursor is not on one of this rowset's rows or its
2784 * insert row, or (3) this rowset is
2785 * <code>ResultSet.CONCUR_READ_ONLY</code>
2786 */
2787 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
2788 throw new UnsupportedOperationException();
2789 }
2790
2791 /**
2792 * Sets the designated column in either the current row or the insert
2793 * row of this <code>CachedRowSetImpl</code> object with the given
2794 * <code>String</code> object.
2795 * <P>
2796 * This method updates a column value in either the current row or
2797 * the insert row of this rowset, but it does not update the
2798 * database. If the cursor is on a row in the rowset, the
2799 * method {@link #updateRow} must be called to mark the row as updated.
2800 * If the cursor is on the insert row, the method {@link #insertRow}
2801 * must be called to insert the new row into this rowset and mark it
2802 * as inserted. Both of these methods must be called before the
2803 * cursor moves to another row.
2804 * <P>
2805 * The method <code>acceptChanges</code> must be called if the
2806 * updated values are to be written back to the underlying database.
2807 *
2808 * @param columnIndex the first column is <code>1</code>, the second
2809 * is <code>2</code>, and so on; must be <code>1</code> or larger
2810 * and equal to or less than the number of columns in this rowset
2811 * @param x the new column value
2812 * @throws SQLException if (1) the given column index is out of bounds,
2813 * (2) the cursor is not on one of this rowset's rows or its
2814 * insert row, or (3) this rowset is
2815 * <code>ResultSet.CONCUR_READ_ONLY</code>
2816 */
2817 public void updateString(int columnIndex, String x) throws SQLException {
2818 throw new UnsupportedOperationException();
2819 }
2820
2821 /**
2822 * Sets the designated column in either the current row or the insert
2823 * row of this <code>CachedRowSetImpl</code> object with the given
2824 * <code>byte</code> array.
2825 *
2826 * This method updates a column value in either the current row or
2827 * the insert row of this rowset, but it does not update the
2828 * database. If the cursor is on a row in the rowset, the
2829 * method {@link #updateRow} must be called to update the database.
2830 * If the cursor is on the insert row, the method {@link #insertRow}
2831 * must be called, which will insert the new row into both this rowset
2832 * and the database. Both of these methods must be called before the
2833 * cursor moves to another row.
2834 *
2835 * @param columnIndex the first column is <code>1</code>, the second
2836 * is <code>2</code>, and so on; must be <code>1</code> or larger
2837 * and equal to or less than the number of columns in this rowset
2838 * @param x the new column value
2839 * @throws SQLException if (1) the given column index is out of bounds,
2840 * (2) the cursor is not on one of this rowset's rows or its
2841 * insert row, or (3) this rowset is
2842 * <code>ResultSet.CONCUR_READ_ONLY</code>
2843 */
2844 public void updateBytes(int columnIndex, byte x[]) throws SQLException {
2845 throw new UnsupportedOperationException();
2846 }
2847
2848 /**
2849 * Sets the designated column in either the current row or the insert
2850 * row of this <code>CachedRowSetImpl</code> object with the given
2851 * <code>Date</code> object.
2852 *
2853 * This method updates a column value in either the current row or
2854 * the insert row of this rowset, but it does not update the
2855 * database. If the cursor is on a row in the rowset, the
2856 * method {@link #updateRow} must be called to update the database.
2857 * If the cursor is on the insert row, the method {@link #insertRow}
2858 * must be called, which will insert the new row into both this rowset
2859 * and the database. Both of these methods must be called before the
2860 * cursor moves to another row.
2861 *
2862 * @param columnIndex the first column is <code>1</code>, the second
2863 * is <code>2</code>, and so on; must be <code>1</code> or larger
2864 * and equal to or less than the number of columns in this rowset
2865 * @param x the new column value
2866 * @throws SQLException if (1) the given column index is out of bounds,
2867 * (2) the cursor is not on one of this rowset's rows or its
2868 * insert row, (3) the type of the designated column is not
2869 * an SQL <code>DATE</code> or <code>TIMESTAMP</code>, or
2870 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2871 */
2872 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
2873 throw new UnsupportedOperationException();
2874 }
2875
2876 /**
2877 * Sets the designated column in either the current row or the insert
2878 * row of this <code>CachedRowSetImpl</code> object with the given
2879 * <code>Time</code> object.
2880 *
2881 * This method updates a column value in either the current row or
2882 * the insert row of this rowset, but it does not update the
2883 * database. If the cursor is on a row in the rowset, the
2884 * method {@link #updateRow} must be called to update the database.
2885 * If the cursor is on the insert row, the method {@link #insertRow}
2886 * must be called, which will insert the new row into both this rowset
2887 * and the database. Both of these methods must be called before the
2888 * cursor moves to another row.
2889 *
2890 * @param columnIndex the first column is <code>1</code>, the second
2891 * is <code>2</code>, and so on; must be <code>1</code> or larger
2892 * and equal to or less than the number of columns in this rowset
2893 * @param x the new column value
2894 * @throws SQLException if (1) the given column index is out of bounds,
2895 * (2) the cursor is not on one of this rowset's rows or its
2896 * insert row, (3) the type of the designated column is not
2897 * an SQL <code>TIME</code> or <code>TIMESTAMP</code>, or
2898 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2899 */
2900 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
2901 throw new UnsupportedOperationException();
2902 }
2903
2904 /**
2905 * Sets the designated column in either the current row or the insert
2906 * row of this <code>CachedRowSetImpl</code> object with the given
2907 * <code>Timestamp</code> object.
2908 *
2909 * This method updates a column value in either the current row or
2910 * the insert row of this rowset, but it does not update the
2911 * database. If the cursor is on a row in the rowset, the
2912 * method {@link #updateRow} must be called to update the database.
2913 * If the cursor is on the insert row, the method {@link #insertRow}
2914 * must be called, which will insert the new row into both this rowset
2915 * and the database. Both of these methods must be called before the
2916 * cursor moves to another row.
2917 *
2918 * @param columnIndex the first column is <code>1</code>, the second
2919 * is <code>2</code>, and so on; must be <code>1</code> or larger
2920 * and equal to or less than the number of columns in this rowset
2921 * @param x the new column value
2922 * @throws SQLException if (1) the given column index is out of bounds,
2923 * (2) the cursor is not on one of this rowset's rows or its
2924 * insert row, (3) the type of the designated column is not
2925 * an SQL <code>DATE</code>, <code>TIME</code>, or
2926 * <code>TIMESTAMP</code>, or (4) this rowset is
2927 * <code>ResultSet.CONCUR_READ_ONLY</code>
2928 */
2929 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
2930 throw new UnsupportedOperationException();
2931 }
2932
2933 /**
2934 * Sets the designated column in either the current row or the insert
2935 * row of this <code>CachedRowSetImpl</code> object with the given
2936 * ASCII stream value.
2937 * <P>
2938 * This method updates a column value in either the current row or
2939 * the insert row of this rowset, but it does not update the
2940 * database. If the cursor is on a row in the rowset, the
2941 * method {@link #updateRow} must be called to update the database.
2942 * If the cursor is on the insert row, the method {@link #insertRow}
2943 * must be called, which will insert the new row into both this rowset
2944 * and the database. Both of these methods must be called before the
2945 * cursor moves to another row.
2946 *
2947 * @param columnIndex the first column is <code>1</code>, the second
2948 * is <code>2</code>, and so on; must be <code>1</code> or larger
2949 * and equal to or less than the number of columns in this rowset
2950 * @param x the new column value
2951 * @param length the number of one-byte ASCII characters in the stream
2952 * @throws SQLException if this method is invoked
2953 */
2954 public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
2955 throw new UnsupportedOperationException();
2956 }
2957
2958 /**
2959 * Sets the designated column in either the current row or the insert
2960 * row of this <code>CachedRowSetImpl</code> object with the given
2961 * <code>java.io.InputStream</code> object.
2962 * <P>
2963 * This method updates a column value in either the current row or
2964 * the insert row of this rowset, but it does not update the
2965 * database. If the cursor is on a row in the rowset, the
2966 * method {@link #updateRow} must be called to update the database.
2967 * If the cursor is on the insert row, the method {@link #insertRow}
2968 * must be called, which will insert the new row into both this rowset
2969 * and the database. Both of these methods must be called before the
2970 * cursor moves to another row.
2971 *
2972 * @param columnIndex the first column is <code>1</code>, the second
2973 * is <code>2</code>, and so on; must be <code>1</code> or larger
2974 * and equal to or less than the number of columns in this rowset
2975 * @param x the new column value; must be a <code>java.io.InputStream</code>
2976 * containing <code>BINARY</code>, <code>VARBINARY</code>, or
2977 * <code>LONGVARBINARY</code> data
2978 * @param length the length of the stream in bytes
2979 * @throws SQLException if (1) the given column index is out of bounds,
2980 * (2) the cursor is not on one of this rowset's rows or its
2981 * insert row, (3) the data in the stream is not binary, or
2982 * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2983 */
2984 public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException {
2985 throw new UnsupportedOperationException();
2986 }
2987
2988 /**
2989 * Sets the designated column in either the current row or the insert
2990 * row of this <code>CachedRowSetImpl</code> object with the given
2991 * <code>java.io.Reader</code> object.
2992 * <P>
2993 * This method updates a column value in either the current row or
2994 * the insert row of this rowset, but it does not update the
2995 * database. If the cursor is on a row in the rowset, the
2996 * method {@link #updateRow} must be called to update the database.
2997 * If the cursor is on the insert row, the method {@link #insertRow}
2998 * must be called, which will insert the new row into both this rowset
2999 * and the database. Both of these methods must be called before the
3000 * cursor moves to another row.
3001 *
3002 * @param columnIndex the first column is <code>1</code>, the second
3003 * is <code>2</code>, and so on; must be <code>1</code> or larger
3004 * and equal to or less than the number of columns in this rowset
3005 * @param x the new column value; must be a <code>java.io.Reader</code>
3006 * containing <code>BINARY</code>, <code>VARBINARY</code>,
3007 * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
3008 * or <code>LONGVARCHAR</code> data
3009 * @param length the length of the stream in characters
3010 * @throws SQLException if (1) the given column index is out of bounds,
3011 * (2) the cursor is not on one of this rowset's rows or its
3012 * insert row, (3) the data in the stream is not a binary or
3013 * character type, or (4) this rowset is
3014 * <code>ResultSet.CONCUR_READ_ONLY</code>
3015 */
3016 public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
3017 throw new UnsupportedOperationException();
3018 }
3019
3020 /**
3021 * Sets the designated column in either the current row or the insert
3022 * row of this <code>CachedRowSetImpl</code> object with the given
3023 * <code>Object</code> value. The <code>scale</code> parameter indicates
3024 * the number of digits to the right of the decimal point and is ignored
3025 * if the new column value is not a type that will be mapped to an SQL
3026 * <code>DECIMAL</code> or <code>NUMERIC</code> value.
3027 * <P>
3028 * This method updates a column value in either the current row or
3029 * the insert row of this rowset, but it does not update the
3030 * database. If the cursor is on a row in the rowset, the
3031 * method {@link #updateRow} must be called to update the database.
3032 * If the cursor is on the insert row, the method {@link #insertRow}
3033 * must be called, which will insert the new row into both this rowset
3034 * and the database. Both of these methods must be called before the
3035 * cursor moves to another row.
3036 *
3037 * @param columnIndex the first column is <code>1</code>, the second
3038 * is <code>2</code>, and so on; must be <code>1</code> or larger
3039 * and equal to or less than the number of columns in this rowset
3040 * @param x the new column value
3041 * @param scale the number of digits to the right of the decimal point (for
3042 * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3043 * @throws SQLException if (1) the given column index is out of bounds,
3044 * (2) the cursor is not on one of this rowset's rows or its
3045 * insert row, or (3) this rowset is
3046 * <code>ResultSet.CONCUR_READ_ONLY</code>
3047 */
3048 public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
3049 throw new UnsupportedOperationException();
3050 }
3051
3052 /**
3053 * Sets the designated column in either the current row or the insert
3054 * row of this <code>CachedRowSetImpl</code> object with the given
3055 * <code>Object</code> value.
3056 * <P>
3057 * This method updates a column value in either the current row or
3058 * the insert row of this rowset, but it does not update the
3059 * database. If the cursor is on a row in the rowset, the
3060 * method {@link #updateRow} must be called to update the database.
3061 * If the cursor is on the insert row, the method {@link #insertRow}
3062 * must be called, which will insert the new row into both this rowset
3063 * and the database. Both of these methods must be called before the
3064 * cursor moves to another row.
3065 *
3066 * @param columnIndex the first column is <code>1</code>, the second
3067 * is <code>2</code>, and so on; must be <code>1</code> or larger
3068 * and equal to or less than the number of columns in this rowset
3069 * @param x the new column value
3070 * @throws SQLException if (1) the given column index is out of bounds,
3071 * (2) the cursor is not on one of this rowset's rows or its
3072 * insert row, or (3) this rowset is
3073 * <code>ResultSet.CONCUR_READ_ONLY</code>
3074 */
3075 public void updateObject(int columnIndex, Object x) throws SQLException {
3076 throw new UnsupportedOperationException();
3077 }
3078
3079
3080 /**
3081 * Sets the designated nullable column in the current row or the
3082 * insert row of this <code>CachedRowSetImpl</code> object with
3083 * <code>null</code> value.
3084 * <P>
3085 * This method updates a column value in the current row or the insert
3086 * row of this rowset, but it does not update the database.
3087 * If the cursor is on a row in the rowset, the
3088 * method {@link #updateRow} must be called to update the database.
3089 * If the cursor is on the insert row, the method {@link #insertRow}
3090 * must be called, which will insert the new row into both this rowset
3091 * and the database.
3092 *
3093 * @param columnName a <code>String</code> object that must match the
3094 * SQL name of a column in this rowset, ignoring case
3095 * @throws SQLException if (1) the given column name does not match the
3096 * name of a column in this rowset, (2) the cursor is not on
3097 * one of this rowset's rows or its insert row, or (3) this
3098 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3099 */
3100 public void updateNull(String columnName) throws SQLException {
3101 throw new UnsupportedOperationException();
3102 }
3103
3104 /**
3105 * Sets the designated column in either the current row or the insert
3106 * row of this <code>CachedRowSetImpl</code> object with the given
3107 * <code>boolean</code> value.
3108 * <P>
3109 * This method updates a column value in the current row or the insert
3110 * row of this rowset, but it does not update the database.
3111 * If the cursor is on a row in the rowset, the
3112 * method {@link #updateRow} must be called to update the database.
3113 * If the cursor is on the insert row, the method {@link #insertRow}
3114 * must be called, which will insert the new row into both this rowset
3115 * and the database. Both of these methods must be called before the
3116 * cursor moves to another row.
3117 *
3118 * @param columnName a <code>String</code> object that must match the
3119 * SQL name of a column in this rowset, ignoring case
3120 * @param x the new column value
3121 * @throws SQLException if (1) the given column name does not match the
3122 * name of a column in this rowset, (2) the cursor is not on
3123 * one of this rowset's rows or its insert row, or (3) this
3124 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3125 */
3126 public void updateBoolean(String columnName, boolean x) throws SQLException {
3127 throw new UnsupportedOperationException();
3128 }
3129
3130 /**
3131 * Sets the designated column in either the current row or the insert
3132 * row of this <code>CachedRowSetImpl</code> object with the given
3133 * <code>byte</code> value.
3134 * <P>
3135 * This method updates a column value in the current row or the insert
3136 * row of this rowset, but it does not update the database.
3137 * If the cursor is on a row in the rowset, the
3138 * method {@link #updateRow} must be called to update the database.
3139 * If the cursor is on the insert row, the method {@link #insertRow}
3140 * must be called, which will insert the new row into both this rowset
3141 * and the database. Both of these methods must be called before the
3142 * cursor moves to another row.
3143 *
3144 * @param columnName a <code>String</code> object that must match the
3145 * SQL name of a column in this rowset, ignoring case
3146 * @param x the new column value
3147 * @throws SQLException if (1) the given column name does not match the
3148 * name of a column in this rowset, (2) the cursor is not on
3149 * one of this rowset's rows or its insert row, or (3) this
3150 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3151 */
3152 public void updateByte(String columnName, byte x) throws SQLException {
3153 throw new UnsupportedOperationException();
3154 }
3155
3156 /**
3157 * Sets the designated column in either the current row or the insert
3158 * row of this <code>CachedRowSetImpl</code> object with the given
3159 * <code>short</code> value.
3160 * <P>
3161 * This method updates a column value in the current row or the insert
3162 * row of this rowset, but it does not update the database.
3163 * If the cursor is on a row in the rowset, the
3164 * method {@link #updateRow} must be called to update the database.
3165 * If the cursor is on the insert row, the method {@link #insertRow}
3166 * must be called, which will insert the new row into both this rowset
3167 * and the database. Both of these methods must be called before the
3168 * cursor moves to another row.
3169 *
3170 * @param columnName a <code>String</code> object that must match the
3171 * SQL name of a column in this rowset, ignoring case
3172 * @param x the new column value
3173 * @throws SQLException if (1) the given column name does not match the
3174 * name of a column in this rowset, (2) the cursor is not on
3175 * one of this rowset's rows or its insert row, or (3) this
3176 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3177 */
3178 public void updateShort(String columnName, short x) throws SQLException {
3179 throw new UnsupportedOperationException();
3180 }
3181
3182 /**
3183 * Sets the designated column in either the current row or the insert
3184 * row of this <code>CachedRowSetImpl</code> object with the given
3185 * <code>int</code> value.
3186 * <P>
3187 * This method updates a column value in the current row or the insert
3188 * row of this rowset, but it does not update the database.
3189 * If the cursor is on a row in the rowset, the
3190 * method {@link #updateRow} must be called to update the database.
3191 * If the cursor is on the insert row, the method {@link #insertRow}
3192 * must be called, which will insert the new row into both this rowset
3193 * and the database. Both of these methods must be called before the
3194 * cursor moves to another row.
3195 *
3196 * @param columnName a <code>String</code> object that must match the
3197 * SQL name of a column in this rowset, ignoring case
3198 * @param x the new column value
3199 * @throws SQLException if (1) the given column name does not match the
3200 * name of a column in this rowset, (2) the cursor is not on
3201 * one of this rowset's rows or its insert row, or (3) this
3202 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3203 */
3204 public void updateInt(String columnName, int x) throws SQLException {
3205 throw new UnsupportedOperationException();
3206 }
3207
3208 /**
3209 * Sets the designated column in either the current row or the insert
3210 * row of this <code>CachedRowSetImpl</code> object with the given
3211 * <code>long</code> value.
3212 * <P>
3213 * This method updates a column value in the current row or the insert
3214 * row of this rowset, but it does not update the database.
3215 * If the cursor is on a row in the rowset, the
3216 * method {@link #updateRow} must be called to update the database.
3217 * If the cursor is on the insert row, the method {@link #insertRow}
3218 * must be called, which will insert the new row into both this rowset
3219 * and the database. Both of these methods must be called before the
3220 * cursor moves to another row.
3221 *
3222 * @param columnName a <code>String</code> object that must match the
3223 * SQL name of a column in this rowset, ignoring case
3224 * @param x the new column value
3225 * @throws SQLException if (1) the given column name does not match the
3226 * name of a column in this rowset, (2) the cursor is not on
3227 * one of this rowset's rows or its insert row, or (3) this
3228 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3229 */
3230 public void updateLong(String columnName, long x) throws SQLException {
3231 throw new UnsupportedOperationException();
3232 }
3233
3234 /**
3235 * Sets the designated column in either the current row or the insert
3236 * row of this <code>CachedRowSetImpl</code> object with the given
3237 * <code>float</code> value.
3238 * <P>
3239 * This method updates a column value in the current row or the insert
3240 * row of this rowset, but it does not update the database.
3241 * If the cursor is on a row in the rowset, the
3242 * method {@link #updateRow} must be called to update the database.
3243 * If the cursor is on the insert row, the method {@link #insertRow}
3244 * must be called, which will insert the new row into both this rowset
3245 * and the database. Both of these methods must be called before the
3246 * cursor moves to another row.
3247 *
3248 * @param columnName a <code>String</code> object that must match the
3249 * SQL name of a column in this rowset, ignoring case
3250 * @param x the new column value
3251 * @throws SQLException if (1) the given column name does not match the
3252 * name of a column in this rowset, (2) the cursor is not on
3253 * one of this rowset's rows or its insert row, or (3) this
3254 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3255 */
3256 public void updateFloat(String columnName, float x) throws SQLException {
3257 throw new UnsupportedOperationException();
3258 }
3259
3260 /**
3261 * Sets the designated column in either the current row or the insert
3262 * row of this <code>CachedRowSetImpl</code> object with the given
3263 * <code>double</code> value.
3264 *
3265 * This method updates a column value in either the current row or
3266 * the insert row of this rowset, but it does not update the
3267 * database. If the cursor is on a row in the rowset, the
3268 * method {@link #updateRow} must be called to update the database.
3269 * If the cursor is on the insert row, the method {@link #insertRow}
3270 * must be called, which will insert the new row into both this rowset
3271 * and the database. Both of these methods must be called before the
3272 * cursor moves to another row.
3273 *
3274 * @param columnName a <code>String</code> object that must match the
3275 * SQL name of a column in this rowset, ignoring case
3276 * @param x the new column value
3277 * @throws SQLException if (1) the given column name does not match the
3278 * name of a column in this rowset, (2) the cursor is not on
3279 * one of this rowset's rows or its insert row, or (3) this
3280 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3281 */
3282 public void updateDouble(String columnName, double x) throws SQLException {
3283 throw new UnsupportedOperationException();
3284 }
3285
3286 /**
3287 * Sets the designated column in either the current row or the insert
3288 * row of this <code>CachedRowSetImpl</code> object with the given
3289 * <code>java.math.BigDecimal</code> object.
3290 * <P>
3291 * This method updates a column value in the current row or the insert
3292 * row of this rowset, but it does not update the database.
3293 * If the cursor is on a row in the rowset, the
3294 * method {@link #updateRow} must be called to update the database.
3295 * If the cursor is on the insert row, the method {@link #insertRow}
3296 * must be called, which will insert the new row into both this rowset
3297 * and the database. Both of these methods must be called before the
3298 * cursor moves to another row.
3299 *
3300 * @param columnName a <code>String</code> object that must match the
3301 * SQL name of a column in this rowset, ignoring case
3302 * @param x the new column value
3303 * @throws SQLException if (1) the given column name does not match the
3304 * name of a column in this rowset, (2) the cursor is not on
3305 * one of this rowset's rows or its insert row, or (3) this
3306 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3307 */
3308 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
3309 throw new UnsupportedOperationException();
3310 }
3311
3312 /**
3313 * Sets the designated column in either the current row or the insert
3314 * row of this <code>CachedRowSetImpl</code> object with the given
3315 * <code>String</code> object.
3316 *
3317 * This method updates a column value in either the current row or
3318 * the insert row of this rowset, but it does not update the
3319 * database. If the cursor is on a row in the rowset, the
3320 * method {@link #updateRow} must be called to update the database.
3321 * If the cursor is on the insert row, the method {@link #insertRow}
3322 * must be called, which will insert the new row into both this rowset
3323 * and the database. Both of these methods must be called before the
3324 * cursor moves to another row.
3325 *
3326 * @param columnName a <code>String</code> object that must match the
3327 * SQL name of a column in this rowset, ignoring case
3328 * @param x the new column value
3329 * @throws SQLException if (1) the given column name does not match the
3330 * name of a column in this rowset, (2) the cursor is not on
3331 * one of this rowset's rows or its insert row, or (3) this
3332 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3333 */
3334 public void updateString(String columnName, String x) throws SQLException {
3335 throw new UnsupportedOperationException();
3336 }
3337
3338 /**
3339 * Sets the designated column in either the current row or the insert
3340 * row of this <code>CachedRowSetImpl</code> object with the given
3341 * <code>byte</code> array.
3342 *
3343 * This method updates a column value in either the current row or
3344 * the insert row of this rowset, but it does not update the
3345 * database. If the cursor is on a row in the rowset, the
3346 * method {@link #updateRow} must be called to update the database.
3347 * If the cursor is on the insert row, the method {@link #insertRow}
3348 * must be called, which will insert the new row into both this rowset
3349 * and the database. Both of these methods must be called before the
3350 * cursor moves to another row.
3351 *
3352 * @param columnName a <code>String</code> object that must match the
3353 * SQL name of a column in this rowset, ignoring case
3354 * @param x the new column value
3355 * @throws SQLException if (1) the given column name does not match the
3356 * name of a column in this rowset, (2) the cursor is not on
3357 * one of this rowset's rows or its insert row, or (3) this
3358 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3359 */
3360 public void updateBytes(String columnName, byte x[]) throws SQLException {
3361 throw new UnsupportedOperationException();
3362 }
3363
3364 /**
3365 * Sets the designated column in either the current row or the insert
3366 * row of this <code>CachedRowSetImpl</code> object with the given
3367 * <code>Date</code> object.
3368 *
3369 * This method updates a column value in either the current row or
3370 * the insert row of this rowset, but it does not update the
3371 * database. If the cursor is on a row in the rowset, the
3372 * method {@link #updateRow} must be called to update the database.
3373 * If the cursor is on the insert row, the method {@link #insertRow}
3374 * must be called, which will insert the new row into both this rowset
3375 * and the database. Both of these methods must be called before the
3376 * cursor moves to another row.
3377 *
3378 * @param columnName a <code>String</code> object that must match the
3379 * SQL name of a column in this rowset, ignoring case
3380 * @param x the new column value
3381 * @throws SQLException if (1) the given column name does not match the
3382 * name of a column in this rowset, (2) the cursor is not on
3383 * one of this rowset's rows or its insert row, (3) the type
3384 * of the designated column is not an SQL <code>DATE</code> or
3385 * <code>TIMESTAMP</code>, or (4) this rowset is
3386 * <code>ResultSet.CONCUR_READ_ONLY</code>
3387 */
3388 public void updateDate(String columnName, java.sql.Date x) throws SQLException {
3389 throw new UnsupportedOperationException();
3390 }
3391
3392 /**
3393 * Sets the designated column in either the current row or the insert
3394 * row of this <code>CachedRowSetImpl</code> object with the given
3395 * <code>Time</code> object.
3396 *
3397 * This method updates a column value in either the current row or
3398 * the insert row of this rowset, but it does not update the
3399 * database. If the cursor is on a row in the rowset, the
3400 * method {@link #updateRow} must be called to update the database.
3401 * If the cursor is on the insert row, the method {@link #insertRow}
3402 * must be called, which will insert the new row into both this rowset
3403 * and the database. Both of these methods must be called before the
3404 * cursor moves to another row.
3405 *
3406 * @param columnName a <code>String</code> object that must match the
3407 * SQL name of a column in this rowset, ignoring case
3408 * @param x the new column value
3409 * @throws SQLException if (1) the given column name does not match the
3410 * name of a column in this rowset, (2) the cursor is not on
3411 * one of this rowset's rows or its insert row, (3) the type
3412 * of the designated column is not an SQL <code>TIME</code> or
3413 * <code>TIMESTAMP</code>, or (4) this rowset is
3414 * <code>ResultSet.CONCUR_READ_ONLY</code>
3415 */
3416 public void updateTime(String columnName, java.sql.Time x) throws SQLException {
3417 throw new UnsupportedOperationException();
3418 }
3419
3420 /**
3421 * Sets the designated column in either the current row or the insert
3422 * row of this <code>CachedRowSetImpl</code> object with the given
3423 * <code>Timestamp</code> object.
3424 *
3425 * This method updates a column value in either the current row or
3426 * the insert row of this rowset, but it does not update the
3427 * database. If the cursor is on a row in the rowset, the
3428 * method {@link #updateRow} must be called to update the database.
3429 * If the cursor is on the insert row, the method {@link #insertRow}
3430 * must be called, which will insert the new row into both this rowset
3431 * and the database. Both of these methods must be called before the
3432 * cursor moves to another row.
3433 *
3434 * @param columnName a <code>String</code> object that must match the
3435 * SQL name of a column in this rowset, ignoring case
3436 * @param x the new column value
3437 * @throws SQLException if the given column index is out of bounds or
3438 * the cursor is not on one of this rowset's rows or its
3439 * insert row
3440 * @throws SQLException if (1) the given column name does not match the
3441 * name of a column in this rowset, (2) the cursor is not on
3442 * one of this rowset's rows or its insert row, (3) the type
3443 * of the designated column is not an SQL <code>DATE</code>,
3444 * <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this
3445 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3446 */
3447 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
3448 throw new UnsupportedOperationException();
3449 }
3450
3451 /**
3452 * Sets the designated column in either the current row or the insert
3453 * row of this <code>CachedRowSetImpl</code> object with the given
3454 * ASCII stream value.
3455 * <P>
3456 * This method updates a column value in either the current row or
3457 * the insert row of this rowset, but it does not update the
3458 * database. If the cursor is on a row in the rowset, the
3459 * method {@link #updateRow} must be called to update the database.
3460 * If the cursor is on the insert row, the method {@link #insertRow}
3461 * must be called, which will insert the new row into both this rowset
3462 * and the database. Both of these methods must be called before the
3463 * cursor moves to another row.
3464 *
3465 * @param columnName a <code>String</code> object that must match the
3466 * SQL name of a column in this rowset, ignoring case
3467 * @param x the new column value
3468 * @param length the number of one-byte ASCII characters in the stream
3469 */
3470 public void updateAsciiStream(String columnName,
3471 java.io.InputStream x,
3472 int length) throws SQLException {
3473 throw new UnsupportedOperationException();
3474 }
3475
3476 /**
3477 * Sets the designated column in either the current row or the insert
3478 * row of this <code>CachedRowSetImpl</code> object with the given
3479 * <code>java.io.InputStream</code> object.
3480 * <P>
3481 * This method updates a column value in either the current row or
3482 * the insert row of this rowset, but it does not update the
3483 * database. If the cursor is on a row in the rowset, the
3484 * method {@link #updateRow} must be called to update the database.
3485 * If the cursor is on the insert row, the method {@link #insertRow}
3486 * must be called, which will insert the new row into both this rowset
3487 * and the database. Both of these methods must be called before the
3488 * cursor moves to another row.
3489 *
3490 * @param columnName a <code>String</code> object that must match the
3491 * SQL name of a column in this rowset, ignoring case
3492 * @param x the new column value; must be a <code>java.io.InputStream</code>
3493 * containing <code>BINARY</code>, <code>VARBINARY</code>, or
3494 * <code>LONGVARBINARY</code> data
3495 * @param length the length of the stream in bytes
3496 * @throws SQLException if (1) the given column name does not match the
3497 * name of a column in this rowset, (2) the cursor is not on
3498 * one of this rowset's rows or its insert row, (3) the data
3499 * in the stream is not binary, or (4) this rowset is
3500 * <code>ResultSet.CONCUR_READ_ONLY</code>
3501 */
3502 public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
3503 throw new UnsupportedOperationException();
3504 }
3505
3506 /**
3507 * Sets the designated column in either the current row or the insert
3508 * row of this <code>CachedRowSetImpl</code> object with the given
3509 * <code>java.io.Reader</code> object.
3510 * <P>
3511 * This method updates a column value in either the current row or
3512 * the insert row of this rowset, but it does not update the
3513 * database. If the cursor is on a row in the rowset, the
3514 * method {@link #updateRow} must be called to update the database.
3515 * If the cursor is on the insert row, the method {@link #insertRow}
3516 * must be called, which will insert the new row into both this rowset
3517 * and the database. Both of these methods must be called before the
3518 * cursor moves to another row.
3519 *
3520 * @param columnName a <code>String</code> object that must match the
3521 * SQL name of a column in this rowset, ignoring case
3522 * @param reader the new column value; must be a
3523 * <code>java.io.Reader</code> containing <code>BINARY</code>,
3524 * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>,
3525 * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> data
3526 * @param length the length of the stream in characters
3527 * @throws SQLException if (1) the given column name does not match the
3528 * name of a column in this rowset, (2) the cursor is not on
3529 * one of this rowset's rows or its insert row, (3) the data
3530 * in the stream is not a binary or character type, or (4) this
3531 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3532 */
3533 public void updateCharacterStream(String columnName,
3534 java.io.Reader reader,
3535 int length) throws SQLException {
3536 throw new UnsupportedOperationException();
3537 }
3538
3539 /**
3540 * Sets the designated column in either the current row or the insert
3541 * row of this <code>CachedRowSetImpl</code> object with the given
3542 * <code>Object</code> value. The <code>scale</code> parameter
3543 * indicates the number of digits to the right of the decimal point
3544 * and is ignored if the new column value is not a type that will be
3545 * mapped to an SQL <code>DECIMAL</code> or <code>NUMERIC</code> value.
3546 * <P>
3547 * This method updates a column value in either the current row or
3548 * the insert row of this rowset, but it does not update the
3549 * database. If the cursor is on a row in the rowset, the
3550 * method {@link #updateRow} must be called to update the database.
3551 * If the cursor is on the insert row, the method {@link #insertRow}
3552 * must be called, which will insert the new row into both this rowset
3553 * and the database. Both of these methods must be called before the
3554 * cursor moves to another row.
3555 *
3556 * @param columnName a <code>String</code> object that must match the
3557 * SQL name of a column in this rowset, ignoring case
3558 * @param x the new column value
3559 * @param scale the number of digits to the right of the decimal point (for
3560 * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3561 * @throws SQLException if (1) the given column name does not match the
3562 * name of a column in this rowset, (2) the cursor is not on
3563 * one of this rowset's rows or its insert row, or (3) this
3564 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3565 */
3566 public void updateObject(String columnName, Object x, int scale) throws SQLException {
3567 throw new UnsupportedOperationException();
3568 }
3569
3570 /**
3571 * Sets the designated column in either the current row or the insert
3572 * row of this <code>CachedRowSetImpl</code> object with the given
3573 * <code>Object</code> value.
3574 * <P>
3575 * This method updates a column value in either the current row or
3576 * the insert row of this rowset, but it does not update the
3577 * database. If the cursor is on a row in the rowset, the
3578 * method {@link #updateRow} must be called to update the database.
3579 * If the cursor is on the insert row, the method {@link #insertRow}
3580 * must be called, which will insert the new row into both this rowset
3581 * and the database. Both of these methods must be called before the
3582 * cursor moves to another row.
3583 *
3584 * @param columnName a <code>String</code> object that must match the
3585 * SQL name of a column in this rowset, ignoring case
3586 * @param x the new column value
3587 * @throws SQLException if (1) the given column name does not match the
3588 * name of a column in this rowset, (2) the cursor is not on
3589 * one of this rowset's rows or its insert row, or (3) this
3590 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3591 */
3592 public void updateObject(String columnName, Object x) throws SQLException {
3593 throw new UnsupportedOperationException();
3594 }
3595
3596 /**
3597 * Inserts the contents of this <code>CachedRowSetImpl</code> object's insert
3598 * row into this rowset immediately following the current row.
3599 * If the current row is the
3600 * position after the last row or before the first row, the new row will
3601 * be inserted at the end of the rowset. This method also notifies
3602 * listeners registered with this rowset that the row has changed.
3603 * <P>
3604 * The cursor must be on the insert row when this method is called.
3605 *
3606 * @throws SQLException if (1) the cursor is not on the insert row,
3607 * (2) one or more of the non-nullable columns in the insert
3608 * row has not been given a value, or (3) this rowset is
3609 * <code>ResultSet.CONCUR_READ_ONLY</code>
3610 */
3611 public void insertRow() throws SQLException {
3612 throw new UnsupportedOperationException();
3613 }
3614
3615 /**
3616 * Marks the current row of this <code>CachedRowSetImpl</code> object as
3617 * updated and notifies listeners registered with this rowset that the
3618 * row has changed.
3619 * <P>
3620 * This method cannot be called when the cursor is on the insert row, and
3621 * it should be called before the cursor moves to another row. If it is
3622 * called after the cursor moves to another row, this method has no effect,
3623 * and the updates made before the cursor moved will be lost.
3624 *
3625 * @throws SQLException if the cursor is on the insert row or this
3626 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3627 */
3628 public void updateRow() throws SQLException {
3629 throw new UnsupportedOperationException();
3630 }
3631
3632 /**
3633 * Deletes the current row from this <code>CachedRowSetImpl</code> object and
3634 * notifies listeners registered with this rowset that a row has changed.
3635 * This method cannot be called when the cursor is on the insert row.
3636 * <P>
3637 * This method marks the current row as deleted, but it does not delete
3638 * the row from the underlying data source. The method
3639 * <code>acceptChanges</code> must be called to delete the row in
3640 * the data source.
3641 *
3642 * @throws SQLException if (1) this method is called when the cursor
3643 * is on the insert row, before the first row, or after the
3644 * last row or (2) this rowset is
3645 * <code>ResultSet.CONCUR_READ_ONLY</code>
3646 */
3647 public void deleteRow() throws SQLException {
3648 throw new UnsupportedOperationException();
3649 }
3650
3651 /**
3652 * Sets the current row with its original value and marks the row as
3653 * not updated, thus undoing any changes made to the row since the
3654 * last call to the methods <code>updateRow</code> or <code>deleteRow</code>.
3655 * This method should be called only when the cursor is on a row in
3656 * this rowset.
3657 *
3658 * @throws SQLException if the cursor is on the insert row, before the
3659 * first row, or after the last row
3660 */
3661 public void refreshRow() throws SQLException {
3662 throw new UnsupportedOperationException();
3663 }
3664
3665 /**
3666 * Rolls back any updates made to the current row of this
3667 * <code>CachedRowSetImpl</code> object and notifies listeners that
3668 * a row has changed. To have an effect, this method
3669 * must be called after an <code>updateXXX</code> method has been
3670 * called and before the method <code>updateRow</code> has been called.
3671 * If no updates have been made or the method <code>updateRow</code>
3672 * has already been called, this method has no effect.
3673 *
3674 * @throws SQLException if the cursor is on the insert row, before the
3675 * first row, or after the last row
3676 */
3677 public void cancelRowUpdates() throws SQLException {
3678 throw new UnsupportedOperationException();
3679 }
3680
3681 /**
3682 * Moves the cursor for this <code>CachedRowSetImpl</code> object
3683 * to the insert row. The current row in the rowset is remembered
3684 * while the cursor is on the insert row.
3685 * <P>
3686 * The insert row is a special row associated with an updatable
3687 * rowset. It is essentially a buffer where a new row may
3688 * be constructed by calling the appropriate <code>updateXXX</code>
3689 * methods to assign a value to each column in the row. A complete
3690 * row must be constructed; that is, every column that is not nullable
3691 * must be assigned a value. In order for the new row to become part
3692 * of this rowset, the method <code>insertRow</code> must be called
3693 * before the cursor is moved back to the rowset.
3694 * <P>
3695 * Only certain methods may be invoked while the cursor is on the insert
3696 * row; many methods throw an exception if they are called while the
3697 * cursor is there. In addition to the <code>updateXXX</code>
3698 * and <code>insertRow</code> methods, only the <code>getXXX</code> methods
3699 * may be called when the cursor is on the insert row. A <code>getXXX</code>
3700 * method should be called on a column only after an <code>updateXXX</code>
3701 * method has been called on that column; otherwise, the value returned is
3702 * undetermined.
3703 *
3704 * @throws SQLException if this <code>CachedRowSetImpl</code> object is
3705 * <code>ResultSet.CONCUR_READ_ONLY</code>
3706 */
3707 public void moveToInsertRow() throws SQLException {
3708 throw new UnsupportedOperationException();
3709 }
3710
3711 /**
3712 * Moves the cursor for this <code>CachedRowSetImpl</code> object to
3713 * the current row. The current row is the row the cursor was on
3714 * when the method <code>moveToInsertRow</code> was called.
3715 * <P>
3716 * Calling this method has no effect unless it is called while the
3717 * cursor is on the insert row.
3718 *
3719 * @throws SQLException if an error occurs
3720 */
3721 public void moveToCurrentRow() throws SQLException {
3722 throw new UnsupportedOperationException();
3723 }
3724
3725 /**
3726 * Returns <code>null</code>.
3727 *
3728 * @return <code>null</code>
3729 * @throws SQLException if an error occurs
3730 */
3731 public Statement getStatement() throws SQLException {
3732 throw new UnsupportedOperationException();
3733 }
3734
3735 /**
3736 * Retrieves the value of the designated column in this
3737 * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
3738 * the Java programming language, using the given
3739 * <code>java.util.Map</code> object to custom map the value if
3740 * appropriate.
3741 *
3742 * @param columnIndex the first column is <code>1</code>, the second
3743 * is <code>2</code>, and so on; must be <code>1</code> or larger
3744 * and equal to or less than the number of columns in this rowset
3745 * @param map a <code>java.util.Map</code> object showing the mapping
3746 * from SQL type names to classes in the Java programming
3747 * language
3748 * @return an <code>Object</code> representing the SQL value
3749 * @throws SQLException if the given column index is out of bounds or
3750 * the cursor is not on one of this rowset's rows or its
3751 * insert row
3752 */
3753 public Object getObject(int columnIndex,
3754 java.util.Map<String,Class<?>> map)
3755 throws SQLException
3756 {
3757 throw new UnsupportedOperationException();
3758 }
3759
3760 /**
3761 * Retrieves the value of the designated column in this
3762 * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
3763 * in the Java programming language.
3764 *
3765 * @param columnIndex the first column is <code>1</code>, the second
3766 * is <code>2</code>, and so on; must be <code>1</code> or larger
3767 * and equal to or less than the number of columns in this rowset
3768 * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3769 * @throws SQLException if (1) the given column index is out of bounds,
3770 * (2) the cursor is not on one of this rowset's rows or its
3771 * insert row, or (3) the designated column does not store an
3772 * SQL <code>REF</code> value
3773 * @see #getRef(String)
3774 */
3775 public Ref getRef(int columnIndex) throws SQLException {
3776 throw new UnsupportedOperationException();
3777 }
3778
3779 /**
3780 * Retrieves the value of the designated column in this
3781 * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
3782 * in the Java programming language.
3783 *
3784 * @param columnIndex the first column is <code>1</code>, the second
3785 * is <code>2</code>, and so on; must be <code>1</code> or larger
3786 * and equal to or less than the number of columns in this rowset
3787 * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3788 * @throws SQLException if (1) the given column index is out of bounds,
3789 * (2) the cursor is not on one of this rowset's rows or its
3790 * insert row, or (3) the designated column does not store an
3791 * SQL <code>BLOB</code> value
3792 * @see #getBlob(String)
3793 */
3794 public Blob getBlob(int columnIndex) throws SQLException {
3795 throw new UnsupportedOperationException();
3796 }
3797
3798 /**
3799 * Retrieves the value of the designated column in this
3800 * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
3801 * in the Java programming language.
3802 *
3803 * @param columnIndex the first column is <code>1</code>, the second
3804 * is <code>2</code>, and so on; must be <code>1</code> or larger
3805 * and equal to or less than the number of columns in this rowset
3806 * @return a <code>Clob</code> object representing an SQL <code>CLOB</code> value
3807 * @throws SQLException if (1) the given column index is out of bounds,
3808 * (2) the cursor is not on one of this rowset's rows or its
3809 * insert row, or (3) the designated column does not store an
3810 * SQL <code>CLOB</code> value
3811 * @see #getClob(String)
3812 */
3813 public Clob getClob(int columnIndex) throws SQLException {
3814 throw new UnsupportedOperationException();
3815 }
3816
3817 /**
3818 * Retrieves the value of the designated column in this
3819 * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
3820 * in the Java programming language.
3821 *
3822 * @param columnIndex the first column is <code>1</code>, the second
3823 * is <code>2</code>, and so on; must be <code>1</code> or larger
3824 * and equal to or less than the number of columns in this rowset
3825 * @return an <code>Array</code> object representing an SQL
3826 * <code>ARRAY</code> value
3827 * @throws SQLException if (1) the given column index is out of bounds,
3828 * (2) the cursor is not on one of this rowset's rows or its
3829 * insert row, or (3) the designated column does not store an
3830 * SQL <code>ARRAY</code> value
3831 * @see #getArray(String)
3832 */
3833 public Array getArray(int columnIndex) throws SQLException {
3834 throw new UnsupportedOperationException();
3835 }
3836
3837 /**
3838 * Retrieves the value of the designated column in this
3839 * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
3840 * the Java programming language, using the given
3841 * <code>java.util.Map</code> object to custom map the value if
3842 * appropriate.
3843 *
3844 * @param columnName a <code>String</code> object that must match the
3845 * SQL name of a column in this rowset, ignoring case
3846 * @param map a <code>java.util.Map</code> object showing the mapping
3847 * from SQL type names to classes in the Java programming
3848 * language
3849 * @return an <code>Object</code> representing the SQL value
3850 * @throws SQLException if the given column name is not the name of
3851 * a column in this rowset or the cursor is not on one of
3852 * this rowset's rows or its insert row
3853 */
3854 public Object getObject(String columnName,
3855 java.util.Map<String,Class<?>> map)
3856 throws SQLException {
3857 throw new UnsupportedOperationException();
3858 }
3859
3860 /**
3861 * Retrieves the value of the designated column in this
3862 * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
3863 * in the Java programming language.
3864 *
3865 * @param colName a <code>String</code> object that must match the
3866 * SQL name of a column in this rowset, ignoring case
3867 * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3868 * @throws SQLException if (1) the given column name is not the name of
3869 * a column in this rowset, (2) the cursor is not on one of
3870 * this rowset's rows or its insert row, or (3) the column value
3871 * is not an SQL <code>REF</code> value
3872 * @see #getRef(int)
3873 */
3874 public Ref getRef(String colName) throws SQLException {
3875 throw new UnsupportedOperationException();
3876 }
3877
3878 /**
3879 * Retrieves the value of the designated column in this
3880 * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
3881 * in the Java programming language.
3882 *
3883 * @param colName a <code>String</code> object that must match the
3884 * SQL name of a column in this rowset, ignoring case
3885 * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3886 * @throws SQLException if (1) the given column name is not the name of
3887 * a column in this rowset, (2) the cursor is not on one of
3888 * this rowset's rows or its insert row, or (3) the designated
3889 * column does not store an SQL <code>BLOB</code> value
3890 * @see #getBlob(int)
3891 */
3892 public Blob getBlob(String colName) throws SQLException {
3893 throw new UnsupportedOperationException();
3894 }
3895
3896 /**
3897 * Retrieves the value of the designated column in this
3898 * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
3899 * in the Java programming language.
3900 *
3901 * @param colName a <code>String</code> object that must match the
3902 * SQL name of a column in this rowset, ignoring case
3903 * @return a <code>Clob</code> object representing an SQL
3904 * <code>CLOB</code> value
3905 * @throws SQLException if (1) the given column name is not the name of
3906 * a column in this rowset, (2) the cursor is not on one of
3907 * this rowset's rows or its insert row, or (3) the designated
3908 * column does not store an SQL <code>CLOB</code> value
3909 * @see #getClob(int)
3910 */
3911 public Clob getClob(String colName) throws SQLException {
3912 throw new UnsupportedOperationException();
3913 }
3914
3915 /**
3916 * Retrieves the value of the designated column in this
3917 * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
3918 * in the Java programming langugage.
3919 *
3920 * @param colName a <code>String</code> object that must match the
3921 * SQL name of a column in this rowset, ignoring case
3922 * @return an <code>Array</code> object representing an SQL
3923 * <code>ARRAY</code> value
3924 * @throws SQLException if (1) the given column name is not the name of
3925 * a column in this rowset, (2) the cursor is not on one of
3926 * this rowset's rows or its insert row, or (3) the designated
3927 * column does not store an SQL <code>ARRAY</code> value
3928 * @see #getArray(int)
3929 */
3930 public Array getArray(String colName) throws SQLException {
3931 throw new UnsupportedOperationException();
3932 }
3933
3934 /**
3935 * Retrieves the value of the designated column in the current row
3936 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
3937 * object, using the given <code>Calendar</code> object to construct an
3938 * appropriate millisecond value for the date.
3939 *
3940 * @param columnIndex the first column is <code>1</code>, the second
3941 * is <code>2</code>, and so on; must be <code>1</code> or larger
3942 * and equal to or less than the number of columns in the rowset
3943 * @param cal the <code>java.util.Calendar</code> object to use in
3944 * constructing the date
3945 * @return the column value; if the value is SQL <code>NULL</code>,
3946 * the result is <code>null</code>
3947 * @throws SQLException if (1) the given column name is not the name of
3948 * a column in this rowset, (2) the cursor is not on one of
3949 * this rowset's rows or its insert row, or (3) the designated
3950 * column does not store an SQL <code>DATE</code> or
3951 * <code>TIMESTAMP</code> value
3952 */
3953 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
3954 throw new UnsupportedOperationException();
3955 }
3956
3957 /**
3958 * Retrieves the value of the designated column in the current row
3959 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
3960 * object, using the given <code>Calendar</code> object to construct an
3961 * appropriate millisecond value for the date.
3962 *
3963 * @param columnName a <code>String</code> object that must match the
3964 * SQL name of a column in this rowset, ignoring case
3965 * @param cal the <code>java.util.Calendar</code> object to use in
3966 * constructing the date
3967 * @return the column value; if the value is SQL <code>NULL</code>,
3968 * the result is <code>null</code>
3969 * @throws SQLException if (1) the given column name is not the name of
3970 * a column in this rowset, (2) the cursor is not on one of
3971 * this rowset's rows or its insert row, or (3) the designated
3972 * column does not store an SQL <code>DATE</code> or
3973 * <code>TIMESTAMP</code> value
3974 */
3975 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
3976 throw new UnsupportedOperationException();
3977 }
3978
3979 /**
3980 * Retrieves the value of the designated column in the current row
3981 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
3982 * object, using the given <code>Calendar</code> object to construct an
3983 * appropriate millisecond value for the date.
3984 *
3985 * @param columnIndex the first column is <code>1</code>, the second
3986 * is <code>2</code>, and so on; must be <code>1</code> or larger
3987 * and equal to or less than the number of columns in the rowset
3988 * @param cal the <code>java.util.Calendar</code> object to use in
3989 * constructing the date
3990 * @return the column value; if the value is SQL <code>NULL</code>,
3991 * the result is <code>null</code>
3992 * @throws SQLException if (1) the given column name is not the name of
3993 * a column in this rowset, (2) the cursor is not on one of
3994 * this rowset's rows or its insert row, or (3) the designated
3995 * column does not store an SQL <code>TIME</code> or
3996 * <code>TIMESTAMP</code> value
3997 */
3998 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
3999 throw new UnsupportedOperationException();
4000 }
4001
4002 /**
4003 * Retrieves the value of the designated column in the current row
4004 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
4005 * object, using the given <code>Calendar</code> object to construct an
4006 * appropriate millisecond value for the date.
4007 *
4008 * @param columnName a <code>String</code> object that must match the
4009 * SQL name of a column in this rowset, ignoring case
4010 * @param cal the <code>java.util.Calendar</code> object to use in
4011 * constructing the date
4012 * @return the column value; if the value is SQL <code>NULL</code>,
4013 * the result is <code>null</code>
4014 * @throws SQLException if (1) the given column name is not the name of
4015 * a column in this rowset, (2) the cursor is not on one of
4016 * this rowset's rows or its insert row, or (3) the designated
4017 * column does not store an SQL <code>TIME</code> or
4018 * <code>TIMESTAMP</code> value
4019 */
4020 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
4021 throw new UnsupportedOperationException();
4022 }
4023
4024 /**
4025 * Retrieves the value of the designated column in the current row
4026 * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Timestamp</code>
4027 * object, using the given <code>Calendar</code> object to construct an
4028 * appropriate millisecond value for the date.
4029 *
4030 * @param columnIndex the first column is <code>1</code>, the second
4031 * is <code>2</code>, and so on; must be <code>1</code> or larger
4032 * and equal to or less than the number of columns in the rowset
4033 * @param cal the <code>java.util.Calendar</code> object to use in
4034 * constructing the date
4035 * @return the column value; if the value is SQL <code>NULL</code>,
4036 * the result is <code>null</code>
4037 * @throws SQLException if (1) the given column name is not the name of
4038 * a column in this rowset, (2) the cursor is not on one of
4039 * this rowset's rows or its insert row, or (3) the designated
4040 * column does not store an SQL <code>TIME</code> or
4041 * <code>TIMESTAMP</code> value
4042 */
4043 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
4044 throw new UnsupportedOperationException();
4045 }
4046
4047 /**
4048 * Retrieves the value of the designated column in the current row
4049 * of this <code>CachedRowSetImpl</code> object as a
4050 * <code>java.sql.Timestamp</code> object, using the given
4051 * <code>Calendar</code> object to construct an appropriate
4052 * millisecond value for the date.
4053 *
4054 * @param columnName a <code>String</code> object that must match the
4055 * SQL name of a column in this rowset, ignoring case
4056 * @param cal the <code>java.util.Calendar</code> object to use in
4057 * constructing the date
4058 * @return the column value; if the value is SQL <code>NULL</code>,
4059 * the result is <code>null</code>
4060 * @throws SQLException if (1) the given column name is not the name of
4061 * a column in this rowset, (2) the cursor is not on one of
4062 * this rowset's rows or its insert row, or (3) the designated
4063 * column does not store an SQL <code>DATE</code>,
4064 * <code>TIME</code>, or <code>TIMESTAMP</code> value
4065 */
4066 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
4067 throw new UnsupportedOperationException();
4068 }
4069
4070 /*
4071 * RowSetInternal Interface
4072 */
4073
4074 /**
4075 * Retrieves the <code>Connection</code> object passed to this
4076 * <code>CachedRowSetImpl</code> object. This connection may be
4077 * used to populate this rowset with data or to write data back
4078 * to its underlying data source.
4079 *
4080 * @return the <code>Connection</code> object passed to this rowset;
4081 * may be <code>null</code> if there is no connection
4082 * @throws SQLException if an error occurs
4083 */
4084 public Connection getConnection() throws SQLException{
4085 throw new UnsupportedOperationException();
4086 }
4087
4088 /**
4089 * Sets the metadata for this <code>CachedRowSetImpl</code> object
4090 * with the given <code>RowSetMetaData</code> object.
4091 *
4092 * @param md a <code>RowSetMetaData</code> object instance containing
4093 * metadata about the columsn in the rowset
4094 * @throws SQLException if invalid meta data is supplied to the
4095 * rowset
4096 */
4097 public void setMetaData(RowSetMetaData md) throws SQLException {
4098 throw new UnsupportedOperationException();
4099 }
4100
4101 /**
4102 * Returns a result set containing the original value of the rowset. The
4103 * original value is the state of the <code>CachedRowSetImpl</code> after the
4104 * last population or synchronization (whichever occured most recently) with
4105 * the data source.
4106 * <p>
4107 * The cursor is positioned before the first row in the result set.
4108 * Only rows contained in the result set returned by <code>getOriginal()</code>
4109 * are said to have an original value.
4110 *
4111 * @return the original result set of the rowset
4112 * @throws SQLException if an error occurs produce the
4113 * <code>ResultSet</code> object
4114 */
4115 public ResultSet getOriginal() throws SQLException {
4116 throw new UnsupportedOperationException();
4117 }
4118
4119 /**
4120 * Returns a result set containing the original value of the current
4121 * row only.
4122 * The original value is the state of the <code>CachedRowSetImpl</code> after
4123 * the last population or synchronization (whichever occured most recently)
4124 * with the data source.
4125 *
4126 * @return the original result set of the row
4127 * @throws SQLException if there is no current row
4128 * @see #setOriginalRow
4129 */
4130 public ResultSet getOriginalRow() throws SQLException {
4131 throw new UnsupportedOperationException();
4132
4133 }
4134
4135 /**
4136 * Marks the current row in this rowset as being an original row.
4137 *
4138 * @throws SQLException if there is no current row
4139 * @see #getOriginalRow
4140 */
4141 public void setOriginalRow() throws SQLException {
4142 throw new UnsupportedOperationException();
4143 }
4144
4145 /**
4146 * Marks all rows in this rowset as being original rows. Any updates
4147 * made to the rows become the original values for the rowset.
4148 * Calls to the method <code>setOriginal</code> connot be reversed.
4149 *
4150 * @throws SQLException if an error occurs
4151 */
4152 public void setOriginal() throws SQLException {
4153 throw new UnsupportedOperationException();
4154 }
4155
4156 /**
4157 * Returns an identifier for the object (table) that was used to create this
4158 * rowset.
4159 *
4160 * @return a <code>String</code> object that identifies the table from
4161 * which this <code>CachedRowSetImpl</code> object was derived
4162 * @throws SQLException if an error occurs
4163 */
4164 public String getTableName() throws SQLException {
4165 throw new UnsupportedOperationException();
4166 }
4167
4168 /**
4169 * Sets the identifier for the table from which this rowset was derived
4170 * to the given table name.
4171 *
4172 * @param tabName a <code>String</code> object that identifies the
4173 * table from which this <code>CachedRowSetImpl</code> object
4174 * was derived
4175 * @throws SQLException if an error occurs
4176 */
4177 public void setTableName(String tabName) throws SQLException {
4178 throw new UnsupportedOperationException();
4179 }
4180
4181 /**
4182 * Returns the columns that make a key to uniquely identify a
4183 * row in this <code>CachedRowSetImpl</code> object.
4184 *
4185 * @return an array of column numbers that constitutes a primary
4186 * key for this rowset. This array should be empty
4187 * if no column is representitive of a primary key
4188 * @throws SQLException if the rowset is empty or no columns
4189 * are designated as primary keys
4190 * @see #setKeyColumns
4191 */
4192 public int[] getKeyColumns() throws SQLException {
4193 throw new UnsupportedOperationException();
4194 }
4195
4196
4197 /**
4198 * Sets this <code>CachedRowSetImpl</code> object's
4199 * <code>keyCols</code> field with the given array of column
4200 * numbers, which forms a key for uniquely identifying a row
4201 * in this rowset.
4202 *
4203 * @param keys an array of <code>int</code> indicating the
4204 * columns that form a primary key for this
4205 * <code>CachedRowSetImpl</code> object; every
4206 * element in the array must be greater than
4207 * <code>0</code> and less than or equal to the number
4208 * of columns in this rowset
4209 * @throws SQLException if any of the numbers in the
4210 * given array is not valid for this rowset
4211 * @see #getKeyColumns
4212 */
4213 public void setKeyColumns(int [] keys) throws SQLException {
4214 throw new UnsupportedOperationException();
4215 }
4216
4217 /**
4218 * Sets the designated column in either the current row or the insert
4219 * row of this <code>CachedRowSetImpl</code> object with the given
4220 * <code>double</code> value.
4221 *
4222 * This method updates a column value in either the current row or
4223 * the insert row of this rowset, but it does not update the
4224 * database. If the cursor is on a row in the rowset, the
4225 * method {@link #updateRow} must be called to update the database.
4226 * If the cursor is on the insert row, the method {@link #insertRow}
4227 * must be called, which will insert the new row into both this rowset
4228 * and the database. Both of these methods must be called before the
4229 * cursor moves to another row.
4230 *
4231 * @param columnIndex the first column is <code>1</code>, the second
4232 * is <code>2</code>, and so on; must be <code>1</code> or larger
4233 * and equal to or less than the number of columns in this rowset
4234 * @param ref the new column <code>java.sql.Ref</code> value
4235 * @throws SQLException if (1) the given column index is out of bounds,
4236 * (2) the cursor is not on one of this rowset's rows or its
4237 * insert row, or (3) this rowset is
4238 * <code>ResultSet.CONCUR_READ_ONLY</code>
4239 */
4240 public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
4241 throw new UnsupportedOperationException();
4242 }
4243
4244 /**
4245 * Sets the designated column in either the current row or the insert
4246 * row of this <code>CachedRowSetImpl</code> object with the given
4247 * <code>double</code> value.
4248 *
4249 * This method updates a column value in either the current row or
4250 * the insert row of this rowset, but it does not update the
4251 * database. If the cursor is on a row in the rowset, the
4252 * method {@link #updateRow} must be called to update the database.
4253 * If the cursor is on the insert row, the method {@link #insertRow}
4254 * must be called, which will insert the new row into both this rowset
4255 * and the database. Both of these methods must be called before the
4256 * cursor moves to another row.
4257 *
4258 * @param columnName a <code>String</code> object that must match the
4259 * SQL name of a column in this rowset, ignoring case
4260 * @param ref the new column <code>java.sql.Ref</code> value
4261 * @throws SQLException if (1) the given column name does not match the
4262 * name of a column in this rowset, (2) the cursor is not on
4263 * one of this rowset's rows or its insert row, or (3) this
4264 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4265 */
4266 public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
4267 throw new UnsupportedOperationException();
4268 }
4269
4270 /**
4271 * Sets the designated column in either the current row or the insert
4272 * row of this <code>CachedRowSetImpl</code> object with the given
4273 * <code>double</code> value.
4274 *
4275 * This method updates a column value in either the current row or
4276 * the insert row of this rowset, but it does not update the
4277 * database. If the cursor is on a row in the rowset, the
4278 * method {@link #updateRow} must be called to update the database.
4279 * If the cursor is on the insert row, the method {@link #insertRow}
4280 * must be called, which will insert the new row into both this rowset
4281 * and the database. Both of these methods must be called before the
4282 * cursor moves to another row.
4283 *
4284 * @param columnIndex the first column is <code>1</code>, the second
4285 * is <code>2</code>, and so on; must be <code>1</code> or larger
4286 * and equal to or less than the number of columns in this rowset
4287 * @param c the new column <code>Clob value
4288 * @throws SQLException if (1) the given column index is out of bounds,
4289 * (2) the cursor is not on one of this rowset's rows or its
4290 * insert row, or (3) this rowset is
4291 * <code>ResultSet.CONCUR_READ_ONLY</code>
4292 */
4293 public void updateClob(int columnIndex, Clob c) throws SQLException {
4294 throw new UnsupportedOperationException();
4295 }
4296
4297 /**
4298 * Sets the designated column in either the current row or the insert
4299 * row of this <code>CachedRowSetImpl</code> object with the given
4300 * <code>double</code> value.
4301 *
4302 * This method updates a column value in either the current row or
4303 * the insert row of this rowset, but it does not update the
4304 * database. If the cursor is on a row in the rowset, the
4305 * method {@link #updateRow} must be called to update the database.
4306 * If the cursor is on the insert row, the method {@link #insertRow}
4307 * must be called, which will insert the new row into both this rowset
4308 * and the database. Both of these methods must be called before the
4309 * cursor moves to another row.
4310 *
4311 * @param columnName a <code>String</code> object that must match the
4312 * SQL name of a column in this rowset, ignoring case
4313 * @param c the new column <code>Clob</code>value
4314 * @throws SQLException if (1) the given column name does not match the
4315 * name of a column in this rowset, (2) the cursor is not on
4316 * one of this rowset's rows or its insert row, or (3) this
4317 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4318 */
4319 public void updateClob(String columnName, Clob c) throws SQLException {
4320 throw new UnsupportedOperationException();
4321 }
4322
4323 /**
4324 * Sets the designated column in either the current row or the insert
4325 * row of this <code>CachedRowSetImpl</code> object with the given
4326 * <code>java.sql.Blob</code> value.
4327 *
4328 * This method updates a column value in either the current row or
4329 * the insert row of this rowset, but it does not update the
4330 * database. If the cursor is on a row in the rowset, the
4331 * method {@link #updateRow} must be called to update the database.
4332 * If the cursor is on the insert row, the method {@link #insertRow}
4333 * must be called, which will insert the new row into both this rowset
4334 * and the database. Both of these methods must be called before the
4335 * cursor moves to another row.
4336 *
4337 * @param columnIndex the first column is <code>1</code>, the second
4338 * is <code>2</code>, and so on; must be <code>1</code> or larger
4339 * and equal to or less than the number of columns in this rowset
4340 * @param b the new column <code>Blob</code> value
4341 * @throws SQLException if (1) the given column index is out of bounds,
4342 * (2) the cursor is not on one of this rowset's rows or its
4343 * insert row, or (3) this rowset is
4344 * <code>ResultSet.CONCUR_READ_ONLY</code>
4345 */
4346 public void updateBlob(int columnIndex, Blob b) throws SQLException {
4347 throw new UnsupportedOperationException();
4348 }
4349
4350 /**
4351 * Sets the designated column in either the current row or the insert
4352 * row of this <code>CachedRowSetImpl</code> object with the given
4353 * <code>java.sql.Blob </code> value.
4354 *
4355 * This method updates a column value in either the current row or
4356 * the insert row of this rowset, but it does not update the
4357 * database. If the cursor is on a row in the rowset, the
4358 * method {@link #updateRow} must be called to update the database.
4359 * If the cursor is on the insert row, the method {@link #insertRow}
4360 * must be called, which will insert the new row into both this rowset
4361 * and the database. Both of these methods must be called before the
4362 * cursor moves to another row.
4363 *
4364 * @param columnName a <code>String</code> object that must match the
4365 * SQL name of a column in this rowset, ignoring case
4366 * @param b the new column <code>Blob</code> value
4367 * @throws SQLException if (1) the given column name does not match the
4368 * name of a column in this rowset, (2) the cursor is not on
4369 * one of this rowset's rows or its insert row, or (3) this
4370 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4371 */
4372 public void updateBlob(String columnName, Blob b) throws SQLException {
4373 throw new UnsupportedOperationException();
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>java.sql.Array</code> values.
4380 *
4381 * This method updates a column value in either the current row or
4382 * the insert row of this rowset, but it does not update the
4383 * database. 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 a the new column <code>Array</code> 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 updateArray(int columnIndex, Array a) throws SQLException {
4400 throw new UnsupportedOperationException();
4401 }
4402
4403 /**
4404 * Sets the designated column in either the current row or the insert
4405 * row of this <code>CachedRowSetImpl</code> object with the given
4406 * <code>java.sql.Array</code> value.
4407 *
4408 * This method updates a column value in either the current row or
4409 * the insert row of this rowset, but it does not update the
4410 * database. If the cursor is on a row in the rowset, the
4411 * method {@link #updateRow} must be called to update the database.
4412 * If the cursor is on the insert row, the method {@link #insertRow}
4413 * must be called, which will insert the new row into both this rowset
4414 * and the database. Both of these methods must be called before the
4415 * cursor moves to another row.
4416 *
4417 * @param columnName a <code>String</code> object that must match the
4418 * SQL name of a column in this rowset, ignoring case
4419 * @param a the new column <code>Array</code> value
4420 * @throws SQLException if (1) the given column name does not match the
4421 * name of a column in this rowset, (2) the cursor is not on
4422 * one of this rowset's rows or its insert row, or (3) this
4423 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4424 */
4425 public void updateArray(String columnName, Array a) throws SQLException {
4426 throw new UnsupportedOperationException();
4427 }
4428
4429
4430 /**
4431 * Retrieves the value of the designated column in this
4432 * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
4433 * in the Java programming language.
4434 *
4435 * @return a java.net.URL object containing the resource reference described by
4436 * the URL
4437 * @throws SQLException if (1) the given column index is out of bounds,
4438 * (2) the cursor is not on one of this rowset's rows or its
4439 * insert row, or (3) the designated column does not store an
4440 * SQL <code>DATALINK</code> value.
4441 * @see #getURL(String)
4442 */
4443 public java.net.URL getURL(int columnIndex) throws SQLException {
4444 throw new UnsupportedOperationException();
4445 }
4446
4447 /**
4448 * Retrieves the value of the designated column in this
4449 * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
4450 * in the Java programming language.
4451 *
4452 * @return a java.net.URL object containing the resource reference described by
4453 * the URL
4454 * @throws SQLException if (1) the given column name not the name of a column
4455 * in this rowset, or
4456 * (2) the cursor is not on one of this rowset's rows or its
4457 * insert row, or (3) the designated column does not store an
4458 * SQL <code>DATALINK</code> value.
4459 * @see #getURL(int)
4460 */
4461 public java.net.URL getURL(String columnName) throws SQLException {
4462 throw new UnsupportedOperationException();
4463
4464 }
4465
4466 /**
4467 * The first warning reported by calls on this <code>CachedRowSetImpl</code>
4468 * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
4469 * be chained to this <code>SQLWarning</code>. All <code>RowSetWarnings</code>
4470 * warnings are generated in the disconnected environment and remain a
4471 * seperate warning chain to that provided by the <code>getWarnings</code>
4472 * method.
4473 *
4474 * <P>The warning chain is automatically cleared each time a new
4475 * row is read.
4476 *
4477 * <P><B>Note:</B> This warning chain only covers warnings caused
4478 * by <code>CachedRowSet</code> (and their child interface)
4479 * methods. All <code>SQLWarnings</code> can be obtained using the
4480 * <code>getWarnings</code> method which tracks warnings generated
4481 * by the underlying JDBC driver.
4482 * @return the first SQLWarning or null
4483 *
4484 */
4485 public RowSetWarning getRowSetWarnings() {
4486 throw new UnsupportedOperationException();
4487 }
4488
4489 /**
4490 * Commits all changes performed by the <code>acceptChanges()</code>
4491 * methods
4492 *
4493 * @see java.sql.Connection#commit
4494 */
4495 public void commit() throws SQLException {
4496 throw new UnsupportedOperationException();
4497 }
4498
4499 /**
4500 * Rolls back all changes performed by the <code>acceptChanges()</code>
4501 * methods
4502 *
4503 * @see java.sql.Connection#rollback
4504 */
4505 public void rollback() throws SQLException {
4506 throw new UnsupportedOperationException();
4507 }
4508
4509 /**
4510 * Rolls back all changes performed by the <code>acceptChanges()</code>
4511 * to the last <code>Savepoint</code> transaction marker.
4512 *
4513 * @see java.sql.Connection#rollback(Savepoint)
4514 */
4515 public void rollback(Savepoint s) throws SQLException {
4516 throw new UnsupportedOperationException();
4517 }
4518
4519 /**
4520 * Unsets the designated parameter to the given int array.
4521 * This was set using <code>setMatchColumn</code>
4522 * as the column which will form the basis of the join.
4523 * <P>
4524 * The parameter value unset by this method should be same
4525 * as was set.
4526 *
4527 * @param columnIdxes the index into this rowset
4528 * object's internal representation of parameter values
4529 * @throws SQLException if an error occurs or the
4530 * parameter index is out of bounds or if the columnIdx is
4531 * not the same as set using <code>setMatchColumn(int [])</code>
4532 */
4533 public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
4534 throw new UnsupportedOperationException();
4535 }
4536
4537 /**
4538 * Unsets the designated parameter to the given String array.
4539 * This was set using <code>setMatchColumn</code>
4540 * as the column which will form the basis of the join.
4541 * <P>
4542 * The parameter value unset by this method should be same
4543 * as was set.
4544 *
4545 * @param columnIdxes the index into this rowset
4546 * object's internal representation of parameter values
4547 * @throws SQLException if an error occurs or the
4548 * parameter index is out of bounds or if the columnName is
4549 * not the same as set using <code>setMatchColumn(String [])</code>
4550 */
4551 public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
4552 throw new UnsupportedOperationException();
4553 }
4554
4555 /**
4556 * Retrieves the column name as <code>String</code> array
4557 * that was set using <code>setMatchColumn(String [])</code>
4558 * for this rowset.
4559 *
4560 * @return a <code>String</code> array object that contains the column names
4561 * for the rowset which has this the match columns
4562 *
4563 * @throws SQLException if an error occurs or column name is not set
4564 */
4565 public String[] getMatchColumnNames() throws SQLException {
4566 throw new UnsupportedOperationException();
4567 }
4568
4569 /**
4570 * Retrieves the column id as <code>int</code> array that was set using
4571 * <code>setMatchColumn(int [])</code> for this rowset.
4572 *
4573 * @return a <code>int</code> array object that contains the column ids
4574 * for the rowset which has this as the match columns.
4575 *
4576 * @throws SQLException if an error occurs or column index is not set
4577 */
4578 public int[] getMatchColumnIndexes() throws SQLException {
4579 throw new UnsupportedOperationException();
4580 }
4581
4582 /**
4583 * Sets the designated parameter to the given int array.
4584 * This forms the basis of the join for the
4585 * <code>JoinRowSet</code> as the column which will form the basis of the
4586 * join.
4587 * <P>
4588 * The parameter value set by this method is stored internally and
4589 * will be supplied as the appropriate parameter in this rowset's
4590 * command when the method <code>getMatchColumnIndexes</code> is called.
4591 *
4592 * @param columnIdxes the indexes into this rowset
4593 * object's internal representation of parameter values; the
4594 * first parameter is 0, the second is 1, and so on; must be
4595 * <code>0</code> or greater
4596 * @throws SQLException if an error occurs or the
4597 * parameter index is out of bounds
4598 */
4599 public void setMatchColumn(int[] columnIdxes) throws SQLException {
4600 throw new UnsupportedOperationException();
4601 }
4602
4603 /**
4604 * Sets the designated parameter to the given String array.
4605 * This forms the basis of the join for the
4606 * <code>JoinRowSet</code> as the column which will form the basis of the
4607 * join.
4608 * <P>
4609 * The parameter value set by this method is stored internally and
4610 * will be supplied as the appropriate parameter in this rowset's
4611 * command when the method <code>getMatchColumn</code> is called.
4612 *
4613 * @param columnNames the name of the column into this rowset
4614 * object's internal representation of parameter values
4615 * @throws SQLException if an error occurs or the
4616 * parameter index is out of bounds
4617 */
4618 public void setMatchColumn(String[] columnNames) throws SQLException {
4619 throw new UnsupportedOperationException();
4620 }
4621
4622
4623 /**
4624 * Sets the designated parameter to the given <code>int</code>
4625 * object. This forms the basis of the join for the
4626 * <code>JoinRowSet</code> as the column which will form the basis of the
4627 * join.
4628 * <P>
4629 * The parameter value set by this method is stored internally and
4630 * will be supplied as the appropriate parameter in this rowset's
4631 * command when the method <code>getMatchColumn</code> is called.
4632 *
4633 * @param columnIdx the index into this rowset
4634 * object's internal representation of parameter values; the
4635 * first parameter is 0, the second is 1, and so on; must be
4636 * <code>0</code> or greater
4637 * @throws SQLException if an error occurs or the
4638 * parameter index is out of bounds
4639 */
4640 public void setMatchColumn(int columnIdx) throws SQLException {
4641 throw new UnsupportedOperationException();
4642 }
4643
4644 /**
4645 * Sets the designated parameter to the given <code>String</code>
4646 * object. This forms the basis of the join for the
4647 * <code>JoinRowSet</code> as the column which will form the basis of the
4648 * join.
4649 * <P>
4650 * The parameter value set by this method is stored internally and
4651 * will be supplied as the appropriate parameter in this rowset's
4652 * command when the method <code>getMatchColumn</code> is called.
4653 *
4654 * @param columnName the name of the column into this rowset
4655 * object's internal representation of parameter values
4656 * @throws SQLException if an error occurs or the
4657 * parameter index is out of bounds
4658 */
4659 public void setMatchColumn(String columnName) throws SQLException {
4660 throw new UnsupportedOperationException();
4661 }
4662
4663 /**
4664 * Unsets the designated parameter to the given <code>int</code>
4665 * object. This was set using <code>setMatchColumn</code>
4666 * as the column which will form the basis of the join.
4667 * <P>
4668 * The parameter value unset by this method should be same
4669 * as was set.
4670 *
4671 * @param columnIdx the index into this rowset
4672 * object's internal representation of parameter values
4673 * @throws SQLException if an error occurs or the
4674 * parameter index is out of bounds or if the columnIdx is
4675 * not the same as set using <code>setMatchColumn(int)</code>
4676 */
4677 public void unsetMatchColumn(int columnIdx) throws SQLException {
4678 throw new UnsupportedOperationException();
4679 }
4680
4681 /**
4682 * Unsets the designated parameter to the given <code>String</code>
4683 * object. This was set using <code>setMatchColumn</code>
4684 * as the column which will form the basis of the join.
4685 * <P>
4686 * The parameter value unset by this method should be same
4687 * as was set.
4688 *
4689 * @param columnName the index into this rowset
4690 * object's internal representation of parameter values
4691 * @throws SQLException if an error occurs or the
4692 * parameter index is out of bounds or if the columnName is
4693 * not the same as set using <code>setMatchColumn(String)</code>
4694 */
4695 public void unsetMatchColumn(String columnName) throws SQLException {
4696 throw new UnsupportedOperationException();
4697 }
4698
4699 /**
4700 * Notifies registered listeners that a RowSet object in the given RowSetEvent
4701 * object has populated a number of additional rows. The <code>numRows</code> parameter
4702 * ensures that this event will only be fired every <code>numRow</code>.
4703 * <p>
4704 * The source of the event can be retrieved with the method event.getSource.
4705 *
4706 * @param event a <code>RowSetEvent</code> object that contains the
4707 * <code>RowSet</code> object that is the source of the events
4708 * @param numRows when populating, the number of rows interval on which the
4709 * <code>CachedRowSet</code> populated should fire; the default value
4710 * is zero; cannot be less than <code>fetchSize</code> or zero
4711 */
4712 public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
4713 throw new UnsupportedOperationException();
4714 }
4715
4716 /**
4717 * Populates this <code>CachedRowSet</code> object with data from
4718 * the given <code>ResultSet</code> object. While related to the <code>populate(ResultSet)</code>
4719 * method, an additional parameter is provided to allow starting position within
4720 * the <code>ResultSet</code> from where to populate the CachedRowSet
4721 * instance.
4722 *
4723 * This method is an alternative to the method <code>execute</code>
4724 * for filling the rowset with data. The method <code>populate</code>
4725 * does not require that the properties needed by the method
4726 * <code>execute</code>, such as the <code>command</code> property,
4727 * be set. This is true because the method <code>populate</code>
4728 * is given the <code>ResultSet</code> object from
4729 * which to get data and thus does not need to use the properties
4730 * required for setting up a connection and executing this
4731 * <code>CachedRowSetImpl</code> object's command.
4732 * <P>
4733 * After populating this rowset with data, the method
4734 * <code>populate</code> sets the rowset's metadata and
4735 * then sends a <code>RowSetChangedEvent</code> object
4736 * to all registered listeners prior to returning.
4737 *
4738 * @param data the <code>ResultSet</code> object containing the data
4739 * to be read into this <code>CachedRowSetImpl</code> object
4740 * @param start the integer specifing the position in the
4741 * <code>ResultSet</code> object to popultate the
4742 * <code>CachedRowSetImpl</code> object.
4743 * @throws SQLException if an error occurs; or the max row setting is
4744 * violated while populating the RowSet.Also id the start position
4745 * is negative.
4746 * @see #execute
4747 */
4748 public void populate(ResultSet data, int start) throws SQLException{
4749 throw new UnsupportedOperationException();
4750
4751 }
4752
4753 /**
4754 * The nextPage gets the next page, that is a <code>CachedRowSetImpl</code> object
4755 * containing the number of rows specified by page size.
4756 * @return boolean value true indicating whether there are more pages to come and
4757 * false indicating that this is the last page.
4758 * @throws SQLException if an error occurs or this called before calling populate.
4759 */
4760 public boolean nextPage() throws SQLException {
4761 throw new UnsupportedOperationException();
4762 }
4763
4764 /**
4765 * This is the setter function for setting the size of the page, which specifies
4766 * how many rows have to be retrived at a time.
4767 *
4768 * @param size which is the page size
4769 * @throws SQLException if size is less than zero or greater than max rows.
4770 */
4771 public void setPageSize (int size) throws SQLException {
4772 throw new UnsupportedOperationException();
4773 }
4774
4775 /**
4776 * This is the getter function for the size of the page.
4777 *
4778 * @return an integer that is the page size.
4779 */
4780 public int getPageSize() {
4781 throw new UnsupportedOperationException();
4782 }
4783
4784
4785 /**
4786 * Retrieves the data present in the page prior to the page from where it is
4787 * called.
4788 * @return boolean value true if it retrieves the previous page, flase if it
4789 * is on the first page.
4790 * @throws SQLException if it is called before populate is called or ResultSet
4791 * is of type <code>ResultSet.TYPE_FORWARD_ONLY</code> or if an error
4792 * occurs.
4793 */
4794 public boolean previousPage() throws SQLException {
4795 throw new UnsupportedOperationException();
4796 }
4797
4798 /**
4799 * Updates the designated column with a character stream value, which will
4800 * have the specified number of bytes. The driver does the necessary conversion
4801 * from Java character format to the national character set in the database.
4802 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4803 * The updater methods are used to update column values in the current row or
4804 * the insert row. The updater methods do not update the underlying database;
4805 * instead the updateRow or insertRow methods are called to update the database.
4806 *
4807 * @param columnIndex - the first column is 1, the second is 2, ...
4808 * @param x - the new column value
4809 * @param length - the length of the stream
4810 * @exception SQLException if a database access error occurs
4811 * @since 1.6
4812 */
4813 public void updateNCharacterStream(int columnIndex,
4814 java.io.Reader x,
4815 int length)
4816 throws SQLException {
4817 throw new UnsupportedOperationException("Operation not yet supported");
4818 }
4819
4820 /**
4821 * Updates the designated column with a character stream value, which will
4822 * have the specified number of bytes. The driver does the necessary conversion
4823 * from Java character format to the national character set in the database.
4824 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4825 * The updater methods are used to update column values in the current row or
4826 * the insert row. The updater methods do not update the underlying database;
4827 * instead the updateRow or insertRow methods are called to update the database.
4828 *
4829 * @param columnName - name of the Column
4830 * @param x - the new column value
4831 * @param length - the length of the stream
4832 * @exception SQLException if a database access error occurs
4833 * @since 1.6
4834 */
4835 public void updateNCharacterStream(String columnName,
4836 java.io.Reader x,
4837 int length)
4838 throws SQLException {
4839 throw new UnsupportedOperationException("Operation not yet supported");
4840 }
4841
4842 /**
4843 * This method re populates the resBundle
4844 * during the deserialization process
4845 *
4846 */
4847 private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
4848 // Default state initialization happens here
4849 ois.defaultReadObject();
4850 // Initialization of transient Res Bundle happens here .
4851 try {
4852 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
4853 } catch(IOException ioe) {
4854 throw new RuntimeException(ioe);
4855 }
4856
4857 }
4858
4859 static final long serialVersionUID = -3345004441725080251L;
4860} //end class