/*
 * 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 JoinRowSet
interface providing an SQL JOIN between RowSet
objects.

The implementation provides an ANSI-style JOIN providing an
inner join between two tables. Any unmatched rows in either table of the
join are  discarded.

Typically, a JoinRowSet implementation is leveraged by
RowSet 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 CachedRowSet objects and implementations derived from
the CachedRowSet interface that will use the JoinRowSetImpl
implementation.
Author:
Amit Handa, Jonathan Bruce/**
 * 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 Vector object that contains the RowSet objects
that have been added to this JoinRowSet object.
/**
     * 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 CachedRowSet object that encapsulates this
JoinRowSet object.
When RowSet objects are added to this JoinRowSet
object, they are also added to crsInternal to form the same kind of
SQL JOIN.  As a result, methods for making updates to this
JoinRowSet object can use crsInternal methods in their
implementations.
/**
     * 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 Vector object containing the types of join that have been set
for this JoinRowSet object.
The last join type set forms the basis of succeeding joins.
/**
     * 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 Vector object containing the names of all the tables entering
the join.
/**
     * A <code>Vector</code> object containing the names of all the tables entering
     * the join.
     */
    private Vector<String> vecTableNames;

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

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

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

    
The WebRowSet object that encapsulates this JoinRowSet
object. This WebRowSet object allows this JoinRowSet
object to leverage the properties and methods of a WebRowSet
object.
/**
     * 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 JoinRowSetImpl class. Configures various internal data
structures to provide mechanisms required for JoinRowSet interface
implementation.
Throws:
SQLException – if an error occurs in instantiating an instance of
JoinRowSetImpl/**
     * 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 RowSet object to this
JoinRowSet object.  If this
rowset is the first to be added to the JoinRowSet
object, it forms the basis for the JOIN
relationships to be formed.

This method should be used when the given RowSet object
already has a match column set.
Params:
rowset – the RowSet object that implements the
        Joinable interface and is to be added
        to this JoinRowSet object
Throws:
SQLException – if an empty RowSet is added to the to the
        JoinRowSet; if a match column is not set; or if an
        additional RowSet violates the active JOIN
See Also:
Joinable.setMatchColumn/**
     * 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 RowSet object to the JOIN relation
and sets the designated column as the match column.
If the given RowSet
object is the first to be added to this JoinRowSet
object, it forms the basis of the JOIN relationship to be formed
when other RowSet objects are added .

This method should be used when the given RowSet object
does not already have a match column set.
Params:
rowset – a RowSet object to be added to
        the JOIN relation; must implement the Joinable
        interface
columnIdx – an int giving the index of the column to be set as
        the match column
Throws:
SQLException – if (1) an empty RowSet object is added to this
        JoinRowSet object, (2) a match column has not been set,
        or (3) the RowSet object being added violates the active
        JOIN
See Also:
Joinable.unsetMatchColumn/**
     * 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 RowSet object to the JOIN relationship
and sets the designated column as the match column. If the given
RowSet
object is the first to be added to this JoinRowSet
object, it forms the basis of the JOIN relationship to be formed
when other RowSet objects are added .

This method should be used when the given RowSet object
does not already have a match column set.
Params:
rowset – a RowSet object to be added to
        the JOIN relation
columnName – a String object giving the name of the column
       to be set as the match column; must implement the Joinable
       interface
Throws:
SQLException – if (1) an empty RowSet object is added to this
        JoinRowSet object, (2) a match column has not been set,
        or (3) the RowSet object being added violates the active
        JOIN/**
     * 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 RowSet objects to the JOIN relationship
and sets the designated columns as the match columns. If the first
RowSet object in the array of RowSet objects
is the first to be added to this JoinRowSet
object, it forms the basis of the JOIN relationship to be formed
when other RowSet objects are added.

The first int
in columnIdx is used to set the match column for the first
RowSet object in rowset, the second int
in columnIdx is used to set the match column for the second
RowSet object in rowset, and so on.

This method should be used when the given RowSet objects
do not already have match columns set.
Params:
rowset – an array of RowSet objects to be added to
        the JOIN relation; each RowSet object must
        implement the Joinable interface
columnIdx – an array of int values designating the columns
       to be set as the
       match columns for the RowSet objects in rowset
Throws:
SQLException – if the number of RowSet objects in
        rowset is not equal to the number of int values
        in columnIdx/**
     * 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 RowSet objects to the JOIN relationship
and sets the designated columns as the match columns. If the first
RowSet object in the array of RowSet objects
is the first to be added to this JoinRowSet
object, it forms the basis of the JOIN relationship to be formed
when other RowSet objects are added.

The first String object
in columnName is used to set the match column for the first
RowSet object in rowset, the second String
object in columnName is used to set the match column for the second
RowSet object in rowset, and so on.

This method should be used when the given RowSet objects
do not already have match columns set.
Params:
rowset – an array of RowSet objects to be added to
        the JOIN relation; each RowSet object must
        implement the Joinable interface
columnName – an array of String objects designating the columns
       to be set as the
       match columns for the RowSet objects in rowset
Throws:
SQLException – if the number of RowSet objects in
        rowset is not equal to the number of String objects
        in columnName, an empty JdbcRowSet is added to the
        JoinRowSet, if a match column is not set,
        or one or the RowSet objects in rowset violates the
        active JOIN/**
     * 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 RowSet object instances
currently residing with the instance of the JoinRowSet
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.
Throws:
SQLException – if an error occours generating a collection
of the originating RowSets contained within the JOIN.
Returns:
A Collection of the added RowSet
object instances/**
     * 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 JoinRowSet object instance.
Throws:
SQLException – if an error occours retrieving the RowSet names
See Also:
CachedRowSet.setTableName
Returns:
a string array of the RowSet names/**
     * 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 CachedRowSet object that contains the data
in this JoinRowSet object.

If any updates or modifications have been applied to this JoinRowSet
object, the CachedRowSet 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
CachedRowSet instance returned should not
contain modification data, such as whether a row has been updated or what the
original values are.  Also, the CachedRowSet object should clear
its  properties pertaining to
its originating SQL statement. An application should reset the
SQL statement using the RowSet.setCommand method.

To persist changes back to the data source, the JoinRowSet object
calls the method acceptChanges. Implementations
can leverage the internal data and update tracking in their
implementations to interact with the SyncProvider to persist any
changes.
Throws:
SQLException – if an error occurs assembling the CachedRowSet
        object
See Also:
RowSet
CachedRowSet
SyncProvider
Returns:
a CachedRowSet object containing the contents of this
        JoinRowSet object/**
     * 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 true if this JoinRowSet object supports
an SQL CROSS_JOIN and false if it does not.
Returns:
true if the CROSS_JOIN is supported; false
        otherwise/**
     * 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 true if this JoinRowSet object supports
an SQL INNER_JOIN and false if it does not.
Returns:
true is the INNER_JOIN is supported; false otherwise/**
     * 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 true if this JoinRowSet object supports
an SQL LEFT_OUTER_JOIN and false if it does not.
Returns:
true is the LEFT_OUTER_JOIN is supported; false otherwise/**
     * 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 true if this JoinRowSet object supports
an SQL RIGHT_OUTER_JOIN and false if it does not.
Returns:
true is the RIGHT_OUTER_JOIN is supported; false otherwise/**
     * 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 true if this JoinRowSet object supports
an SQL FULL_JOIN and false if it does not.
Returns:
true is the FULL_JOIN is supported; false otherwise/**
     * 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 JOIN that this JoinRowSet
object will use. This method
allows an application to adjust the type of JOIN imposed
on tables contained within this JoinRowSet object and to do it
on the fly. The last JOIN type set determines the type of
JOIN to be performed.

Implementations should throw an SQLException if they do
not support the given JOIN type.
Params:
type – one of the standard JoinRowSet constants
       indicating the type of JOIN.  Must be one of the
       following:
           JoinRowSet.CROSS_JOIN
           JoinRowSet.INNER_JOIN
           JoinRowSet.LEFT_OUTER_JOIN
           JoinRowSet.RIGHT_OUTER_JOIN, or
           JoinRowSet.FULL_JOIN
Throws:
SQLException – if an unsupported JOIN type is set/**
     * 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.
Throws:
SQLException – if MatchColumn is not set.
@param
CachedRowSet object whose match column needs to be checked./**
     * 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 JoinRowSet.
/**
     * 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 WHERE clause being used
in a JoinRowSet object instance. An implementation can describe
the WHERE clause of the SQL JOIN by supplying a SQL
strings description of JOIN or provide a textual description to assist
applications using a JoinRowSet.
Throws:
SQLException – if an error occurs in generating a representation
of the WHERE clause.
Returns:
whereClause a textual or SQL descripition of the logical
WHERE cluase used in the JoinRowSet instance/**
     * 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 true if the new cursor position is a
valid row.
The cursor for a new ResultSet object is initially
positioned before the first row. The first call to the method
next moves the cursor to the first row, making it
the current row; the second call makes the second row the
current row, and so on.
If an input stream from the previous row is open, it is
implicitly closed. The ResultSet object's warning
chain is cleared when a new row is read.
Throws:
SQLException – if an error occurs or
           the cursor is not positioned in the rowset, before
           the first row, or after the last row
Returns:
true if the new current row is valid;
        false if there are no more rows/**
     * 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
release is called. This method sends a
RowSetChangedEvent object to all registered listeners prior
to returning.
Throws:
SQLException – if an error occurs/**
     * 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 NULL.
Note that you must first call the method getXXX
on a column to try to read its value and then call the method
wasNull to determine whether the value was
SQL NULL.
Throws:
SQLException – if an error occurs
Returns:
true if the value in the last column read
        was SQL NULL; false otherwise/**
     * 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 JoinRowSetImpl object as a
String object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds or
           the cursor is not on a valid row
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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 JoinRowSetImpl object as a
boolean value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is false/**
     * 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 JoinRowSetImpl object as a
byte value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
short value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
short value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
long value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
float value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
double value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is 0/**
     * 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 JoinRowSetImpl object as a
java.math.BigDecimal object.

This method is deprecated; use the version of getBigDecimal
that does not take a scale parameter and returns a value with full
precision.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
scale – the number of digits to the right of the decimal point in the
       value returned
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value with the specified number of digits to the right
        of the decimal point; if the value is SQL NULL, the
        result is null
Deprecated:
/**
     * 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 JoinRowSetImpl object as a
byte array value.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
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
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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 JoinRowSetImpl object as a
java.sql.Date object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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 JoinRowSetImpl object as a
java.sql.Time object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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 JoinRowSetImpl object as a
java.sql.Timestamp object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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 JoinRowSetImpl object as a
java.sql.Timestamp object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
the column value; if the value is SQL NULL, the
        result is null/**
     * 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.
Note: 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.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if an error occurs
Returns:
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.
Deprecated:
/**
     * 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.
Note: 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.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if an error occurs
Returns:
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./**
     * 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 String object.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 boolean value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is false/**
     * 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 byte value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 short value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 int value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 long value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 float value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 double value.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is 0/**
     * 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 java.math.BigDecimal object.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
scale – the number of digits to the right of the decimal point
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
Returns:
the column value; if the value is SQL NULL,
        the result is null
Deprecated:
use the method getBigDecimal(String columnName)
            instead/**
     * 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.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 java.sql.Date object.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 java.sql.Time object.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 java.sql.Timestamp object.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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
UnsupportedOperationException if it is called.

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.
Note: All the data in the returned stream must
be read prior to getting the value of any other column. The
next call to a getXXX method implicitly closes the stream.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
Throws:
UnsupportedOperationException – if this method is called
Returns:
a Java input stream that delivers the database column value
        as a stream of one-byte ASCII characters.  If the value is SQL
        NULL, the result is null./**
     * 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 java.io.InputStream 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 LONGVARCHAR values.
The JDBC driver will do any necessary conversion from the database
format into Unicode.
Note: All the data in the returned stream must
be read prior to getting the value of any other column. The
next call to a getXXX method implicitly closes the stream.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
a Java input stream that delivers the database column value
        as a stream of two-byte Unicode characters.  If the value is
        SQL NULL, the result is null.
Deprecated:
use the method getCharacterStream instead/**
     * 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 java.io.InputStream 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 LONGVARBINARY values.
Note: 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.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
a Java input stream that delivers the database column value
        as a stream of uninterpreted bytes.  If the value is SQL
        NULL, the result is null./**
     * 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 UnsupportedOperationException if called.

After a call to this method, the getWarnings method
returns null until a new warning is reported for this
JoinRowSetImpl object.
Throws:
UnsupportedOperationException – if this method is called/**
     * 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
JoinRowSetImpl object.
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 SELECT
statement should be of the form 'select for update'. If the 'for update'
clause is omitted, positioned updates may fail.
JDBC supports this SQL feature by providing the name of the
SQL cursor used by a ResultSet object. The current row
of a result set is also the current row of this SQL cursor.
Note: If positioned updates are not supported, an
SQLException is thrown.
Throws:
SQLException – if an error occurs
Returns:
the SQL cursor name for this JoinRowSetImpl object's
        cursor/**
     * 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 ResultSetMetaData object that contains
information about this CachedRowsSet object. The
information includes the number of columns, the data type for each
column, and other properties for each column.
Throws:
SQLException – if an error occurs
Returns:
the ResultSetMetaData object that describes this
        JoinRowSetImpl object's columns/**
     * 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 JoinRowSetImpl object as an
Object value.

The type of the Object will be the default
Java object type corresponding to the column's SQL type,
following the mapping for built-in types specified in the JDBC
specification.

This method may also be used to read datatabase-specific
abstract data types.

This implementation of the method getObject extends its
behavior so that it gets the attributes of an SQL structured type as
as an array of Object values.  This method also custom
maps SQL user-defined types to classes in the Java programming language.
When the specified column contains
a structured or distinct value, the behavior of this method is as
if it were a call to the method getObject(columnIndex,
this.getStatement().getConnection().getTypeMap()).
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
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 Class object for a custom mapping
Returns:
a java.lang.Object holding the column value;
        if the value is SQL NULL, the result is null
Since:
1.2/**
     * 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 JoinRowSetImpl object as an
Object value.

The type of the Object will be the default
Java object type corresponding to the column's SQL type,
following the mapping for built-in types specified in the JDBC
specification.

This method may also be used to read datatabase-specific
abstract data types.

This implementation of the method getObject extends its
behavior so that it gets the attributes of an SQL structured type as
as an array of Object values.  This method also custom
maps SQL user-defined types to classes
in the Java programming language. When the specified column contains
a structured or distinct value, the behavior of this method is as
if it were a call to the method getObject(columnIndex,
this.getStatement().getConnection().getTypeMap()).
Params:
columnIndex – the first column is 1, the second
        is 2, and so on; must be 1 or larger
        and equal to or less than the number of columns in the rowset
map – a java.util.Map object showing the mapping
        from SQL type names to classes in the Java programming
        language
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 Class object for a custom mapping
Returns:
a java.lang.Object holding the column value;
        if the value is SQL NULL, the result is
        null/**
     * 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 JoinRowSetImpl object as an
Object value.

The type of the Object will be the default
Java object type corresponding to the column's SQL type,
following the mapping for built-in types specified in the JDBC
specification.

This method may also be used to read datatabase-specific
abstract data types.

This implementation of the method getObject extends its
behavior so that it gets the attributes of an SQL structured type as
as an array of Object values.  This method also custom
maps SQL user-defined types to classes
in the Java programming language. When the specified column contains
a structured or distinct value, the behavior of this method is as
if it were a call to the method getObject(columnIndex,
this.getStatement().getConnection().getTypeMap()).
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
Throws:
SQLException – if (1) the given column name does not match
       one of this rowset's column names, (2) the cursor is not
       on a valid row, or (3) there is a problem getting
       the Class object for a custom mapping
Returns:
a java.lang.Object holding the column value;
       if the value is SQL NULL, the result is
       null/**
     * 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
JoinRowSetImpl object as an Object in
the Java programming lanugage, using the given
java.util.Map object to custom map the value if
appropriate.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
map – a java.util.Map object showing the mapping
           from SQL type names to classes in the Java programming
           language
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
Returns:
an Object representing the SQL value/**
     * 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 java.io.Reader object.
Note: All the data in the returned stream must
be read prior to getting the value of any other column. The
next call to a getXXX method implicitly closes the stream.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
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
Returns:
a Java character stream that delivers the database column value
        as a java.io.Reader object.  If the value is
        SQL NULL, the result is null./**
     * 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 java.io.Reader object.
Note: All the data in the returned stream must
be read prior to getting the value of any other column. The
next call to a getXXX method implicitly closes the stream.
Params:
columnName – a String object giving the SQL name of
       a column in this JoinRowSetImpl object
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
Returns:
a Java input stream that delivers the database column value
        as a stream of two-byte Unicode characters.  If the value is
        SQL NULL, the result is null./**
     * 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 JoinRowSetImpl object as a
java.math.BigDecimal object.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
a java.math.BigDecimal value with full precision;
        if the value is SQL NULL, the result is null/**
     * 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 JoinRowSetImpl object as a
java.math.BigDecimal object.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
Throws:
SQLException – if the given column index is out of bounds,
           the cursor is not on a valid row, or this method fails
Returns:
a java.math.BigDecimal value with full precision;
        if the value is SQL NULL, the result is null/**
     * 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 JoinRowSetImpl object.
Returns:
number of rows in the rowset/**
     * 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
JoinRowSetImpl object.
Throws:
SQLException – if an error occurs
Returns:
true if the cursor is before the first row;
        false otherwise or if the rowset contains no rows/**
     * 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
JoinRowSetImpl object.
Throws:
SQLException – if an error occurs
Returns:
true if the cursor is after the last row;
        false otherwise or if the rowset contains no rows/**
     * 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
JoinRowSetImpl object.
Throws:
SQLException – if an error occurs
Returns:
true if the cursor is on the first row;
        false otherwise or if the rowset contains no rows/**
     * 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
JoinRowSetImpl object.

Note: Calling the method isLast may be expensive
because the JDBC driver might need to fetch ahead one row in order
to determine whether the current row is the last row in this rowset.
Throws:
SQLException – if an error occurs
Returns:
true if the cursor is on the last row;
        false otherwise or if this rowset contains no rows/**
     * 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 JoinRowSetImpl 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 ResultSet.TYPE_FORWARD_ONLY/**
     * 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 JoinRowSetImpl 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/**
     * 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 JoinRowSetImpl object's cursor to the first row
and returns true if the operation was successful.  This
method also notifies registered listeners that the cursor has moved.
Throws:
SQLException – if the type of this rowset
           is ResultSet.TYPE_FORWARD_ONLY
Returns:
true if the cursor is on a valid row;
        false otherwise or if there are no rows in this
        JoinRowSetImpl object/**
     * 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 JoinRowSetImpl object's cursor to the last row
and returns true if the operation was successful.  This
method also notifies registered listeners that the cursor has moved.
Throws:
SQLException – if the type of this rowset
           is ResultSet.TYPE_FORWARD_ONLY
Returns:
true if the cursor is on a valid row;
        false otherwise or if there are no rows in this
        JoinRowSetImpl object/**
     * 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 JoinRowSetImpl
object. The first row is number 1, the second number 2, and so on.
Throws:
SQLException – if an error occurs
Returns:
the number of the current row;  0 if there is no
        current row/**
     * 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 JoinRowSetImpl object's cursor to the row number
specified.
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
crs is a JoinRowSetImpl object, moves the cursor
to the fourth row, starting from the beginning of the rowset.

   crs.absolute(4);
 

If the number is negative, the cursor moves to an absolute row position
with respect to the end of the rowset.  For example, calling
absolute(-1) positions the cursor on the last row,
absolute(-2) moves it on the next-to-last row, and so on.
If the JoinRowSetImpl object crs has five rows,
the following command moves the cursor to the fourth-to-last row, which
in the case of a  rowset with five rows, is also the second row, counting
from the beginning.

   crs.absolute(-4);
 
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.

Note: Calling absolute(1) is the same as calling the
method first().  Calling absolute(-1) is the
same as calling last().
Params:
row – a positive number to indicate the row, starting row numbering from
       the first row, which is 1; a negative number to indicate
       the row, starting row numbering from the last row, which is
       -1; must not be 0
Throws:
SQLException – if the given cursor position is 0 or the
           type of this rowset is ResultSet.TYPE_FORWARD_ONLY
Returns:
true if the cursor is on the rowset; false
        otherwise/**
     * 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.

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
crs is a JoinRowSetImpl 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.

   crs.relative(4);
 

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
absolute(-1) positions the cursor on the last row,
absolute(-2) moves it on the next-to-last row, and so on.
If the JoinRowSetImpl object crs has five rows,
the following command moves the cursor to the fourth-to-last row, which
in the case of a  rowset with five rows, is also the second row
from the beginning.

   crs.absolute(-4);
 
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 SQLException.

Note: Calling absolute(1) is the same as calling the
method first().  Calling absolute(-1) is the
same as calling last().  Calling relative(0)
is valid, but it does not change the cursor position.
Params:
rows – an int indicating the number of rows to move
            the cursor, starting at the current row; a positive number
            moves the cursor forward; a negative number moves the cursor
            backward; must not move the cursor past the valid
            rows
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 ResultSet.TYPE_FORWARD_ONLY
Returns:
true if the cursor is on a row in this
        JoinRowSetImpl object; false
        otherwise/**
     * 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 JoinRowSetImpl object's cursor to the
previous row and returns true if the cursor is on
a valid row or false if it is not.
This method also notifies all listeners registered with this
JoinRowSetImpl object that its cursor has moved.

Note: calling the method previous() is not the same
as calling the method relative(-1).  This is true
because it is possible to call previous() from the insert
row, from after the last row, or from the current row, whereas
relative may only be called from the current row.

The method previous may used in a while
loop to iterate through a rowset starting after the last row
and moving toward the beginning. The loop ends when previous
returns false, meaning that there are no more rows.
For example, the following code fragment retrieves all the data in
the JoinRowSetImpl object crs, which has
three columns.  Note that the cursor must initially be positioned
after the last row so that the first call to the method
previous places the cursor on the last line.
 
    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);
    }
 
This method throws an SQLException if the cursor is not
on a row in the rowset, 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 ResultSet.TYPE_FORWARD_ONLY
Returns:
true if the cursor is on a valid row;
        false if it is before the first row or after the
        last row/**
     * 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 columnName.
Params:
columnName – a String 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 JoinRowSet
       object, ignoring case
Throws:
SQLException – if the given column name does not match one of the
        column names for this JoinRowSet object/**
     * 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 JoinRowSetImpl
object has been updated.  The value returned
depends on whether this rowset can detect updates: false
will always be returned if it does not detect updates.
Throws:
SQLException – if the cursor is on the insert row or not
           on a valid row
See Also:
DatabaseMetaData.updatesAreDetected
Returns:
true if the row has been visibly updated
        by the owner or another and updates are detected;
        false otherwise/**
     * 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 JoinRowSetImpl object has been updated. The
value returned depends on whether this rowset can detcted updates:
false will always be returned if it does not detect updates.
Throws:
SQLException – if the cursor is on the insert row or not
         on a valid row
See Also:
DatabaseMetaData.updatesAreDetected
Returns:
true if the column updated
         false otherwse/**
     * 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.
Throws:
SQLException – if the cursor is on the insert row or not
           not on a valid row
See Also:
DatabaseMetaData.insertsAreDetected
Returns:
true if a row has been inserted and inserts are detected;
        false otherwise/**
     * 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 false if this rowset cannot detect
deletions.
Throws:
SQLException – if the cursor is on a valid row in this rowset
See Also:
DatabaseMetaData.deletesAreDetected
Returns:
true if (1)the current row is blank, indicating that
        the row has been deleted, and (2)deletions are detected;
        false otherwise/**
     * 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 JoinRowSetImpl object with
null value.
 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 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 insertRow must be called to insert the new row into this rowset and to notify listeners that a row has changed. 

In order to propagate updates in this rowset to the underlying
data source, an application must call the method acceptChanges
after it calls either updateRow or insertRow.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
boolean value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
byte value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
short value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
int value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
long value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
float value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
double value. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
java.math.BigDecimal object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
String object.
 This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to mark the row as updated. If the cursor is on the insert row, the method 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. 

The method acceptChanges must be called if the
updated values are to be written back to the underlying database.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
byte array. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Date object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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 DATE or TIMESTAMP, or
           (4) this rowset is ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Time object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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 TIME or TIMESTAMP, or
           (4) this rowset is ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Timestamp object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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 DATE, TIME, or
           TIMESTAMP, or (4) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
java.io.InputStream 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
x – the new column value; must be a java.io.InputStream
         containing BINARY, VARBINARY, or
         LONGVARBINARY data
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
java.io.Reader 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
x – the new column value; must be a java.io.Reader
         containing BINARY, VARBINARY,
         LONGVARBINARY, CHAR, VARCHAR,
         or LONGVARCHAR data
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Object value.  The scale parameter indicates
the number of digits to the right of the decimal point and is ignored
if the new column value is not a type that will be mapped to an SQL
DECIMAL or NUMERIC 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
x – the new column value
scale – the number of digits to the right of the decimal point (for
             DECIMAL and NUMERIC types only)
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Object 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with
null value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method insertRow must be called, which will insert the new row into both this rowset and the database. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
Throws:
SQLException – if (1) the given column name does not match the
           name of a column in this rowset, (2) the cursor is not on
           one of this rowset's rows or its insert row, or (3) this
           rowset is ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
boolean value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
byte value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
short value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
int value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
long value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
float value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
double value. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
java.math.BigDecimal object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
String object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
byte array. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Date object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 DATE or
           TIMESTAMP, or (4) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Time object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 TIME or
           TIMESTAMP, or (4) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Timestamp object. This method updates a column value in either the current row or the insert row of this rowset, but it does not update the database. If the cursor is on a row in the rowset, the method updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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
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 DATE,
           TIME, or TIMESTAMP, or (4) this
           rowset is ResultSet.CONCUR_READ_ONLY/**
     * 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 UnsupportedOperationException
if called.

Sets the designated column in either the current row or the insert
row of this JoinRowSetImpl object with the given
ASCII stream 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
x – the new column value
length – the number of one-byte ASCII characters in the stream
Throws:
UnsupportedOperationException – if this method is invoked/**
     * 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 JoinRowSetImpl object with the given
java.io.InputStream 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
x – the new column value; must be a java.io.InputStream
         containing BINARY, VARBINARY, or
         LONGVARBINARY data
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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
java.io.Reader 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
x – the new column value; must be a java.io.Reader
         containing BINARY, VARBINARY,
         LONGVARBINARY, CHAR, VARCHAR,
         or LONGVARCHAR data
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Object value.  The scale parameter
indicates the number of digits to the right of the decimal point
and is ignored if the new column value is not a type that will be
 mapped to an SQL DECIMAL or NUMERIC 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
x – the new column value
scale – the number of digits to the right of the decimal point (for
             DECIMAL and NUMERIC 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
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Object 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl 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.

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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object as
updated and notifies listeners registered with this rowset that the
row has changed.

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 ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl 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.

This method marks the current row as deleted, but it does not delete
the row from the underlying data source.  The method
acceptChanges must be called to delete the row in
the data source.
Throws:
SQLException – if (1) this method is called when the cursor
           is on the insert row, before the first row, or after the
           last row or (2) this rowset is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 updateRow or deleteRow.
This method should be called only when the cursor is on a row in
this rowset.
Throws:
SQLException – if the cursor is on the insert row, before the
           first row, or after the last row/**
     * 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
JoinRowSetImpl object and notifies listeners that
a row has changed.  To have an effect, this method
must be called after an updateXXX method has been
called and before the method updateRow has been called.
If no updates have been made or the method updateRow
has already been called, this method has no effect.

After updateRow is called it is the
cancelRowUpdates has no affect on the newly
inserted values. The method cancelRowInsert 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/**
     * 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 JoinRowSetImpl object
to the insert row.  The current row in the rowset is remembered
while the cursor is on the insert row.

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 updateXXX
methods to assign a value to each column in the row.  A complete
row must be constructed; that is, every column that is not nullable
must be assigned a value.  In order for the new row to become part
of this rowset, the method insertRow must be called
before the cursor is moved back to the rowset.

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 updateXXX
and insertRow methods, only the getXXX methods
may be called when the cursor is on the insert row.  A getXXX
method should be called on a column only after an updateXXX
method has been called on that column; otherwise, the value returned is
undetermined.
Throws:
SQLException – if this JoinRowSetImpl object is
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object to
the current row.  The current row is the row the cursor was on
when the method moveToInsertRow was called.

Calling this method has no effect unless it is called while the
cursor is on the insert row.
Throws:
SQLException – if an error occurs/**
     * 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 null.
Throws:
SQLException – if an error occurs
Returns:
null/**
     * 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
JoinRowSetImpl object as a Ref object
in the Java programming lanugage.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) the designated column does not store an
           SQL REF value
Returns:
a Ref object representing an SQL REF value/**
     * 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
JoinRowSetImpl object as a Blob object
in the Java programming lanugage.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) the designated column does not store an
           SQL BLOB value
Returns:
a Blob object representing an SQL BLOB value/**
     * 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
JoinRowSetImpl object as a Clob object
in the Java programming lanugage.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) the designated column does not store an
           SQL CLOB value
Returns:
a Clob object representing an SQL CLOB value/**
     * 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
JoinRowSetImpl object as an Array object
in the Java programming lanugage.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
Throws:
SQLException – if (1) the given column index is out of bounds,
           (2) the cursor is not on one of this rowset's rows or its
           insert row, or (3) the designated column does not store an
           SQL ARRAY value
Returns:
an Array object representing an SQL
        ARRAY value/**
     * 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
JoinRowSetImpl object as a Ref object
in the Java programming lanugage.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 REF value
Returns:
a Ref object representing an SQL REF value/**
     * 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
JoinRowSetImpl object as a Blob object
in the Java programming lanugage.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 BLOB value
Returns:
a Blob object representing an SQL
       BLOB value/**
     * 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
JoinRowSetImpl object as a Clob object
in the Java programming lanugage.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 CLOB value
Returns:
a Clob object representing an SQL
        CLOB value/**
     * 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
JoinRowSetImpl object as an Array object
in the Java programming lanugage.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
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 ARRAY value
Returns:
an Array object representing an SQL
       ARRAY value/**
     * 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 JoinRowSetImpl object as a java.sql.Date
object, using the given Calendar object to construct an
appropriate millisecond value for the date.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
cal – the java.util.Calendar object to use in
           constructing the date
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 DATE or
           TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object as a java.sql.Date
object, using the given Calendar object to construct an
appropriate millisecond value for the date.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
cal – the java.util.Calendar object to use in
           constructing the date
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 DATE or
           TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object as a java.sql.Time
object, using the given Calendar object to construct an
appropriate millisecond value for the date.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
cal – the java.util.Calendar object to use in
           constructing the date
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 TIME or
           TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object as a java.sql.Time
object, using the given Calendar object to construct an
appropriate millisecond value for the date.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
cal – the java.util.Calendar object to use in
           constructing the date
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 TIME or
           TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object as a java.sql.Timestamp
object, using the given Calendar object to construct an
appropriate millisecond value for the date.
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in the rowset
cal – the java.util.Calendar object to use in
           constructing the date
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 TIME or
           TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object as a
java.sql.Timestamp object, using the given
Calendar object to construct an appropriate
millisecond value for the date.
Params:
columnName – a String object that must match the
       SQL name of a column in this rowset, ignoring case
cal – the java.util.Calendar object to use in
           constructing the date
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 DATE,
           TIME, or TIMESTAMP value
Returns:
the column value; if the value is SQL NULL,
        the result is null/**
     * 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 JoinRowSetImpl object
with the given RowSetMetaData object.
Params:
md – a RowSetMetaData object instance containing
           metadata about the columsn in the rowset
Throws:
SQLException – if invalid meta data is supplied to the
           rowset/**
    * 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.
Throws:
SQLException – if an error occurs produce the
          ResultSet object
Returns:
the original result set of the rowset/**
    * 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 Also:
setOriginalRow/**
    * 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 JoinRowSetImpl object.
Throws:
SQLException – if the rowset is empty or no columns
          are designated as primary keys
See Also:
setKeyColumns
Returns:
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/**
    * 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 JoinRowSetImpl object's
keyCols field with the given array of column
numbers, which forms a key for uniquely identifying a row
in this rowset.
Params:
cols – an array of int indicating the
       columns that form a primary key for this
       JoinRowSetImpl object; every
       element in the array must be greater than
       0 and less than or equal to the number
       of columns in this rowset
Throws:
SQLException – if any of the numbers in the
           given array is not valid for this rowset
See Also:
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 JoinRowSetImpl object with the given
Ref value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
ref – the java.sql.Ref 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Ref value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object giving the name of the column
       to be updated; must match one of the column names in this
       JoinRowSetImpl object
ref – the java.sql.Ref 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Clob object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
c – the java.sql.Clob 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Clob object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object giving the name of the column
       to be updated; must match one of the column names in this
       JoinRowSetImpl object
c – the java.sql.Clob 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Blob value.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
b – the java.sql.Blob 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Blob object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object giving the name of the column
       to be updated; must match one of the column names in this
       JoinRowSetImpl object
b – the java.sql.Blob 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Array object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnIndex – the first column is 1, the second
       is 2, and so on; must be 1 or larger
       and equal to or less than the number of columns in this rowset
a – the java.sql.Array 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl object with the given
Array object.
 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 updateRow must be called to update the database. If the cursor is on the insert row, the method 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. 
Params:
columnName – a String object giving the name of the column
       to be updated; must match one of the column names in this
       JoinRowSetImpl object
a – the java.sql.Array 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
           ResultSet.CONCUR_READ_ONLY/**
     * 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 JoinRowSetImpl 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.

Another form of this method uses an existing JDBC Connection
object instead of creating a new one; therefore, it ignores the
properties used for establishing a new connection.

The query specified by the command property is executed to create a
ResultSet object from which to retrieve data.
The current contents of the rowset are discarded, and the
rowset's metadata is also (re)set.  If there are outstanding updates,
they are also ignored.

The method execute closes any database connections that it
creates.
Throws:
SQLException – if an error occurs or the
                        necessary properties have not been set/**
     * 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 JoinRowSetImpl 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 execute
that is given a connection ignores these properties.
 @param conn A standard JDBC Connection object with valid
          properties that the JoinRowSet implementation
          can pass to a synchronization provider to establish a
          connection to the datasource
Throws:
SQLException – if an invalid Connection is supplied
          or an error occurs in establishing the connection to the
          data soure
See Also:
Connection/**
     * 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->RowSet /**
     * 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->RowSet /**
     * 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 WebRowSet object, populates it with the
data in the given ResultSet object, and writes it
to the given java.io.Writer object in XML format.
Throws:
SQLException – if an error occurs writing out the rowset
         contents to XML/**
    * 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 JoinRowSet object to the given
java.io.Writer 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/**
     * 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 JoinRowSet object in its XML format.
Throws:
SQLException – if a database access error occurs/**
     * 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 WebRowSet
Throws:
SQLException – if a data source access occurs
IOException – if a IO exception occurs/**
     * 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
WebRowSet for XML proceessing
Throws:
SQLException – if a datasource access occurs
IOException – if an IO exception occurs/**
     * 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 WebRowSet object, populates it with
the contents of the ResultSet and creates an output
streams the internal state and contents of the rowset for XML processing.
Throws:
SQLException – if a datasource access occurs
IOException – if an IO exception occurs/**
     * 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
/**
     * %%% 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 JOIN type in this JoinRowSetImpl
object
Throws:
SQLException – if an error occurs determining the current join type
Returns:
joinType One of the standard JoinRowSet static field JOIN types/**
     * 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 JoinRowSet
object.

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 RowSet object.

Note: if the RowSetListener object is
null, this method silently discards the null
value and does not add a null reference to the set of listeners.

Note: if the listener is already set, and the new RowSetListerner
instance is added to the set of listeners already registered to receive
event notifications from this RowSet.
Params:
listener – an object that has implemented the
    javax.sql.RowSetListener interface and wants to be notified
    of any events that occur on this JoinRowSet object; May be
    null.
See Also:
removeRowSetListener/**
    * 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 JoinRowSet object's list of listeners.
If the given argument is not a registered listener, this method
does nothing.
 Note: if the RowSetListener object is
null, this method silently discards the null
value.
Params:
listener – a RowSetListener object that is on the list
       of listeners for this JoinRowSet object
See Also:
addRowSetListener/**
    * 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 JoinRowSetImpl object to a collection
of tables. The sample implementation utilitizes the TreeMap
collection type.
This class guarantees that the map will be in ascending key order,
sorted according to the natural order for the key's class.
Throws:
SQLException – if an error occurs in generating the collection
See Also:
toCollection(int)
toCollection(String)
TreeMap
Returns:
a Collection object consisting of tables,
        each of which is a copy of a row in this
        JoinRowSetImpl object/**
     * 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 JoinRowSetImpl object
as a Collection object.  This method makes a copy of the
column's data and utilitizes the Vector to establish the
collection. The Vector class implements a growable array
objects allowing the individual components to be accessed using an
an integer index similar to that of an array.
Throws:
SQLException – if an error occurs generated the collection; or
         an invalid column is provided.
See Also:
toCollection()
toCollection(String)
Vector
Returns:
a Collection object that contains the value(s)
        stored in the specified column of this
        JoinRowSetImpl
        object/**
     * 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 JoinRowSetImpl object
as a Collection object.  This method makes a copy of the
column's data and utilitizes the Vector to establish the
collection. The Vector class implements a growable array
objects allowing the individual components to be accessed using an
an integer index similar to that of an array.
Throws:
SQLException – if an error occurs generated the collection; or
         an invalid column is provided.
See Also:
toCollection()
toCollection(int)
Vector
Returns:
a Collection object that contains the value(s)
        stored in the specified column of this
        JoinRowSetImpl
        object/**
     * 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 RowSet object that is a copy of
this JoinRowSetImpl 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.

This helps in getting the underlying XML schema which can
be used as the basis for populating a WebRowSet.
Throws:
SQLException – if an error occurs in generating the copy
of the CachedRowSet object
See Also:
CachedRowSetImpl.createShared
CachedRowSetImpl.createCopy
CachedRowSetImpl.createCopyNoConstraints
RowSetEvent
RowSetListener
Returns:
a new CachedRowSet object that is a copy
of this JoinRowSetImpl object's schema and
retains all the constraints on the original rowset but contains
no data/**
     * 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}
/**
      * {@inheritDoc}
      */
     public void setSyncProvider(String providerStr) throws SQLException {
         crsInternal.setSyncProvider(providerStr);
     }

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

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

    
This method re populates the resBundle
during the deserialization process
/**
     * 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;
}