Back to index...

	/*
	* Copyright (c) 2004, 2019, 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.
	*/
	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 beacuse {@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 a 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 is occurs rolling back the RowSet
	* state to the definied 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 a 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 interate 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 utilitizes 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 utilitizes 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 utilitizes 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 progamming 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 recommened
	* 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 recommened
	* 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 langugage.
	*
	* @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 columsn 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} connot 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
	* seperate 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 specifing 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 retrived 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

Back to index...