src/java.sql.rowset/share/classes/com/sun/rowset/internal/SyncResolverImpl.java

/*
 * Copyright (c) 2004, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.rowset.internal;

import java.sql.*;
import javax.sql.*;
import java.util.*;
import java.math.BigDecimal;

import javax.sql.rowset.*;
import javax.sql.rowset.spi.*;

import com.sun.rowset.*;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * There will be two sets of data which will be maintained by the rowset at the
 * time of synchronization. The {@code SyncProvider} will utilize the
 * {@code SyncResolver} to synchronize the changes back to database.
 */
public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
    /**
     * This CachedRowSet object will encapsulate a rowset
     * which will be sync'ed with the datasource but will
     * contain values in rows where there is conflict.
     * For rows other than conflict, it will *not* contain
     * any data. For rows containing conflict it will
     * return either of the three values set by SyncResolver.*_CONFLICT
     * from getStatus()
     */
    private CachedRowSetImpl crsRes;

    /**
     * This is the actual CachedRowSet object
     * which is being synchronized back to
     * datasource.
     */
    private CachedRowSetImpl crsSync;

    /**
     *  This ArrayList will contain the status of a row
     *  from the SyncResolver.* values else it will be null.
     */
    private ArrayList<?> stats;

    /**
     * The RowSetWriter associated with the original
     * CachedRowSet object which is being synchronized.
     */
    private CachedRowSetWriter crw;

    /**
     * Row number identifier
     */
    private int rowStatus;

    /**
     * This will contain the size of the {@code CachedRowSet} object
     */
    private int sz;

    /**
     * The {@code Connection} handle used to synchronize the changes
     * back to datasource. This is the same connection handle as was passed
     * to the CachedRowSet while fetching the data.
     */
    private transient Connection con;

    /**
     * The {@code CachedRowSet} object which will encapsulate
     * a row at any time. This will be built from CachedRowSet and
     * SyncResolver values. Synchronization takes place on a row by
     * row basis encapsulated as a CahedRowSet.
     */
    @SuppressWarnings("serial")
    private CachedRowSet row;

    private JdbcRowSetResourceBundle resBundle;

    /**
     * Public constructor
     */
    public SyncResolverImpl() throws SQLException {
        try {
            crsSync = new CachedRowSetImpl();
            crsRes = new CachedRowSetImpl();
            crw = new CachedRowSetWriter();
            row = new CachedRowSetImpl();
            rowStatus = 1;
            try {
                resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
            } catch(IOException ioe) {
                throw new RuntimeException(ioe);
            }

        } catch(SQLException sqle) {
        }
     }


    /**
     * Retrieves the conflict status of the current row of this
     * {@code SyncResolver}, which indicates the operation the {@code RowSet}
     * object was attempting when the conflict occurred.
     *
     * @return one of the following constants:
     *         {@code SyncResolver.UPDATE_ROW_CONFLICT},
     *         {@code SyncResolver.DELETE_ROW_CONFLICT}, or
     *         {@code SyncResolver.INSERT_ROW_CONFLICT}
     */
    public int getStatus() {
        return stats != null ? (Integer) stats.get(rowStatus - 1) :
                SyncResolver.NO_ROW_CONFLICT;
    }

    /**
     * Retrieves the value in the designated column in the current row of this
     * {@code SyncResolver} object, which is the value that caused a conflict.
     *
     * @param index {@code int} designating the column in this row of this
     *        {@code SyncResolver} object from which to retrieve the value
     *        causing a conflict
     */
    public Object getConflictValue(int index) throws SQLException {
        try {
             return crsRes.getObject(index);
        } catch(SQLException sqle) {
            throw new SQLException(sqle.getMessage());
        } catch (Exception e ) {
            throw new SQLException("Problem obtaining conflicted value!", e);
        }
    }

    /**
     * Retrieves the value in the designated column in the current row of this
     * {@code SyncResolver} object, which is the value that caused a conflict.
     *
     * @param columnName a {@code String} object designating the column in this row of this
     *        {@code SyncResolver} object from which to retrieve the value
     *        causing a conflict
     */
    public Object getConflictValue(String columnName) throws SQLException {
        try {
             return crsRes.getObject(columnName);
        } catch(SQLException sqle) {
             throw new SQLException(sqle.getMessage());
        } catch (Exception e ) {
            throw new SQLException("Problem obtaining conflicted value!", e);
        }
    }

    /**
     * Sets <i>obj</i> as the value in column <i>index</i> in the current row of the
     * {@code RowSet} object. This value is the resolved value that is to be
     * persisted in the data source.
     *
     * @param index an {@code int} giving the number of the column into which to
     *        set the value to be persisted
     * @param obj an {@code Object} that is the value to be set in the data source
     */
    public void setResolvedValue(int index, Object obj) throws SQLException {
        // modify method to throw SQLException in spec

        /**
         * When a value is resolved properly make it to null
         * inside crsRes for that column.
         *
         * For more than one conflicts in the row,
         * check for the last resolved value of the current row
         * (Note: it can be resolved randomly for same row)
         * then sync back immediately.
         **/
        try {
            ResultSetMetaData rsmd = crsSync.getMetaData();
            // check whether the index is in range
            if(index<=0 || rsmd == null || index > rsmd.getColumnCount() ) {
                throw new SQLException(resBundle.handleGetObject("syncrsimpl.indexval").toString()+ index);
            }
             // check whether index col is in conflict
            if(crsRes.getObject(index) == null) {
                throw new SQLException(resBundle.handleGetObject("syncrsimpl.noconflict").toString());
            }
        } catch (SQLException sqle) {
            // modify method to throw for SQLException
            throw new SQLException(sqle.getMessage());
        }
        try {
             boolean bool = true;
             /** Check resolved value to be either of conflict
               * or in rowset else throw sql exception.
               * If we allow a value other than that in CachedRowSet or
               * datasource we will end up in looping the loop of exceptions.
              **/

             if( ((crsSync.getObject(index)).toString()).equals(obj.toString()) ||
                     ((crsRes.getObject(index)).toString()).equals(obj.toString()) ) {

                /**
                 * Check whether this is the only conflict in the row.
                 * If yes, synchronize this row back
                 * which has been resolved, else wait
                 * for all conflicts of current row to be resolved
                 *
                 * Step 1: Update crsRes and make the index col as null
                 * i.e. resolved
                 * crsRes.updateObject(index, obj);
                 **/
                  crsRes.updateNull(index);
                  crsRes.updateRow();

                 /**
                  * Step 2: Change the value in the CachedRowSetImpl object
                  * crsSync.updateObject(index, obj);
                  * crsSync.updateRow();
                  **/
                 if(row.size() != 1) {
                    row = buildCachedRow();
                 }

                 row.updateObject(index, obj);
                 row.updateRow();

                 for(int j=1; j < crsRes.getMetaData().getColumnCount(); j++) {
                     if(crsRes.getObject(j) != null) {
                        bool = false;
                        break;
                         // break out of loop and wait for other cols
                         // in same row to get resolved
                     } //end if

                  } //end for

                  if(bool) {
                     /**
                      * sync data back using CachedRowSetWriter
                      * construct the present row and pass it to the writer
                      * to write back to db.
                      **/
                     try {
                           /**
                            * Note : The use of CachedRowSetWriter to get *same* Connection handle.
                            * The CachedRowSetWriter uses the connection handle
                            * from the reader, Hence will use the same connection handle
                            * as of original CachedRowSetImpl
                            **/

                          writeData(row);

                          //crw.writeData( (RowSetInternal)crsRow);
                          //System.out.printlnt.println("12");

                     } catch(SyncProviderException spe) {
                         /**
                          * This will occur if db is not allowing
                          * even after resolving the conflicts
                          * due to some reasons.
                          * Also will prevent from going into a loop of SPE's
                          **/
                         throw new SQLException(resBundle.handleGetObject("syncrsimpl.syncnotpos").toString());
                     }
                  } //end if(bool)

             } else {
                 throw new SQLException(resBundle.handleGetObject("syncrsimpl.valtores").toString());
             } //end if (crs.getObject ...) block


        } catch(SQLException sqle) {
           throw new SQLException(sqle.getMessage());
        }
    }

    /**
     * This passes a CachedRowSet as a row to the CachedRowSetWriter
     * after the values have been resolved, back to the datasource.
     *
     * @param row a {@code CachedRowSet} object which will hold the
     *        values of a particular row after they have been resolved by
     *        the user to synchronize back to datasource.
     * @throws SQLException if synchronization does not happen properly
     *         maybe because {@code Connection} has timed out.
     **/
     private void writeData(CachedRowSet row) throws SQLException {
        crw.updateResolvedConflictToDB(row, crw.getReader().connect((RowSetInternal)crsSync));
     }

    /**
     * This function builds a row  as a {@code CachedRowSet} object
     * which has been resolved and is ready to be synchrinized to the datasource
     *
     * @throws SQLException if there is problem in building
     *         the metadata of the row.
     **/
     private CachedRowSet buildCachedRow() throws SQLException {
       int iColCount;
       CachedRowSetImpl crsRow = new CachedRowSetImpl();

       RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
       RowSetMetaDataImpl rsmdWrite = (RowSetMetaDataImpl)crsSync.getMetaData();
       RowSetMetaDataImpl rsmdRow = new RowSetMetaDataImpl();

       iColCount = rsmdWrite.getColumnCount();
       rsmdRow.setColumnCount(iColCount);

       for(int i =1;i<=iColCount;i++) {
          rsmdRow.setColumnType(i,rsmdWrite.getColumnType(i));
          rsmdRow.setColumnName(i,rsmdWrite.getColumnName(i));
          rsmdRow.setNullable(i,ResultSetMetaData.columnNullableUnknown);

          try {
             rsmdRow.setCatalogName(i, rsmdWrite.getCatalogName(i));
             rsmdRow.setSchemaName(i, rsmdWrite.getSchemaName(i));
          } catch(SQLException e) {
               e.printStackTrace();
          }
        } //end for

       crsRow.setMetaData(rsmdRow);

       crsRow.moveToInsertRow();

       for(int col=1;col<=crsSync.getMetaData().getColumnCount();col++) {
           crsRow.updateObject(col, crsSync.getObject(col));
       }

       crsRow.insertRow();
       crsRow.moveToCurrentRow();

       crsRow.absolute(1);
       crsRow.setOriginalRow();

      try {
          crsRow.setUrl(crsSync.getUrl());
      } catch(SQLException sqle) {

      }

      try {
          crsRow.setDataSourceName(crsSync.getCommand());
       } catch(SQLException sqle) {

       }

       try {
           if(crsSync.getTableName()!= null){
              crsRow.setTableName(crsSync.getTableName());
           }
        } catch(SQLException sqle) {

        }

       try {
            if(crsSync.getCommand() != null)
                crsRow.setCommand(crsSync.getCommand());
       } catch(SQLException sqle) {

       }

       try {
            crsRow.setKeyColumns(crsSync.getKeyColumns());
       } catch(SQLException sqle) {

       }
       return crsRow;
    }



    /**
     * Sets <i>obj</i> as the value in column <i>columnName</i> in the current row of the
     * {@code RowSet} object. This value is the resolved value that is to be
     * persisted in the data source.
     *
     * @param columnName a {@code String} object giving the name of the column
     *        into which to set the value to be persisted
     * @param obj an {@code Object} that is the value to be set in the data source
     */
    public void setResolvedValue(String columnName, Object obj) throws SQLException {
        // %%% Missing implementation!
        throw new SQLException("Method not supported");
    }

    /**
     * This function is package private,
     * i.e. cannot be accesses outside this package.
     * This is used to set the actual CachedRowSet
     * which is being synchronized to the database
     **/
   void setCachedRowSet(CachedRowSet crs) {
           crsSync = (CachedRowSetImpl)crs;
    }

    /**
     * This function is package private,
     * i.e. cannot be accesses outside this package.
     * This is used to set the CachedRowSet formed
     * with conflict values.
     **/
    void setCachedRowSetResolver(CachedRowSet crs){
         try {
              crsRes = (CachedRowSetImpl)crs;
              crsRes.afterLast();
              sz = crsRes.size();
         } catch (SQLException sqle) {
            // do nothing
         }
    }

    /**
     * This function is package private,
     * i.e. cannot be accesses outside this package.
     * This is used to set the status of each row
     * to either of the values SyncResolver.*_CONFLICT
     **/
    @SuppressWarnings("rawtypes")
    void setStatus(ArrayList status){
             stats = status;
    }

    /**
     * This function is package private,
     * i.e. cannot be accesses outside this package.
     * This is used to set the handle to the writer object
     * which will write the resolved values back to datasource
     **/
    void setCachedRowSetWriter(CachedRowSetWriter CRWriter) {
         crw = CRWriter;
    }

    /**
     * Moves the cursor down one row from its current position. A {@code SyncResolver}
     * cursor is initially positioned before the first conflict row; the first call to the
     * method {@code nextConflict()} makes the first conflict row the current row;
     * the second call makes the second conflict row the current row, and so on.
     * <p>
     * If an input stream is open for the current row, a call to the method next will
     * implicitly close it. A {@code SyncResolver} object's warning chain is cleared
     * when a new row
     *
     * @return true if the new current row is valid; false if there are no more rows
     * @throws SQLException if a database access occurs
     *
     */
    public boolean nextConflict() throws SQLException {
        /**
          * The next() method will hop from
          * one conflict to another
          *
          * Internally do a crs.next() until
          * next conflict.
          **/
      boolean bool = false;

      crsSync.setShowDeleted(true);
      while(crsSync.next()) {
           crsRes.previous();
           rowStatus++;  //sz--;

          if((rowStatus-1) >= stats.size()) {
             bool = false;
             break;
          }

          if(((Integer)stats.get(rowStatus-1)).intValue() == SyncResolver.NO_ROW_CONFLICT) {
              // do nothing
              // bool remains as false
             ;
           } else {
             bool = true;
             break;
           } //end if

      } //end while

        crsSync.setShowDeleted(false);
        return bool;
   } // end next() method


    /**
     * Moves the cursor to the previous conflict row in this {@code SyncResolver} object.
     *
     * @return {@code true} if the cursor is on a valid row; {@code false}
     *     if it is off the result set
     * @throws SQLException if a database access error occurs or the result set type
     *     is TYPE_FORWARD_ONLY
     */
   public boolean previousConflict() throws SQLException {
       return false;
   }

    //-----------------------------------------------------------------------
    // Properties
    //-----------------------------------------------------------------------

    /**
     * Sets this {@code CachedRowSetImpl} object's command property
     * to the given {@code String} object and clears the parameters,
     * if any, that were set for the previous command.
     * <P>
     * The command property may not be needed
     * if the rowset is produced by a data source, such as a spreadsheet,
     * that does not support commands. Thus, this property is optional
     * and may be {@code null}.
     *
     * @param cmd a {@code String} object containing an SQL query
     *            that will be set as the command; may be {@code null}
     * @throws SQLException if an error occurs
     */
    public void setCommand(String cmd) throws SQLException {
         throw new UnsupportedOperationException();
    }


    //---------------------------------------------------------------------
    // Reading and writing data
    //---------------------------------------------------------------------

    /**
     * Populates this {@code CachedRowSetImpl} object with data from
     * the given {@code ResultSet} object.  This
     * method is an alternative to the method {@code execute}
     * for filling the rowset with data.  The method {@code populate}
     * does not require that the properties needed by the method
     * {@code execute}, such as the {@code command} property,
     * be set. This is true because the method {@code populate}
     * is given the {@code ResultSet} object from
     * which to get data and thus does not need to use the properties
     * required for setting up a connection and executing this
     * {@code CachedRowSetImpl} object's command.
     * <P>
     * After populating this rowset with data, the method
     * {@code populate} sets the rowset's metadata and
     * then sends a {@code RowSetChangedEvent} object
     * to all registered listeners prior to returning.
     *
     * @param data the {@code ResultSet} object containing the data
     *             to be read into this {@code CachedRowSetImpl} object
     * @throws SQLException if an error occurs; or the max row setting is
     *          violated while populating the RowSet
     * @see #execute
     */
    public void populate(ResultSet data) throws SQLException {
         throw new UnsupportedOperationException();
    }

    /**
     * Populates this {@code CachedRowSetImpl} object with data,
     * using the given connection to produce the result set from
     * which data will be read.  A second form of this method,
     * which takes no arguments, uses the values from this rowset's
     * user, password, and either url or data source properties to
     * create a new database connection. The form of {@code execute}
     * that is given a connection ignores these properties.
     *
     * @param conn A standard JDBC {@code Connection} object that this
     * {@code CachedRowSet} object can pass to a synchronization provider
     * to establish a connection to the data source
     * @throws SQLException if an invalid {@code Connection} is supplied
     *           or an error occurs in establishing the connection to the
     *           data source
     * @see #populate
     * @see java.sql.Connection
     */
    public void execute(Connection conn) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Propagates all row update, insert, and delete changes to the
     * underlying data source backing this {@code CachedRowSetImpl}
     * object.
     * <P>
     * <b>Note</b>In the reference implementation an optimistic concurrency implementation
     * is provided as a sample implementation of the {@code SyncProvider}
     * abstract class.
     * <P>
     * This method fails if any of the updates cannot be propagated back
     * to the data source.  When it fails, the caller can assume that
     * none of the updates are reflected in the data source.
     * When an exception is thrown, the current row
     * is set to the first "updated" row that resulted in an exception
     * unless the row that caused the exception is a "deleted" row.
     * In that case, when deleted rows are not shown, which is usually true,
     * the current row is not affected.
     * <P>
     * If no {@code SyncProvider} is configured, the reference implementation
     * leverages the {@code RIOptimisticProvider} available which provides the
     * default and reference synchronization capabilities for disconnected
     * {@code RowSets}.
     *
     * @throws SQLException if the cursor is on the insert row or the underlying
     *          reference synchronization provider fails to commit the updates
     *          to the datasource
     * @throws SyncProviderException if an internal error occurs within the
     *          {@code SyncProvider} instance during either during the
     *          process or at any time when the {@code SyncProvider}
     *          instance touches the data source.
     * @see #acceptChanges(java.sql.Connection)
     * @see javax.sql.RowSetWriter
     * @see javax.sql.rowset.spi.SyncProvider
     */
    public void acceptChanges() throws SyncProviderException {
        throw new UnsupportedOperationException();
    }

    /**
     * Propagates all row update, insert, and delete changes to the
     * data source backing this {@code CachedRowSetImpl} object
     * using the given {@code Connection} object.
     * <P>
     * The reference implementation {@code RIOptimisticProvider}
     * modifies its synchronization to a write back function given
     * the updated connection
     * The reference implementation modifies its synchronization behaviour
     * via the {@code SyncProvider} to ensure the synchronization
     * occurs according to the updated JDBC {@code Connection}
     * properties.
     *
     * @param con a standard JDBC {@code Connection} object
     * @throws SQLException if the cursor is on the insert row or the underlying
     *                   synchronization provider fails to commit the updates
     *                   back to the data source
     * @see #acceptChanges
     * @see javax.sql.RowSetWriter
     * @see javax.sql.rowset.spi.SyncFactory
     * @see javax.sql.rowset.spi.SyncProvider
     */
    public void acceptChanges(Connection con) throws SyncProviderException{
     throw new UnsupportedOperationException();
    }

    /**
     * Restores this {@code CachedRowSetImpl} object to its original state,
     * that is, its state before the last set of changes.
     * <P>
     * Before returning, this method moves the cursor before the first row
     * and sends a {@code rowSetChanged} event to all registered
     * listeners.
     * @throws SQLException if an error occurs rolling back the RowSet
     *           state to the defined original value.
     * @see javax.sql.RowSetListener#rowSetChanged
     */
    public void restoreOriginal() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Releases the current contents of this {@code CachedRowSetImpl}
     * object and sends a {@code rowSetChanged} event object to all
     * registered listeners.
     *
     * @throws SQLException if an error occurs flushing the contents of
     *           RowSet.
     * @see javax.sql.RowSetListener#rowSetChanged
     */
    public void release() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Cancels deletion of the current row and notifies listeners that
     * a row has changed.
     * <P>
     * Note:  This method can be ignored if deleted rows are not being shown,
     * which is the normal case.
     *
     * @throws SQLException if the cursor is not on a valid row
     */
    public void undoDelete() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Immediately removes the current row from this
     * {@code CachedRowSetImpl} object if the row has been inserted, and
     * also notifies listeners the row has changed.  An exception is thrown
     * if the row is not a row that has been inserted or the cursor is before
     * the first row, after the last row, or on the insert row.
     * <P>
     * This operation cannot be undone.
     *
     * @throws SQLException if an error occurs,
     *                         the cursor is not on a valid row,
     *                         or the row has not been inserted
     */
    public void undoInsert() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Immediately reverses the last update operation if the
     * row has been modified. This method can be
     * called to reverse updates on a all columns until all updates in a row have
     * been rolled back to their originating state since the last synchronization
     * ({@code acceptChanges}) or population. This method may also be called
     * while performing updates to the insert row.
     * <P>
     * {@code undoUpdate} may be called at any time during the life-time of a
     * rowset, however after a synchronization has occurs this method has no
     * affect until further modification to the RowSet data occurs.
     *
     * @throws SQLException if cursor is before the first row, after the last
     *     row in rowset.
     * @see #undoDelete
     * @see #undoInsert
     * @see java.sql.ResultSet#cancelRowUpdates
     */
    public void undoUpdate() throws SQLException {
        throw new UnsupportedOperationException();

    }

    //--------------------------------------------------------------------
    // Views
    //--------------------------------------------------------------------

    /**
     * Returns a new {@code RowSet} object backed by the same data as
     * that of this {@code CachedRowSetImpl} object and sharing a set of cursors
     * with it. This allows cursors to iterate over a shared set of rows, providing
     * multiple views of the underlying data.
     *
     * @return a {@code RowSet} object that is a copy of this {@code CachedRowSetImpl}
     * object and shares a set of cursors with it
     * @throws SQLException if an error occurs or cloning is
     *                         not supported
     * @see javax.sql.RowSetEvent
     * @see javax.sql.RowSetListener
     */
    public RowSet createShared() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns a new {@code RowSet} object containing by the same data
     * as this {@code CachedRowSetImpl} object.  This method
     * differs from the method {@code createCopy} in that it throws a
     * {@code CloneNotSupportedException} object instead of an
     * {@code SQLException} object, as the method {@code createShared}
     * does.  This {@code clone}
     * method is called internally by the method {@code createShared},
     * which catches the {@code CloneNotSupportedException} object
     * and in turn throws a new {@code SQLException} object.
     *
     * @return a copy of this {@code CachedRowSetImpl} object
     * @throws CloneNotSupportedException if an error occurs when
     * attempting to clone this {@code CachedRowSetImpl} object
     * @see #createShared
     */
    protected Object clone() throws CloneNotSupportedException  {
       throw new UnsupportedOperationException();
    }

    /**
     * Creates a {@code RowSet} object that is a deep copy of
     * this {@code CachedRowSetImpl} object's data, including
     * constraints.  Updates made
     * on a copy are not visible to the original rowset;
     * a copy of a rowset is completely independent from the original.
     * <P>
     * Making a copy saves the cost of creating an identical rowset
     * from first principles, which can be quite expensive.
     * For example, it can eliminate the need to query a
     * remote database server.
     * @return a new {@code CachedRowSet} object that is a deep copy
     *           of this {@code CachedRowSet} object and is
     *           completely independent from this {@code CachedRowSetImpl}
     *           object.
     * @throws SQLException if an error occurs in generating the copy of this
     *           of the {@code CachedRowSetImpl}
     * @see #createShared
     * @see javax.sql.RowSetEvent
     * @see javax.sql.RowSetListener
     */
    public CachedRowSet createCopy() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Creates a {@code RowSet} object that is a copy of
     * this {@code CachedRowSetImpl} object's table structure
     * and the constraints only.
     * There will be no data in the object being returned.
     * Updates made on a copy are not visible to the original rowset.
     * <P>
     * This helps in getting the underlying XML schema which can
     * be used as the basis for populating a {@code WebRowSet}.
     *
     * @return a new {@code CachedRowSet} object that is a copy
     * of this {@code CachedRowSetImpl} object's schema and
     * retains all the constraints on the original rowset but contains
     * no data
     * @throws SQLException if an error occurs in generating the copy
     * of the {@code CachedRowSet} object
     * @see #createShared
     * @see #createCopy
     * @see #createCopyNoConstraints
     * @see javax.sql.RowSetEvent
     * @see javax.sql.RowSetListener
     */
    public CachedRowSet createCopySchema() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Creates a {@code CachedRowSet} object that is a copy of
     * this {@code CachedRowSetImpl} object's data only.
     * All constraints set in this object will not be there
     * in the returning object.  Updates made
     * on a copy are not visible to the original rowset.
     *
     * @return a new {@code CachedRowSet} object that is a deep copy
     * of this {@code CachedRowSetImpl} object and is
     * completely independent from this {@code CachedRowSetImpl} object
     * @throws SQLException if an error occurs in generating the copy of the
     * of the {@code CachedRowSet}
     * @see #createShared
     * @see #createCopy
     * @see #createCopySchema
     * @see javax.sql.RowSetEvent
     * @see javax.sql.RowSetListener
     */
    public CachedRowSet createCopyNoConstraints() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Converts this {@code CachedRowSetImpl} object to a collection
     * of tables. The sample implementation utilizes the {@code TreeMap}
     * collection type.
     * This class guarantees that the map will be in ascending key order,
     * sorted according to the natural order for the key's class.
     *
     * @return a {@code Collection} object consisting of tables,
     *         each of which is a copy of a row in this
     *         {@code CachedRowSetImpl} object
     * @throws SQLException if an error occurs in generating the collection
     * @see #toCollection(int)
     * @see #toCollection(String)
     * @see java.util.TreeMap
     */
    @SuppressWarnings("rawtypes")
    public Collection toCollection() throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Returns the specified column of this {@code CachedRowSetImpl} object
     * as a {@code Collection} object.  This method makes a copy of the
     * column's data and utilizes the {@code Vector} to establish the
     * collection. The {@code Vector} class implements a growable array
     * objects allowing the individual components to be accessed using an
     * an integer index similar to that of an array.
     *
     * @return a {@code Collection} object that contains the value(s)
     *         stored in the specified column of this
     *         {@code CachedRowSetImpl}
     *         object
     * @throws SQLException if an error occurs generated the collection; or
     *          an invalid column is provided.
     * @see #toCollection()
     * @see #toCollection(String)
     * @see java.util.Vector
     */
    @SuppressWarnings("rawtypes")
    public Collection toCollection(int column) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Returns the specified column of this {@code CachedRowSetImpl} object
     * as a {@code Collection} object.  This method makes a copy of the
     * column's data and utilizes the {@code Vector} to establish the
     * collection. The {@code Vector} class implements a growable array
     * objects allowing the individual components to be accessed using an
     * an integer index similar to that of an array.
     *
     * @return a {@code Collection} object that contains the value(s)
     *         stored in the specified column of this
     *         {@code CachedRowSetImpl}
     *         object
     * @throws SQLException if an error occurs generated the collection; or
     *          an invalid column is provided.
     * @see #toCollection()
     * @see #toCollection(int)
     * @see java.util.Vector
     */
    @SuppressWarnings("rawtypes")
    public Collection toCollection(String column) throws SQLException {
        throw new UnsupportedOperationException();
    }

    //--------------------------------------------------------------------
    // Advanced features
    //--------------------------------------------------------------------


    /**
     * Returns the {@code SyncProvider} implementation being used
     * with this {@code CachedRowSetImpl} implementation rowset.
     *
     * @return the SyncProvider used by the rowset. If not provider was
     *          set when the rowset was instantiated, the reference
     *          implementation (default) provider is returned.
     * @throws SQLException if error occurs while return the
     *          {@code SyncProvider} instance.
     */
    public SyncProvider getSyncProvider() throws SQLException {
      throw new UnsupportedOperationException();
    }

    /**
     * Sets the active {@code SyncProvider} and attempts to load
     * load the new provider using the {@code SyncFactory} SPI.
     *
     * @throws SQLException if an error occurs while resetting the
     *          {@code SyncProvider}.
     */
    public void setSyncProvider(String providerStr) throws SQLException {
        throw new UnsupportedOperationException();
    }


    //-----------------
    // methods inherited from RowSet
    //-----------------






    //---------------------------------------------------------------------
    // Reading and writing data
    //---------------------------------------------------------------------

    /**
     * Populates this {@code CachedRowSetImpl} object with data.
     * This form of the method uses the rowset's user, password, and url or
     * data source name properties to create a database
     * connection.  If properties that are needed
     * have not been set, this method will throw an exception.
     * <P>
     * Another form of this method uses an existing JDBC {@code Connection}
     * object instead of creating a new one; therefore, it ignores the
     * properties used for establishing a new connection.
     * <P>
     * The query specified by the command property is executed to create a
     * {@code ResultSet} object from which to retrieve data.
     * The current contents of the rowset are discarded, and the
     * rowset's metadata is also (re)set.  If there are outstanding updates,
     * they are also ignored.
     * <P>
     * The method {@code execute} closes any database connections that it
     * creates.
     *
     * @throws SQLException if an error occurs or the
     *                         necessary properties have not been set
     */
    public void execute() throws SQLException {
        throw new UnsupportedOperationException();
    }



    //-----------------------------------
    // Methods inherited from ResultSet
    //-----------------------------------

    /**
     * Moves the cursor down one row from its current position and
     * returns {@code true} if the new cursor position is a
     * valid row.
     * The cursor for a new {@code ResultSet} object is initially
     * positioned before the first row. The first call to the method
     * {@code next} moves the cursor to the first row, making it
     * the current row; the second call makes the second row the
     * current row, and so on.
     *
     * <P>If an input stream from the previous row is open, it is
     * implicitly closed. The {@code ResultSet} object's warning
     * chain is cleared when a new row is read.
     *
     * @return {@code true} if the new current row is valid;
     *         {@code false} if there are no more rows
     * @throws SQLException if an error occurs or
     *            the cursor is not positioned in the rowset, before
     *            the first row, or after the last row
     */
    public boolean next() throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the next
     * row and returns {@code true} if the cursor is still in the rowset;
     * returns {@code false} if the cursor has moved to the position after
     * the last row.
     * <P>
     * This method handles the cases where the cursor moves to a row that
     * has been deleted.
     * If this rowset shows deleted rows and the cursor moves to a row
     * that has been deleted, this method moves the cursor to the next
     * row until the cursor is on a row that has not been deleted.
     * <P>
     * The method {@code internalNext} is called by methods such as
     * {@code next}, {@code absolute}, and {@code relative},
     * and, as its name implies, is only called internally.
     * <p>
     * This is a implementation only method and is not required as a standard
     * implementation of the {@code CachedRowSet} interface.
     *
     * @return {@code true} if the cursor is on a valid row in this
     *         rowset; {@code false} if it is after the last row
     * @throws SQLException if an error occurs
     */
    protected boolean internalNext() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Closes this {@code CachedRowSetImpl} objecy and releases any resources
     * it was using.
     *
     * @throws SQLException if an error occurs when releasing any resources in use
     * by this {@code CachedRowSetImpl} object
     */
    public void close() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Reports whether the last column read was SQL {@code NULL}.
     * Note that you must first call the method {@code getXXX}
     * on a column to try to read its value and then call the method
     * {@code wasNull} to determine whether the value was
     * SQL {@code NULL}.
     *
     * @return {@code true} if the value in the last column read
     *         was SQL {@code NULL}; {@code false} otherwise
     * @throws SQLException if an error occurs
     */
    public boolean wasNull() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns the insert row or the current row of this
     * {@code CachedRowSetImpl} object.
     *
     * @return the {@code Row} object on which this {@code CachedRowSetImpl}
     * objects's cursor is positioned
     */
    protected BaseRow getCurrentRow() {
        throw new UnsupportedOperationException();
    }

    /**
     * Removes the row on which the cursor is positioned.
     * <p>
     * This is a implementation only method and is not required as a standard
     * implementation of the {@code CachedRowSet} interface.
     *
     * @throws SQLException if the cursor is positioned on the insert
     *            row
     */
    protected void removeCurrentRow() {
        throw new UnsupportedOperationException();
    }


    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code String} object.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code null}
     * @throws SQLException if (1) the given column index is out of bounds,
     * (2) the cursor is not on one of this rowset's rows or its
     * insert row, or (3) the designated column does not store an
     * SQL {@code TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
     * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT,} <b>{@code CHAR, VARCHAR}</b>
     * or {@code LONGVARCHAR} value. The bold SQL type designates the
     * recommended return type.
     */
    public String getString(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code boolean} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value as a {@code boolean} in the Java programming language;
     *        if the value is SQL {@code NULL}, the result is {@code false}
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL {@code BOOLEAN} value
     * @see #getBoolean(String)
     */
    public boolean getBoolean(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code byte} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value as a {@code byte} in the Java programming
     * language; if the value is SQL {@code NULL}, the result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL <b>{@code TINYINT}</b>, {@code SMALLINT, INTEGER,
     *            BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
     *            VARCHAR} or {@code LONGVARCHAR} value. The bold SQL type
     *            designates the recommended return type.
     * @see #getByte(String)
     */
    public byte getByte(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code short} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT}, <b>{@code SMALLINT}</b>,
     *         {@code INTEGER, BIGINT, REAL, FLOAT, DOUBLE,
     *         DECIMAL, NUMERIC, BIT, CHAR, VARCHAR}
     *         or {@code LONGVARCHAR} value. The bold SQL type
     *         designates the recommended return type.
     * @see #getShort(String)
     */
    public short getShort(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as an
     * {@code int} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT,} <b>{@code INTEGER}</b>,
     *         {@code BIGINT, REAL, FLOAT, DOUBLE, DECIMAL,
     *         NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the
     *         recommended return type.
     */
    public int getInt(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code long} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT, INTEGER,}
     *         <b>{@code BIGINT}</b>, {@code REAL, FLOAT, DOUBLE,
     *         DECIMAL, NUMERIC, BIT, CHAR, VARCHAR}
     *         or {@code LONGVARCHAR} value. The bold SQL type
     * designates the recommended return type.
     * @see #getLong(String)
     */
    public long getLong(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code float} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT, INTEGER, BIGINT,}
     *         <b>{@code REAL}</b>, {@code FLOAT, DOUBLE, DECIMAL, NUMERIC,
     *         BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type.
     * @see #getFloat(String)
     */
    public float getFloat(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code double} value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code 0}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT, INTEGER, BIGINT, REAL,}
     *         <b>{@code FLOAT, DOUBLE}</b>,
     *         {@code DECIMAL, NUMERIC, BIT, CHAR, VARCHAR}
     *         or {@code LONGVARCHAR} value. The bold SQL type
     *         designates the recommended return type.
     * @see #getDouble(String)
     *
     */
    public double getDouble(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.math.BigDecimal} object.
     * <P>
     * This method is deprecated; use the version of {@code getBigDecimal}
     * that does not take a scale parameter and returns a value with full
     * precision.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @param scale the number of digits to the right of the decimal point in the
     *        value returned
     * @return the column value with the specified number of digits to the right
     *         of the decimal point; if the value is SQL {@code NULL}, the
     *         result is {@code null}
     * @throws SQLException if the given column index is out of bounds,
     *            the cursor is not on a valid row, or this method fails
     * @deprecated
     */
    @Deprecated
    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code byte} array value.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value as a {@code byte} array in the Java programming
     * language; if the value is SQL {@code NULL}, the
     * result is {@code null}
     *
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL <b>{@code BINARY, VARBINARY}</b> or
     *         {@code LONGVARBINARY} value.
     *         The bold SQL type designates the recommended return type.
     * @see #getBytes(String)
     */
    public byte[] getBytes(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.sql.Date} object.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value as a {@code java.sql.Data} object; if
     *        the value is SQL {@code NULL}, the
     *        result is {@code null}
     * @throws SQLException if the given column index is out of bounds,
     *         the cursor is not on a valid row, or this method fails
     */
    public java.sql.Date getDate(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.sql.Time} object.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code null}
     * @throws SQLException if the given column index is out of bounds,
     *         the cursor is not on a valid row, or this method fails
     */
    public java.sql.Time getTime(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.sql.Timestamp} object.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return the column value; if the value is SQL {@code NULL}, the
     *         result is {@code null}
     * @throws SQLException if the given column index is out of bounds,
     *            the cursor is not on a valid row, or this method fails
     */
    public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row of this
     * {@code CachedRowSetImpl} object as a {@code java.io.InputStream}
     * object.
     *
     * A column value can be retrieved as a stream of ASCII characters
     * and then read in chunks from the stream.  This method is particularly
     * suitable for retrieving large {@code LONGVARCHAR} values.  The JDBC
     * driver will do any necessary conversion from the database format into ASCII.
     *
     * <P><B>Note:</B> All the data in the returned stream must be
     * read prior to getting the value of any other column. The next
     * call to a get method implicitly closes the stream. . Also, a
     * stream may return {@code 0} for {@code CachedRowSetImpl.available()}
     * whether there is data available or not.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return a Java input stream that delivers the database column value
     *         as a stream of one-byte ASCII characters.  If the value is SQL
     *         {@code NULL}, the result is {@code null}.
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code CHAR, VARCHAR}, <b>{@code LONGVARCHAR}</b>,
     *         {@code BINARY, VARBINARY} or {@code LONGVARBINARY} value. The
     *         bold SQL type designates the recommended return types
     *         that this method is used to retrieve.
     * @see #getAsciiStream(String)
     */
    public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * A column value can be retrieved as a stream of Unicode characters
     * and then read in chunks from the stream.  This method is particularly
     * suitable for retrieving large LONGVARCHAR values.  The JDBC driver will
     * do any necessary conversion from the database format into Unicode.
     *
     * <P><B>Note:</B> All the data in the returned stream must be
     * read prior to getting the value of any other column. The next
     * call to a get method implicitly closes the stream. . Also, a
     * stream may return 0 for available() whether there is data
     * available or not.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return a Java input stream that delivers the database column value
     * as a stream of two byte Unicode characters.  If the value is SQL NULL
     * then the result is null.
     * @throws SQLException if an error occurs
     * @deprecated
     */
    @Deprecated
    public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row of this
     * {@code CachedRowSetImpl} object as a {@code java.io.InputStream}
     * object.
     * <P>
     * A column value can be retrieved as a stream of uninterpreted bytes
     * and then read in chunks from the stream.  This method is particularly
     * suitable for retrieving large {@code LONGVARBINARY} values.
     *
     * <P><B>Note:</B> All the data in the returned stream must be
     * read prior to getting the value of any other column. The next
     * call to a get method implicitly closes the stream. Also, a
     * stream may return {@code 0} for
     * {@code CachedRowSetImpl.available()} whether there is data
     * available or not.
     *
     * @param columnIndex the first column is {@code 1}, the second
     * is {@code 2}, and so on; must be {@code 1} or larger
     * and equal to or less than the number of columns in the rowset
     * @return a Java input stream that delivers the database column value
     * as a stream of uninterpreted bytes.  If the value is SQL {@code NULL}
     * then the result is {@code null}.
     * @throws SQLException if (1) the given column index is out of bounds,
     * (2) the cursor is not on one of this rowset's rows or its
     * insert row, or (3) the designated column does not store an
     * SQL {@code BINARY, VARBINARY} or <b>{@code LONGVARBINARY}</b>.
     * The bold type indicates the SQL type that this method is recommended
     * to retrieve.
     * @see #getBinaryStream(String)
     */
    public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
       throw new UnsupportedOperationException();

    }


    //======================================================================
    // Methods for accessing results by column name
    //======================================================================

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code String} object.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,
     *         BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT,}
     *         <b>{@code CHAR, VARCHAR}</b> or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type.
     */
    public String getString(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code boolean} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value as a {@code boolean} in the Java programming
     *        language; if the value is SQL {@code NULL},
     *        the result is {@code false}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code BOOLEAN} value
     * @see #getBoolean(int)
     */
    public boolean getBoolean(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code byte} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value as a {@code byte} in the Java programming
     * language; if the value is SQL {@code NULL}, the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL <b>{@code TINYINT}</b>,
     *         {@code SMALLINT, INTEGER, BIGINT, REAL, FLOAT, DOUBLE,
     *         DECIMAL, NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR}
     *         value. The bold type designates the recommended return type.
     */
    public byte getByte(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code short} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT,}
     *         <b>{@code SMALLINT}</b>, {@code INTEGER,
     *         BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
     *         VARCHAR} or {@code LONGVARCHAR} value. The bold SQL type
     *         designates the recommended return type.
     * @see #getShort(int)
     */
    public short getShort(String columnName) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as an {@code int} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name
     *         of a column in this rowset,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT,} <b>{@code INTEGER}</b>,
     *         {@code BIGINT, REAL, FLOAT, DOUBLE, DECIMAL,
     *         NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the
     *         recommended return type.
     */
    public int getInt(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code long} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,}
     *         <b>{@code BIGINT}</b>, {@code REAL, FLOAT, DOUBLE, DECIMAL,
     *         NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type.
     * @see #getLong(int)
     */
    public long getLong(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code float} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,
     *         BIGINT,} <b>{@code REAL}</b>, {@code FLOAT, DOUBLE, DECIMAL,
     *         NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type.
     * @see #getFloat(String)
     */
    public float getFloat(String columnName) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row of this {@code CachedRowSetImpl} object
     * as a {@code double} value.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code 0}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,
     *         BIGINT, REAL,} <b>{@code FLOAT, DOUBLE}</b>, {@code DECIMAL,
     *         NUMERIC, BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return types.
     * @see #getDouble(int)
     */
    public double getDouble(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.math.BigDecimal} object.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @param scale the number of digits to the right of the decimal point
     * @return a java.math.BugDecimal object with <i>{@code scale}</i>
     *         number of digits to the right of the decimal point.
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,
     *         BIGINT, REAL, FLOAT, DOUBLE,} <b>{@code DECIMAL, NUMERIC}</b>,
     *         {@code BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type
     *         that this method is used to retrieve.
     * @deprecated Use the {@code getBigDecimal(String columnName)}
     *             method instead
     */
    @Deprecated
    public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code byte} array.
     * The bytes represent the raw values returned by the driver.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value as a {@code byte} array in the Java programming
     *         language; if the value is SQL {@code NULL}, the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL <b>{@code BINARY, VARBINARY}</b>
     *         or {@code LONGVARBINARY} values.
     *         The bold SQL type designates the recommended return type.
     * @see #getBytes(int)
     */
    public byte[] getBytes(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.sql.Date} object.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code DATE} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Date getDate(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.sql.Time} object.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if the given column name does not match one of
     *            this rowset's column names or the cursor is not on one of
     *            this rowset's rows or its insert row
     */
    public java.sql.Time getTime(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.sql.Timestamp} object.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if the given column name does not match one of
     *            this rowset's column names or the cursor is not on one of
     *            this rowset's rows or its insert row
     */
    public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row of this
     * {@code CachedRowSetImpl} object as a {@code java.io.InputStream}
     * object.
     *
     * A column value can be retrieved as a stream of ASCII characters
     * and then read in chunks from the stream. This method is particularly
     * suitable for retrieving large {@code LONGVARCHAR} values. The
     * {@code SyncProvider} will rely on the JDBC driver to do any necessary
     * conversion from the database format into ASCII format.
     *
     * <P><B>Note:</B> All the data in the returned stream must
     * be read prior to getting the value of any other column. The
     * next call to a {@code getXXX} method implicitly closes the stream.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return a Java input stream that delivers the database column value
     *         as a stream of one-byte ASCII characters.  If the value is SQL
     *         {@code NULL}, the result is {@code null}.
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code CHAR, VARCHAR}, <b>{@code LONGVARCHAR}</b>,
     *         {@code BINARY, VARBINARY} or {@code LONGVARBINARY} value. The
     *         bold SQL type designates the recommended return types
     *         that this method is used to retrieve.
     * @see #getAsciiStream(int)
     */
    public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
        throw new UnsupportedOperationException();

    }

    /**
     * A column value can be retrieved as a stream of Unicode characters
     * and then read in chunks from the stream.  This method is particularly
     * suitable for retrieving large {@code LONGVARCHAR} values.
     * The JDBC driver will do any necessary conversion from the database
     * format into Unicode.
     *
     * <P><B>Note:</B> All the data in the returned stream must
     * be read prior to getting the value of any other column. The
     * next call to a {@code getXXX} method implicitly closes the stream.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return a Java input stream that delivers the database column value
     *         as a stream of two-byte Unicode characters.  If the value is
     *         SQL {@code NULL}, the result is {@code null}.
     * @throws SQLException if the given column name does not match one of
     *            this rowset's column names or the cursor is not on one of
     *            this rowset's rows or its insert row
     * @deprecated use the method {@code getCharacterStream} instead
     */
    @Deprecated
    public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row of this
     * {@code CachedRowSetImpl} object as a {@code java.io.InputStream}
     * object.
     * <P>
     * A column value can be retrieved as a stream of uninterpreted bytes
     * and then read in chunks from the stream.  This method is particularly
     * suitable for retrieving large {@code LONGVARBINARY} values.
     *
     * <P><B>Note:</B> All the data in the returned stream must be
     * read prior to getting the value of any other column. The next
     * call to a get method implicitly closes the stream. Also, a
     * stream may return {@code 0} for {@code CachedRowSetImpl.available()}
     * whether there is data available or not.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return a Java input stream that delivers the database column value
     *         as a stream of uninterpreted bytes.  If the value is SQL
     *         {@code NULL}, the result is {@code null}.
     * @throws SQLException if (1) the given column name is unknown,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code BINARY, VARBINARY} or <b>{@code LONGVARBINARY}</b>
     *         The bold type indicates the SQL type that this method is recommended
     *         to retrieve.
     * @see #getBinaryStream(int)
     *
     */
    public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }


    //=====================================================================
    // Advanced features:
    //=====================================================================

    /**
     * The first warning reported by calls on this {@code CachedRowSetImpl}
     * object is returned. Subsequent {@code CachedRowSetImpl} warnings will
     * be chained to this {@code SQLWarning}.
     *
     * <P>The warning chain is automatically cleared each time a new
     * row is read.
     *
     * <P><B>Note:</B> This warning chain only covers warnings caused
     * by {@code ResultSet} methods.  Any warning caused by statement
     * methods (such as reading OUT parameters) will be chained on the
     * {@code Statement} object.
     *
     * @return the first SQLWarning or null
     */
    public SQLWarning getWarnings() {
        throw new UnsupportedOperationException();
    }

    /**
     * Clears all the warnings reporeted for the {@code CachedRowSetImpl}
     * object. After a call to this method, the {@code getWarnings} method
     * returns {@code null} until a new warning is reported for this
     * {@code CachedRowSetImpl} object.
     */
    public void clearWarnings() {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the name of the SQL cursor used by this
     * {@code CachedRowSetImpl} object.
     *
     * <P>In SQL, a result table is retrieved through a cursor that is
     * named. The current row of a {@code ResultSet} can be updated or deleted
     * using a positioned update/delete statement that references the
     * cursor name. To ensure that the cursor has the proper isolation
     * level to support an update operation, the cursor's {@code SELECT}
     * statement should be of the form {@code select for update}.
     * If the {@code for update} clause
     * is omitted, positioned updates may fail.
     *
     * <P>JDBC supports this SQL feature by providing the name of the
     * SQL cursor used by a {@code ResultSet} object. The current row
     * of a result set is also the current row of this SQL cursor.
     *
     * <P><B>Note:</B> If positioned updates are not supported, an
     * {@code SQLException} is thrown.
     *
     * @return the SQL cursor name for this {@code CachedRowSetImpl} object's
     *         cursor
     * @throws SQLException if an error occurs
     */
    public String getCursorName() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves a {@code ResultSetMetaData} object instance that
     * contains information about the {@code CachedRowSet} object.
     * However, applications should cast the returned object to a
     * {@code RowSetMetaData} interface implementation. In the
     * reference implementation, this cast can be done on the
     * {@code RowSetMetaDataImpl} class.
     * <P>
     * For example:
     * <pre>
     * CachedRowSet crs = new CachedRowSetImpl();
     * RowSetMetaDataImpl metaData =
     *     (RowSetMetaDataImpl)crs.getMetaData();
     * // Set the number of columns in the RowSet object for
     * // which this RowSetMetaDataImpl object was created to the
     * // given number.
     * metaData.setColumnCount(3);
     * crs.setMetaData(metaData);
     * </pre>
     *
     * @return the {@code ResultSetMetaData} object that describes this
     *         {@code CachedRowSetImpl} object's columns
     * @throws SQLException if an error occurs in generating the RowSet
     * meta data; or if the {@code CachedRowSetImpl} is empty.
     * @see javax.sql.RowSetMetaData
     */
    public ResultSetMetaData getMetaData() throws SQLException {
        throw new UnsupportedOperationException();
    }


    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as an
     * {@code Object} value.
     * <P>
     * The type of the {@code Object} will be the default
     * Java object type corresponding to the column's SQL type,
     * following the mapping for built-in types specified in the JDBC 3.0
     * specification.
     * <P>
     * This method may also be used to read datatabase-specific
     * abstract data types.
     * <P>
     * This implementation of the method {@code getObject} extends its
     * behavior so that it gets the attributes of an SQL structured type
     * as an array of {@code Object} values.  This method also custom
     * maps SQL user-defined types to classes in the Java programming language.
     * When the specified column contains
     * a structured or distinct value, the behavior of this method is as
     * if it were a call to the method {@code getObject(columnIndex,
     * this.getStatement().getConnection().getTypeMap())}.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return a {@code java.lang.Object} holding the column value;
     *         if the value is SQL {@code NULL}, the result is {@code null}
     * @throws SQLException if the given column index is out of bounds,
     *            the cursor is not on a valid row, or there is a problem getting
     *            the {@code Class} object for a custom mapping
     * @see #getObject(String)
     */
    public Object getObject(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as an
     * {@code Object} value.
     * <P>
     * The type of the {@code Object} will be the default
     * Java object type corresponding to the column's SQL type,
     * following the mapping for built-in types specified in the JDBC 3.0
     * specification.
     * <P>
     * This method may also be used to read datatabase-specific
     * abstract data types.
     * <P>
     * This implementation of the method {@code getObject} extends its
     * behavior so that it gets the attributes of an SQL structured type
     * as an array of {@code Object} values.  This method also custom
     * maps SQL user-defined types to classes
     * in the Java programming language. When the specified column contains
     * a structured or distinct value, the behavior of this method is as
     * if it were a call to the method {@code getObject(columnIndex,
     * this.getStatement().getConnection().getTypeMap())}.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return a {@code java.lang.Object} holding the column value;
     *         if the value is SQL {@code NULL}, the result is {@code null}
     * @throws SQLException if (1) the given column name does not match one of
     *            this rowset's column names, (2) the cursor is not
     *            on a valid row, or (3) there is a problem getting
     *            the {@code Class} object for a custom mapping
     * @see #getObject(int)
     */
    public Object getObject(String columnName) throws SQLException {
       throw new UnsupportedOperationException();
    }

    //----------------------------------------------------------------

    /**
     * Maps the given column name for one of this {@code CachedRowSetImpl}
     * object's columns to its column number.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return the column index of the given column name
     * @throws SQLException if the given column name does not match one
     *            of this rowset's column names
     */
    public int findColumn(String columnName) throws SQLException {
       throw new UnsupportedOperationException();
    }

    //--------------------------JDBC 2.0-----------------------------------

    //---------------------------------------------------------------------
    // Getter's and Setter's
    //---------------------------------------------------------------------

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.io.Reader} object.
     *
     * <P><B>Note:</B> All the data in the returned stream must
     * be read prior to getting the value of any other column. The
     * next call to a {@code getXXX} method implicitly closes the stream.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return a Java character stream that delivers the database column value
     * as a stream of two-byte unicode characters in a
     * {@code java.io.Reader} object.  If the value is
     * SQL {@code NULL}, the result is {@code null}.
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code CHAR, VARCHAR,} <b>{@code LONGVARCHAR}</b>,
     *         {@code BINARY, VARBINARY} or {@code LONGVARBINARY} value.
     *         The bold SQL type designates the recommended return type.
     * @see #getCharacterStream(String)
     */
    public java.io.Reader getCharacterStream(int columnIndex) throws SQLException{
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value stored in the designated column
     * of the current row as a {@code java.io.Reader} object.
     *
     * <P><B>Note:</B> All the data in the returned stream must
     * be read prior to getting the value of any other column. The
     * next call to a {@code getXXX} method implicitly closes the stream.
     *
     * @param columnName a {@code String} object giving the SQL name of
     *        a column in this {@code CachedRowSetImpl} object
     * @return a Java input stream that delivers the database column value
     *         as a stream of two-byte Unicode characters.  If the value is
     *         SQL {@code NULL}, the result is {@code null}.
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code CHAR, VARCHAR,}
     *         <b>{@code LONGVARCHAR}</b>,
     *         {@code BINARY, VARYBINARY} or {@code LONGVARBINARY} value.
     *         The bold SQL type designates the recommended return type.
     */
    public java.io.Reader getCharacterStream(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.math.BigDecimal} object.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @return a {@code java.math.BigDecimal} value with full precision;
     *         if the value is SQL {@code NULL}, the result is {@code null}
     * @throws SQLException if (1) the given column index is out of bounds,
     *         (2) the cursor is not on one of this rowset's rows or its
     *         insert row, or (3) the designated column does not store an
     *         SQL {@code TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
     *         FLOAT, DOUBLE,} <b>{@code DECIMAL, NUMERIC}</b>,
     *         {@code BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the
     *         recommended return types that this method is used to retrieve.
     * @see #getBigDecimal(String)
     */
    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.math.BigDecimal} object.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return a {@code java.math.BigDecimal} value with full precision;
     *         if the value is SQL {@code NULL}, the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *         a column in this rowset, (2) the cursor is not on one of
     *         this rowset's rows or its insert row, or (3) the designated
     *         column does not store an SQL {@code TINYINT, SMALLINT, INTEGER,
     *         BIGINT, REAL, FLOAT, DOUBLE,} <b>{@code DECIMAL, NUMERIC}</b>,
     *         {@code BIT, CHAR, VARCHAR} or {@code LONGVARCHAR} value.
     *         The bold SQL type designates the recommended return type
     *         that this method is used to retrieve.
     * @see #getBigDecimal(int)
     */
    public BigDecimal getBigDecimal(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    //---------------------------------------------------------------------
    // Traversal/Positioning
    //---------------------------------------------------------------------

    /**
     * Returns the number of rows in this {@code CachedRowSetImpl} object.
     *
     * @return number of rows in the rowset
     */
    public int size() {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the cursor is before the first row in this
     * {@code CachedRowSetImpl} object.
     *
     * @return {@code true} if the cursor is before the first row;
     *         {@code false} otherwise or if the rowset contains no rows
     * @throws SQLException if an error occurs
     */
    public boolean isBeforeFirst() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the cursor is after the last row in this
     * {@code CachedRowSetImpl} object.
     *
     * @return {@code true} if the cursor is after the last row;
     *         {@code false} otherwise or if the rowset contains no rows
     * @throws SQLException if an error occurs
     */
    public boolean isAfterLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the cursor is on the first row in this
     * {@code CachedRowSetImpl} object.
     *
     * @return {@code true} if the cursor is on the first row;
     *         {@code false} otherwise or if the rowset contains no rows
     * @throws SQLException if an error occurs
     */
    public boolean isFirst() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the cursor is on the last row in this
     * {@code CachedRowSetImpl} object.
     * <P>
     * Note: Calling the method {@code isLast} may be expensive
     * because the JDBC driver might need to fetch ahead one row in order
     * to determine whether the current row is the last row in this rowset.
     *
     * @return {@code true} if the cursor is on the last row;
     *         {@code false} otherwise or if this rowset contains no rows
     * @throws SQLException if an error occurs
     */
    public boolean isLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the front of
     * the rowset, just before the first row. This method has no effect if
     * this rowset contains no rows.
     *
     * @throws SQLException if an error occurs or the type of this rowset
     *            is {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public void beforeFirst() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the end of
     * the rowset, just after the last row. This method has no effect if
     * this rowset contains no rows.
     *
     * @throws SQLException if an error occurs
     */
    public void afterLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the first row
     * and returns {@code true} if the operation was successful.  This
     * method also notifies registered listeners that the cursor has moved.
     *
     * @return {@code true} if the cursor is on a valid row;
     *         {@code false} otherwise or if there are no rows in this
     *         {@code CachedRowSetImpl} object
     * @throws SQLException if the type of this rowset
     *            is {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public boolean first() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the first
     * row and returns {@code true} if the operation is successful.
     * <P>
     * This method is called internally by the methods {@code first},
     * {@code isFirst}, and {@code absolute}.
     * It in turn calls the method {@code internalNext} in order to
     * handle the case where the first row is a deleted row that is not visible.
     * <p>
     * This is a implementation only method and is not required as a standard
     * implementation of the {@code CachedRowSet} interface.
     *
     * @return {@code true} if the cursor moved to the first row;
     *         {@code false} otherwise
     * @throws SQLException if an error occurs
     */
    protected boolean internalFirst() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the last row
     * and returns {@code true} if the operation was successful.  This
     * method also notifies registered listeners that the cursor has moved.
     *
     * @return {@code true} if the cursor is on a valid row;
     *         {@code false} otherwise or if there are no rows in this
     *         {@code CachedRowSetImpl} object
     * @throws SQLException if the type of this rowset
     *            is {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public boolean last() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the last
     * row and returns {@code true} if the operation is successful.
     * <P>
     * This method is called internally by the method {@code last}
     * when rows have been deleted and the deletions are not visible.
     * The method {@code internalLast} handles the case where the
     * last row is a deleted row that is not visible by in turn calling
     * the method {@code internalPrevious}.
     * <p>
     * This is a implementation only method and is not required as a standard
     * implementation of the {@code CachedRowSet} interface.
     *
     * @return {@code true} if the cursor moved to the last row;
     *         {@code false} otherwise
     * @throws SQLException if an error occurs
     */
    protected boolean internalLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns the number of the current row in this {@code CachedRowSetImpl}
     * object. The first row is number 1, the second number 2, and so on.
     *
     * @return the number of the current row;  {@code 0} if there is no
     *         current row
     * @throws SQLException if an error occurs; or if the {@code CacheRowSetImpl}
     *         is empty
     */
    public int getRow() throws SQLException {
        return crsSync.getRow();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the row number
     * specified.
     *
     * <p>If the number is positive, the cursor moves to an absolute row with
     * respect to the beginning of the rowset.  The first row is row 1, the second
     * is row 2, and so on.  For example, the following command, in which
     * {@code crs} is a {@code CachedRowSetImpl} object, moves the cursor
     * to the fourth row, starting from the beginning of the rowset.
     * <PRE>{@code
     *
     *    crs.absolute(4);
     *
     * }</PRE>
     * <P>
     * If the number is negative, the cursor moves to an absolute row position
     * with respect to the end of the rowset.  For example, calling
     * {@code absolute(-1)} positions the cursor on the last row,
     * {@code absolute(-2)} moves it on the next-to-last row, and so on.
     * If the {@code CachedRowSetImpl} object {@code crs} has five rows,
     * the following command moves the cursor to the fourth-to-last row, which
     * in the case of a  rowset with five rows, is also the second row, counting
     * from the beginning.
     * <PRE>{@code
     *
     *    crs.absolute(-4);
     *
     * }</PRE>
     *
     * If the number specified is larger than the number of rows, the cursor
     * will move to the position after the last row. If the number specified
     * would move the cursor one or more rows before the first row, the cursor
     * moves to the position before the first row.
     * <P>
     * Note: Calling {@code absolute(1)} is the same as calling the
     * method {@code first()}.  Calling {@code absolute(-1)} is the
     * same as calling {@code last()}.
     *
     * @param row a positive number to indicate the row, starting row numbering from
     *        the first row, which is {@code 1}; a negative number to indicate
     *        the row, starting row numbering from the last row, which is
     *        {@code -1}; it must not be {@code 0}
     * @return {@code true} if the cursor is on the rowset; {@code false}
     *         otherwise
     * @throws SQLException if the given cursor position is {@code 0} or the
     *            type of this rowset is {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public boolean absolute( int row ) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves the cursor the specified number of rows from the current
     * position, with a positive number moving it forward and a
     * negative number moving it backward.
     * <P>
     * If the number is positive, the cursor moves the specified number of
     * rows toward the end of the rowset, starting at the current row.
     * For example, the following command, in which
     * {@code crs} is a {@code CachedRowSetImpl} object with 100 rows,
     * moves the cursor forward four rows from the current row.  If the
     * current row is 50, the cursor would move to row 54.
     * <PRE>{@code
     *
     *    crs.relative(4);
     *
     * }</PRE>
     * <P>
     * If the number is negative, the cursor moves back toward the beginning
     * the specified number of rows, starting at the current row.
     * For example, calling the method
     * {@code absolute(-1)} positions the cursor on the last row,
     * {@code absolute(-2)} moves it on the next-to-last row, and so on.
     * If the {@code CachedRowSetImpl} object {@code crs} has five rows,
     * the following command moves the cursor to the fourth-to-last row, which
     * in the case of a  rowset with five rows, is also the second row
     * from the beginning.
     * <PRE>{@code
     *
     *    crs.absolute(-4);
     *
     * }</PRE>
     *
     * If the number specified is larger than the number of rows, the cursor
     * will move to the position after the last row. If the number specified
     * would move the cursor one or more rows before the first row, the cursor
     * moves to the position before the first row. In both cases, this method
     * throws an {@code SQLException}.
     * <P>
     * Note: Calling {@code absolute(1)} is the same as calling the
     * method {@code first()}.  Calling {@code absolute(-1)} is the
     * same as calling {@code last()}.  Calling {@code relative(0)}
     * is valid, but it does not change the cursor position.
     *
     * @param rows an {@code int} indicating the number of rows to move
     *             the cursor, starting at the current row; a positive number
     *             moves the cursor forward; a negative number moves the cursor
     *             backward; must not move the cursor past the valid
     *             rows
     * @return {@code true} if the cursor is on a row in this
     *         {@code CachedRowSetImpl} object; {@code false}
     *         otherwise
     * @throws SQLException if there are no rows in this rowset, the cursor is
     *         positioned either before the first row or after the last row, or
     *         the rowset is type {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public boolean relative(int rows) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves this {@code CachedRowSetImpl} object's cursor to the
     * previous row and returns {@code true} if the cursor is on
     * a valid row or {@code false} if it is not.
     * This method also notifies all listeners registered with this
     * {@code CachedRowSetImpl} object that its cursor has moved.
     * <P>
     * Note: calling the method {@code previous()} is not the same
     * as calling the method {@code relative(-1)}.  This is true
     * because it is possible to call {@code previous()} from the insert
     * row, from after the last row, or from the current row, whereas
     * {@code relative} may only be called from the current row.
     * <P>
     * The method {@code previous} may used in a {@code while}
     * loop to iterate through a rowset starting after the last row
     * and moving toward the beginning. The loop ends when {@code previous}
     * returns {@code false}, meaning that there are no more rows.
     * For example, the following code fragment retrieves all the data in
     * the {@code CachedRowSetImpl} object {@code crs}, which has
     * three columns.  Note that the cursor must initially be positioned
     * after the last row so that the first call to the method
     * {@code previous} places the cursor on the last line.
     * <PRE>{@code
     *
     *     crs.afterLast();
     *     while (previous()) {
     *         String name = crs.getString(1);
     *         int age = crs.getInt(2);
     *         short ssn = crs.getShort(3);
     *         System.out.println(name + "   " + age + "   " + ssn);
     *     }
     *
     * }</PRE>
     * This method throws an {@code SQLException} if the cursor is not
     * on a row in the rowset, before the first row, or after the last row.
     *
     * @return {@code true} if the cursor is on a valid row;
     *         {@code false} if it is before the first row or after the
     *         last row
     * @throws SQLException if the cursor is not on a valid position or the
     *           type of this rowset is {@code ResultSet.TYPE_FORWARD_ONLY}
     */
    public boolean previous() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves the cursor to the previous row in this {@code CachedRowSetImpl}
     * object, skipping past deleted rows that are not visible; returns
     * {@code true} if the cursor is on a row in this rowset and
     * {@code false} when the cursor goes before the first row.
     * <P>
     * This method is called internally by the method {@code previous}.
     * <P>
     * This is a implementation only method and is not required as a standard
     * implementation of the {@code CachedRowSet} interface.
     *
     * @return {@code true} if the cursor is on a row in this rowset;
     *         {@code false} when the cursor reaches the position before
     *         the first row
     * @throws SQLException if an error occurs
     */
    protected boolean internalPrevious() throws SQLException {
        throw new UnsupportedOperationException();
    }


    //---------------------------------------------------------------------
    // Updates
    //---------------------------------------------------------------------

    /**
     * Indicates whether the current row of this {@code CachedRowSetImpl}
     * object has been updated.  The value returned
     * depends on whether this rowset can detect updates: {@code false}
     * will always be returned if it does not detect updates.
     *
     * @return {@code true} if the row has been visibly updated
     *         by the owner or another and updates are detected;
     *         {@code false} otherwise
     * @throws SQLException if the cursor is on the insert row or not
     *            not on a valid row
     *
     * @see DatabaseMetaData#updatesAreDetected
     */
    public boolean rowUpdated() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the designated column of the current row of
     * this {@code CachedRowSetImpl} object has been updated. The
     * value returned depends on whether this rowset can detcted updates:
     * {@code false} will always be returned if it does not detect updates.
     *
     * @param idx the index identifier of the column that may be have been updated.
     * @return {@code true} is the designated column has been updated
     * and the rowset detects updates; {@code false} if the rowset has not
     * been updated or the rowset does not detect updates
     * @throws SQLException if the cursor is on the insert row or not
     *          on a valid row
     * @see DatabaseMetaData#updatesAreDetected
     */
    public boolean columnUpdated(int idx) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the designated column of the current row of
     * this {@code CachedRowSetImpl} object has been updated. The
     * value returned depends on whether this rowset can detcted updates:
     * {@code false} will always be returned if it does not detect updates.
     *
     * @param columnName the {@code String} column name column that may be have
     * been updated.
     * @return {@code true} is the designated column has been updated
     * and the rowset detects updates; {@code false} if the rowset has not
     * been updated or the rowset does not detect updates
     * @throws SQLException if the cursor is on the insert row or not
     *          on a valid row
     * @see DatabaseMetaData#updatesAreDetected
     */
    public boolean columnUpdated(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the current row has been inserted.  The value returned
     * depends on whether or not the rowset can detect visible inserts.
     *
     * @return {@code true} if a row has been inserted and inserts are detected;
     *         {@code false} otherwise
     * @throws SQLException if the cursor is on the insert row or not
     *            not on a valid row
     *
     * @see DatabaseMetaData#insertsAreDetected
     */
    public boolean rowInserted() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Indicates whether the current row has been deleted.  A deleted row
     * may leave a visible "hole" in a rowset.  This method can be used to
     * detect such holes if the rowset can detect deletions. This method
     * will always return {@code false} if this rowset cannot detect
     * deletions.
     *
     * @return {@code true} if (1)the current row is blank, indicating that
     *         the row has been deleted, and (2)deletions are detected;
     *         {@code false} otherwise
     * @throws SQLException if the cursor is on a valid row in this rowset
     * @see DatabaseMetaData#deletesAreDetected
     */
    public boolean rowDeleted() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated nullable column in the current row or the
     * insert row of this {@code CachedRowSetImpl} object with
     * {@code null} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset; however, another method must be called to complete
     * the update process. If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to mark the row as updated
     * and to notify listeners that the row has changed.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called to insert the new row into this rowset and to notify
     * listeners that a row has changed.
     * <P>
     * In order to propagate updates in this rowset to the underlying
     * data source, an application must call the method {@link #acceptChanges}
     * after it calls either {@code updateRow} or {@code insertRow}.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateNull(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code boolean} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code byte} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateByte(int columnIndex, byte x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code short} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateShort(int columnIndex, short x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code int} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateInt(int columnIndex, int x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code long} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateLong(int columnIndex, long x) throws SQLException {
       throw new UnsupportedOperationException();

    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code float} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateFloat(int columnIndex, float x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateDouble(int columnIndex, double x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.math.BigDecimal} object.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code String} object.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to mark the row as updated.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called to insert the new row into this rowset and mark it
     * as inserted. Both of these methods must be called before the
     * cursor moves to another row.
     * <P>
     * The method {@code acceptChanges} must be called if the
     * updated values are to be written back to the underlying database.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateString(int columnIndex, String x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code byte} array.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBytes(int columnIndex, byte x[]) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Date} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, (3) the type of the designated column is not
     *            an SQL {@code DATE} or {@code TIMESTAMP}, or
     *            (4) this rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Time} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, (3) the type of the designated column is not
     *            an SQL {@code TIME} or {@code TIMESTAMP}, or
     *            (4) this rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Timestamp} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, (3) the type of the designated column is not
     *            an SQL {@code DATE}, {@code TIME}, or
     *            {@code TIMESTAMP}, or (4) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * ASCII stream value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @param length the number of one-byte ASCII characters in the stream
     * @throws SQLException if this method is invoked
     */
    public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.io.InputStream} object.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value; must be a {@code java.io.InputStream}
     *          containing {@code BINARY}, {@code VARBINARY}, or
     *          {@code LONGVARBINARY} data
     * @param length the length of the stream in bytes
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, (3) the data in the stream is not binary, or
     *            (4) this rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.io.Reader} object.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value; must be a {@code java.io.Reader}
     *          containing {@code BINARY}, {@code VARBINARY},
     *          {@code LONGVARBINARY}, {@code CHAR}, {@code VARCHAR},
     *          or {@code LONGVARCHAR} data
     * @param length the length of the stream in characters
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, (3) the data in the stream is not a binary or
     *            character type, or (4) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Object} value.  The {@code scale} parameter indicates
     * the number of digits to the right of the decimal point and is ignored
     * if the new column value is not a type that will be mapped to an SQL
     * {@code DECIMAL} or {@code NUMERIC} value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @param scale the number of digits to the right of the decimal point (for
     *              {@code DECIMAL} and {@code NUMERIC} types only)
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Object} value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param x the new column value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateObject(int columnIndex, Object x) throws SQLException {
        throw new UnsupportedOperationException();
    }


    /**
     * Sets the designated nullable column in the current row or the
     * insert row of this {@code CachedRowSetImpl} object with
     * {@code null} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateNull(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code boolean} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBoolean(String columnName, boolean x) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code byte} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateByte(String columnName, byte x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code short} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateShort(String columnName, short x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code int} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateInt(String columnName, int x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code long} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateLong(String columnName, long x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code float} value.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateFloat(String columnName, float x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateDouble(String columnName, double x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.math.BigDecimal} object.
     * <P>
     * This method updates a column value in the current row or the insert
     * row of this rowset, but it does not update the database.
     * If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code String} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateString(String columnName, String x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code byte} array.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBytes(String columnName, byte x[]) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Date} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, (3) the type
     *            of the designated column is not an SQL {@code DATE} or
     *            {@code TIMESTAMP}, or (4) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateDate(String columnName, java.sql.Date x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Time} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, (3) the type
     *            of the designated column is not an SQL {@code TIME} or
     *            {@code TIMESTAMP}, or (4) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateTime(String columnName, java.sql.Time x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Timestamp} object.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if the given column index is out of bounds or
     *            the cursor is not on one of this rowset's rows or its
     *            insert row
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, (3) the type
     *            of the designated column is not an SQL {@code DATE},
     *            {@code TIME}, or {@code TIMESTAMP}, or (4) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * ASCII stream value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @param length the number of one-byte ASCII characters in the stream
     */
    public void updateAsciiStream(String columnName,
    java.io.InputStream x,
    int length) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.io.InputStream} object.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value; must be a {@code java.io.InputStream}
     *          containing {@code BINARY}, {@code VARBINARY}, or
     *          {@code LONGVARBINARY} data
     * @param length the length of the stream in bytes
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, (3) the data
     *            in the stream is not binary, or (4) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.io.Reader} object.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param reader the new column value; must be a
     * {@code java.io.Reader} containing {@code BINARY},
     * {@code VARBINARY}, {@code LONGVARBINARY}, {@code CHAR},
     * {@code VARCHAR}, or {@code LONGVARCHAR} data
     * @param length the length of the stream in characters
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, (3) the data
     *            in the stream is not a binary or character type, or (4) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateCharacterStream(String columnName,
    java.io.Reader reader,
    int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Object} value.  The {@code scale} parameter
     * indicates the number of digits to the right of the decimal point
     * and is ignored if the new column value is not a type that will be
     *  mapped to an SQL {@code DECIMAL} or {@code NUMERIC} value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @param scale the number of digits to the right of the decimal point (for
     *              {@code DECIMAL} and {@code NUMERIC} types only)
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateObject(String columnName, Object x, int scale) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code Object} value.
     * <P>
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param x the new column value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateObject(String columnName, Object x) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Inserts the contents of this {@code CachedRowSetImpl} object's insert
     * row into this rowset immediately following the current row.
     * If the current row is the
     * position after the last row or before the first row, the new row will
     * be inserted at the end of the rowset.  This method also notifies
     * listeners registered with this rowset that the row has changed.
     * <P>
     * The cursor must be on the insert row when this method is called.
     *
     * @throws SQLException if (1) the cursor is not on the insert row,
     *            (2) one or more of the non-nullable columns in the insert
     *            row has not been given a value, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void insertRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Marks the current row of this {@code CachedRowSetImpl} object as
     * updated and notifies listeners registered with this rowset that the
     * row has changed.
     * <P>
     * This method  cannot be called when the cursor is on the insert row, and
     * it should be called before the cursor moves to another row.  If it is
     * called after the cursor moves to another row, this method has no effect,
     * and the updates made before the cursor moved will be lost.
     *
     * @throws SQLException if the cursor is on the insert row or this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Deletes the current row from this {@code CachedRowSetImpl} object and
     * notifies listeners registered with this rowset that a row has changed.
     * This method cannot be called when the cursor is on the insert row.
     * <P>
     * This method marks the current row as deleted, but it does not delete
     * the row from the underlying data source.  The method
     * {@code acceptChanges} must be called to delete the row in
     * the data source.
     *
     * @throws SQLException if (1) this method is called when the cursor
     *            is on the insert row, before the first row, or after the
     *            last row or (2) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void deleteRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the current row with its original value and marks the row as
     * not updated, thus undoing any changes made to the row since the
     * last call to the methods {@code updateRow} or {@code deleteRow}.
     * This method should be called only when the cursor is on a row in
     * this rowset.
     *
     * @throws SQLException if the cursor is on the insert row, before the
     *            first row, or after the last row
     */
    public void refreshRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Rolls back any updates made to the current row of this
     * {@code CachedRowSetImpl} object and notifies listeners that
     * a row has changed.  To have an effect, this method
     * must be called after an {@code updateXXX} method has been
     * called and before the method {@code updateRow} has been called.
     * If no updates have been made or the method {@code updateRow}
     * has already been called, this method has no effect.
     *
     * @throws SQLException if the cursor is on the insert row, before the
     *            first row, or after the last row
     */
    public void cancelRowUpdates() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves the cursor for this {@code CachedRowSetImpl} object
     * to the insert row.  The current row in the rowset is remembered
     * while the cursor is on the insert row.
     * <P>
     * The insert row is a special row associated with an updatable
     * rowset.  It is essentially a buffer where a new row may
     * be constructed by calling the appropriate {@code updateXXX}
     * methods to assign a value to each column in the row.  A complete
     * row must be constructed; that is, every column that is not nullable
     * must be assigned a value.  In order for the new row to become part
     * of this rowset, the method {@code insertRow} must be called
     * before the cursor is moved back to the rowset.
     * <P>
     * Only certain methods may be invoked while the cursor is on the insert
     * row; many methods throw an exception if they are called while the
     * cursor is there.  In addition to the {@code updateXXX}
     * and {@code insertRow} methods, only the {@code getXXX} methods
     * may be called when the cursor is on the insert row.  A {@code getXXX}
     * method should be called on a column only after an {@code updateXXX}
     * method has been called on that column; otherwise, the value returned is
     * undetermined.
     *
     * @throws SQLException if this {@code CachedRowSetImpl} object is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void moveToInsertRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Moves the cursor for this {@code CachedRowSetImpl} object to
     * the current row.  The current row is the row the cursor was on
     * when the method {@code moveToInsertRow} was called.
     * <P>
     * Calling this method has no effect unless it is called while the
     * cursor is on the insert row.
     *
     * @throws SQLException if an error occurs
     */
    public void moveToCurrentRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns {@code null}.
     *
     * @return {@code null}
     * @throws SQLException if an error occurs
     */
    public Statement getStatement() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as an {@code Object} in
     * the Java programming language, using the given
     * {@code java.util.Map} object to custom map the value if
     * appropriate.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param map a {@code java.util.Map} object showing the mapping
     *            from SQL type names to classes in the Java programming
     *            language
     * @return an {@code Object} representing the SQL value
     * @throws SQLException if the given column index is out of bounds or
     *            the cursor is not on one of this rowset's rows or its
     *            insert row
     */
    public Object getObject(int columnIndex,
                            java.util.Map<String,Class<?>> map)
          throws SQLException
    {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Ref} object
     * in the Java programming language.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return a {@code Ref} object representing an SQL{@code  REF} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL {@code REF} value
     * @see #getRef(String)
     */
    public Ref getRef(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Blob} object
     * in the Java programming language.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return a {@code Blob} object representing an SQL {@code BLOB} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL {@code BLOB} value
     * @see #getBlob(String)
     */
    public Blob getBlob(int columnIndex) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Clob} object
     * in the Java programming language.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return a {@code Clob} object representing an SQL {@code CLOB} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL {@code CLOB} value
     * @see #getClob(String)
     */
    public Clob getClob(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as an {@code Array} object
     * in the Java programming language.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @return an {@code Array} object representing an SQL
     *         {@code ARRAY} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) the designated column does not store an
     *            SQL {@code ARRAY} value
     * @see #getArray(String)
     */
    public Array getArray(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as an {@code Object} in
     * the Java programming language, using the given
     * {@code java.util.Map} object to custom map the value if
     * appropriate.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param map a {@code java.util.Map} object showing the mapping
     *        from SQL type names to classes in the Java programming
     *        language
     * @return an {@code Object} representing the SQL value
     * @throws SQLException if the given column name is not the name of
     *         a column in this rowset or the cursor is not on one of
     *         this rowset's rows or its insert row
     */
    public Object getObject(String columnName,
                            java.util.Map<String,Class<?>> map)
    throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Ref} object
     * in the Java programming language.
     *
     * @param colName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return a {@code Ref} object representing an SQL{@code  REF} value
     * @throws SQLException  if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the column value
     *            is not an SQL {@code REF} value
     * @see #getRef(int)
     */
    public Ref getRef(String colName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Blob} object
     * in the Java programming language.
     *
     * @param colName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return a {@code Blob} object representing an SQL {@code BLOB} value
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code BLOB} value
     * @see #getBlob(int)
     */
    public Blob getBlob(String colName) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code Clob} object
     * in the Java programming language.
     *
     * @param colName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return a {@code Clob} object representing an SQL
     *         {@code CLOB} value
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code CLOB} value
     * @see #getClob(int)
     */
    public Clob getClob(String colName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as an {@code Array} object
     * in the Java programming language.
     *
     * @param colName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @return an {@code Array} object representing an SQL
     *         {@code ARRAY} value
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code ARRAY} value
     * @see #getArray(int)
     */
    public Array getArray(String colName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a {@code java.sql.Date}
     * object, using the given {@code Calendar} object to construct an
     * appropriate millisecond value for the date.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code DATE} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a {@code java.sql.Date}
     * object, using the given {@code Calendar} object to construct an
     * appropriate millisecond value for the date.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code DATE} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a {@code java.sql.Time}
     * object, using the given {@code Calendar} object to construct an
     * appropriate millisecond value for the date.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code TIME} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a {@code java.sql.Time}
     * object, using the given {@code Calendar} object to construct an
     * appropriate millisecond value for the date.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code TIME} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a {@code java.sql.Timestamp}
     * object, using the given {@code Calendar} object to construct an
     * appropriate millisecond value for the date.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in the rowset
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code TIME} or
     *            {@code TIMESTAMP} value
     */
    public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in the current row
     * of this {@code CachedRowSetImpl} object as a
     * {@code java.sql.Timestamp} object, using the given
     * {@code Calendar} object to construct an appropriate
     * millisecond value for the date.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param cal the {@code java.util.Calendar} object to use in
     *            constructing the date
     * @return the column value; if the value is SQL {@code NULL},
     *         the result is {@code null}
     * @throws SQLException if (1) the given column name is not the name of
     *            a column in this rowset, (2) the cursor is not on one of
     *            this rowset's rows or its insert row, or (3) the designated
     *            column does not store an SQL {@code DATE},
     *            {@code TIME}, or {@code TIMESTAMP} value
     */
    public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /*
     * RowSetInternal Interface
     */

    /**
     * Retrieves the {@code Connection} object passed to this
     * {@code CachedRowSetImpl} object.  This connection may be
     * used to populate this rowset with data or to write data back
     * to its underlying data source.
     *
     * @return the {@code Connection} object passed to this rowset;
     *         may be {@code null} if there is no connection
     * @throws SQLException if an error occurs
     */
    public Connection getConnection() throws SQLException{
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the metadata for this {@code CachedRowSetImpl} object
     * with the given {@code RowSetMetaData} object.
     *
     * @param md a {@code RowSetMetaData} object instance containing
     *            metadata about the columns in the rowset
     * @throws SQLException if invalid meta data is supplied to the
     *            rowset
     */
    public void setMetaData(RowSetMetaData md) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns a result set containing the original value of the rowset. The
     * original value is the state of the {@code CachedRowSetImpl} after the
     * last population or synchronization (whichever occurred most recently) with
     * the data source.
     * <p>
     * The cursor is positioned before the first row in the result set.
     * Only rows contained in the result set returned by {@code getOriginal()}
     * are said to have an original value.
     *
     * @return the original result set of the rowset
     * @throws SQLException if an error occurs produce the
     *           {@code ResultSet} object
     */
    public ResultSet getOriginal() throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Returns a result set containing the original value of the current
     * row only.
     * The original value is the state of the {@code CachedRowSetImpl} after
     * the last population or synchronization (whichever occurred most recently)
     * with the data source.
     *
     * @return the original result set of the row
     * @throws SQLException if there is no current row
     * @see #setOriginalRow
     */
    public ResultSet getOriginalRow() throws SQLException {
        throw new UnsupportedOperationException();

    }

    /**
     * Marks the current row in this rowset as being an original row.
     *
     * @throws SQLException if there is no current row
     * @see #getOriginalRow
     */
    public void setOriginalRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Marks all rows in this rowset as being original rows. Any updates
     * made to the rows become the original values for the rowset.
     * Calls to the method {@code setOriginal} cannot be reversed.
     *
     * @throws SQLException if an error occurs
     */
    public void setOriginal() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns an identifier for the object (table) that was used to create this
     * rowset.
     *
     * @return a {@code String} object that identifies the table from
     *         which this {@code CachedRowSetImpl} object was derived
     * @throws SQLException if an error occurs
     */
    public String getTableName() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the identifier for the table from which this rowset was derived
     * to the given table name.
     *
     * @param tabName a {@code String} object that identifies the
     *          table from which this {@code CachedRowSetImpl} object
     *          was derived
     * @throws SQLException if an error occurs
     */
    public void setTableName(String tabName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Returns the columns that make a key to uniquely identify a
     * row in this {@code CachedRowSetImpl} object.
     *
     * @return an array of column numbers that constitutes a primary
     *           key for this rowset. This array should be empty
     *           if no column is representitive of a primary key
     * @throws SQLException if the rowset is empty or no columns
     *           are designated as primary keys
     * @see #setKeyColumns
     */
    public int[] getKeyColumns() throws SQLException {
        throw new UnsupportedOperationException();
    }


    /**
     * Sets this {@code CachedRowSetImpl} object's
     * {@code keyCols} field with the given array of column
     * numbers, which forms a key for uniquely identifying a row
     * in this rowset.
     *
     * @param keys an array of {@code int} indicating the
     *        columns that form a primary key for this
     *        {@code CachedRowSetImpl} object; every
     *        element in the array must be greater than
     *        {@code 0} and less than or equal to the number
     *        of columns in this rowset
     * @throws SQLException if any of the numbers in the
     *            given array is not valid for this rowset
     * @see #getKeyColumns
     */
    public void setKeyColumns(int [] keys) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param ref the new column {@code java.sql.Ref} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *        (2) the cursor is not on one of this rowset's rows or its
     *        insert row, or (3) this rowset is
     *        {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param ref the new column {@code java.sql.Ref} value
     * @throws SQLException if (1) the given column name does not match the
     *        name of a column in this rowset, (2) the cursor is not on
     *        one of this rowset's rows or its insert row, or (3) this
     *        rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param c the new column {@code Clob} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *        (2) the cursor is not on one of this rowset's rows or its
     *        insert row, or (3) this rowset is
     *        {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateClob(int columnIndex, Clob c) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code double} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param c the new column {@code Clob} value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateClob(String columnName, Clob c) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.sql.Blob} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param b the new column {@code Blob} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBlob(int columnIndex, Blob b) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.sql.Blob } value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param b the new column {@code Blob} value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateBlob(String columnName, Blob b) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.sql.Array} values.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnIndex the first column is {@code 1}, the second
     *        is {@code 2}, and so on; must be {@code 1} or larger
     *        and equal to or less than the number of columns in this rowset
     * @param a the new column {@code Array} value
     * @throws SQLException if (1) the given column index is out of bounds,
     *            (2) the cursor is not on one of this rowset's rows or its
     *            insert row, or (3) this rowset is
     *            {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateArray(int columnIndex, Array a) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated column in either the current row or the insert
     * row of this {@code CachedRowSetImpl} object with the given
     * {@code java.sql.Array} value.
     *
     * This method updates a column value in either the current row or
     * the insert row of this rowset, but it does not update the
     * database.  If the cursor is on a row in the rowset, the
     * method {@link #updateRow} must be called to update the database.
     * If the cursor is on the insert row, the method {@link #insertRow}
     * must be called, which will insert the new row into both this rowset
     * and the database. Both of these methods must be called before the
     * cursor moves to another row.
     *
     * @param columnName a {@code String} object that must match the
     *        SQL name of a column in this rowset, ignoring case
     * @param a the new column {@code Array} value
     * @throws SQLException if (1) the given column name does not match the
     *            name of a column in this rowset, (2) the cursor is not on
     *            one of this rowset's rows or its insert row, or (3) this
     *            rowset is {@code ResultSet.CONCUR_READ_ONLY}
     */
    public void updateArray(String columnName, Array a) throws SQLException {
        throw new UnsupportedOperationException();
    }


    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code java.net.URL} object
     * in the Java programming language.
     *
     * @return a java.net.URL object containing the resource reference described by
     * the URL
     * @throws SQLException if (1) the given column index is out of bounds,
     * (2) the cursor is not on one of this rowset's rows or its
     * insert row, or (3) the designated column does not store an
     * SQL {@code DATALINK} value.
     * @see #getURL(String)
     */
    public java.net.URL getURL(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the value of the designated column in this
     * {@code CachedRowSetImpl} object as a {@code java.net.URL} object
     * in the Java programming language.
     *
     * @return a java.net.URL object containing the resource reference described by
     * the URL
     * @throws SQLException if (1) the given column name not the name of a column
     * in this rowset, or
     * (2) the cursor is not on one of this rowset's rows or its
     * insert row, or (3) the designated column does not store an
     * SQL {@code DATALINK} value.
     * @see #getURL(int)
     */
    public java.net.URL getURL(String columnName) throws SQLException {
        throw new UnsupportedOperationException();

    }

    /**
     * The first warning reported by calls on this {@code CachedRowSetImpl}
     * object is returned. Subsequent {@code CachedRowSetImpl} warnings will
     * be chained to this {@code SQLWarning}. All {@code RowSetWarnings}
     * warnings are generated in the disconnected environment and remain a
     * separate warning chain to that provided by the {@code getWarnings}
     * method.
     *
     * <P>The warning chain is automatically cleared each time a new
     * row is read.
     *
     * <P><B>Note:</B> This warning chain only covers warnings caused
     * by {@code CachedRowSet} (and their child interface)
     * methods. All {@code SQLWarnings} can be obtained using the
     * {@code getWarnings} method which tracks warnings generated
     * by the underlying JDBC driver.
     * @return the first SQLWarning or null
     *
     */
    public RowSetWarning getRowSetWarnings() {
        throw new UnsupportedOperationException();
    }

     /**
     * Commits all changes performed by the {@code acceptChanges()}
     * methods
     *
     * @see java.sql.Connection#commit
     */
    public void commit() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Rolls back all changes performed by the {@code acceptChanges()}
     * methods
     *
     * @see java.sql.Connection#rollback
     */
    public void rollback() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Rolls back all changes performed by the {@code acceptChanges()}
     * to the last {@code Savepoint} transaction marker.
     *
     * @see java.sql.Connection#rollback(Savepoint)
     */
    public void rollback(Savepoint s) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Unsets the designated parameter to the given int array.
     * This was set using {@code setMatchColumn}
     * as the column which will form the basis of the join.
     * <P>
     * The parameter value unset by this method should be same
     * as was set.
     *
     * @param columnIdxes the index into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds or if the columnIdx is
     *  not the same as set using {@code setMatchColumn(int [])}
     */
    public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
         throw new UnsupportedOperationException();
    }

   /**
     * Unsets the designated parameter to the given String array.
     * This was set using {@code setMatchColumn}
     * as the column which will form the basis of the join.
     * <P>
     * The parameter value unset by this method should be same
     * as was set.
     *
     * @param columnIdxes the index into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds or if the columnName is
     *  not the same as set using {@code setMatchColumn(String [])}
     */
    public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the column name as {@code String} array
     * that was set using {@code setMatchColumn(String [])}
     * for this rowset.
     *
     * @return a {@code String} array object that contains the column names
     *         for the rowset which has this the match columns
     *
     * @throws SQLException if an error occurs or column name is not set
     */
    public String[] getMatchColumnNames() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Retrieves the column id as {@code int} array that was set using
     * {@code setMatchColumn(int [])} for this rowset.
     *
     * @return an {@code int} array object that contains the column ids
     *         for the rowset which has this as the match columns.
     *
     * @throws SQLException if an error occurs or column index is not set
     */
    public int[] getMatchColumnIndexes() throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated parameter to the given int array.
     * This forms the basis of the join for the
     * {@code JoinRowSet} as the column which will form the basis of the
     * join.
     * <P>
     * The parameter value set by this method is stored internally and
     * will be supplied as the appropriate parameter in this rowset's
     * command when the method {@code getMatchColumnIndexes} is called.
     *
     * @param columnIdxes the indexes into this rowset
     *        object's internal representation of parameter values; the
     *        first parameter is 0, the second is 1, and so on; must be
     *        {@code 0} or greater
     * @throws SQLException if an error occurs or the
     *                         parameter index is out of bounds
     */
    public void setMatchColumn(int[] columnIdxes) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated parameter to the given String array.
     *  This forms the basis of the join for the
     * {@code JoinRowSet} as the column which will form the basis of the
     * join.
     * <P>
     * The parameter value set by this method is stored internally and
     * will be supplied as the appropriate parameter in this rowset's
     * command when the method {@code getMatchColumn} is called.
     *
     * @param columnNames the name of the column into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds
     */
    public void setMatchColumn(String[] columnNames) throws SQLException {
        throw new UnsupportedOperationException();
    }


    /**
     * Sets the designated parameter to the given {@code int}
     * object.  This forms the basis of the join for the
     * {@code JoinRowSet} as the column which will form the basis of the
     * join.
     * <P>
     * The parameter value set by this method is stored internally and
     * will be supplied as the appropriate parameter in this rowset's
     * command when the method {@code getMatchColumn} is called.
     *
     * @param columnIdx the index into this rowset
     *        object's internal representation of parameter values; the
     *        first parameter is 0, the second is 1, and so on; must be
     *        {@code 0} or greater
     * @throws SQLException if an error occurs or the
     *                         parameter index is out of bounds
     */
    public void setMatchColumn(int columnIdx) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Sets the designated parameter to the given {@code String}
     * object.  This forms the basis of the join for the
     * {@code JoinRowSet} as the column which will form the basis of the
     * join.
     * <P>
     * The parameter value set by this method is stored internally and
     * will be supplied as the appropriate parameter in this rowset's
     * command when the method {@code getMatchColumn} is called.
     *
     * @param columnName the name of the column into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds
     */
    public void setMatchColumn(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Unsets the designated parameter to the given {@code int}
     * object.  This was set using {@code setMatchColumn}
     * as the column which will form the basis of the join.
     * <P>
     * The parameter value unset by this method should be same
     * as was set.
     *
     * @param columnIdx the index into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds or if the columnIdx is
     *  not the same as set using {@code setMatchColumn(int)}
     */
    public void unsetMatchColumn(int columnIdx) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Unsets the designated parameter to the given {@code String}
     * object.  This was set using {@code setMatchColumn}
     * as the column which will form the basis of the join.
     * <P>
     * The parameter value unset by this method should be same
     * as was set.
     *
     * @param columnName the index into this rowset
     *        object's internal representation of parameter values
     * @throws SQLException if an error occurs or the
     *  parameter index is out of bounds or if the columnName is
     *  not the same as set using {@code setMatchColumn(String)}
     */
    public void unsetMatchColumn(String columnName) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Notifies registered listeners that a RowSet object in the given RowSetEvent
     * object has populated a number of additional rows. The {@code numRows} parameter
     * ensures that this event will only be fired every {@code numRow}.
     * <p>
     * The source of the event can be retrieved with the method event.getSource.
     *
     * @param event a {@code RowSetEvent} object that contains the
     *     {@code RowSet} object that is the source of the events
     * @param numRows when populating, the number of rows interval on which the
     *     {@code CachedRowSet} populated should fire; the default value
     *     is zero; cannot be less than {@code fetchSize} or zero
     */
    public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
        throw new UnsupportedOperationException();
    }

    /**
     * Populates this {@code CachedRowSet} object with data from
     * the given {@code ResultSet} object. While related to the {@code populate(ResultSet)}
     * method, an additional parameter is provided to allow starting position within
     * the {@code ResultSet} from where to populate the CachedRowSet
     * instance.
     *
     * This method is an alternative to the method {@code execute}
     * for filling the rowset with data.  The method {@code populate}
     * does not require that the properties needed by the method
     * {@code execute}, such as the {@code command} property,
     * be set. This is true because the method {@code populate}
     * is given the {@code ResultSet} object from
     * which to get data and thus does not need to use the properties
     * required for setting up a connection and executing this
     * {@code CachedRowSetImpl} object's command.
     * <P>
     * After populating this rowset with data, the method
     * {@code populate} sets the rowset's metadata and
     * then sends a {@code RowSetChangedEvent} object
     * to all registered listeners prior to returning.
     *
     * @param data the {@code ResultSet} object containing the data
     *             to be read into this {@code CachedRowSetImpl} object
     * @param start the integer specifying the position in the
     *        {@code ResultSet} object to popultate the
     *        {@code CachedRowSetImpl} object.
     * @throws SQLException if an error occurs; or the max row setting is
     *          violated while populating the RowSet.Also id the start position
     *          is negative.
     * @see #execute
     */
     public void populate(ResultSet data, int start) throws SQLException{
        throw new UnsupportedOperationException();

     }

    /**
     * The nextPage gets the next page, that is a {@code CachedRowSetImpl} object
     * containing the number of rows specified by page size.
     * @return boolean value true indicating whether there are more pages to come and
     *         false indicating that this is the last page.
     * @throws SQLException if an error occurs or this called before calling populate.
     */
     public boolean nextPage() throws SQLException {
         throw new UnsupportedOperationException();
     }

    /**
     * This is the setter function for setting the size of the page, which specifies
     * how many rows have to be retrieved at a time.
     *
     * @param size which is the page size
     * @throws SQLException if size is less than zero or greater than max rows.
     */
     public void setPageSize (int size) throws SQLException {
        throw new UnsupportedOperationException();
     }

    /**
     * This is the getter function for the size of the page.
     *
     * @return an integer that is the page size.
     */
    public int getPageSize() {
        throw new UnsupportedOperationException();
    }


    /**
     * Retrieves the data present in the page prior to the page from where it is
     * called.
     * @return boolean value true if it retrieves the previous page, flase if it
     *         is on the first page.
     * @throws SQLException if it is called before populate is called or ResultSet
     *         is of type {@code ResultSet.TYPE_FORWARD_ONLY} or if an error
     *         occurs.
     */
    public boolean previousPage() throws SQLException {
       throw new UnsupportedOperationException();
    }

    /**
       * Updates the designated column with a character stream value, which will
       * have the specified number of bytes. The driver does the necessary conversion
       * from Java character format to the national character set in the database.
       * It is intended for use when updating NCHAR, NVARCHAR and LONGNVARCHAR columns.
       * The updater methods are used to update column values in the current row or
       * the insert row. The updater methods do not update the underlying database;
       * instead the updateRow or insertRow methods are called to update the database.
       *
       * @param columnIndex - the first column is 1, the second is 2, ...
       * @param x - the new column value
       * @param length - the length of the stream
       * @exception SQLException if a database access error occurs
       * @since 1.6
       */
       public void updateNCharacterStream(int columnIndex,
                            java.io.Reader x,
                            int length)
                            throws SQLException {
          throw new UnsupportedOperationException("Operation not yet supported");
       }

     /**
       * Updates the designated column with a character stream value, which will
       * have the specified number of bytes. The driver does the necessary conversion
       * from Java character format to the national character set in the database.
       * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
       * The updater methods are used to update column values in the current row or
       * the insert row. The updater methods do not update the underlying database;
       * instead the updateRow or insertRow methods are called to update the database.
       *
       * @param columnName - name of the Column
       * @param x - the new column value
       * @param length - the length of the stream
       * @exception SQLException if a database access error occurs
       * @since 1.6
       */
       public void updateNCharacterStream(String columnName,
                            java.io.Reader x,
                            int length)
                            throws SQLException {
          throw new UnsupportedOperationException("Operation not yet supported");
       }

      /**
       * This method re populates the resBundle
       * during the deserialization process
       *
       */
       private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
         // Default state initialization happens here
         ois.defaultReadObject();
         // Initialization of transient Res Bundle happens here .
         try {
            resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
         } catch(IOException ioe) {
             throw new RuntimeException(ioe);
         }

       }

       static final long serialVersionUID = -3345004441725080251L;
} //end class