Java example source code file (SyncResolverImpl.java)
The SyncResolverImpl.java Java example source code/*
* Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.rowset.internal;
import java.sql.*;
import javax.sql.*;
import java.util.*;
import java.math.BigDecimal;
import javax.sql.rowset.*;
import javax.sql.rowset.spi.*;
import com.sun.rowset.*;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* There will be two sets of data which will be maintained by the rowset at the
* time of synchronization. The <code>SyncProvider will utilize the
* <code>SyncResolver to synchronize the changes back to database.
*/
public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
/**
* This CachedRowSet object will encapsulate a rowset
* which will be sync'ed with the datasource but will
* contain values in rows where there is conflict.
* For rows other than conflict, it will *not* contain
* any data. For rows containing conflict it will
* return either of the three values set by SyncResolver.*_CONFLICT
* from getStatus()
*/
private CachedRowSetImpl crsRes;
/**
* This is the actual CachedRowSet object
* which is being synchronized back to
* datasource.
*/
private CachedRowSetImpl crsSync;
/**
* This ArrayList will contain the status of a row
* from the SyncResolver.* values else it will be null.
*/
private ArrayList<?> stats;
/**
* The RowSetWriter associated with the original
* CachedRowSet object which is being synchronized.
*/
private CachedRowSetWriter crw;
/**
* Row number identifier
*/
private int rowStatus;
/**
* This will contain the size of the <code>CachedRowSet object
*/
private int sz;
/**
* The <code>Connection handle used to synchronize the changes
* back to datasource. This is the same connection handle as was passed
* to the CachedRowSet while fetching the data.
*/
private transient Connection con;
/**
* The <code>CachedRowSet object which will encapsulate
* a row at any time. This will be built from CachedRowSet and
* SyncResolver values. Synchronization takes place on a row by
* row basis encapsulated as a CahedRowSet.
*/
private CachedRowSet row;
private JdbcRowSetResourceBundle resBundle;
/**
* Public constructor
*/
public SyncResolverImpl() throws SQLException {
try {
crsSync = new CachedRowSetImpl();
crsRes = new CachedRowSetImpl();
crw = new CachedRowSetWriter();
row = new CachedRowSetImpl();
rowStatus = 1;
try {
resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
} catch(IOException ioe) {
throw new RuntimeException(ioe);
}
} catch(SQLException sqle) {
}
}
/**
* Retrieves the conflict status of the current row of this
* <code>SyncResolver, which indicates the operationthe
* <P>
* If the number is negative, the cursor moves to an absolute row position
* with respect to the end of the rowset. For example, calling
* <code>absolute(-1) positions the cursor on the last row,
* <code>absolute(-2) moves it on the next-to-last row, and so on.
* If the <code>CachedRowSetImpl object crs has five rows,
* the following command moves the cursor to the fourth-to-last row, which
* in the case of a rowset with five rows, is also the second row, counting
* from the beginning.
* <PRE>
*
* crs.absolute(-4);
*
* </code>
*
* If the number specified is larger than the number of rows, the cursor
* will move to the position after the last row. If the number specified
* would move the cursor one or more rows before the first row, the cursor
* moves to the position before the first row.
* <P>
* Note: Calling <code>absolute(1) is the same as calling the
* method <code>first(). Calling absolute(-1) is the
* same as calling <code>last().
*
* @param row a positive number to indicate the row, starting row numbering from
* the first row, which is <code>1; a negative number to indicate
* the row, starting row numbering from the last row, which is
* <code>-1; it must not be 0
* @return <code>true if the cursor is on the rowset; false
* otherwise
* @throws SQLException if the given cursor position is <code>0 or the
* type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY
*/
public boolean absolute( int row ) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Moves the cursor the specified number of rows from the current
* position, with a positive number moving it forward and a
* negative number moving it backward.
* <P>
* If the number is positive, the cursor moves the specified number of
* rows toward the end of the rowset, starting at the current row.
* For example, the following command, in which
* <code>crs is a CachedRowSetImpl object with 100 rows,
* moves the cursor forward four rows from the current row. If the
* current row is 50, the cursor would move to row 54.
* <PRE>
*
* crs.relative(4);
*
* </code>
* <P>
* If the number is negative, the cursor moves back toward the beginning
* the specified number of rows, starting at the current row.
* For example, calling the method
* <code>absolute(-1) positions the cursor on the last row,
* <code>absolute(-2) moves it on the next-to-last row, and so on.
* If the <code>CachedRowSetImpl object crs has five rows,
* the following command moves the cursor to the fourth-to-last row, which
* in the case of a rowset with five rows, is also the second row
* from the beginning.
* <PRE>
*
* crs.absolute(-4);
*
* </code>
*
* If the number specified is larger than the number of rows, the cursor
* will move to the position after the last row. If the number specified
* would move the cursor one or more rows before the first row, the cursor
* moves to the position before the first row. In both cases, this method
* throws an <code>SQLException.
* <P>
* Note: Calling <code>absolute(1) is the same as calling the
* method <code>first(). Calling absolute(-1) is the
* same as calling <code>last(). Calling relative(0)
* is valid, but it does not change the cursor position.
*
* @param rows an <code>int indicating the number of rows to move
* the cursor, starting at the current row; a positive number
* moves the cursor forward; a negative number moves the cursor
* backward; must not move the cursor past the valid
* rows
* @return <code>true if the cursor is on a row in this
* <code>CachedRowSetImpl object; false
* otherwise
* @throws SQLException if there are no rows in this rowset, the cursor is
* positioned either before the first row or after the last row, or
* the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY
*/
public boolean relative(int rows) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Moves this <code>CachedRowSetImpl object's cursor to the
* previous row and returns <code>true if the cursor is on
* a valid row or <code>false if it is not.
* This method also notifies all listeners registered with this
* <code>CachedRowSetImpl object that its cursor has moved.
* <P>
* Note: calling the method <code>previous() is not the same
* as calling the method <code>relative(-1). This is true
* because it is possible to call <code>previous() from the insert
* row, from after the last row, or from the current row, whereas
* <code>relative may only be called from the current row.
* <P>
* The method <code>previous may used in a while
* loop to iterate through a rowset starting after the last row
* and moving toward the beginning. The loop ends when <code>previous
* returns <code>false, meaning that there are no more rows.
* For example, the following code fragment retrieves all the data in
* the <code>CachedRowSetImpl object crs, which has
* three columns. Note that the cursor must initially be positioned
* after the last row so that the first call to the method
* <code>previous places the cursor on the last line.
* <PRE>
*
* crs.afterLast();
* while (previous()) {
* String name = crs.getString(1);
* int age = crs.getInt(2);
* short ssn = crs.getShort(3);
* System.out.println(name + " " + age + " " + ssn);
* }
*
* </code>
* This method throws an <code>SQLException if the cursor is not
* on a row in the rowset, before the first row, or after the last row.
*
* @return <code>true if the cursor is on a valid row;
* <code>false if it is before the first row or after the
* last row
* @throws SQLException if the cursor is not on a valid position or the
* type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY
*/
public boolean previous() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Moves the cursor to the previous row in this <code>CachedRowSetImpl
* object, skipping past deleted rows that are not visible; returns
* <code>true if the cursor is on a row in this rowset and
* <code>false when the cursor goes before the first row.
* <P>
* This method is called internally by the method <code>previous.
* <P>
* This is a implementation only method and is not required as a standard
* implementation of the <code>CachedRowSet interface.
*
* @return <code>true if the cursor is on a row in this rowset;
* <code>false when the cursor reaches the position before
* the first row
* @throws SQLException if an error occurs
*/
protected boolean internalPrevious() throws SQLException {
throw new UnsupportedOperationException();
}
//---------------------------------------------------------------------
// Updates
//---------------------------------------------------------------------
/**
* Indicates whether the current row of this <code>CachedRowSetImpl
* object has been updated. The value returned
* depends on whether this rowset can detect updates: <code>false
* will always be returned if it does not detect updates.
*
* @return <code>true if the row has been visibly updated
* by the owner or another and updates are detected;
* <code>false otherwise
* @throws SQLException if the cursor is on the insert row or not
* not on a valid row
*
* @see DatabaseMetaData#updatesAreDetected
*/
public boolean rowUpdated() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Indicates whether the designated column of the current row of
* this <code>CachedRowSetImpl object has been updated. The
* value returned depends on whether this rowset can detcted updates:
* <code>false will always be returned if it does not detect updates.
*
* @param idx the index identifier of the column that may be have been updated.
* @return <code>true is the designated column has been updated
* and the rowset detects updates; <code>false if the rowset has not
* been updated or the rowset does not detect updates
* @throws SQLException if the cursor is on the insert row or not
* on a valid row
* @see DatabaseMetaData#updatesAreDetected
*/
public boolean columnUpdated(int idx) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Indicates whether the designated column of the current row of
* this <code>CachedRowSetImpl object has been updated. The
* value returned depends on whether this rowset can detcted updates:
* <code>false will always be returned if it does not detect updates.
*
* @param columnName the <code>String column name column that may be have
* been updated.
* @return <code>true is the designated column has been updated
* and the rowset detects updates; <code>false if the rowset has not
* been updated or the rowset does not detect updates
* @throws SQLException if the cursor is on the insert row or not
* on a valid row
* @see DatabaseMetaData#updatesAreDetected
*/
public boolean columnUpdated(String columnName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Indicates whether the current row has been inserted. The value returned
* depends on whether or not the rowset can detect visible inserts.
*
* @return <code>true if a row has been inserted and inserts are detected;
* <code>false otherwise
* @throws SQLException if the cursor is on the insert row or not
* not on a valid row
*
* @see DatabaseMetaData#insertsAreDetected
*/
public boolean rowInserted() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Indicates whether the current row has been deleted. A deleted row
* may leave a visible "hole" in a rowset. This method can be used to
* detect such holes if the rowset can detect deletions. This method
* will always return <code>false if this rowset cannot detect
* deletions.
*
* @return <code>true if (1)the current row is blank, indicating that
* the row has been deleted, and (2)deletions are detected;
* <code>false otherwise
* @throws SQLException if the cursor is on a valid row in this rowset
* @see DatabaseMetaData#deletesAreDetected
*/
public boolean rowDeleted() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated nullable column in the current row or the
* insert row of this <code>CachedRowSetImpl object with
* <code>null value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset; however, another method must be called to complete
* the update process. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to mark the row as updated
* and to notify listeners that the row has changed.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called to insert the new row into this rowset and to notify
* listeners that a row has changed.
* <P>
* In order to propagate updates in this rowset to the underlying
* data source, an application must call the method {@link #acceptChanges}
* after it calls either <code>updateRow or insertRow.
*
* @param columnIndex the first column is <code>1, the second
* is <code>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
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateNull(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>boolean value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>byte value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateByte(int columnIndex, byte x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>short value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateShort(int columnIndex, short x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>int value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateInt(int columnIndex, int x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>long value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateLong(int columnIndex, long x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>float value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateFloat(int columnIndex, float x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateDouble(int columnIndex, double x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.math.BigDecimal object.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>String object.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to mark the row as updated.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called to insert the new row into this rowset and mark it
* as inserted. Both of these methods must be called before the
* cursor moves to another row.
* <P>
* The method <code>acceptChanges must be called if the
* updated values are to be written back to the underlying database.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateString(int columnIndex, String x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>byte array.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBytes(int columnIndex, byte x[]) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Date object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the type of the designated column is not
* an SQL <code>DATE or TIMESTAMP, or
* (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Time object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the type of the designated column is not
* an SQL <code>TIME or TIMESTAMP, or
* (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Timestamp object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the type of the designated column is not
* an SQL <code>DATE, TIME, or
* <code>TIMESTAMP, or (4) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* ASCII stream value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @param length the number of one-byte ASCII characters in the stream
* @throws SQLException if this method is invoked
*/
public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.io.InputStream object.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value; must be a <code>java.io.InputStream
* containing <code>BINARY, VARBINARY, or
* <code>LONGVARBINARY data
* @param length the length of the stream in bytes
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the data in the stream is not binary, or
* (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.io.Reader object.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value; must be a <code>java.io.Reader
* containing <code>BINARY, VARBINARY,
* <code>LONGVARBINARY, CHAR, VARCHAR,
* or <code>LONGVARCHAR data
* @param length the length of the stream in characters
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, (3) the data in the stream is not a binary or
* character type, or (4) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Object value. The scale parameter indicates
* the number of digits to the right of the decimal point and is ignored
* if the new column value is not a type that will be mapped to an SQL
* <code>DECIMAL or NUMERIC value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @param scale the number of digits to the right of the decimal point (for
* <code>DECIMAL and NUMERIC types only)
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Object value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param x the new column value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateObject(int columnIndex, Object x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated nullable column in the current row or the
* insert row of this <code>CachedRowSetImpl object with
* <code>null value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateNull(String columnName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>boolean value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBoolean(String columnName, boolean x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>byte value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateByte(String columnName, byte x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>short value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateShort(String columnName, short x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>int value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateInt(String columnName, int x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>long value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateLong(String columnName, long x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>float value.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateFloat(String columnName, float x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateDouble(String columnName, double x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.math.BigDecimal object.
* <P>
* This method updates a column value in the current row or the insert
* row of this rowset, but it does not update the database.
* If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>String object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateString(String columnName, String x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>byte array.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBytes(String columnName, byte x[]) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Date object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL <code>DATE or
* <code>TIMESTAMP, or (4) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateDate(String columnName, java.sql.Date x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Time object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL <code>TIME or
* <code>TIMESTAMP, or (4) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateTime(String columnName, java.sql.Time x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Timestamp object.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if the given column index is out of bounds or
* the cursor is not on one of this rowset's rows or its
* insert row
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the type
* of the designated column is not an SQL <code>DATE,
* <code>TIME, or TIMESTAMP, or (4) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* ASCII stream value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @param length the number of one-byte ASCII characters in the stream
*/
public void updateAsciiStream(String columnName,
java.io.InputStream x,
int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.io.InputStream object.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value; must be a <code>java.io.InputStream
* containing <code>BINARY, VARBINARY, or
* <code>LONGVARBINARY data
* @param length the length of the stream in bytes
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, (3) the data
* in the stream is not binary, or (4) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.io.Reader object.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param reader the new column value; must be a
* <code>java.io.Reader containing BINARY,
* <code>VARBINARY, LONGVARBINARY, CHAR,
* <code>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 <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateCharacterStream(String columnName,
java.io.Reader reader,
int length) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Object value. The scale parameter
* indicates the number of digits to the right of the decimal point
* and is ignored if the new column value is not a type that will be
* mapped to an SQL <code>DECIMAL or NUMERIC value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @param scale the number of digits to the right of the decimal point (for
* <code>DECIMAL and NUMERIC types only)
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateObject(String columnName, Object x, int scale) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>Object value.
* <P>
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param x the new column value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateObject(String columnName, Object x) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Inserts the contents of this <code>CachedRowSetImpl object's insert
* row into this rowset immediately following the current row.
* If the current row is the
* position after the last row or before the first row, the new row will
* be inserted at the end of the rowset. This method also notifies
* listeners registered with this rowset that the row has changed.
* <P>
* The cursor must be on the insert row when this method is called.
*
* @throws SQLException if (1) the cursor is not on the insert row,
* (2) one or more of the non-nullable columns in the insert
* row has not been given a value, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void insertRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Marks the current row of this <code>CachedRowSetImpl object as
* updated and notifies listeners registered with this rowset that the
* row has changed.
* <P>
* This method cannot be called when the cursor is on the insert row, and
* it should be called before the cursor moves to another row. If it is
* called after the cursor moves to another row, this method has no effect,
* and the updates made before the cursor moved will be lost.
*
* @throws SQLException if the cursor is on the insert row or this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Deletes the current row from this <code>CachedRowSetImpl object and
* notifies listeners registered with this rowset that a row has changed.
* This method cannot be called when the cursor is on the insert row.
* <P>
* This method marks the current row as deleted, but it does not delete
* the row from the underlying data source. The method
* <code>acceptChanges must be called to delete the row in
* the data source.
*
* @throws SQLException if (1) this method is called when the cursor
* is on the insert row, before the first row, or after the
* last row or (2) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void deleteRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the current row with its original value and marks the row as
* not updated, thus undoing any changes made to the row since the
* last call to the methods <code>updateRow or deleteRow.
* This method should be called only when the cursor is on a row in
* this rowset.
*
* @throws SQLException if the cursor is on the insert row, before the
* first row, or after the last row
*/
public void refreshRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Rolls back any updates made to the current row of this
* <code>CachedRowSetImpl object and notifies listeners that
* a row has changed. To have an effect, this method
* must be called after an <code>updateXXX method has been
* called and before the method <code>updateRow has been called.
* If no updates have been made or the method <code>updateRow
* has already been called, this method has no effect.
*
* @throws SQLException if the cursor is on the insert row, before the
* first row, or after the last row
*/
public void cancelRowUpdates() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Moves the cursor for this <code>CachedRowSetImpl object
* to the insert row. The current row in the rowset is remembered
* while the cursor is on the insert row.
* <P>
* The insert row is a special row associated with an updatable
* rowset. It is essentially a buffer where a new row may
* be constructed by calling the appropriate <code>updateXXX
* methods to assign a value to each column in the row. A complete
* row must be constructed; that is, every column that is not nullable
* must be assigned a value. In order for the new row to become part
* of this rowset, the method <code>insertRow must be called
* before the cursor is moved back to the rowset.
* <P>
* Only certain methods may be invoked while the cursor is on the insert
* row; many methods throw an exception if they are called while the
* cursor is there. In addition to the <code>updateXXX
* and <code>insertRow methods, only the getXXX methods
* may be called when the cursor is on the insert row. A <code>getXXX
* method should be called on a column only after an <code>updateXXX
* method has been called on that column; otherwise, the value returned is
* undetermined.
*
* @throws SQLException if this <code>CachedRowSetImpl object is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void moveToInsertRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Moves the cursor for this <code>CachedRowSetImpl object to
* the current row. The current row is the row the cursor was on
* when the method <code>moveToInsertRow was called.
* <P>
* Calling this method has no effect unless it is called while the
* cursor is on the insert row.
*
* @throws SQLException if an error occurs
*/
public void moveToCurrentRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Returns <code>null.
*
* @return <code>null
* @throws SQLException if an error occurs
*/
public Statement getStatement() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as an Object in
* the Java programming language, using the given
* <code>java.util.Map object to custom map the value if
* appropriate.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param map a <code>java.util.Map object showing the mapping
* from SQL type names to classes in the Java programming
* language
* @return an <code>Object representing the SQL value
* @throws SQLException if the given column index is out of bounds or
* the cursor is not on one of this rowset's rows or its
* insert row
*/
public Object getObject(int columnIndex,
java.util.Map<String,Class map)
throws SQLException
{
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Ref object
* in the Java programming language.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @return a <code>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 <code>REF value
* @see #getRef(String)
*/
public Ref getRef(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Blob object
* in the Java programming language.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @return a <code>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 <code>BLOB value
* @see #getBlob(String)
*/
public Blob getBlob(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Clob object
* in the Java programming language.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @return a <code>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 <code>CLOB value
* @see #getClob(String)
*/
public Clob getClob(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as an Array object
* in the Java programming language.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @return an <code>Array object representing an SQL
* <code>ARRAY value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL <code>ARRAY value
* @see #getArray(String)
*/
public Array getArray(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as an Object in
* the Java programming language, using the given
* <code>java.util.Map object to custom map the value if
* appropriate.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param map a <code>java.util.Map object showing the mapping
* from SQL type names to classes in the Java programming
* language
* @return an <code>Object representing the SQL value
* @throws SQLException if the given column name is not the name of
* a column in this rowset or the cursor is not on one of
* this rowset's rows or its insert row
*/
public Object getObject(String columnName,
java.util.Map<String,Class map)
throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Ref object
* in the Java programming language.
*
* @param colName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a <code>Ref object representing an SQL REF value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the column value
* is not an SQL <code>REF value
* @see #getRef(int)
*/
public Ref getRef(String colName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Blob object
* in the Java programming language.
*
* @param colName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a <code>Blob object representing an SQL BLOB value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>BLOB value
* @see #getBlob(int)
*/
public Blob getBlob(String colName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a Clob object
* in the Java programming language.
*
* @param colName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return a <code>Clob object representing an SQL
* <code>CLOB value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>CLOB value
* @see #getClob(int)
*/
public Clob getClob(String colName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as an Array object
* in the Java programming langugage.
*
* @param colName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @return an <code>Array object representing an SQL
* <code>ARRAY value
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>ARRAY value
* @see #getArray(int)
*/
public Array getArray(String colName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a java.sql.Date
* object, using the given <code>Calendar object to construct an
* appropriate millisecond value for the date.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in the rowset
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>DATE or
* <code>TIMESTAMP value
*/
public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a java.sql.Date
* object, using the given <code>Calendar object to construct an
* appropriate millisecond value for the date.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>DATE or
* <code>TIMESTAMP value
*/
public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a java.sql.Time
* object, using the given <code>Calendar object to construct an
* appropriate millisecond value for the date.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in the rowset
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>TIME or
* <code>TIMESTAMP value
*/
public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a java.sql.Time
* object, using the given <code>Calendar object to construct an
* appropriate millisecond value for the date.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>TIME or
* <code>TIMESTAMP value
*/
public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a java.sql.Timestamp
* object, using the given <code>Calendar object to construct an
* appropriate millisecond value for the date.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in the rowset
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>TIME or
* <code>TIMESTAMP value
*/
public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>CachedRowSetImpl object as a
* <code>java.sql.Timestamp object, using the given
* <code>Calendar object to construct an appropriate
* millisecond value for the date.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param cal the <code>java.util.Calendar object to use in
* constructing the date
* @return the column value; if the value is SQL <code>NULL,
* the result is <code>null
* @throws SQLException if (1) the given column name is not the name of
* a column in this rowset, (2) the cursor is not on one of
* this rowset's rows or its insert row, or (3) the designated
* column does not store an SQL <code>DATE,
* <code>TIME, or TIMESTAMP value
*/
public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
throw new UnsupportedOperationException();
}
/*
* RowSetInternal Interface
*/
/**
* Retrieves the <code>Connection object passed to this
* <code>CachedRowSetImpl object. This connection may be
* used to populate this rowset with data or to write data back
* to its underlying data source.
*
* @return the <code>Connection object passed to this rowset;
* may be <code>null if there is no connection
* @throws SQLException if an error occurs
*/
public Connection getConnection() throws SQLException{
throw new UnsupportedOperationException();
}
/**
* Sets the metadata for this <code>CachedRowSetImpl object
* with the given <code>RowSetMetaData object.
*
* @param md a <code>RowSetMetaData object instance containing
* metadata about the columsn in the rowset
* @throws SQLException if invalid meta data is supplied to the
* rowset
*/
public void setMetaData(RowSetMetaData md) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Returns a result set containing the original value of the rowset. The
* original value is the state of the <code>CachedRowSetImpl after the
* last population or synchronization (whichever occurred most recently) with
* the data source.
* <p>
* The cursor is positioned before the first row in the result set.
* Only rows contained in the result set returned by <code>getOriginal()
* are said to have an original value.
*
* @return the original result set of the rowset
* @throws SQLException if an error occurs produce the
* <code>ResultSet object
*/
public ResultSet getOriginal() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Returns a result set containing the original value of the current
* row only.
* The original value is the state of the <code>CachedRowSetImpl after
* the last population or synchronization (whichever occurred most recently)
* with the data source.
*
* @return the original result set of the row
* @throws SQLException if there is no current row
* @see #setOriginalRow
*/
public ResultSet getOriginalRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Marks the current row in this rowset as being an original row.
*
* @throws SQLException if there is no current row
* @see #getOriginalRow
*/
public void setOriginalRow() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Marks all rows in this rowset as being original rows. Any updates
* made to the rows become the original values for the rowset.
* Calls to the method <code>setOriginal connot be reversed.
*
* @throws SQLException if an error occurs
*/
public void setOriginal() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Returns an identifier for the object (table) that was used to create this
* rowset.
*
* @return a <code>String object that identifies the table from
* which this <code>CachedRowSetImpl object was derived
* @throws SQLException if an error occurs
*/
public String getTableName() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the identifier for the table from which this rowset was derived
* to the given table name.
*
* @param tabName a <code>String object that identifies the
* table from which this <code>CachedRowSetImpl object
* was derived
* @throws SQLException if an error occurs
*/
public void setTableName(String tabName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Returns the columns that make a key to uniquely identify a
* row in this <code>CachedRowSetImpl object.
*
* @return an array of column numbers that constitutes a primary
* key for this rowset. This array should be empty
* if no column is representitive of a primary key
* @throws SQLException if the rowset is empty or no columns
* are designated as primary keys
* @see #setKeyColumns
*/
public int[] getKeyColumns() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets this <code>CachedRowSetImpl object's
* <code>keyCols field with the given array of column
* numbers, which forms a key for uniquely identifying a row
* in this rowset.
*
* @param keys an array of <code>int indicating the
* columns that form a primary key for this
* <code>CachedRowSetImpl object; every
* element in the array must be greater than
* <code>0 and less than or equal to the number
* of columns in this rowset
* @throws SQLException if any of the numbers in the
* given array is not valid for this rowset
* @see #getKeyColumns
*/
public void setKeyColumns(int [] keys) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param ref the new column <code>java.sql.Ref value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param ref the new column <code>java.sql.Ref value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param c the new column <code>Clob value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateClob(int columnIndex, Clob c) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>double value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param c the new column <code>Clobvalue
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateClob(String columnName, Clob c) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.sql.Blob value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param b the new column <code>Blob value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBlob(int columnIndex, Blob b) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.sql.Blob value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param b the new column <code>Blob value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateBlob(String columnName, Blob b) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.sql.Array values.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnIndex the first column is <code>1, the second
* is <code>2, and so on; must be 1 or larger
* and equal to or less than the number of columns in this rowset
* @param a the new column <code>Array value
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) this rowset is
* <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateArray(int columnIndex, Array a) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated column in either the current row or the insert
* row of this <code>CachedRowSetImpl object with the given
* <code>java.sql.Array value.
*
* This method updates a column value in either the current row or
* the insert row of this rowset, but it does not update the
* database. If the cursor is on a row in the rowset, the
* method {@link #updateRow} must be called to update the database.
* If the cursor is on the insert row, the method {@link #insertRow}
* must be called, which will insert the new row into both this rowset
* and the database. Both of these methods must be called before the
* cursor moves to another row.
*
* @param columnName a <code>String object that must match the
* SQL name of a column in this rowset, ignoring case
* @param a the new column <code>Array value
* @throws SQLException if (1) the given column name does not match the
* name of a column in this rowset, (2) the cursor is not on
* one of this rowset's rows or its insert row, or (3) this
* rowset is <code>ResultSet.CONCUR_READ_ONLY
*/
public void updateArray(String columnName, Array a) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a java.net.URL object
* in the Java programming language.
*
* @return a java.net.URL object containing the resource reference described by
* the URL
* @throws SQLException if (1) the given column index is out of bounds,
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL <code>DATALINK value.
* @see #getURL(String)
*/
public java.net.URL getURL(int columnIndex) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the value of the designated column in this
* <code>CachedRowSetImpl object as a java.net.URL object
* in the Java programming language.
*
* @return a java.net.URL object containing the resource reference described by
* the URL
* @throws SQLException if (1) the given column name not the name of a column
* in this rowset, or
* (2) the cursor is not on one of this rowset's rows or its
* insert row, or (3) the designated column does not store an
* SQL <code>DATALINK value.
* @see #getURL(int)
*/
public java.net.URL getURL(String columnName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* The first warning reported by calls on this <code>CachedRowSetImpl
* object is returned. Subsequent <code>CachedRowSetImpl warnings will
* be chained to this <code>SQLWarning. All RowSetWarnings
* warnings are generated in the disconnected environment and remain a
* seperate warning chain to that provided by the <code>getWarnings
* method.
*
* <P>The warning chain is automatically cleared each time a new
* row is read.
*
* <P>Note: This warning chain only covers warnings caused
* by <code>CachedRowSet (and their child interface)
* methods. All <code>SQLWarnings can be obtained using the
* <code>getWarnings method which tracks warnings generated
* by the underlying JDBC driver.
* @return the first SQLWarning or null
*
*/
public RowSetWarning getRowSetWarnings() {
throw new UnsupportedOperationException();
}
/**
* Commits all changes performed by the <code>acceptChanges()
* methods
*
* @see java.sql.Connection#commit
*/
public void commit() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Rolls back all changes performed by the <code>acceptChanges()
* methods
*
* @see java.sql.Connection#rollback
*/
public void rollback() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Rolls back all changes performed by the <code>acceptChanges()
* to the last <code>Savepoint transaction marker.
*
* @see java.sql.Connection#rollback(Savepoint)
*/
public void rollback(Savepoint s) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Unsets the designated parameter to the given int array.
* This was set using <code>setMatchColumn
* as the column which will form the basis of the join.
* <P>
* The parameter value unset by this method should be same
* as was set.
*
* @param columnIdxes the index into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds or if the columnIdx is
* not the same as set using <code>setMatchColumn(int [])
*/
public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Unsets the designated parameter to the given String array.
* This was set using <code>setMatchColumn
* as the column which will form the basis of the join.
* <P>
* The parameter value unset by this method should be same
* as was set.
*
* @param columnIdxes the index into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds or if the columnName is
* not the same as set using <code>setMatchColumn(String [])
*/
public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the column name as <code>String array
* that was set using <code>setMatchColumn(String [])
* for this rowset.
*
* @return a <code>String array object that contains the column names
* for the rowset which has this the match columns
*
* @throws SQLException if an error occurs or column name is not set
*/
public String[] getMatchColumnNames() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Retrieves the column id as <code>int array that was set using
* <code>setMatchColumn(int []) for this rowset.
*
* @return a <code>int array object that contains the column ids
* for the rowset which has this as the match columns.
*
* @throws SQLException if an error occurs or column index is not set
*/
public int[] getMatchColumnIndexes() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated parameter to the given int array.
* This forms the basis of the join for the
* <code>JoinRowSet as the column which will form the basis of the
* join.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this rowset's
* command when the method <code>getMatchColumnIndexes is called.
*
* @param columnIdxes the indexes into this rowset
* object's internal representation of parameter values; the
* first parameter is 0, the second is 1, and so on; must be
* <code>0 or greater
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
*/
public void setMatchColumn(int[] columnIdxes) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated parameter to the given String array.
* This forms the basis of the join for the
* <code>JoinRowSet as the column which will form the basis of the
* join.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this rowset's
* command when the method <code>getMatchColumn is called.
*
* @param columnNames the name of the column into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
*/
public void setMatchColumn(String[] columnNames) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated parameter to the given <code>int
* object. This forms the basis of the join for the
* <code>JoinRowSet as the column which will form the basis of the
* join.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this rowset's
* command when the method <code>getMatchColumn is called.
*
* @param columnIdx the index into this rowset
* object's internal representation of parameter values; the
* first parameter is 0, the second is 1, and so on; must be
* <code>0 or greater
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
*/
public void setMatchColumn(int columnIdx) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Sets the designated parameter to the given <code>String
* object. This forms the basis of the join for the
* <code>JoinRowSet as the column which will form the basis of the
* join.
* <P>
* The parameter value set by this method is stored internally and
* will be supplied as the appropriate parameter in this rowset's
* command when the method <code>getMatchColumn is called.
*
* @param columnName the name of the column into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds
*/
public void setMatchColumn(String columnName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Unsets the designated parameter to the given <code>int
* object. This was set using <code>setMatchColumn
* as the column which will form the basis of the join.
* <P>
* The parameter value unset by this method should be same
* as was set.
*
* @param columnIdx the index into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds or if the columnIdx is
* not the same as set using <code>setMatchColumn(int)
*/
public void unsetMatchColumn(int columnIdx) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Unsets the designated parameter to the given <code>String
* object. This was set using <code>setMatchColumn
* as the column which will form the basis of the join.
* <P>
* The parameter value unset by this method should be same
* as was set.
*
* @param columnName the index into this rowset
* object's internal representation of parameter values
* @throws SQLException if an error occurs or the
* parameter index is out of bounds or if the columnName is
* not the same as set using <code>setMatchColumn(String)
*/
public void unsetMatchColumn(String columnName) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Notifies registered listeners that a RowSet object in the given RowSetEvent
* object has populated a number of additional rows. The <code>numRows parameter
* ensures that this event will only be fired every <code>numRow.
* <p>
* The source of the event can be retrieved with the method event.getSource.
*
* @param event a <code>RowSetEvent object that contains the
* <code>RowSet object that is the source of the events
* @param numRows when populating, the number of rows interval on which the
* <code>CachedRowSet populated should fire; the default value
* is zero; cannot be less than <code>fetchSize or zero
*/
public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Populates this <code>CachedRowSet object with data from
* the given <code>ResultSet object. While related to the populate(ResultSet)
* method, an additional parameter is provided to allow starting position within
* the <code>ResultSet from where to populate the CachedRowSet
* instance.
*
* This method is an alternative to the method <code>execute
* for filling the rowset with data. The method <code>populate
* does not require that the properties needed by the method
* <code>execute, such as the command property,
* be set. This is true because the method <code>populate
* is given the <code>ResultSet object from
* which to get data and thus does not need to use the properties
* required for setting up a connection and executing this
* <code>CachedRowSetImpl object's command.
* <P>
* After populating this rowset with data, the method
* <code>populate sets the rowset's metadata and
* then sends a <code>RowSetChangedEvent object
* to all registered listeners prior to returning.
*
* @param data the <code>ResultSet object containing the data
* to be read into this <code>CachedRowSetImpl object
* @param start the integer specifing the position in the
* <code>ResultSet object to popultate the
* <code>CachedRowSetImpl object.
* @throws SQLException if an error occurs; or the max row setting is
* violated while populating the RowSet.Also id the start position
* is negative.
* @see #execute
*/
public void populate(ResultSet data, int start) throws SQLException{
throw new UnsupportedOperationException();
}
/**
* The nextPage gets the next page, that is a <code>CachedRowSetImpl object
* containing the number of rows specified by page size.
* @return boolean value true indicating whether there are more pages to come and
* false indicating that this is the last page.
* @throws SQLException if an error occurs or this called before calling populate.
*/
public boolean nextPage() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* This is the setter function for setting the size of the page, which specifies
* how many rows have to be retrived at a time.
*
* @param size which is the page size
* @throws SQLException if size is less than zero or greater than max rows.
*/
public void setPageSize (int size) throws SQLException {
throw new UnsupportedOperationException();
}
/**
* This is the getter function for the size of the page.
*
* @return an integer that is the page size.
*/
public int getPageSize() {
throw new UnsupportedOperationException();
}
/**
* Retrieves the data present in the page prior to the page from where it is
* called.
* @return boolean value true if it retrieves the previous page, flase if it
* is on the first page.
* @throws SQLException if it is called before populate is called or ResultSet
* is of type <code>ResultSet.TYPE_FORWARD_ONLY or if an error
* occurs.
*/
public boolean previousPage() throws SQLException {
throw new UnsupportedOperationException();
}
/**
* Updates the designated column with a character stream value, which will
* have the specified number of bytes. The driver does the necessary conversion
* from Java character format to the national character set in the database.
* It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
* The updater methods are used to update column values in the current row or
* the insert row. The updater methods do not update the underlying database;
* instead the updateRow or insertRow methods are called to update the database.
*
* @param columnIndex - the first column is 1, the second is 2, ...
* @param x - the new column value
* @param length - the length of the stream
* @exception SQLException if a database access error occurs
* @since 1.6
*/
public void updateNCharacterStream(int columnIndex,
java.io.Reader x,
int length)
throws SQLException {
throw new UnsupportedOperationException("Operation not yet supported");
}
/**
* Updates the designated column with a character stream value, which will
* have the specified number of bytes. The driver does the necessary conversion
* from Java character format to the national character set in the database.
* It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
* The updater methods are used to update column values in the current row or
* the insert row. The updater methods do not update the underlying database;
* instead the updateRow or insertRow methods are called to update the database.
*
* @param columnName - name of the Column
* @param x - the new column value
* @param length - the length of the stream
* @exception SQLException if a database access error occurs
* @since 1.6
*/
public void updateNCharacterStream(String columnName,
java.io.Reader x,
int length)
throws SQLException {
throw new UnsupportedOperationException("Operation not yet supported");
}
/**
* This method re populates the resBundle
* during the deserialization process
*
*/
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
// Default state initialization happens here
ois.defaultReadObject();
// Initialization of transient Res Bundle happens here .
try {
resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
} catch(IOException ioe) {
throw new RuntimeException(ioe);
}
}
static final long serialVersionUID = -3345004441725080251L;
} //end class
Other Java examples (source code examples)Here is a short list of links related to this Java SyncResolverImpl.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
