Back to index...

	/*
	* Copyright (c) 2003, 2012, 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;

	import java.sql.*;
	import javax.sql.*;
	import javax.naming.*;
	import java.io.*;
	import java.math.*;
	import java.util.*;

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

	/**
	* The standard implementation of the <code>JoinRowSet</code>
	* interface providing an SQL <code>JOIN</code> between <code>RowSet</code>
	* objects.
	* <P>
	* The implementation provides an ANSI-style <code>JOIN</code> providing an
	* inner join between two tables. Any unmatched rows in either table of the
	* join are discarded.
	* <p>
	* Typically, a <code>JoinRowSet</code> implementation is leveraged by
	* <code>RowSet</code> instances that are in a disconnected environment and
	* thus do not have the luxury of an open connection to the data source to
	* establish logical relationships between themselves. In other words, it is
	* largely <code>CachedRowSet</code> objects and implementations derived from
	* the <code>CachedRowSet</code> interface that will use the <code>JoinRowSetImpl</code>
	* implementation.
	*
	* @author Amit Handa, Jonathan Bruce
	*/
	public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
	/**
	* A <code>Vector</code> object that contains the <code>RowSet</code> objects
	* that have been added to this <code>JoinRowSet</code> object.
	*/
	private Vector<CachedRowSetImpl> vecRowSetsInJOIN;

	/**
	* The <code>CachedRowSet</code> object that encapsulates this
	* <code>JoinRowSet</code> object.
	* When <code>RowSet</code> objects are added to this <code>JoinRowSet</code>
	* object, they are also added to <i>crsInternal</i> to form the same kind of
	* SQL <code>JOIN</code>. As a result, methods for making updates to this
	* <code>JoinRowSet</code> object can use <i>crsInternal</i> methods in their
	* implementations.
	*/
	private CachedRowSetImpl crsInternal;

	/**
	* A <code>Vector</code> object containing the types of join that have been set
	* for this <code>JoinRowSet</code> object.
	* The last join type set forms the basis of succeeding joins.
	*/
	private Vector<Integer> vecJoinType;

	/**
	* A <code>Vector</code> object containing the names of all the tables entering
	* the join.
	*/
	private Vector<String> vecTableNames;

	/**
	* An <code>int</code> that indicates the column index of the match column.
	*/
	private int iMatchKey;

	/**
	* A <code>String</code> object that stores the name of the match column.
	*/
	private String strMatchKey ;

	/**
	* An array of <code>boolean</code> values indicating the types of joins supported
	* by this <code>JoinRowSet</code> implementation.
	*/
	boolean[] supportedJOINs;

	/**
	* The <code>WebRowSet</code> object that encapsulates this <code>JoinRowSet</code>
	* object. This <code>WebRowSet</code> object allows this <code>JoinRowSet</code>
	* object to leverage the properties and methods of a <code>WebRowSet</code>
	* object.
	*/
	private WebRowSet wrs;


	/**
	* Constructor for <code>JoinRowSetImpl</code> class. Configures various internal data
	* structures to provide mechanisms required for <code>JoinRowSet</code> interface
	* implementation.
	*
	* @throws SQLException if an error occurs in instantiating an instance of
	* <code>JoinRowSetImpl</code>
	*/
	public JoinRowSetImpl() throws SQLException {

	vecRowSetsInJOIN = new Vector<CachedRowSetImpl>();
	crsInternal = new CachedRowSetImpl();
	vecJoinType = new Vector<Integer>();
	vecTableNames = new Vector<String>();
	iMatchKey = -1;
	strMatchKey = null;
	supportedJOINs =
	new boolean[] {false, true, false, false, false};
	try {
	resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
	} catch(IOException ioe) {
	throw new RuntimeException(ioe);
	}

	}

	/**
	* Adds the given <code>RowSet</code> object to this
	* <code>JoinRowSet</code> object. If this
	* rowset is the first to be added to the <code>JoinRowSet</code>
	* object, it forms the basis for the <code>JOIN</code>
	* relationships to be formed.
	* <p>
	* This method should be used when the given <code>RowSet</code> object
	* already has a match column set.
	*
	* @param rowset the <code>RowSet</code> object that implements the
	* <code>Joinable</code> interface and is to be added
	* to this <code>JoinRowSet</code> object
	* @throws SQLException if an empty <code>RowSet</code> is added to the to the
	* <code>JoinRowSet</code>; if a match column is not set; or if an
	* additional <code>RowSet</code> violates the active <code>JOIN</code>
	* @see CachedRowSet#setMatchColumn
	*/
	public void addRowSet(Joinable rowset) throws SQLException {
	boolean boolColId, boolColName;

	boolColId = false;
	boolColName = false;
	CachedRowSetImpl cRowset;

	if(!(rowset instanceof RowSet)) {
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notinstance").toString());
	}

	if(rowset instanceof JdbcRowSetImpl ) {
	cRowset = new CachedRowSetImpl();
	cRowset.populate((RowSet)rowset);
	if(cRowset.size() == 0){
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.emptyrowset").toString());
	}


	try {
	int matchColumnCount = 0;
	for(int i=0; i< rowset.getMatchColumnIndexes().length; i++) {
	if(rowset.getMatchColumnIndexes()[i] != -1)
	++ matchColumnCount;
	else
	break;
	}
	int[] pCol = new int[matchColumnCount];
	for(int i=0; i<matchColumnCount; i++)
	pCol[i] = rowset.getMatchColumnIndexes()[i];
	cRowset.setMatchColumn(pCol);
	} catch(SQLException sqle) {

	}

	} else {
	cRowset = (CachedRowSetImpl)rowset;
	if(cRowset.size() == 0){
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.emptyrowset").toString());
	}
	}

	// Either column id or column name will be set
	// If both not set throw exception.

	try {
	iMatchKey = (cRowset.getMatchColumnIndexes())[0];
	} catch(SQLException sqle) {
	//if not set catch the exception but do nothing now.
	boolColId = true;
	}

	try {
	strMatchKey = (cRowset.getMatchColumnNames())[0];
	} catch(SQLException sqle) {
	//if not set catch the exception but do nothing now.
	boolColName = true;
	}

	if(boolColId && boolColName) {
	// neither setter methods have been used to set
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.matchnotset").toString());
	} else {
	//if(boolColId \|\| boolColName)
	// either of the setter methods have been set.
	if(boolColId){
	//
	ArrayList<Integer> indices = new ArrayList<>();
	for(int i=0;i<cRowset.getMatchColumnNames().length;i++) {
	if( (strMatchKey = (cRowset.getMatchColumnNames())[i]) != null) {
	iMatchKey = cRowset.findColumn(strMatchKey);
	indices.add(iMatchKey);
	}
	else
	break;
	}
	int[] indexes = new int[indices.size()];
	for(int i=0; i<indices.size();i++)
	indexes[i] = indices.get(i);
	cRowset.setMatchColumn(indexes);
	// Set the match column here because join will be
	// based on columnId,
	// (nested for loop in initJOIN() checks for equality
	// based on columnIndex)
	} else {
	//do nothing, iMatchKey is set.
	}
	// Now both iMatchKey and strMatchKey have been set pointing
	// to the same column
	}

	// Till first rowset setJoinType may not be set because
	// default type is JoinRowSet.INNER_JOIN which should
	// be set and for subsequent additions of rowset, if not set
	// keep on adding join type as JoinRowSet.INNER_JOIN
	// to vecJoinType.

	initJOIN(cRowset);
	}

	/**
	* Adds the given <code>RowSet</code> object to the <code>JOIN</code> relation
	* and sets the designated column as the match column.
	* If the given <code>RowSet</code>
	* object is the first to be added to this <code>JoinRowSet</code>
	* object, it forms the basis of the <code>JOIN</code> relationship to be formed
	* when other <code>RowSet</code> objects are added .
	* <P>
	* This method should be used when the given <code>RowSet</code> object
	* does not already have a match column set.
	*
	* @param rowset a <code>RowSet</code> object to be added to
	* the <code>JOIN</code> relation; must implement the <code>Joinable</code>
	* interface
	* @param columnIdx an <code>int</code> giving the index of the column to be set as
	* the match column
	* @throws SQLException if (1) an empty <code>RowSet</code> object is added to this
	* <code>JoinRowSet</code> object, (2) a match column has not been set,
	* or (3) the <code>RowSet</code> object being added violates the active
	* <code>JOIN</code>
	* @see CachedRowSet#unsetMatchColumn
	*/
	public void addRowSet(RowSet rowset, int columnIdx) throws SQLException {
	//passing the rowset as well as the columnIdx to form the joinrowset.

	((CachedRowSetImpl)rowset).setMatchColumn(columnIdx);

	addRowSet((Joinable)rowset);
	}

	/**
	* Adds the given <code>RowSet</code> object to the <code>JOIN</code> relationship
	* and sets the designated column as the match column. If the given
	* <code>RowSet</code>
	* object is the first to be added to this <code>JoinRowSet</code>
	* object, it forms the basis of the <code>JOIN</code> relationship to be formed
	* when other <code>RowSet</code> objects are added .
	* <P>
	* This method should be used when the given <code>RowSet</code> object
	* does not already have a match column set.
	*
	* @param rowset a <code>RowSet</code> object to be added to
	* the <code>JOIN</code> relation
	* @param columnName a <code>String</code> object giving the name of the column
	* to be set as the match column; must implement the <code>Joinable</code>
	* interface
	* @throws SQLException if (1) an empty <code>RowSet</code> object is added to this
	* <code>JoinRowSet</code> object, (2) a match column has not been set,
	* or (3) the <code>RowSet</code> object being added violates the active
	* <code>JOIN</code>
	*/
	public void addRowSet(RowSet rowset, String columnName) throws SQLException {
	//passing the rowset as well as the columnIdx to form the joinrowset.
	((CachedRowSetImpl)rowset).setMatchColumn(columnName);
	addRowSet((Joinable)rowset);
	}

	/**
	* Adds the given <code>RowSet</code> objects to the <code>JOIN</code> relationship
	* and sets the designated columns as the match columns. If the first
	* <code>RowSet</code> object in the array of <code>RowSet</code> objects
	* is the first to be added to this <code>JoinRowSet</code>
	* object, it forms the basis of the <code>JOIN</code> relationship to be formed
	* when other <code>RowSet</code> objects are added.
	* <P>
	* The first <code>int</code>
	* in <i>columnIdx</i> is used to set the match column for the first
	* <code>RowSet</code> object in <i>rowset</i>, the second <code>int</code>
	* in <i>columnIdx</i> is used to set the match column for the second
	* <code>RowSet</code> object in <i>rowset</i>, and so on.
	* <P>
	* This method should be used when the given <code>RowSet</code> objects
	* do not already have match columns set.
	*
	* @param rowset an array of <code>RowSet</code> objects to be added to
	* the <code>JOIN</code> relation; each <code>RowSet</code> object must
	* implement the <code>Joinable</code> interface
	* @param columnIdx an array of <code>int</code> values designating the columns
	* to be set as the
	* match columns for the <code>RowSet</code> objects in <i>rowset</i>
	* @throws SQLException if the number of <code>RowSet</code> objects in
	* <i>rowset</i> is not equal to the number of <code>int</code> values
	* in <i>columnIdx</i>
	*/
	public void addRowSet(RowSet[] rowset,
	int[] columnIdx) throws SQLException {
	//validate if length of rowset array is same as length of int array.
	if(rowset.length != columnIdx.length) {
	throw new SQLException
	(resBundle.handleGetObject("joinrowsetimpl.numnotequal").toString());
	} else {
	for(int i=0; i< rowset.length; i++) {
	((CachedRowSetImpl)rowset[i]).setMatchColumn(columnIdx[i]);
	addRowSet((Joinable)rowset[i]);
	} //end for
	} //end if

	}


	/**
	* Adds the given <code>RowSet</code> objects to the <code>JOIN</code> relationship
	* and sets the designated columns as the match columns. If the first
	* <code>RowSet</code> object in the array of <code>RowSet</code> objects
	* is the first to be added to this <code>JoinRowSet</code>
	* object, it forms the basis of the <code>JOIN</code> relationship to be formed
	* when other <code>RowSet</code> objects are added.
	* <P>
	* The first <code>String</code> object
	* in <i>columnName</i> is used to set the match column for the first
	* <code>RowSet</code> object in <i>rowset</i>, the second <code>String</code>
	* object in <i>columnName</i> is used to set the match column for the second
	* <code>RowSet</code> object in <i>rowset</i>, and so on.
	* <P>
	* This method should be used when the given <code>RowSet</code> objects
	* do not already have match columns set.
	*
	* @param rowset an array of <code>RowSet</code> objects to be added to
	* the <code>JOIN</code> relation; each <code>RowSet</code> object must
	* implement the <code>Joinable</code> interface
	* @param columnName an array of <code>String</code> objects designating the columns
	* to be set as the
	* match columns for the <code>RowSet</code> objects in <i>rowset</i>
	* @throws SQLException if the number of <code>RowSet</code> objects in
	* <i>rowset</i> is not equal to the number of <code>String</code> objects
	* in <i>columnName</i>, an empty <code>JdbcRowSet</code> is added to the
	* <code>JoinRowSet</code>, if a match column is not set,
	* or one or the <code>RowSet</code> objects in <i>rowset</i> violates the
	* active <code>JOIN</code>
	*/
	public void addRowSet(RowSet[] rowset,
	String[] columnName) throws SQLException {
	//validate if length of rowset array is same as length of int array.

	if(rowset.length != columnName.length) {
	throw new SQLException
	(resBundle.handleGetObject("joinrowsetimpl.numnotequal").toString());
	} else {
	for(int i=0; i< rowset.length; i++) {
	((CachedRowSetImpl)rowset[i]).setMatchColumn(columnName[i]);
	addRowSet((Joinable)rowset[i]);
	} //end for
	} //end if

	}

	/**
	* Returns a Collection of the <code>RowSet</code> object instances
	* currently residing with the instance of the <code>JoinRowSet</code>
	* object instance. This should return the 'n' number of RowSet contained
	* within the JOIN and maintain any updates that have occoured while in
	* this union.
	*
	* @return A <code>Collection</code> of the added <code>RowSet</code>
	* object instances
	* @throws SQLException if an error occours generating a collection
	* of the originating RowSets contained within the JOIN.
	*/
	@SuppressWarnings("rawtypes")
	public Collection getRowSets() throws SQLException {
	return vecRowSetsInJOIN;
	}

	/**
	* Returns a string array of the RowSet names currently residing
	* with the <code>JoinRowSet</code> object instance.
	*
	* @return a string array of the RowSet names
	* @throws SQLException if an error occours retrieving the RowSet names
	* @see CachedRowSet#setTableName
	*/
	public String[] getRowSetNames() throws SQLException {
	Object [] arr = vecTableNames.toArray();
	String []strArr = new String[arr.length];

	for( int i = 0;i < arr.length; i++) {
	strArr[i] = arr[i].toString();
	}

	return strArr;
	}

	/**
	* Creates a separate <code>CachedRowSet</code> object that contains the data
	* in this <code>JoinRowSet</code> object.
	* <P>
	* If any updates or modifications have been applied to this <code>JoinRowSet</code>
	* object, the <code>CachedRowSet</code> object returned by this method will
	* not be able to persist
	* the changes back to the originating rows and tables in the
	* data source because the data may be from different tables. The
	* <code>CachedRowSet</code> instance returned should not
	* contain modification data, such as whether a row has been updated or what the
	* original values are. Also, the <code>CachedRowSet</code> object should clear
	* its properties pertaining to
	* its originating SQL statement. An application should reset the
	* SQL statement using the <code>RowSet.setCommand</code> method.
	* <p>
	* To persist changes back to the data source, the <code>JoinRowSet</code> object
	* calls the method <code>acceptChanges</code>. Implementations
	* can leverage the internal data and update tracking in their
	* implementations to interact with the <code>SyncProvider</code> to persist any
	* changes.
	*
	* @return a <code>CachedRowSet</code> object containing the contents of this
	* <code>JoinRowSet</code> object
	* @throws SQLException if an error occurs assembling the <code>CachedRowSet</code>
	* object
	* @see javax.sql.RowSet
	* @see javax.sql.rowset.CachedRowSet
	* @see javax.sql.rowset.spi.SyncProvider
	*/
	public CachedRowSet toCachedRowSet() throws SQLException {
	return crsInternal;
	}

	/**
	* Returns <code>true</code> if this <code>JoinRowSet</code> object supports
	* an SQL <code>CROSS_JOIN</code> and <code>false</code> if it does not.
	*
	* @return <code>true</code> if the CROSS_JOIN is supported; <code>false</code>
	* otherwise
	*/
	public boolean supportsCrossJoin() {
	return supportedJOINs[JoinRowSet.CROSS_JOIN];
	}

	/**
	* Returns <code>true</code> if this <code>JoinRowSet</code> object supports
	* an SQL <code>INNER_JOIN</code> and <code>false</code> if it does not.
	*
	* @return true is the INNER_JOIN is supported; false otherwise
	*/
	public boolean supportsInnerJoin() {
	return supportedJOINs[JoinRowSet.INNER_JOIN];
	}

	/**
	* Returns <code>true</code> if this <code>JoinRowSet</code> object supports
	* an SQL <code>LEFT_OUTER_JOIN</code> and <code>false</code> if it does not.
	*
	* @return true is the LEFT_OUTER_JOIN is supported; false otherwise
	*/
	public boolean supportsLeftOuterJoin() {
	return supportedJOINs[JoinRowSet.LEFT_OUTER_JOIN];
	}

	/**
	* Returns <code>true</code> if this <code>JoinRowSet</code> object supports
	* an SQL <code>RIGHT_OUTER_JOIN</code> and <code>false</code> if it does not.
	*
	* @return true is the RIGHT_OUTER_JOIN is supported; false otherwise
	*/
	public boolean supportsRightOuterJoin() {
	return supportedJOINs[JoinRowSet.RIGHT_OUTER_JOIN];
	}

	/**
	* Returns <code>true</code> if this <code>JoinRowSet</code> object supports
	* an SQL <code>FULL_JOIN</code> and <code>false</code> if it does not.
	*
	* @return true is the FULL_JOIN is supported; false otherwise
	*/
	public boolean supportsFullJoin() {
	return supportedJOINs[JoinRowSet.FULL_JOIN];

	}

	/**
	* Sets the type of SQL <code>JOIN</code> that this <code>JoinRowSet</code>
	* object will use. This method
	* allows an application to adjust the type of <code>JOIN</code> imposed
	* on tables contained within this <code>JoinRowSet</code> object and to do it
	* on the fly. The last <code>JOIN</code> type set determines the type of
	* <code>JOIN</code> to be performed.
	* <P>
	* Implementations should throw an <code>SQLException</code> if they do
	* not support the given <code>JOIN</code> type.
	*
	* @param type one of the standard <code>JoinRowSet</code> constants
	* indicating the type of <code>JOIN</code>. Must be one of the
	* following:
	* <code>JoinRowSet.CROSS_JOIN</code>
	* <code>JoinRowSet.INNER_JOIN</code>
	* <code>JoinRowSet.LEFT_OUTER_JOIN</code>
	* <code>JoinRowSet.RIGHT_OUTER_JOIN</code>, or
	* <code>JoinRowSet.FULL_JOIN</code>
	* @throws SQLException if an unsupported <code>JOIN</code> type is set
	*/
	public void setJoinType(int type) throws SQLException {
	// The join which governs the join of two rowsets is the last
	// join set, using setJoinType

	if (type >= JoinRowSet.CROSS_JOIN && type <= JoinRowSet.FULL_JOIN) {
	if (type != JoinRowSet.INNER_JOIN) {
	// This 'if' will be removed after all joins are implemented.
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notsupported").toString());
	} else {
	Integer Intgr = Integer.valueOf(JoinRowSet.INNER_JOIN);
	vecJoinType.add(Intgr);
	}
	} else {
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notdefined").toString());
	} //end if
	}


	/**
	* This checks for a match column for
	* whether it exists or not.
	*
	* @param <code>CachedRowSet</code> object whose match column needs to be checked.
	* @throws SQLException if MatchColumn is not set.
	*/
	private boolean checkforMatchColumn(Joinable rs) throws SQLException {
	int[] i = rs.getMatchColumnIndexes();
	if (i.length <= 0) {
	return false;
	}
	return true;
	}

	/**
	* Internal initialization of <code>JoinRowSet</code>.
	*/
	private void initJOIN(CachedRowSet rowset) throws SQLException {
	try {

	CachedRowSetImpl cRowset = (CachedRowSetImpl)rowset;
	// Create a new CachedRowSet object local to this function.
	CachedRowSetImpl crsTemp = new CachedRowSetImpl();
	RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();

	/* The following 'if block' seems to be always going true.
	commenting this out for present

	if (!supportedJOINs[1]) {
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notsupported").toString());
	}

	*/

	if (vecRowSetsInJOIN.isEmpty() ) {

	// implies first cRowset to be added to the Join
	// simply add this as a CachedRowSet.
	// Also add it to the class variable of type vector
	// do not need to check "type" of Join but it should be set.
	crsInternal = (CachedRowSetImpl)rowset.createCopy();
	crsInternal.setMetaData((RowSetMetaDataImpl)cRowset.getMetaData());
	// metadata will also set the MatchColumn.

	vecRowSetsInJOIN.add(cRowset);

	} else {
	// At this point we are ready to add another rowset to 'this' object
	// Check the size of vecJoinType and vecRowSetsInJoin

	// If nothing is being set, internally call setJoinType()
	// to set to JoinRowSet.INNER_JOIN.

	// For two rowsets one (valid) entry should be there in vecJoinType
	// For three rowsets two (valid) entries should be there in vecJoinType

	// Maintain vecRowSetsInJoin = vecJoinType + 1


	if( (vecRowSetsInJOIN.size() - vecJoinType.size() ) == 2 ) {
	// we are going to add next rowset and setJoinType has not been set
	// recently, so set it to setJoinType() to JoinRowSet.INNER_JOIN.
	// the default join type

	setJoinType(JoinRowSet.INNER_JOIN);
	} else if( (vecRowSetsInJOIN.size() - vecJoinType.size() ) == 1 ) {
	// do nothing setjoinType() has been set by programmer
	}

	// Add the table names to the class variable of type vector.
	vecTableNames.add(crsInternal.getTableName());
	vecTableNames.add(cRowset.getTableName());
	// Now we have two rowsets crsInternal and cRowset which need
	// to be INNER JOIN'ED to form a new rowset
	// Compare table1.MatchColumn1.value1 == { table2.MatchColumn2.value1
	// ... upto table2.MatchColumn2.valueN }
	// ...
	// Compare table1.MatchColumn1.valueM == { table2.MatchColumn2.value1
	// ... upto table2.MatchColumn2.valueN }
	//
	// Assuming first rowset has M rows and second N rows.

	int rowCount2 = cRowset.size();
	int rowCount1 = crsInternal.size();

	// total columns in the new CachedRowSet will be sum of both -1
	// (common column)
	int matchColumnCount = 0;
	for(int i=0; i< crsInternal.getMatchColumnIndexes().length; i++) {
	if(crsInternal.getMatchColumnIndexes()[i] != -1)
	++ matchColumnCount;
	else
	break;
	}

	rsmd.setColumnCount
	(crsInternal.getMetaData().getColumnCount() +
	cRowset.getMetaData().getColumnCount() - matchColumnCount);

	crsTemp.setMetaData(rsmd);
	crsInternal.beforeFirst();
	cRowset.beforeFirst();
	for (int i = 1 ; i <= rowCount1 ; i++) {
	if(crsInternal.isAfterLast() ) {
	break;
	}
	if(crsInternal.next()) {
	cRowset.beforeFirst();
	for(int j = 1 ; j <= rowCount2 ; j++) {
	if( cRowset.isAfterLast()) {
	break;
	}
	if(cRowset.next()) {
	boolean match = true;
	for(int k=0; k<matchColumnCount; k++) {
	if (!crsInternal.getObject( crsInternal.getMatchColumnIndexes()[k]).equals
	(cRowset.getObject(cRowset.getMatchColumnIndexes()[k]))) {
	match = false;
	break;
	}
	}
	if (match) {

	int p;
	int colc = 0; // reset this variable everytime you loop
	// re create a JoinRowSet in crsTemp object
	crsTemp.moveToInsertRow();

	// create a new rowset crsTemp with data from first rowset
	for( p=1;
	p<=crsInternal.getMetaData().getColumnCount();p++) {

	match = false;
	for(int k=0; k<matchColumnCount; k++) {
	if (p == crsInternal.getMatchColumnIndexes()[k] ) {
	match = true;
	break;
	}
	}
	if ( !match ) {

	crsTemp.updateObject(++colc, crsInternal.getObject(p));
	// column type also needs to be passed.

	rsmd.setColumnName
	(colc, crsInternal.getMetaData().getColumnName(p));
	rsmd.setTableName(colc, crsInternal.getTableName());

	rsmd.setColumnType(p, crsInternal.getMetaData().getColumnType(p));
	rsmd.setAutoIncrement(p, crsInternal.getMetaData().isAutoIncrement(p));
	rsmd.setCaseSensitive(p, crsInternal.getMetaData().isCaseSensitive(p));
	rsmd.setCatalogName(p, crsInternal.getMetaData().getCatalogName(p));
	rsmd.setColumnDisplaySize(p, crsInternal.getMetaData().getColumnDisplaySize(p));
	rsmd.setColumnLabel(p, crsInternal.getMetaData().getColumnLabel(p));
	rsmd.setColumnType(p, crsInternal.getMetaData().getColumnType(p));
	rsmd.setColumnTypeName(p, crsInternal.getMetaData().getColumnTypeName(p));
	rsmd.setCurrency(p,crsInternal.getMetaData().isCurrency(p) );
	rsmd.setNullable(p, crsInternal.getMetaData().isNullable(p));
	rsmd.setPrecision(p, crsInternal.getMetaData().getPrecision(p));
	rsmd.setScale(p, crsInternal.getMetaData().getScale(p));
	rsmd.setSchemaName(p, crsInternal.getMetaData().getSchemaName(p));
	rsmd.setSearchable(p, crsInternal.getMetaData().isSearchable(p));
	rsmd.setSigned(p, crsInternal.getMetaData().isSigned(p));

	} else {
	// will happen only once, for that merged column pass
	// the types as OBJECT, if types not equal

	crsTemp.updateObject(++colc, crsInternal.getObject(p));

	rsmd.setColumnName(colc, crsInternal.getMetaData().getColumnName(p));
	rsmd.setTableName
	(colc, crsInternal.getTableName()+
	"#"+
	cRowset.getTableName());


	rsmd.setColumnType(p, crsInternal.getMetaData().getColumnType(p));
	rsmd.setAutoIncrement(p, crsInternal.getMetaData().isAutoIncrement(p));
	rsmd.setCaseSensitive(p, crsInternal.getMetaData().isCaseSensitive(p));
	rsmd.setCatalogName(p, crsInternal.getMetaData().getCatalogName(p));
	rsmd.setColumnDisplaySize(p, crsInternal.getMetaData().getColumnDisplaySize(p));
	rsmd.setColumnLabel(p, crsInternal.getMetaData().getColumnLabel(p));
	rsmd.setColumnType(p, crsInternal.getMetaData().getColumnType(p));
	rsmd.setColumnTypeName(p, crsInternal.getMetaData().getColumnTypeName(p));
	rsmd.setCurrency(p,crsInternal.getMetaData().isCurrency(p) );
	rsmd.setNullable(p, crsInternal.getMetaData().isNullable(p));
	rsmd.setPrecision(p, crsInternal.getMetaData().getPrecision(p));
	rsmd.setScale(p, crsInternal.getMetaData().getScale(p));
	rsmd.setSchemaName(p, crsInternal.getMetaData().getSchemaName(p));
	rsmd.setSearchable(p, crsInternal.getMetaData().isSearchable(p));
	rsmd.setSigned(p, crsInternal.getMetaData().isSigned(p));

	//don't do ++colc in the above statement
	} //end if
	} //end for


	// append the rowset crsTemp, with data from second rowset
	for(int q=1;
	q<= cRowset.getMetaData().getColumnCount();q++) {

	match = false;
	for(int k=0; k<matchColumnCount; k++) {
	if (q == cRowset.getMatchColumnIndexes()[k] ) {
	match = true;
	break;
	}
	}
	if ( !match ) {

	crsTemp.updateObject(++colc, cRowset.getObject(q));

	rsmd.setColumnName
	(colc, cRowset.getMetaData().getColumnName(q));
	rsmd.setTableName(colc, cRowset.getTableName());

	/**
	* This will happen for a special case scenario. The value of 'p'
	* will always be one more than the number of columns in the first
	* rowset in the join. So, for a value of 'q' which is the number of
	* columns in the second rowset that participates in the join.
	* So decrement value of 'p' by 1 else `p+q-1` will be out of range.
	**/

	//if((p+q-1) > ((crsInternal.getMetaData().getColumnCount()) +
	// (cRowset.getMetaData().getColumnCount()) - 1)) {
	// --p;
	//}
	rsmd.setColumnType(p+q-1, cRowset.getMetaData().getColumnType(q));
	rsmd.setAutoIncrement(p+q-1, cRowset.getMetaData().isAutoIncrement(q));
	rsmd.setCaseSensitive(p+q-1, cRowset.getMetaData().isCaseSensitive(q));
	rsmd.setCatalogName(p+q-1, cRowset.getMetaData().getCatalogName(q));
	rsmd.setColumnDisplaySize(p+q-1, cRowset.getMetaData().getColumnDisplaySize(q));
	rsmd.setColumnLabel(p+q-1, cRowset.getMetaData().getColumnLabel(q));
	rsmd.setColumnType(p+q-1, cRowset.getMetaData().getColumnType(q));
	rsmd.setColumnTypeName(p+q-1, cRowset.getMetaData().getColumnTypeName(q));
	rsmd.setCurrency(p+q-1,cRowset.getMetaData().isCurrency(q) );
	rsmd.setNullable(p+q-1, cRowset.getMetaData().isNullable(q));
	rsmd.setPrecision(p+q-1, cRowset.getMetaData().getPrecision(q));
	rsmd.setScale(p+q-1, cRowset.getMetaData().getScale(q));
	rsmd.setSchemaName(p+q-1, cRowset.getMetaData().getSchemaName(q));
	rsmd.setSearchable(p+q-1, cRowset.getMetaData().isSearchable(q));
	rsmd.setSigned(p+q-1, cRowset.getMetaData().isSigned(q));
	}
	else {
	--p;
	}
	}
	crsTemp.insertRow();
	crsTemp.moveToCurrentRow();

	} else {
	// since not equa12
	// so do nothing
	} //end if
	// bool1 = cRowset.next();
	}

	} // end inner for
	//bool2 = crsInternal.next();
	}

	} //end outer for
	crsTemp.setMetaData(rsmd);
	crsTemp.setOriginal();

	// Now the join is done.
	// Make crsInternal = crsTemp, to be ready for next merge, if at all.

	int[] pCol = new int[matchColumnCount];
	for(int i=0; i<matchColumnCount; i++)
	pCol[i] = crsInternal.getMatchColumnIndexes()[i];

	crsInternal = (CachedRowSetImpl)crsTemp.createCopy();

	// Because we add the first rowset as crsInternal to the
	// merged rowset, so pCol will point to the Match column.
	// until reset, am not sure we should set this or not(?)
	// if this is not set next inner join won't happen
	// if we explicitly do not set a set MatchColumn of
	// the new crsInternal.

	crsInternal.setMatchColumn(pCol);
	// Add the merged rowset to the class variable of type vector.
	crsInternal.setMetaData(rsmd);
	vecRowSetsInJOIN.add(cRowset);
	} //end if
	} catch(SQLException sqle) {
	// %%% Exception should not dump here:
	sqle.printStackTrace();
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.initerror").toString() + sqle);
	} catch (Exception e) {
	e.printStackTrace();
	throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.genericerr").toString() + e);
	}
	}

	/**
	* Return a SQL-like description of the <code>WHERE</code> clause being used
	* in a <code>JoinRowSet</code> object instance. An implementation can describe
	* the <code>WHERE</code> clause of the SQL <code>JOIN</code> by supplying a <code>SQL</code>
	* strings description of <code>JOIN</code> or provide a textual description to assist
	* applications using a <code>JoinRowSet</code>.
	*
	* @return whereClause a textual or SQL descripition of the logical
	* <code>WHERE</code> cluase used in the <code>JoinRowSet</code> instance
	* @throws SQLException if an error occurs in generating a representation
	* of the <code>WHERE</code> clause.
	*/
	public String getWhereClause() throws SQLException {

	String strWhereClause = "Select ";
	String whereClause;
	String tabName= "";
	String strTabName = "";
	int sz,cols;
	int j;
	CachedRowSetImpl crs;

	// get all the column(s) names from each rowset.
	// append them with their tablenames i.e. tableName.columnName
	// Select tableName1.columnName1,..., tableNameX.columnNameY
	// from tableName1,...tableNameX where
	// tableName1.(rowset1.getMatchColumnName()) ==
	// tableName2.(rowset2.getMatchColumnName()) + "and" +
	// tableNameX.(rowsetX.getMatchColumnName()) ==
	// tableNameZ.(rowsetZ.getMatchColumnName()));

	sz = vecRowSetsInJOIN.size();
	for(int i=0;i<sz; i++) {
	crs = vecRowSetsInJOIN.get(i);
	cols = crs.getMetaData().getColumnCount();
	tabName = tabName.concat(crs.getTableName());
	strTabName = strTabName.concat(tabName+", ");
	j = 1;
	while(j<cols) {

	strWhereClause = strWhereClause.concat
	(tabName+"."+crs.getMetaData().getColumnName(j++));
	strWhereClause = strWhereClause.concat(", ");
	} //end while
	} //end for


	// now remove the last ","
	strWhereClause = strWhereClause.substring
	(0, strWhereClause.lastIndexOf(','));

	// Add from clause
	strWhereClause = strWhereClause.concat(" from ");

	// Add the table names.
	strWhereClause = strWhereClause.concat(strTabName);

	//Remove the last ","
	strWhereClause = strWhereClause.substring
	(0, strWhereClause.lastIndexOf(','));

	// Add the where clause
	strWhereClause = strWhereClause.concat(" where ");

	// Get the match columns
	// rowset1.getMatchColumnName() == rowset2.getMatchColumnName()
	for(int i=0;i<sz; i++) {
	strWhereClause = strWhereClause.concat(
	vecRowSetsInJOIN.get(i).getMatchColumnNames()[0]);
	if(i%2!=0) {
	strWhereClause = strWhereClause.concat("=");
	} else {
	strWhereClause = strWhereClause.concat(" and");
	}
	strWhereClause = strWhereClause.concat(" ");
	}

	return strWhereClause;
	}


	/**
	* Moves the cursor down one row from its current position and
	* returns <code>true</code> if the new cursor position is a
	* valid row.
	* The cursor for a new <code>ResultSet</code> object is initially
	* positioned before the first row. The first call to the method
	* <code>next</code> 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</code> object's warning
	* chain is cleared when a new row is read.
	*
	* @return <code>true</code> if the new current row is valid;
	* <code>false</code> 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 {
	return crsInternal.next();
	}


	/**
	* Releases the current contents of this rowset, discarding outstanding
	* updates. The rowset contains no rows after the method
	* <code>release</code> is called. This method sends a
	* <code>RowSetChangedEvent</code> object to all registered listeners prior
	* to returning.
	*
	* @throws SQLException if an error occurs
	*/
	public void close() throws SQLException {
	crsInternal.close();
	}


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

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>String</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @throws SQLException if the given column index is out of bounds or
	* the cursor is not on a valid row
	*/
	public String getString(int columnIndex) throws SQLException {
	return crsInternal.getString(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>boolean</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>false</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public boolean getBoolean(int columnIndex) throws SQLException {
	return crsInternal.getBoolean(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>byte</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public byte getByte(int columnIndex) throws SQLException {
	return crsInternal.getByte(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>short</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public short getShort(int columnIndex) throws SQLException {
	return crsInternal.getShort(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>short</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public int getInt(int columnIndex) throws SQLException {
	return crsInternal.getInt(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>long</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public long getLong(int columnIndex) throws SQLException {
	return crsInternal.getLong(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>float</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public float getFloat(int columnIndex) throws SQLException {
	return crsInternal.getFloat(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>double</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>0</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public double getDouble(int columnIndex) throws SQLException {
	return crsInternal.getDouble(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.math.BigDecimal</code> object.
	* <P>
	* This method is deprecated; use the version of <code>getBigDecimal</code>
	* that does not take a scale parameter and returns a value with full
	* precision.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @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 {
	return crsInternal.getBigDecimal(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>byte array</code> value.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or the value to be
	* retrieved is not binary
	*/
	public byte[] getBytes(int columnIndex) throws SQLException {
	return crsInternal.getBytes(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.sql.Date</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @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 {
	return crsInternal.getDate(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.sql.Time</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @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 {
	return crsInternal.getTime(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.sql.Timestamp</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @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 {
	return crsInternal.getTimestamp(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.sql.Timestamp</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>, the
	* result is <code>null</code>
	* @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.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
	return crsInternal.getAsciiStream(columnIndex);
	}

	/**
	* 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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 {
	return crsInternal.getUnicodeStream(columnIndex);
	}

	/**
	* 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 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 0 for available() whether there is data
	* available or not.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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 NULL
	* then the result is null.
	* @throws SQLException if an error occurs
	*/
	public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
	return crsInternal.getBinaryStream(columnIndex);
	}

	// ColumnName methods

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>String</code> object.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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 String getString(String columnName) throws SQLException {
	return crsInternal.getString(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>boolean</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>false</code>
	* @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 boolean getBoolean(String columnName) throws SQLException {
	return crsInternal.getBoolean(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>byte</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 byte getByte(String columnName) throws SQLException {
	return crsInternal.getByte(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>short</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 short getShort(String columnName) throws SQLException {
	return crsInternal.getShort(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as an <code>int</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 int getInt(String columnName) throws SQLException {
	return crsInternal.getInt(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>long</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 long getLong(String columnName) throws SQLException {
	return crsInternal.getLong(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>float</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 float getFloat(String columnName) throws SQLException {
	return crsInternal.getFloat(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>double</code> value.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>0</code>
	* @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 double getDouble(String columnName) throws SQLException {
	return crsInternal.getDouble(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.math.BigDecimal</code> object.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @param scale the number of digits to the right of the decimal point
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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>getBigDecimal(String columnName)</code>
	* instead
	*/
	@Deprecated
	public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
	return crsInternal.getBigDecimal(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a byte array.
	* The bytes represent the raw values returned by the driver.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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 byte[] getBytes(String columnName) throws SQLException {
	return crsInternal.getBytes(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.sql.Date</code> object.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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.Date getDate(String columnName) throws SQLException {
	return crsInternal.getDate(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.sql.Time</code> object.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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 {
	return crsInternal.getTime(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.sql.Timestamp</code> object.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> object
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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 {
	return crsInternal.getTimestamp(columnName);
	}

	/**
	* This method is not supported, and it will throw an
	* <code>UnsupportedOperationException</code> if it is called.
	* <P>
	* 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 LONGVARCHAR values. The JDBC driver will
	* 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</code> method implicitly closes the stream.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> 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</code>, the result is <code>null</code>.
	* @throws UnsupportedOperationException if this method is called
	*/
	public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
	return crsInternal.getAsciiStream(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.io.InputStream</code> object.
	* 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</code> 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</code> method implicitly closes the stream.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> 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</code>, the result is <code>null</code>.
	* @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</code> instead
	*/
	@Deprecated
	public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
	return crsInternal.getUnicodeStream(columnName);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.io.InputStream</code> object.
	* 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</code> 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.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> 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</code>, the result is <code>null</code>.
	* @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.io.InputStream getBinaryStream(String columnName) throws SQLException {
	return crsInternal.getBinaryStream(columnName);
	}

	/* The first warning reported by calls on this <code>JoinRowSetImpl</code>
	* object is returned. Subsequent <code>JoinRowSetImpl</code> warnings will
	* be chained to this <code>SQLWarning</code>.
	*
	* <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</code> methods. Any warning caused by statement
	* methods (such as reading OUT parameters) will be chained on the
	* <code>Statement</code> object.
	*
	* @return the first SQLWarning or null
	* @throws UnsupportedOperationException if this method is called
	*/
	public SQLWarning getWarnings() {
	return crsInternal.getWarnings();
	}

	/**
	* Throws an <code>UnsupportedOperationException</code> if called.
	* <P>
	* After a call to this method, the <code>getWarnings</code> method
	* returns <code>null</code> until a new warning is reported for this
	* <code>JoinRowSetImpl</code> object.
	*
	* @throws UnsupportedOperationException if this method is called
	*/
	public void clearWarnings() {
	crsInternal.clearWarnings();
	}

	/**
	* Retrieves the name of the SQL cursor used by this
	* <code>JoinRowSetImpl</code> object.
	*
	* <P>In SQL, a result table is retrieved through a cursor that is
	* named. The current row of a result can be updated or deleted
	* using a positioned update/delete statement that references the
	* cursor name. To insure that the cursor has the proper isolation
	* level to support an update operation, the cursor's <code>SELECT</code>
	* statement should be of the form 'select for update'. If the '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</code> 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</code> is thrown.
	*
	* @return the SQL cursor name for this <code>JoinRowSetImpl</code> object's
	* cursor
	* @throws SQLException if an error occurs
	*/
	public String getCursorName() throws SQLException {
	return crsInternal.getCursorName();
	}

	/**
	* Retrieves the <code>ResultSetMetaData</code> object that contains
	* information about this <code>CachedRowsSet</code> object. The
	* information includes the number of columns, the data type for each
	* column, and other properties for each column.
	*
	* @return the <code>ResultSetMetaData</code> object that describes this
	* <code>JoinRowSetImpl</code> object's columns
	* @throws SQLException if an error occurs
	*/
	public ResultSetMetaData getMetaData() throws SQLException {
	return crsInternal.getMetaData();
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as an
	* <code>Object</code> value.
	* <P>
	* The type of the <code>Object</code> 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
	* specification.
	* <P>
	* This method may also be used to read datatabase-specific
	* abstract data types.
	* <P>
	* This implementation of the method <code>getObject</code> extends its
	* behavior so that it gets the attributes of an SQL structured type as
	* as an array of <code>Object</code> 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())</code>.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @return a <code>java.lang.Object</code> holding the column value;
	* if the value is SQL <code>NULL</code>, the result is <code>null</code>
	* @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</code> object for a custom mapping
	* @since 1.2
	*/
	public Object getObject(int columnIndex) throws SQLException {
	return crsInternal.getObject(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as an
	* <code>Object</code> value.
	* <P>
	* The type of the <code>Object</code> 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
	* specification.
	* <P>
	* This method may also be used to read datatabase-specific
	* abstract data types.
	* <P>
	* This implementation of the method <code>getObject</code> extends its
	* behavior so that it gets the attributes of an SQL structured type as
	* as an array of <code>Object</code> 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())</code>.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @param map a <code>java.util.Map</code> object showing the mapping
	* from SQL type names to classes in the Java programming
	* language
	* @return a <code>java.lang.Object</code> holding the column value;
	* if the value is SQL <code>NULL</code>, the result is
	* <code>null</code>
	* @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</code> object for a custom mapping
	*/
	public Object getObject(int columnIndex,
	java.util.Map<String,Class<?>> map)
	throws SQLException {
	return crsInternal.getObject(columnIndex, map);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as an
	* <code>Object</code> value.
	* <P>
	* The type of the <code>Object</code> 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
	* specification.
	* <P>
	* This method may also be used to read datatabase-specific
	* abstract data types.
	* <P>
	* This implementation of the method <code>getObject</code> extends its
	* behavior so that it gets the attributes of an SQL structured type as
	* as an array of <code>Object</code> 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())</code>.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return a <code>java.lang.Object</code> holding the column value;
	* if the value is SQL <code>NULL</code>, the result is
	* <code>null</code>
	* @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</code> object for a custom mapping
	*/
	public Object getObject(String columnName) throws SQLException {
	return crsInternal.getObject(columnName);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as an <code>Object</code> in
	* the Java programming lanugage, using the given
	* <code>java.util.Map</code> object to custom map the value if
	* appropriate.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @param map a <code>java.util.Map</code> object showing the mapping
	* from SQL type names to classes in the Java programming
	* language
	* @return an <code>Object</code> 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(String columnName,
	java.util.Map<String,Class<?>> map)
	throws SQLException {
	return crsInternal.getObject(columnName, map);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.io.Reader</code> 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</code> method implicitly closes the stream.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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 <code>java.io.Reader</code> object. If the value is
	* SQL <code>NULL</code>, the result is <code>null</code>.
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or there is a type mismatch
	*/
	public java.io.Reader getCharacterStream(int columnIndex) throws SQLException {
	return crsInternal.getCharacterStream(columnIndex);
	}

	/**
	* Retrieves the value stored in the designated column
	* of the current row as a <code>java.io.Reader</code> 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</code> method implicitly closes the stream.
	*
	* @param columnName a <code>String</code> object giving the SQL name of
	* a column in this <code>JoinRowSetImpl</code> 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</code>, the result is <code>null</code>.
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or there is a type mismatch
	*/
	public java.io.Reader getCharacterStream(String columnName) throws SQLException {
	return crsInternal.getCharacterStream(columnName);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.math.BigDecimal</code> object.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @return a <code>java.math.BigDecimal</code> value with full precision;
	* if the value is SQL <code>NULL</code>, the result is <code>null</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
	return crsInternal.getBigDecimal(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.math.BigDecimal</code> object.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return a <code>java.math.BigDecimal</code> value with full precision;
	* if the value is SQL <code>NULL</code>, the result is <code>null</code>
	* @throws SQLException if the given column index is out of bounds,
	* the cursor is not on a valid row, or this method fails
	*/
	public BigDecimal getBigDecimal(String columnName) throws SQLException {
	return crsInternal.getBigDecimal(columnName);
	}

	/**
	* Returns the number of rows in this <code>JoinRowSetImpl</code> object.
	*
	* @return number of rows in the rowset
	*/
	public int size() {
	return crsInternal.size();
	}

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

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

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

	/**
	* Indicates whether the cursor is on the last row in this
	* <code>JoinRowSetImpl</code> object.
	* <P>
	* Note: Calling the method <code>isLast</code> 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</code> if the cursor is on the last row;
	* <code>false</code> otherwise or if this rowset contains no rows
	* @throws SQLException if an error occurs
	*/
	public boolean isLast() throws SQLException {
	return crsInternal.isLast();
	}

	/**
	* Moves this <code>JoinRowSetImpl</code> 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</code>
	*/
	public void beforeFirst() throws SQLException {
	crsInternal.beforeFirst();
	}

	/**
	* Moves this <code>JoinRowSetImpl</code> 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 {
	crsInternal.afterLast();
	}

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


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

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

	/**
	* Moves this <code>JoinRowSetImpl</code> 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</code> is a <code>JoinRowSetImpl</code> object, moves the cursor
	* to the fourth row, starting from the beginning of the rowset.
	* <PRE><code>
	*
	* crs.absolute(4);
	*
	* </code> </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)</code> positions the cursor on the last row,
	* <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
	* If the <code>JoinRowSetImpl</code> object <code>crs</code> 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);
	*
	* </code> </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)</code> is the same as calling the
	* method <code>first()</code>. Calling <code>absolute(-1)</code> is the
	* same as calling <code>last()</code>.
	*
	* @param row a positive number to indicate the row, starting row numbering from
	* the first row, which is <code>1</code>; a negative number to indicate
	* the row, starting row numbering from the last row, which is
	* <code>-1</code>; must not be <code>0</code>
	* @return <code>true</code> if the cursor is on the rowset; <code>false</code>
	* otherwise
	* @throws SQLException if the given cursor position is <code>0</code> or the
	* type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
	*/
	public boolean absolute(int row) throws SQLException {
	return crsInternal.absolute(row);
	}

	/**
	* 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</code> is a <code>JoinRowSetImpl</code> 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);
	*
	* </code> </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)</code> positions the cursor on the last row,
	* <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
	* If the <code>JoinRowSetImpl</code> object <code>crs</code> 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);
	*
	* </code> </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</code>.
	* <P>
	* Note: Calling <code>absolute(1)</code> is the same as calling the
	* method <code>first()</code>. Calling <code>absolute(-1)</code> is the
	* same as calling <code>last()</code>. Calling <code>relative(0)</code>
	* is valid, but it does not change the cursor position.
	*
	* @param rows an <code>int</code> 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</code> if the cursor is on a row in this
	* <code>JoinRowSetImpl</code> object; <code>false</code>
	* 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</code>
	*/
	public boolean relative(int rows) throws SQLException {
	return crsInternal.relative(rows);
	}

	/**
	* Moves this <code>JoinRowSetImpl</code> object's cursor to the
	* previous row and returns <code>true</code> if the cursor is on
	* a valid row or <code>false</code> if it is not.
	* This method also notifies all listeners registered with this
	* <code>JoinRowSetImpl</code> object that its cursor has moved.
	* <P>
	* Note: calling the method <code>previous()</code> is not the same
	* as calling the method <code>relative(-1)</code>. This is true
	* because it is possible to call <code>previous()</code> from the insert
	* row, from after the last row, or from the current row, whereas
	* <code>relative</code> may only be called from the current row.
	* <P>
	* The method <code>previous</code> may used in a <code>while</code>
	* loop to iterate through a rowset starting after the last row
	* and moving toward the beginning. The loop ends when <code>previous</code>
	* returns <code>false</code>, meaning that there are no more rows.
	* For example, the following code fragment retrieves all the data in
	* the <code>JoinRowSetImpl</code> object <code>crs</code>, 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</code> 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);
	* }
	*
	* </code> </PRE>
	* This method throws an <code>SQLException</code> if the cursor is not
	* on a row in the rowset, before the first row, or after the last row.
	*
	* @return <code>true</code> if the cursor is on a valid row;
	* <code>false</code> 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</code>
	*/
	public boolean previous() throws SQLException {
	return crsInternal.previous();
	}

	/**
	* Returns the index of the column whose name is <i>columnName</i>.
	*
	* @param columnName a <code>String</code> object giving the name of the
	* column for which the index will be returned; the name must
	* match the SQL name of a column in this <code>JoinRowSet</code>
	* object, ignoring case
	* @throws SQLException if the given column name does not match one of the
	* column names for this <code>JoinRowSet</code> object
	*/
	public int findColumn(String columnName) throws SQLException {
	return crsInternal.findColumn(columnName);
	}

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

	/**
	* Indicates whether the designated column of the current row of
	* this <code>JoinRowSetImpl</code> object has been updated. The
	* value returned depends on whether this rowset can detcted updates:
	* <code>false</code> will always be returned if it does not detect updates.
	*
	* @return <code>true</code> if the column updated
	* <code>false</code> otherwse
	* @throws SQLException if the cursor is on the insert row or not
	* on a valid row
	* @see DatabaseMetaData#updatesAreDetected
	*/
	public boolean columnUpdated(int indexColumn) throws SQLException {
	return crsInternal.columnUpdated(indexColumn);
	}

	/**
	* 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</code> if a row has been inserted and inserts are detected;
	* <code>false</code> 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 {
	return crsInternal.rowInserted();
	}

	/**
	* 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</code> if this rowset cannot detect
	* deletions.
	*
	* @return <code>true</code> if (1)the current row is blank, indicating that
	* the row has been deleted, and (2)deletions are detected;
	* <code>false</code> otherwise
	* @throws SQLException if the cursor is on a valid row in this rowset
	* @see DatabaseMetaData#deletesAreDetected
	*/
	public boolean rowDeleted() throws SQLException {
	return crsInternal.rowDeleted();
	}

	/**
	* Sets the designated nullable column in the current row or the
	* insert row of this <code>JoinRowSetImpl</code> object with
	* <code>null</code> 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 acceptChanges
	* after it calls either <code>updateRow</code> or <code>insertRow</code>.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateNull(int columnIndex) throws SQLException {
	crsInternal.updateNull(columnIndex);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>boolean</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateBoolean(int columnIndex, boolean x) throws SQLException {
	crsInternal.updateBoolean(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>byte</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateByte(int columnIndex, byte x) throws SQLException {
	crsInternal.updateByte(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>short</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateShort(int columnIndex, short x) throws SQLException {
	crsInternal.updateShort(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>int</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateInt(int columnIndex, int x) throws SQLException {
	crsInternal.updateInt(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>long</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateLong(int columnIndex, long x) throws SQLException {
	crsInternal.updateLong(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>float</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateFloat(int columnIndex, float x) throws SQLException {
	crsInternal.updateFloat(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>double</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateDouble(int columnIndex, double x) throws SQLException {
	crsInternal.updateDouble(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.math.BigDecimal</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
	crsInternal.updateBigDecimal(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>String</code> 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</code> must be called if the
	* updated values are to be written back to the underlying database.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateString(int columnIndex, String x) throws SQLException {
	crsInternal.updateString(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>byte</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateBytes(int columnIndex, byte x[]) throws SQLException {
	crsInternal.updateBytes(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Date</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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> or <code>TIMESTAMP</code>, or
	* (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
	crsInternal.updateDate(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Time</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code> or <code>TIMESTAMP</code>, or
	* (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
	crsInternal.updateTime(columnIndex, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Timestamp</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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>, <code>TIME</code>, or
	* <code>TIMESTAMP</code>, or (4) this rowset is
	* <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
	crsInternal.updateTimestamp(columnIndex, x);
	}

	/*
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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 UnsupportedOperationException if this method is invoked
	*/
	public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
	crsInternal.updateAsciiStream(columnIndex, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.io.InputStream</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	* containing <code>BINARY</code>, <code>VARBINARY</code>, or
	* <code>LONGVARBINARY</code> 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</code>
	*/
	public void updateBinaryStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
	crsInternal.updateBinaryStream(columnIndex, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.io.Reader</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	* containing <code>BINARY</code>, <code>VARBINARY</code>,
	* <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
	* or <code>LONGVARCHAR</code> 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</code>
	*/
	public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
	crsInternal.updateCharacterStream(columnIndex, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Object</code> value. The <code>scale</code> 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</code> or <code>NUMERIC</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code> and <code>NUMERIC</code> 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</code>
	*/
	public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
	crsInternal.updateObject(columnIndex, x, scale);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Object</code> 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</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> 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</code>
	*/
	public void updateObject(int columnIndex, Object x) throws SQLException {
	crsInternal.updateObject(columnIndex, x);
	}

	// columnName updates

	/**
	* Sets the designated nullable column in the current row or the
	* insert row of this <code>JoinRowSetImpl</code> object with
	* <code>null</code> 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</code> 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</code>
	*/
	public void updateNull(String columnName) throws SQLException {
	crsInternal.updateNull(columnName);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>boolean</code> 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</code> 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</code>
	*/
	public void updateBoolean(String columnName, boolean x) throws SQLException {
	crsInternal.updateBoolean(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>byte</code> 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</code> 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</code>
	*/
	public void updateByte(String columnName, byte x) throws SQLException {
	crsInternal.updateByte(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>short</code> 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</code> 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</code>
	*/
	public void updateShort(String columnName, short x) throws SQLException {
	crsInternal.updateShort(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>int</code> 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</code> 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</code>
	*/
	public void updateInt(String columnName, int x) throws SQLException {
	crsInternal.updateInt(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>long</code> 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</code> 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</code>
	*/
	public void updateLong(String columnName, long x) throws SQLException {
	crsInternal.updateLong(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>float</code> 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</code> 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</code>
	*/
	public void updateFloat(String columnName, float x) throws SQLException {
	crsInternal.updateFloat(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>double</code> 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</code> 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</code>
	*/
	public void updateDouble(String columnName, double x) throws SQLException {
	crsInternal.updateDouble(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.math.BigDecimal</code> 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</code> 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</code>
	*/
	public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
	crsInternal.updateBigDecimal(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>String</code> 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</code> 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</code>
	*/
	public void updateString(String columnName, String x) throws SQLException {
	crsInternal.updateString(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>byte</code> 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</code> 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</code>
	*/
	public void updateBytes(String columnName, byte x[]) throws SQLException {
	crsInternal.updateBytes(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Date</code> 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</code> 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</code> or
	* <code>TIMESTAMP</code>, or (4) this rowset is
	* <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateDate(String columnName, java.sql.Date x) throws SQLException {
	crsInternal.updateDate(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Time</code> 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</code> 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</code> or
	* <code>TIMESTAMP</code>, or (4) this rowset is
	* <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateTime(String columnName, java.sql.Time x) throws SQLException {
	crsInternal.updateTime(columnName, x);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Timestamp</code> 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</code> 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>,
	* <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this
	* rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
	crsInternal.updateTimestamp(columnName, x);
	}

	/**
	* Unsupported; throws an <code>UnsupportedOperationException</code>
	* if called.
	* <P>
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> 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</code> 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
	* @throws UnsupportedOperationException if this method is invoked
	*/
	public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException {
	crsInternal.updateAsciiStream(columnName, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.io.InputStream</code> 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</code> 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</code>
	* containing <code>BINARY</code>, <code>VARBINARY</code>, or
	* <code>LONGVARBINARY</code> 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</code>
	*/
	public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
	crsInternal.updateBinaryStream(columnName, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>java.io.Reader</code> 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</code> 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.Reader</code>
	* containing <code>BINARY</code>, <code>VARBINARY</code>,
	* <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
	* or <code>LONGVARCHAR</code> 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</code>
	*/
	public void updateCharacterStream(String columnName, java.io.Reader x, int length) throws SQLException {
	crsInternal.updateCharacterStream(columnName, x, length);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Object</code> value. The <code>scale</code> 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</code> or <code>NUMERIC</code> 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</code> 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</code> and <code>NUMERIC</code> types only)
	* @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, or (3) this
	* rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void updateObject(String columnName, Object x, int scale) throws SQLException {
	crsInternal.updateObject(columnName, x, scale);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Object</code> 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</code> 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</code>
	*/
	public void updateObject(String columnName, Object x) throws SQLException {
	crsInternal.updateObject(columnName, x);
	}

	/**
	* Inserts the contents of this <code>JoinRowSetImpl</code> 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</code>
	*/
	public void insertRow() throws SQLException {
	crsInternal.insertRow();
	}

	/**
	* Marks the current row of this <code>JoinRowSetImpl</code> 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</code>
	*/
	public void updateRow() throws SQLException {
	crsInternal.updateRow();
	}

	/**
	* Deletes the current row from this <code>JoinRowSetImpl</code> 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</code> 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</code>
	*/
	public void deleteRow() throws SQLException {
	crsInternal.deleteRow();
	}

	/**
	* 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</code> or <code>deleteRow</code>.
	* 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 {
	crsInternal.refreshRow();
	}

	/**
	* Rolls back any updates made to the current row of this
	* <code>JoinRowSetImpl</code> object and notifies listeners that
	* a row has changed. To have an effect, this method
	* must be called after an <code>updateXXX</code> method has been
	* called and before the method <code>updateRow</code> has been called.
	* If no updates have been made or the method <code>updateRow</code>
	* has already been called, this method has no effect.
	* <P>
	* After <code>updateRow</code> is called it is the
	* <code>cancelRowUpdates</code> has no affect on the newly
	* inserted values. The method <code>cancelRowInsert</code> can
	* be used to remove any rows inserted into the RowSet.
	*
	* @throws SQLException if the cursor is on the insert row, before the
	* first row, or after the last row
	*/
	public void cancelRowUpdates() throws SQLException {
	crsInternal.cancelRowUpdates();
	}

	/**
	* Moves the cursor for this <code>JoinRowSetImpl</code> 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</code>
	* 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</code> 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</code>
	* and <code>insertRow</code> methods, only the <code>getXXX</code> methods
	* may be called when the cursor is on the insert row. A <code>getXXX</code>
	* method should be called on a column only after an <code>updateXXX</code>
	* method has been called on that column; otherwise, the value returned is
	* undetermined.
	*
	* @throws SQLException if this <code>JoinRowSetImpl</code> object is
	* <code>ResultSet.CONCUR_READ_ONLY</code>
	*/
	public void moveToInsertRow() throws SQLException {
	crsInternal.moveToInsertRow();
	}

	/**
	* Moves the cursor for this <code>JoinRowSetImpl</code> object to
	* the current row. The current row is the row the cursor was on
	* when the method <code>moveToInsertRow</code> 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 {
	crsInternal.moveToCurrentRow();
	}

	/**
	* Returns <code>null</code>.
	*
	* @return <code>null</code>
	* @throws SQLException if an error occurs
	*/
	public Statement getStatement() throws SQLException {
	return crsInternal.getStatement();
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Ref</code> object
	* in the Java programming lanugage.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @return a <code>Ref</code> object representing an SQL<code> REF</code> 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</code> value
	*/
	public Ref getRef(int columnIndex) throws SQLException {
	return crsInternal.getRef(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Blob</code> object
	* in the Java programming lanugage.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @return a <code>Blob</code> object representing an SQL <code>BLOB</code> 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</code> value
	*/
	public Blob getBlob(int columnIndex) throws SQLException {
	return crsInternal.getBlob(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Clob</code> object
	* in the Java programming lanugage.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @return a <code>Clob</code> object representing an SQL <code>CLOB</code> 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</code> value
	*/
	public Clob getClob(int columnIndex) throws SQLException {
	return crsInternal.getClob(columnIndex);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as an <code>Array</code> object
	* in the Java programming lanugage.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @return an <code>Array</code> object representing an SQL
	* <code>ARRAY</code> 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</code> value
	*/
	public Array getArray(int columnIndex) throws SQLException {
	return crsInternal.getArray(columnIndex);
	}

	// ColumnName

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Ref</code> object
	* in the Java programming lanugage.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return a <code>Ref</code> object representing an SQL<code> REF</code> 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</code> value
	*/
	public Ref getRef(String columnName) throws SQLException {
	return crsInternal.getRef(columnName);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Blob</code> object
	* in the Java programming lanugage.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return a <code>Blob</code> object representing an SQL
	* <code>BLOB</code> 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</code> value
	*/
	public Blob getBlob(String columnName) throws SQLException {
	return crsInternal.getBlob(columnName);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as a <code>Clob</code> object
	* in the Java programming lanugage.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return a <code>Clob</code> object representing an SQL
	* <code>CLOB</code> 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</code> value
	*/
	public Clob getClob(String columnName) throws SQLException {
	return crsInternal.getClob(columnName);
	}

	/**
	* Retrieves the value of the designated column in this
	* <code>JoinRowSetImpl</code> object as an <code>Array</code> object
	* in the Java programming lanugage.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @return an <code>Array</code> object representing an SQL
	* <code>ARRAY</code> 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</code> value
	*/
	public Array getArray(String columnName) throws SQLException {
	return crsInternal.getArray(columnName);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a <code>java.sql.Date</code>
	* object, using the given <code>Calendar</code> object to construct an
	* appropriate millisecond value for the date.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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> or
	* <code>TIMESTAMP</code> value
	*/
	public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
	return crsInternal.getDate(columnIndex, cal);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a <code>java.sql.Date</code>
	* object, using the given <code>Calendar</code> object to construct an
	* appropriate millisecond value for the date.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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> or
	* <code>TIMESTAMP</code> value
	*/
	public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
	return crsInternal.getDate(columnName, cal);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a <code>java.sql.Time</code>
	* object, using the given <code>Calendar</code> object to construct an
	* appropriate millisecond value for the date.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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</code> or
	* <code>TIMESTAMP</code> value
	*/
	public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
	return crsInternal.getTime(columnIndex, cal);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a <code>java.sql.Time</code>
	* object, using the given <code>Calendar</code> object to construct an
	* appropriate millisecond value for the date.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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</code> or
	* <code>TIMESTAMP</code> value
	*/
	public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
	return crsInternal.getTime(columnName, cal);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a <code>java.sql.Timestamp</code>
	* object, using the given <code>Calendar</code> object to construct an
	* appropriate millisecond value for the date.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in the rowset
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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</code> or
	* <code>TIMESTAMP</code> value
	*/
	public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
	return crsInternal.getTimestamp(columnIndex, cal);
	}

	/**
	* Retrieves the value of the designated column in the current row
	* of this <code>JoinRowSetImpl</code> object as a
	* <code>java.sql.Timestamp</code> object, using the given
	* <code>Calendar</code> object to construct an appropriate
	* millisecond value for the date.
	*
	* @param columnName a <code>String</code> object that must match the
	* SQL name of a column in this rowset, ignoring case
	* @param cal the <code>java.util.Calendar</code> object to use in
	* constructing the date
	* @return the column value; if the value is SQL <code>NULL</code>,
	* the result is <code>null</code>
	* @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>,
	* <code>TIME</code>, or <code>TIMESTAMP</code> value
	*/
	public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
	return crsInternal.getTimestamp(columnName, cal);
	}

	/**
	* Sets the metadata for this <code>JoinRowSetImpl</code> object
	* with the given <code>RowSetMetaData</code> object.
	*
	* @param md a <code>RowSetMetaData</code> 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 {
	crsInternal.setMetaData(md);
	}

	public ResultSet getOriginal() throws SQLException {
	return crsInternal.getOriginal();
	}

	/**
	* Returns a result set containing the original value of the rowset.
	* The cursor is positioned before the first row in the result set.
	* Only rows contained in the result set returned by 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</code> object
	*/
	public ResultSet getOriginalRow() throws SQLException {
	return crsInternal.getOriginalRow();
	}

	/**
	* Returns a result set containing the original value of the current
	* row only.
	*
	* @throws SQLException if there is no current row
	* @see #setOriginalRow
	*/
	public void setOriginalRow() throws SQLException {
	crsInternal.setOriginalRow();
	}

	/**
	* Returns the columns that make a key to uniquely identify a
	* row in this <code>JoinRowSetImpl</code> object.
	*
	* @return an array of column number that constites a primary
	* key for this rowset. This array should be empty
	* if no columns 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 {
	return crsInternal.getKeyColumns();
	}

	/**
	* Sets this <code>JoinRowSetImpl</code> object's
	* <code>keyCols</code> field with the given array of column
	* numbers, which forms a key for uniquely identifying a row
	* in this rowset.
	*
	* @param cols an array of <code>int</code> indicating the
	* columns that form a primary key for this
	* <code>JoinRowSetImpl</code> object; every
	* element in the array must be greater than
	* <code>0</code> 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[] cols) throws SQLException {
	crsInternal.setKeyColumns(cols);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Ref</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @param ref the <code>java.sql.Ref</code> object that will be set as
	* 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</code>
	*/
	public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
	crsInternal.updateRef(columnIndex, ref);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Ref</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnName a <code>String</code> object giving the name of the column
	* to be updated; must match one of the column names in this
	* <code>JoinRowSetImpl</code> object
	* @param ref the <code>java.sql.Ref</code> object that will be set as
	* the new column value
	* @throws SQLException if (1) the given column name is not valid,
	* (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</code>
	*/
	public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
	crsInternal.updateRef(columnName, ref);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Clob</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @param c the <code>java.sql.Clob</code> object that will be set as
	* 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</code>
	*/
	public void updateClob(int columnIndex, Clob c) throws SQLException {
	crsInternal.updateClob(columnIndex, c);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Clob</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnName a <code>String</code> object giving the name of the column
	* to be updated; must match one of the column names in this
	* <code>JoinRowSetImpl</code> object
	* @param c the <code>java.sql.Clob</code> object that will be set as
	* the new column value
	* @throws SQLException if (1) the given column name is not valid,
	* (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</code>
	*/
	public void updateClob(String columnName, Clob c) throws SQLException {
	crsInternal.updateClob(columnName, c);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Blob</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @param b the <code>java.sql.Blob</code> object that will be set as
	* 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</code>
	*/
	public void updateBlob(int columnIndex, Blob b) throws SQLException {
	crsInternal.updateBlob(columnIndex, b);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Blob</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnName a <code>String</code> object giving the name of the column
	* to be updated; must match one of the column names in this
	* <code>JoinRowSetImpl</code> object
	* @param b the <code>java.sql.Blob</code> object that will be set as
	* the new column value
	* @throws SQLException if (1) the given column name is not valid,
	* (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</code>
	*/
	public void updateBlob(String columnName, Blob b) throws SQLException {
	crsInternal.updateBlob(columnName, b);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Array</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnIndex the first column is <code>1</code>, the second
	* is <code>2</code>, and so on; must be <code>1</code> or larger
	* and equal to or less than the number of columns in this rowset
	* @param a the <code>java.sql.Array</code> object that will be set as
	* 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</code>
	*/
	public void updateArray(int columnIndex, Array a) throws SQLException {
	crsInternal.updateArray(columnIndex, a);
	}

	/**
	* Sets the designated column in either the current row or the insert
	* row of this <code>JoinRowSetImpl</code> object with the given
	* <code>Array</code> 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. Either of these methods must be called before the
	* cursor moves to another row.
	*
	* @param columnName a <code>String</code> object giving the name of the column
	* to be updated; must match one of the column names in this
	* <code>JoinRowSetImpl</code> object
	* @param a the <code>java.sql.Array</code> object that will be set as
	* the new column value
	* @throws SQLException if (1) the given column name is not valid,
	* (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</code>
	*/
	public void updateArray(String columnName, Array a) throws SQLException {
	crsInternal.updateArray(columnName, a);
	}

	/**
	* Populates this <code>JoinRowSetImpl</code> 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</code>
	* 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</code> 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</code> 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 {
	crsInternal.execute();
	}

	/**
	* Populates this <code>JoinRowSetImpl</code> 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</code>
	* that is given a connection ignores these properties.
	*
	* @param conn A standard JDBC <code>Connection</code> object with valid
	* properties that the <code>JoinRowSet</code> implementation
	* can pass to a synchronization provider to establish a
	* connection to the datasource
	* @throws SQLException if an invalid <code>Connection</code> is supplied
	* or an error occurs in establishing the connection to the
	* data soure
	* @see java.sql.Connection
	*/
	public void execute(Connection conn) throws SQLException {
	crsInternal.execute(conn);
	}

	/**
	* Provide interface coverage for getURL(int) in
	* ResultSet{@literal ->}RowSet
	*/
	public java.net.URL getURL(int columnIndex) throws SQLException {
	return crsInternal.getURL(columnIndex);
	}

	/**
	* Provide interface coverage for getURL(String) in
	* ResultSet{@literal ->}RowSet
	*/
	public java.net.URL getURL(String columnName) throws SQLException {
	return crsInternal.getURL(columnName);
	}

	/**
	* Creates a new <code>WebRowSet</code> object, populates it with the
	* data in the given <code>ResultSet</code> object, and writes it
	* to the given <code>java.io.Writer</code> object in XML format.
	*
	* @throws SQLException if an error occurs writing out the rowset
	* contents to XML
	*/
	public void writeXml(ResultSet rs, java.io.Writer writer)
	throws SQLException {
	wrs = new WebRowSetImpl();
	wrs.populate(rs);
	wrs.writeXml(writer);
	}

	/**
	* Writes this <code>JoinRowSet</code> object to the given
	* <code>java.io.Writer</code> object in XML format. In
	* addition to the rowset's data, its properties and metadata
	* are also included.
	*
	* @throws SQLException if an error occurs writing out the rowset
	* contents to XML
	*/
	public void writeXml(java.io.Writer writer) throws SQLException {
	createWebRowSet().writeXml(writer);
	}

	/**
	* Reads this <code>JoinRowSet</code> object in its XML format.
	*
	* @throws SQLException if a database access error occurs
	*/
	public void readXml(java.io.Reader reader) throws SQLException {
	wrs = new WebRowSetImpl();
	wrs.readXml(reader);
	crsInternal = (CachedRowSetImpl)wrs;
	}

	// Stream based methods
	/**
	* Reads a stream based XML input to populate an <code>WebRowSet</code>
	*
	* @throws SQLException if a data source access occurs
	* @throws IOException if a IO exception occurs
	*/
	public void readXml(java.io.InputStream iStream) throws SQLException, IOException {
	wrs = new WebRowSetImpl();
	wrs.readXml(iStream);
	crsInternal = (CachedRowSetImpl)wrs;
	}

	/**
	* Creates an output stream of the internal state and contents of a
	* <code>WebRowSet</code> for XML proceessing
	*
	* @throws SQLException if a datasource access occurs
	* @throws IOException if an IO exception occurs
	*/
	public void writeXml(java.io.OutputStream oStream) throws SQLException, IOException {
	createWebRowSet().writeXml(oStream);
	}

	/**
	* Creates a new <code>WebRowSet</code> object, populates it with
	* the contents of the <code>ResultSet</code> and creates an output
	* streams the internal state and contents of the rowset for XML processing.
	*
	* @throws SQLException if a datasource access occurs
	* @throws IOException if an IO exception occurs
	*/
	public void writeXml(ResultSet rs, java.io.OutputStream oStream) throws SQLException, IOException {
	wrs = new WebRowSetImpl();
	wrs.populate(rs);
	wrs.writeXml(oStream);
	}

	/**
	* %%% Javadoc comments to be added here
	*/
	private WebRowSet createWebRowSet() throws SQLException {
	if(wrs != null) {
	// check if it has already been initialized.
	return wrs;
	} else {
	wrs = new WebRowSetImpl();
	crsInternal.beforeFirst();
	wrs.populate(crsInternal);
	return wrs;
	}
	}

	/**
	* Returns the last set SQL <code>JOIN</code> type in this JoinRowSetImpl
	* object
	*
	* @return joinType One of the standard JoinRowSet static field JOIN types
	* @throws SQLException if an error occurs determining the current join type
	*/
	public int getJoinType() throws SQLException {
	if (vecJoinType == null) {
	// Default JoinRowSet type
	this.setJoinType(JoinRowSet.INNER_JOIN);
	}
	Integer i = vecJoinType.get(vecJoinType.size()-1);
	return i.intValue();
	}

	/**
	* The listener will be notified whenever an event occurs on this <code>JoinRowSet</code>
	* object.
	* <P>
	* A listener might, for example, be a table or graph that needs to
	* be updated in order to accurately reflect the current state of
	* the <code>RowSet</code> object.
	* <p>
	* <b>Note</b>: if the <code>RowSetListener</code> object is
	* <code>null</code>, this method silently discards the <code>null</code>
	* value and does not add a null reference to the set of listeners.
	* <p>
	* <b>Note</b>: if the listener is already set, and the new <code>RowSetListerner</code>
	* instance is added to the set of listeners already registered to receive
	* event notifications from this <code>RowSet</code>.
	*
	* @param listener an object that has implemented the
	* <code>javax.sql.RowSetListener</code> interface and wants to be notified
	* of any events that occur on this <code>JoinRowSet</code> object; May be
	* null.
	* @see #removeRowSetListener
	*/
	public void addRowSetListener(RowSetListener listener) {
	crsInternal.addRowSetListener(listener);
	}

	/**
	* Removes the designated object from this <code>JoinRowSet</code> object's list of listeners.
	* If the given argument is not a registered listener, this method
	* does nothing.
	*
	* <b>Note</b>: if the <code>RowSetListener</code> object is
	* <code>null</code>, this method silently discards the <code>null</code>
	* value.
	*
	* @param listener a <code>RowSetListener</code> object that is on the list
	* of listeners for this <code>JoinRowSet</code> object
	* @see #addRowSetListener
	*/
	public void removeRowSetListener(RowSetListener listener) {
	crsInternal.removeRowSetListener(listener);
	}

	/**
	* Converts this <code>JoinRowSetImpl</code> object to a collection
	* of tables. The sample implementation utilitizes the <code>TreeMap</code>
	* 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</code> object consisting of tables,
	* each of which is a copy of a row in this
	* <code>JoinRowSetImpl</code> object
	* @throws SQLException if an error occurs in generating the collection
	* @see #toCollection(int)
	* @see #toCollection(String)
	* @see java.util.TreeMap
	*/
	public Collection<?> toCollection() throws SQLException {
	return crsInternal.toCollection();
	}

	/**
	* Returns the specified column of this <code>JoinRowSetImpl</code> object
	* as a <code>Collection</code> object. This method makes a copy of the
	* column's data and utilitizes the <code>Vector</code> to establish the
	* collection. The <code>Vector</code> 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</code> object that contains the value(s)
	* stored in the specified column of this
	* <code>JoinRowSetImpl</code>
	* 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
	*/
	public Collection<?> toCollection(int column) throws SQLException {
	return crsInternal.toCollection(column);
	}

	/**
	* Returns the specified column of this <code>JoinRowSetImpl</code> object
	* as a <code>Collection</code> object. This method makes a copy of the
	* column's data and utilitizes the <code>Vector</code> to establish the
	* collection. The <code>Vector</code> 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</code> object that contains the value(s)
	* stored in the specified column of this
	* <code>JoinRowSetImpl</code>
	* 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
	*/
	public Collection<?> toCollection(String column) throws SQLException {
	return crsInternal.toCollection(column);
	}

	/**
	* Creates a <code>RowSet</code> object that is a copy of
	* this <code>JoinRowSetImpl</code> 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</code>.
	*
	* @return a new <code>CachedRowSet</code> object that is a copy
	* of this <code>JoinRowSetImpl</code> 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</code> object
	* @see #createShared
	* @see #createCopy
	* @see #createCopyNoConstraints
	* @see javax.sql.RowSetEvent
	* @see javax.sql.RowSetListener
	*/
	public CachedRowSet createCopySchema() throws SQLException {
	return crsInternal.createCopySchema();
	}

	/**
	* {@inheritDoc}
	*/
	public void setSyncProvider(String providerStr) throws SQLException {
	crsInternal.setSyncProvider(providerStr);
	}

	/**
	* {@inheritDoc}
	*/
	public void acceptChanges() throws SyncProviderException {
	crsInternal.acceptChanges();
	}

	/**
	* {@inheritDoc}
	*/
	public SyncProvider getSyncProvider() throws SQLException {
	return crsInternal.getSyncProvider();
	}

	/**
	* 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 = -5590501621560008453L;
	}

Back to index...