View Javadoc
1   /*
2    * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package com.sun.rowset.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) {
198                 throw new SQLException(resBundle.handleGetObject("syncrsimpl.noconflict").toString());
199             }
200         } catch (SQLException sqle) {
201             // modify method to throw for SQLException
202             throw new SQLException(sqle.getMessage());
203         }
204         try {
205              boolean bool = true;
206              /** Check resolved value to be either of conflict
207                * or in rowset else throw sql exception.
208                * If we allow a value other than that in CachedRowSet or
209                * datasource we will end up in looping the loop of exceptions.
210               **/
211 
212              if( ((crsSync.getObject(index)).toString()).equals(obj.toString()) ||
213                      ((crsRes.getObject(index)).toString()).equals(obj.toString()) ) {
214 
215                 /**
216                  * Check whether this is the only conflict in the row.
217                  * If yes, synchronize this row back
218                  * which has been resolved, else wait
219                  * for all conflicts of current row to be resolved
220                  *
221                  * Step 1: Update crsRes and make the index col as null
222                  * i.e. resolved
223                  * crsRes.updateObject(index, obj);
224                  **/
225                   crsRes.updateNull(index);
226                   crsRes.updateRow();
227 
228                  /**
229                   * Step 2: Change the value in the CachedRowSetImpl object
230                   * crsSync.updateObject(index, obj);
231                   * crsSync.updateRow();
232                   **/
233                  if(row.size() != 1) {
234                     row = buildCachedRow();
235                  }
236 
237                  row.updateObject(index, obj);
238                  row.updateRow();
239 
240                  for(int j=1; j < crsRes.getMetaData().getColumnCount(); j++) {
241                      if(crsRes.getObject(j) != null) {
242                         bool = false;
243                         break;
244                          // break out of loop and wait for other cols
245                          // in same row to get resolved
246                      } //end if
247 
248                   } //end for
249 
250                   if(bool) {
251                      /**
252                       * sync data back using CachedRowSetWriter
253                       * construct the present row and pass it to the writer
254                       * to write back to db.
255                       **/
256                      try {
257                            /**
258                             * Note : The use of CachedRowSetWriter to get *same* Connection handle.
259                             * The CachedRowSetWriter uses the connection handle
260                             * from the reader, Hence will use the same connection handle
261                             * as of original CachedRowSetImpl
262                             **/
263 
264                           writeData(row);
265 
266                           //crw.writeData( (RowSetInternal)crsRow);
267                           //System.out.printlnt.println("12");
268 
269                      } catch(SyncProviderException spe) {
270                          /**
271                           * This will occur if db is not allowing
272                           * even after resolving the conflicts
273                           * due to some reasons.
274                           * Also will prevent from going into a loop of SPE's
275                           **/
276                          throw new SQLException(resBundle.handleGetObject("syncrsimpl.syncnotpos").toString());
277                      }
278                   } //end if(bool)
279 
280              } else {
281                  throw new SQLException(resBundle.handleGetObject("syncrsimpl.valtores").toString());
282              } //end if (crs.getObject ...) block
283 
284 
285         } catch(SQLException sqle) {
286            throw new SQLException(sqle.getMessage());
287         }
288     }
289 
290     /**
291      * This passes a CachedRowSet as a row the the CachedRowSetWriter
292      * after the values have been resolved, back to the datasource.
293      *
294      * @param row a <code>CachedRowSet</code> object which will hold the
295      *        values of a particular row after they have been resolved by
296      *        the user to synchronize back to datasource.
297      * @throws SQLException if synchronization does not happen properly
298      *         maybe beacuse <code>Connection</code> has timed out.
299      **/
300      private void writeData(CachedRowSet row) throws SQLException {
301         crw.updateResolvedConflictToDB(row, crw.getReader().connect((RowSetInternal)crsSync));
302      }
303 
304     /**
305      * This function builds a row  as a <code>CachedRowSet</code> object
306      * which has been resolved and is ready to be synchrinized to the datasource
307      *
308      * @throws SQLException if there is problem in building
309      *         the metadata of the row.
310      **/
311      private CachedRowSet buildCachedRow() throws SQLException {
312        int iColCount;
313        CachedRowSetImpl crsRow = new CachedRowSetImpl();
314 
315        RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
316        RowSetMetaDataImpl rsmdWrite = (RowSetMetaDataImpl)crsSync.getMetaData();
317        RowSetMetaDataImpl rsmdRow = new RowSetMetaDataImpl();
318 
319        iColCount = rsmdWrite.getColumnCount();
320        rsmdRow.setColumnCount(iColCount);
321 
322        for(int i =1;i<=iColCount;i++) {
323           rsmdRow.setColumnType(i,rsmdWrite.getColumnType(i));
324           rsmdRow.setColumnName(i,rsmdWrite.getColumnName(i));
325           rsmdRow.setNullable(i,ResultSetMetaData.columnNullableUnknown);
326 
327           try {
328              rsmdRow.setCatalogName(i, rsmdWrite.getCatalogName(i));
329              rsmdRow.setSchemaName(i, rsmdWrite.getSchemaName(i));
330           } catch(SQLException e) {
331                e.printStackTrace();
332           }
333         } //end for
334 
335        crsRow.setMetaData(rsmdRow);
336 
337        crsRow.moveToInsertRow();
338 
339        for(int col=1;col<=crsSync.getMetaData().getColumnCount();col++) {
340            crsRow.updateObject(col, crsSync.getObject(col));
341        }
342 
343        crsRow.insertRow();
344        crsRow.moveToCurrentRow();
345 
346        crsRow.absolute(1);
347        crsRow.setOriginalRow();
348 
349       try {
350           crsRow.setUrl(crsSync.getUrl());
351       } catch(SQLException sqle) {
352 
353       }
354 
355       try {
356           crsRow.setDataSourceName(crsSync.getCommand());
357        } catch(SQLException sqle) {
358 
359        }
360 
361        try {
362            if(crsSync.getTableName()!= null){
363               crsRow.setTableName(crsSync.getTableName());
364            }
365         } catch(SQLException sqle) {
366 
367         }
368 
369        try {
370             if(crsSync.getCommand() != null)
371                 crsRow.setCommand(crsSync.getCommand());
372        } catch(SQLException sqle) {
373 
374        }
375 
376        try {
377             crsRow.setKeyColumns(crsSync.getKeyColumns());
378        } catch(SQLException sqle) {
379 
380        }
381        return crsRow;
382     }
383 
384 
385 
386     /**
387      * Sets <i>obj</i> as the value in column <i>columnName</i> in the current row of the
388      * <code>RowSet</code> object. This value is the resolved value that is to be
389      * persisted in the data source.
390      *
391      * @param columnName a <code>String</code> object giving the name of the column
392      *        into which to set the value to be persisted
393      * @param obj an <code>Object</code> that is the value to be set in the data source
394      */
395     public void setResolvedValue(String columnName, Object obj) throws SQLException {
396        // modify method to throw SQLException in spec
397        // %%% Missing implementation!
398     }
399 
400     /**
401      * This function is package private,
402      * i.e. cannot be accesses outside this package.
403      * This is used to set the actual CachedRowSet
404      * which is being synchronized to the database
405      **/
406    void setCachedRowSet(CachedRowSet crs) {
407            crsSync = (CachedRowSetImpl)crs;
408     }
409 
410     /**
411      * This function is package private,
412      * i.e. cannot be accesses outside this package.
413      * This is used to set the CachedRowSet formed
414      * with conflict values.
415      **/
416     void setCachedRowSetResolver(CachedRowSet crs){
417          try {
418               crsRes = (CachedRowSetImpl)crs;
419               crsRes.afterLast();
420               sz = crsRes.size();
421          } catch (SQLException sqle) {
422             // do nothing
423          }
424     }
425 
426     /**
427      * This function is package private,
428      * i.e. cannot be accesses outside this package.
429      * This is used to set the status of each row
430      * to either of the values SyncResolver.*_CONFLICT
431      **/
432     @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--;
475 
476           if((rowStatus-1) >= stats.size()) {
477              bool = false;
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
4831        * from Java character format to the national character set in the database.
4832        * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4833        * The updater methods are used to update column values in the current row or
4834        * the insert row. The updater methods do not update the underlying database;
4835        * instead the updateRow or insertRow methods are called to update the database.
4836        *
4837        * @param columnName - name of the Column
4838        * @param x - the new column value
4839        * @param length - the length of the stream
4840        * @exception SQLException if a database access error occurs
4841        * @since 1.6
4842        */
4843        public void updateNCharacterStream(String columnName,
4844                             java.io.Reader x,
4845                             int length)
4846                             throws SQLException {
4847           throw new UnsupportedOperationException("Operation not yet supported");
4848        }
4849 
4850       /**
4851        * This method re populates the resBundle
4852        * during the deserialization process
4853        *
4854        */
4855        private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
4856          // Default state initialization happens here
4857          ois.defaultReadObject();
4858          // Initialization of transient Res Bundle happens here .
4859          try {
4860             resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
4861          } catch(IOException ioe) {
4862              throw new RuntimeException(ioe);
4863          }
4864 
4865        }
4866 
4867        static final long serialVersionUID = -3345004441725080251L;
4868 } //end class