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
* This method should be used when the given
* This method should be used when the given
* This method should be used when the given
* The first
* This method should be used when the given
* The first
* This method should be used when the given
* If any updates or modifications have been applied to this
* To persist changes back to the data source, the
* Implementations should throw an If an input stream from the previous row is open, it is
* implicitly closed. The
* This method is deprecated; use the version of 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.
*
* @param columnIndex the first column is 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.
*
* @param columnIndex the first column is
* 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 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 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.
*
* @param columnName a The warning chain is automatically cleared each time a new
* row is read.
*
* Note: This warning chain only covers warnings caused
* by
* After a call to this method, the 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 JDBC supports this SQL feature by providing the name of the
* SQL cursor used by a Note: If positioned updates are not supported, an
*
* The type of the
* This method may also be used to read datatabase-specific
* abstract data types.
*
* This implementation of the method
* The type of the
* This method may also be used to read datatabase-specific
* abstract data types.
*
* This implementation of the method
* The type of the
* This method may also be used to read datatabase-specific
* abstract data types.
*
* This implementation of the method 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 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
* Note: Calling the method 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
*
* If the number is negative, the cursor moves to an absolute row position
* with respect to the end of the rowset. For example, calling
*
* Note: Calling
* 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
*
* 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
*
* Note: Calling
* Note: calling the method
* The method
* 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.
*
* In order to propagate updates in this rowset to the underlying
* data source, an application must call the method acceptChanges
* after it calls either
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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.
*
* The method
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* Sets the designated column in either the current row or the insert
* row of this
* 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
* 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
* 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
* 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
* 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
* 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
*
* 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
* This method marks the current row as deleted, but it does not delete
* the row from the underlying data source. The method
*
* After
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* 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
* Another form of this method uses an existing JDBC
* The query specified by the command property is executed to create a
*
* The method
* 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
* Note: if the
* Note: if the listener is already set, and the new
* This helps in getting the underlying XML schema which can
* be used as the basis for populating 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
*/
public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
/**
* A Vector object that contains the RowSet objects
* that have been added to this JoinRowSet object.
*/
private VectorCachedRowSet 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.
*/
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.
*/
private VectorVector object containing the names of all the tables entering
* the join.
*/
private Vectorint that indicates the column index of the match column.
*/
private int iMatchKey;
/**
* A String 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.
*/
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.
*/
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
*/
public JoinRowSetImpl() throws SQLException {
vecRowSetsInJOIN = new VectorRowSet 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.
* RowSet object
* already has a match column set.
*
* @param 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 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; iJOIN 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 .
* RowSet object
* does not already have a match column set.
*
* @param rowset a RowSet object to be added to
* the JOIN relation; must implement the Joinable
* interface
* @param 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 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 .
* RowSet object
* does not already have a match column set.
*
* @param rowset a RowSet object to be added to
* the JOIN relation
* @param 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
*/
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.
* 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.
* RowSet objects
* do not already have match columns set.
*
* @param rowset an array of RowSet objects to be added to
* the JOIN relation; each RowSet object must
* implement the Joinable interface
* @param 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
*/
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.
* 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.
* RowSet objects
* do not already have match columns set.
*
* @param rowset an array of RowSet objects to be added to
* the JOIN relation; each RowSet object must
* implement the Joinable interface
* @param 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
*/
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.
*
* @return A Collection of the added RowSet
* object instances
* @throws SQLException if an error occours generating a collection
* of the originating RowSets contained within the JOIN.
*/
public Collection getRowSets() throws SQLException {
return vecRowSetsInJOIN;
}
/**
* Returns a string array of the RowSet names currently residing
* with the JoinRowSet 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.
* 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.
* 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.
*
* @return a CachedRowSet object containing the contents of this
* JoinRowSet object
* @throws SQLException if an error occurs assembling the CachedRowSet
* 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.
*
* @return true if the CROSS_JOIN is supported; false
* 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.
*
* @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.
*
* @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.
*
* @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.
*
* @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.
* SQLException if they do
* not support the given JOIN type.
*
* @param 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
*/
public void setJoinType(int type) throws SQLException {
// The join which governs the join of two rowsets is the last
// join set, using setJoinType
if (type >= JoinRowSet.CROSS_JOIN && type <= JoinRowSet.FULL_JOIN) {
if (type != JoinRowSet.INNER_JOIN) {
// This 'if' will be removed after all joins are implemented.
throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notsupported").toString());
} else {
Integer Intgr = Integer.valueOf(JoinRowSet.INNER_JOIN);
vecJoinType.add(Intgr);
}
} else {
throw new SQLException(resBundle.handleGetObject("joinrowsetimpl.notdefined").toString());
} //end if
}
/**
* This checks for a match column for
* whether it exists or not.
*
* @param CachedRowSet 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.
*/
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; kJoinRowSet 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.
*
* @return whereClause a textual or SQL descripition of the logical
* WHERE cluase used in the JoinRowSet instance
* @throws SQLException if an error occurs in generating a representation
* of the WHERE 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;iResultSet 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.
*
* ResultSet object's warning
* chain is cleared when a new row is read.
*
* @return true if the new current row is valid;
* false if there are no more rows
* @throws SQLException if an error occurs or
* the cursor is not positioned in the rowset, before
* the first row, or after the last row
*/
public boolean next() throws SQLException {
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
*/
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.
*
* @return true if the value in the last column read
* was SQL NULL; false 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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is false
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is 0
* @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.
* getBigDecimal
* that does not take a scale parameter and returns a value with full
* precision.
*
* @param 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
* @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 NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
* @deprecated
*/
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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or the 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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public java.sql.Date getDate(int columnIndex) throws SQLException {
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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public java.sql.Time getTime(int columnIndex) throws SQLException {
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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
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.
*
* @param 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
* @return the column value; if the value is SQL NULL, the
* result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public java.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.
*
* 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
* @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
*/
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.
*
* 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
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
*/
public 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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is false
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is 0
* @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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @param scale the number of digits to the right of the decimal point
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
* @deprecated use the method getBigDecimal(String columnName)
* instead
*/
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
return crsInternal.getBigDecimal(columnName);
}
/**
* Retrieves the value stored in the designated column
* of the current row as a byte array.
* The bytes represent the raw values returned by the driver.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
*/
public 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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
*/
public java.sql.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.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
*/
public java.sql.Time getTime(String columnName) throws SQLException {
return crsInternal.getTime(columnName);
}
/**
* Retrieves the value stored in the designated column
* of the current row as a java.sql.Timestamp object.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
*/
public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
return crsInternal.getTimestamp(columnName);
}
/**
* This method is not supported, and it will throw an
* UnsupportedOperationException if it is called.
* getXXX method implicitly closes the stream.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl 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
* NULL, the result is null.
* @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.
*
* getXXX method implicitly closes the stream.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl 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 NULL, the result is null.
* @throws SQLException if the given column name does not match one of
* this rowset's column names or the cursor is not on one of
* this rowset's rows or its insert row
* @deprecated use the method getCharacterStream instead
*/
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.
*
* String object giving the SQL name of
* a column in this JoinRowSetImpl object
* @return 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.
* @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 JoinRowSetImpl
* object is returned. Subsequent JoinRowSetImpl warnings will
* be chained to this SQLWarning.
*
* ResultSet methods. Any warning caused by statement
* methods (such as reading OUT parameters) will be chained on the
* Statement 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.
* getWarnings method
* returns null until a new warning is reported for this
* JoinRowSetImpl 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.
*
* SELECT
* statement should be of the form 'select for update'. If the 'for update'
* clause is omitted, positioned updates may fail.
*
* ResultSet object. The current row
* of a result set is also the current row of this SQL cursor.
*
* SQLException is thrown.
*
* @return the SQL cursor name for this JoinRowSetImpl 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.
*
* @return the ResultSetMetaData object that describes this
* JoinRowSetImpl 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.
* 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.
* 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()).
*
* @param 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
* @return a java.lang.Object holding the column value;
* if the value is SQL NULL, the result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or there is a problem getting
* the Class 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.
* 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.
* 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()).
*
* @param 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
* @param map a java.util.Map object showing the mapping
* from SQL type names to classes in the Java programming
* language
* @return a java.lang.Object holding the column value;
* if the value is SQL NULL, the result is
* null
* @throws SQLException if (1) the given column name does not match
* one of this rowset's column names, (2) the cursor is not
* on a valid row, or (3) there is a problem getting
* the Class object for a custom mapping
*/
public Object getObject(int columnIndex,
java.util.MapJoinRowSetImpl object as an
* Object value.
* 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.
* 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()).
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a java.lang.Object holding the column value;
* if the value is SQL NULL, the result is
* null
* @throws SQLException if (1) the given column name does not match
* one of this rowset's column names, (2) the cursor is not
* on a valid row, or (3) there is a problem getting
* the Class 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param map a java.util.Map object showing the mapping
* from SQL type names to classes in the Java programming
* language
* @return an Object representing the SQL value
* @throws SQLException if the given column index is out of bounds or
* the cursor is not on one of this rowset's rows or its
* insert row
*/
public Object getObject(String columnName,
java.util.Mapjava.io.Reader object.
*
* getXXX method implicitly closes the stream.
*
* @param 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
* @return 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.
* @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.
*
* getXXX method implicitly closes the stream.
*
* @param columnName a String object giving the SQL name of
* a column in this JoinRowSetImpl 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 NULL, the result is null.
* @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.
*
* @param 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
* @return a java.math.BigDecimal value with full precision;
* if the value is SQL NULL, the result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a java.math.BigDecimal value with full precision;
* if the value is SQL NULL, the result is null
* @throws SQLException if the given column index is out of bounds,
* the cursor is not on a valid row, or this method fails
*/
public BigDecimal getBigDecimal(String columnName) throws SQLException {
return crsInternal.getBigDecimal(columnName);
}
/**
* Returns the number of rows in this JoinRowSetImpl 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.
*
* @return true if the cursor is before the first row;
* false 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.
*
* @return true if the cursor is after the last row;
* false 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.
*
* @return true if the cursor is on the first row;
* false 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.
* isLast may be expensive
* because the JDBC driver might need to fetch ahead one row in order
* to determine whether the current row is the last row in this rowset.
*
* @return true if the cursor is on the last row;
* false 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
*/
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
*/
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.
*
* @return true if the cursor is on a valid row;
* false otherwise or if there are no rows in this
* JoinRowSetImpl object
* @throws SQLException if the type of this rowset
* is ResultSet.TYPE_FORWARD_ONLY
*/
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.
*
* @return true if the cursor is on a valid row;
* false otherwise or if there are no rows in this
* JoinRowSetImpl object
* @throws SQLException if the type of this rowset
* is ResultSet.TYPE_FORWARD_ONLY
*/
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.
*
* @return the number of the current row; 0 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.
*
* crs is a JoinRowSetImpl object, moves the cursor
* to the fourth row, starting from the beginning of the rowset.
*
*
*
* crs.absolute(4);
*
* 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.
*
*
* 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.
*
*
* crs.absolute(-4);
*
* absolute(1) is the same as calling the
* method first(). Calling absolute(-1) is the
* same as calling last().
*
* @param 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
* @return true if the cursor is on the rowset; false
* otherwise
* @throws SQLException if the given cursor position is 0 or the
* type of this rowset is ResultSet.TYPE_FORWARD_ONLY
*/
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.
* 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);
*
* 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.
*
*
* 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
*
* crs.absolute(-4);
*
* SQLException.
* 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.
*
* @param 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
* @return true if the cursor is on a row in this
* JoinRowSetImpl object; false
* otherwise
* @throws SQLException if there are no rows in this rowset, the cursor is
* positioned either before the first row or after the last row, or
* the rowset is type ResultSet.TYPE_FORWARD_ONLY
*/
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.
* 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.
* 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.
*
* This method throws an
*
* 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);
* }
*
* SQLException if the cursor is not
* on a row in the rowset, before the first row, or after the last row.
*
* @return true if the cursor is on a valid row;
* false if it is before the first row or after the
* last row
* @throws SQLException if the cursor is not on a valid position or the
* type of this rowset is ResultSet.TYPE_FORWARD_ONLY
*/
public boolean previous() throws SQLException {
return crsInternal.previous();
}
/**
* Returns the index of the column whose name is columnName.
*
* @param 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
*/
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.
*
* @return true if the row has been visibly updated
* by the owner or another and updates are detected;
* false 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.
*
* @return true if the column updated
* false otherwse
* @throws SQLException if the cursor is on the insert row or not
* on a valid row
* @see DatabaseMetaData#updatesAreDetected
*/
public boolean columnUpdated(int indexColumn) throws SQLException {
return crsInternal.columnUpdated(indexColumn);
}
/**
* Indicates whether the current row has been inserted. The value returned
* depends on whether or not the rowset can detect visible inserts.
*
* @return true if a row has been inserted and inserts are detected;
* false otherwise
* @throws SQLException if the cursor is on the insert row or not
* not on a valid row
*
* @see DatabaseMetaData#insertsAreDetected
*/
public boolean rowInserted() throws SQLException {
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.
*
* @return true if (1)the current row is blank, indicating that
* the row has been deleted, and (2)deletions are detected;
* false 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.
* updateRow or insertRow.
*
* @param 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
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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 {@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 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* acceptChanges must be called if the
* updated values are to be written back to the underlying database.
*
* @param 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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 {@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 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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 {@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 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
* @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 DATE or TIMESTAMP, or
* (4) this rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 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
* @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 TIME or TIMESTAMP, or
* (4) this rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 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
* @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 DATE, TIME, or
* TIMESTAMP, or (4) this rowset is
* ResultSet.CONCUR_READ_ONLY
*/
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 JoinRowSetImpl object with the given
* ASCII stream value.
* 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
* @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.
* 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
* @param x the new column value; must be a java.io.InputStream
* containing BINARY, VARBINARY, or
* LONGVARBINARY data
* @param length the length of the stream in bytes
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the data in the stream is not binary, or
* (4) this rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @param x the new column value; must be a java.io.Reader
* containing BINARY, VARBINARY,
* LONGVARBINARY, CHAR, VARCHAR,
* or LONGVARCHAR data
* @param length the length of the stream in characters
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the data in the stream is not a binary or
* character type, or (4) this rowset is
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
* @param x the new column value
* @param 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
*/
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.
* 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
* @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
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL DATE or
* TIMESTAMP, or (4) this rowset is
* ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL TIME or
* TIMESTAMP, or (4) this rowset is
* ResultSet.CONCUR_READ_ONLY
*/
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 {@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 String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if the given column index is out of bounds or
* the cursor is not on one of this rowset's rows or its
* insert row
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL DATE,
* TIME, or TIMESTAMP, or (4) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
crsInternal.updateTimestamp(columnName, x);
}
/**
* Unsupported; throws an UnsupportedOperationException
* if called.
* JoinRowSetImpl object with the given
* ASCII stream value.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @param length the number of one-byte ASCII characters in the stream
* @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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value; must be a java.io.InputStream
* containing BINARY, VARBINARY, or
* LONGVARBINARY data
* @param length the length of the stream in bytes
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the data
* in the stream is not binary, or (4) this rowset is
* ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value; must be a java.io.Reader
* containing BINARY, VARBINARY,
* LONGVARBINARY, CHAR, VARCHAR,
* or LONGVARCHAR data
* @param length the length of the stream in characters
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the data
* in the stream is not a binary or character type, or (4) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @param scale the number of digits to the right of the decimal point (for
* 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
* @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
*/
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.
* String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is ResultSet.CONCUR_READ_ONLY
*/
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.
* ResultSet.CONCUR_READ_ONLY
*/
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.
* ResultSet.CONCUR_READ_ONLY
*/
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.
* 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
*/
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
*/
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.
* 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
*/
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.
* 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.
* 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
*/
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.
* null.
*
* @return null
* @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.
*
* @param 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
* @return a Ref object representing an SQL REF value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL REF 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.
*
* @param 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
* @return a Blob object representing an SQL BLOB value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL BLOB 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.
*
* @param 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
* @return a Clob object representing an SQL CLOB value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL CLOB 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.
*
* @param 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
* @return an Array object representing an SQL
* ARRAY value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL ARRAY 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a Ref object representing an SQL REF value
* @throws SQLException if (1) the given column name is not the name
* of a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the column value
* is not an SQL REF 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a Blob object representing an SQL
* BLOB value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL BLOB 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a Clob object representing an SQL
* CLOB value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL CLOB 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return an Array object representing an SQL
* ARRAY value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL ARRAY 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.
*
* @param 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
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL DATE or
* TIMESTAMP 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL DATE or
* TIMESTAMP 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.
*
* @param 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
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL TIME or
* TIMESTAMP 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL TIME or
* TIMESTAMP 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.
*
* @param 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
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL TIME or
* TIMESTAMP 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.
*
* @param columnName a String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL NULL,
* the result is null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL DATE,
* TIME, or TIMESTAMP 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.
*
* @param md a RowSetMetaData object instance containing
* metadata about the columsn in the rowset
* @throws SQLException if invalid meta data is supplied to the
* rowset
*/
public void setMetaData(RowSetMetaData md) throws SQLException {
crsInternal.setMetaData(md);
}
public ResultSet getOriginal() throws SQLException {
return crsInternal.getOriginal();
}
/**
* Returns a result set containing the original value of the rowset.
* The cursor is positioned before the first row in the result set.
* Only rows contained in the result set returned by getOriginal()
* are said to have an original value.
*
* @return the original result set of the rowset
* @throws SQLException if an error occurs produce the
* ResultSet object
*/
public ResultSet getOriginalRow() throws SQLException {
return crsInternal.getOriginalRow();
}
/**
* Returns a result set containing the original value of the current
* row only.
*
* @throws SQLException if there is no current row
* @see #setOriginalRow
*/
public void setOriginalRow() throws SQLException {
crsInternal.setOriginalRow();
}
/**
* Returns the columns that make a key to uniquely identify a
* row in this JoinRowSetImpl 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.
*
* @param 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 #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.
* 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
* @param 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
*/
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.
* String object giving the name of the column
* to be updated; must match one of the column names in this
* JoinRowSetImpl object
* @param 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
*/
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.
* 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
* @param 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
*/
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.
* String object giving the name of the column
* to be updated; must match one of the column names in this
* JoinRowSetImpl object
* @param 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
*/
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.
* 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
* @param 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
*/
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.
* String object giving the name of the column
* to be updated; must match one of the column names in this
* JoinRowSetImpl object
* @param 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
*/
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.
* 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
* @param 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
*/
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.
* String object giving the name of the column
* to be updated; must match one of the column names in this
* JoinRowSetImpl object
* @param 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
*/
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.
* Connection
* object instead of creating a new one; therefore, it ignores the
* properties used for establishing a new connection.
* 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.
* execute closes any database connections that it
* creates.
*
* @throws SQLException if an error occurs or the
* necessary properties have not been set
*/
public void execute() throws SQLException {
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 java.sql.Connection
*/
public void execute(Connection conn) throws SQLException {
crsInternal.execute(conn);
}
/**
* Provide interface coverage for getURL(int) in ResultSet->RowSet
*/
public java.net.URL getURL(int columnIndex) throws SQLException {
return crsInternal.getURL(columnIndex);
}
/**
* Provide interface coverage for getURL(String) in ResultSet->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
*/
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
*/
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
*/
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
* @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 an output stream of the internal state and contents of a
* WebRowSet 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
* @throws IOException if an IO exception occurs
*/
public void writeXml(ResultSet rs, java.io.OutputStream oStream) throws SQLException, IOException {
wrs = new WebRowSetImpl();
wrs.populate(rs);
wrs.writeXml(oStream);
}
/**
* %%% Javadoc comments to be added here
*/
private WebRowSet createWebRowSet() throws SQLException {
if(wrs != null) {
// check if it has already been initialized.
return wrs;
} else {
wrs = new WebRowSetImpl();
crsInternal.beforeFirst();
wrs.populate(crsInternal);
return wrs;
}
}
/**
* Returns the last set SQL JOIN 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 = (Integer)(vecJoinType.get(vecJoinType.size()-1));
return i.intValue();
}
/**
* The listener will be notified whenever an event occurs on this JoinRowSet
* object.
* RowSet object.
* RowSetListener object is
* null, this method silently discards the null
* value and does not add a null reference to the set of listeners.
* RowSetListerner
* instance is added to the set of listeners already registered to receive
* event notifications from this RowSet.
*
* @param 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 #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.
*
* @param listener a RowSetListener object that is on the list
* of listeners for this JoinRowSet 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.
*
* @return a Collection object consisting of tables,
* each of which is a copy of a row in this
* JoinRowSetImpl 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.
*
* @return a Collection object that contains the value(s)
* stored in the specified column of this
* JoinRowSetImpl
* 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.
*
* @return a Collection object that contains the value(s)
* stored in the specified column of this
* JoinRowSetImpl
* 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.
* WebRowSet.
*
* @return 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
* @throws SQLException if an error occurs in generating the copy
* of the CachedRowSet object
* @see #createShared
* @see #createCopy
* @see #createCopyNoConstraints
* @see javax.sql.RowSetEvent
* @see javax.sql.RowSetListener
*/
public CachedRowSet createCopySchema() throws SQLException {
return crsInternal.createCopySchema();
}
/**
* {@inheritDoc}
*/
public void setSyncProvider(String providerStr) throws SQLException {
crsInternal.setSyncProvider(providerStr);
}
/**
* {@inheritDoc}
*/
public void acceptChanges() throws SyncProviderException {
crsInternal.acceptChanges();
}
/**
* {@inheritDoc}
*/
public SyncProvider getSyncProvider() throws SQLException {
return crsInternal.getSyncProvider();
}
/**
* This method re populates the resBundle
* during the deserialization process
*
*/
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
// Default state initialization happens here
ois.defaultReadObject();
// Initialization of transient Res Bundle happens here .
try {
resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
} catch(IOException ioe) {
throw new RuntimeException(ioe);
}
}
static final long serialVersionUID = -5590501621560008453L;
}