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