| Method from com.sun.rowset.JdbcRowSetImpl Detail: |
|---|
 public boolean absolute(int row) throws SQLException {
checkState();
boolean b = rs.absolute(row);
notifyCursorMoved();
return b;
}
Moves the cursor to the given row number in
this rowset's internal ResultSet object.
If the row number is positive, the cursor moves to
the given row number with respect to the
beginning of the result set. The first row is row 1, the second
is row 2, and so on.
If the given row number is negative, the cursor moves to
an absolute row position with respect to
the end of the result set. For example, calling the method
absolute(-1) positions the
cursor on the last row, calling the method absolute(-2)
moves the cursor to the next-to-last row, and so on.
An attempt to position the cursor beyond the first/last row in
the result set leaves the cursor before the first row or after
the last row.
Note: Calling absolute(1) is the same
as calling first(). Calling absolute(-1)
is the same as calling last(). |
public void afterLast() throws SQLException {
checkState();
rs.afterLast();
notifyCursorMoved();
} Moves the cursor to the end of
this rowset's ResultSet object, just after the
last row. This method has no effect if the result set contains no rows. |
public void beforeFirst() throws SQLException {
checkState();
rs.beforeFirst();
notifyCursorMoved();
} Moves the cursor to the front of
this rowset's ResultSet object, just before the
first row. This method has no effect if the result set contains no rows. |
public void cancelRowUpdates() throws SQLException {
checkState();
rs.cancelRowUpdates();
notifyRowChanged();
} Cancels the updates made to the current row in this
ResultSet object and notifies listeners that a row
has changed. This method may be called after calling an
updateXXX method(s) and before calling
the method updateRow to roll back
the updates made to a row. If no updates have been made or
updateRow has already been called, this method has no
effect. |
protected void checkState() throws SQLException {
// If all the three i.e. conn, ps & rs are
// simultaneously null implies we are not connected
// to the db, implies undesirable state so throw exception
if (conn == null && ps == null && rs == null ) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.invalstate").toString());
}
} |
public void clearWarnings() throws SQLException {
checkState();
rs.clearWarnings();
} Clears all warnings reported on this rowset's ResultSet object.
After this method is called, the method getWarnings
returns null until a new warning is
reported for this rowset's ResultSet object. |
public void close() throws SQLException {
if (rs != null)
rs.close();
if (ps != null)
ps.close();
if (conn != null)
conn.close();
} Releases this rowset's ResultSet object's database and
JDBC resources immediately instead of waiting for
this to happen when it is automatically closed.
Note: A ResultSet object
is automatically closed by the
Statement object that generated it when
that Statement object is closed,
re-executed, or is used to retrieve the next result from a
sequence of multiple results. A ResultSet object
is also automatically closed when it is garbage collected. |
public void commit() throws SQLException {
conn.commit();
// Checking the holadbility value and making the result set handle null
// Added as per Rave requirements
if( conn.getHoldability() != HOLD_CURSORS_OVER_COMMIT) {
ResultSet oldVal = rs;
rs = null;
// propertyChangeSupport.firePropertyChange("ResultSet",oldVal,rs);
}
} Commits all updates in this JdbcRowSet object by
wrapping the internal Connection object and calling
its commit method.
This method sets this JdbcRowSet object's private field
rs to null after saving its value to another
object, but only if the ResultSet
constant HOLD_CURSORS_OVER_COMMIT has not been set.
(The field rs is this JdbcRowSet object's
ResultSet object.) |
protected Connection connect() throws SQLException {
// Get a JDBC connection.
// First check for Connection handle object as such if
// "this" initialized using conn.
if(conn != null) {
return conn;
} else if (getDataSourceName() != null) {
// Connect using JNDI.
try {
Context ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup
(getDataSourceName());
//return ds.getConnection(getUsername(),getPassword());
if(getUsername() != null && !getUsername().equals("")) {
return ds.getConnection(getUsername(),getPassword());
} else {
return ds.getConnection();
}
}
catch (javax.naming.NamingException ex) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
}
} else if (getUrl() != null) {
// Check only for getUrl() != null because
// user, passwd can be null
// Connect using the driver manager.
return DriverManager.getConnection
(getUrl(), getUsername(), getPassword());
}
else {
return null;
}
} |
public void deleteRow() throws SQLException {
checkState();
rs.deleteRow();
notifyRowChanged();
} Deletes the current row from this rowset's ResultSet object
and from the underlying database and also notifies listeners that a row
has changed. This method cannot be called when the cursor is on the insert
row. |
public void execute() throws SQLException {
/*
* To execute based on the properties:
* i) determine how to get a connection
* ii) prepare the statement
* iii) set the properties of the statement
* iv) parse the params. and set them
* v) execute the statement
*
* During all of this try to tolerate as many errors
* as possible, many drivers will not support all of
* the properties and will/should throw SQLException
* at us...
*
*/
prepare();
// set the properties of our shiny new statement
setProperties(ps);
// set the parameters
decodeParams(getParams(), ps);
// execute the statement
rs = ps.executeQuery();
// notify listeners
notifyRowSetChanged();
} Creates the internal ResultSet object for which this
JdbcRowSet object is a wrapper, effectively
making the result set a JavaBeans component.
Certain properties must have been set before this method is called
so that it can establish a connection to a database and execute the
query that will create the result set. If a DataSource
object will be used to create the connection, properties for the
data source name, user name, and password must be set. If the
DriverManager will be used, the properties for the
URL, user name, and password must be set. In either case, the
property for the command must be set. If the command has placeholder
parameters, those must also be set. This method throws
an exception if the required properties are not set.
Other properties have default values that may optionally be set
to new values. The execute method will use the value
for the command property to create a PreparedStatement
object and set its properties (escape processing, maximum field
size, maximum number of rows, and query timeout limit) to be those
of this rowset. |
public int findColumn(String columnName) throws SQLException {
checkState();
return rs.findColumn(columnName);
} Maps the given JdbcRowSetImpl column name to its
JdbcRowSetImpl column index and reflects this on
the internal ResultSet object. |
public boolean first() throws SQLException {
checkState();
boolean b = rs.first();
notifyCursorMoved();
return b;
} Moves the cursor to the first row in
this rowset's ResultSet object. |
public Array getArray(int i) throws SQLException {
checkState();
return rs.getArray(i);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as an Array object. |
public Array getArray(String colName) throws SQLException {
return getArray(findColumn(colName));
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as an Array object. |
public InputStream getAsciiStream(int columnIndex) throws SQLException {
checkState();
return rs.getAsciiStream(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a stream of ASCII characters. The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving large LONGVARCHAR values.
The JDBC driver will
do any necessary conversion from the database format into ASCII.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method
InputStream.available
is called whether there is data available or not. |
public InputStream getAsciiStream(String columnName) throws SQLException {
return getAsciiStream(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a stream of
ASCII characters. The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving large LONGVARCHAR values.
The JDBC driver will
do any necessary conversion from the database format into ASCII.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method available
is called whether there is data available or not. |
public boolean getAutoCommit() throws SQLException {
return conn.getAutoCommit();
} Returns the auto-commit status with this JdbcRowSet. |
public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
checkState();
return rs.getBigDecimal(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a
java.math.BigDecimal with full precision. |
public BigDecimal getBigDecimal(String columnName) throws SQLException {
return getBigDecimal(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a
java.math.BigDecimal with full precision. |
public BigDecimal getBigDecimal(int columnIndex,
int scale) throws SQLException {
checkState();
return rs.getBigDecimal(columnIndex, scale);
} Deprecated!
Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.BigDecimal. |
public BigDecimal getBigDecimal(String columnName,
int scale) throws SQLException {
return getBigDecimal(findColumn(columnName), scale);
} Deprecated!
Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.math.BigDecimal. |
public InputStream getBinaryStream(int columnIndex) throws SQLException {
checkState();
return rs.getBinaryStream(columnIndex);
} Gets the value of a column in the current row as a stream of
the value of the designated column in the current row
of this rowset's ResultSet object as a binary stream of
uninterpreted bytes. The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving large LONGVARBINARY values.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method
InputStream.available
is called whether there is data available or not. |
public InputStream getBinaryStream(String columnName) throws SQLException {
return getBinaryStream(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a stream of uninterpreted
bytes.
The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving large LONGVARBINARY
values.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method available
is called whether there is data available or not. |
public Blob getBlob(int i) throws SQLException {
checkState();
return rs.getBlob(i);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Blob object. |
public Blob getBlob(String colName) throws SQLException {
return getBlob(findColumn(colName));
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Blob object. |
public boolean getBoolean(int columnIndex) throws SQLException {
checkState();
return rs.getBoolean(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a boolean. |
public boolean getBoolean(String columnName) throws SQLException {
return getBoolean(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a boolean. |
public byte getByte(int columnIndex) throws SQLException {
checkState();
return rs.getByte(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a byte. |
public byte getByte(String columnName) throws SQLException {
return getByte(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a byte. |
public byte[] getBytes(int columnIndex) throws SQLException {
checkState();
return rs.getBytes(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a byte array in the Java programming language.
The bytes represent the raw values returned by the driver. |
public byte[] getBytes(String columnName) throws SQLException {
return getBytes(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a byte array in the Java programming language.
The bytes represent the raw values returned by the driver. |
public Reader getCharacterStream(int columnIndex) throws SQLException {
checkState();
return rs.getCharacterStream(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a
java.io.Reader object. |
public Reader getCharacterStream(String columnName) throws SQLException {
return getCharacterStream(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as a
java.io.Reader object. |
public Clob getClob(int i) throws SQLException {
checkState();
return rs.getClob(i);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Clob object. |
public Clob getClob(String colName) throws SQLException {
return getClob(findColumn(colName));
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Clob object. |
public int getConcurrency() throws SQLException {
try {
checkState();
} catch(SQLException sqle) {
super.getConcurrency();
}
return rs.getConcurrency();
} Returns the concurrency mode of this rowset's ResultSet object.
The concurrency used is determined by the
Statement object that created the result set. |
protected Connection getConnection() {
return conn;
} Gets this JdbcRowSet object's Connection property |
public String getCursorName() throws SQLException {
checkState();
return rs.getCursorName();
} Gets the name of the SQL cursor used by this rowset's ResultSet
object.
In SQL, a result table is retrieved through a cursor that is
named. The current row of a result set can be updated or deleted
using a positioned update/delete statement that references the
cursor name. To insure that the cursor has the proper isolation
level to support update, the cursor's select statement should be
of the form 'select for update'. If the 'for update' clause is
omitted, the positioned updates may fail.
The JDBC API supports this SQL feature by providing the name of the
SQL cursor used by a ResultSet object.
The current row of a ResultSet object
is also the current row of this SQL cursor.
Note: If positioned update is not supported, a
SQLException is thrown. |
public DatabaseMetaData getDatabaseMetaData() throws SQLException {
Connection con = connect();
return con.getMetaData();
} Retrieves the DatabaseMetaData associated with
the connection handle associated this this
JdbcRowSet object. |
public Date getDate(int columnIndex) throws SQLException {
checkState();
return rs.getDate(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Date object in the Java programming language. |
public Date getDate(String columnName) throws SQLException {
return getDate(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Date object in the Java programming language. |
public Date getDate(int columnIndex,
Calendar cal) throws SQLException {
checkState();
return rs.getDate(columnIndex, cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a java.sql.Date
object. This method uses the given calendar to construct an appropriate
millisecond value for the date if the underlying database does not store
timezone information. |
public Date getDate(String columnName,
Calendar cal) throws SQLException {
return getDate(findColumn(columnName), cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a java.sql.Date
object. This method uses the given calendar to construct an appropriate
millisecond value for the date if the underlying database does not store
timezone information. |
public double getDouble(int columnIndex) throws SQLException {
checkState();
return rs.getDouble(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a double. |
public double getDouble(String columnName) throws SQLException {
return getDouble(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a double. |
public int getFetchDirection() throws SQLException {
try {
checkState();
} catch(SQLException sqle) {
super.getFetchDirection();
}
return rs.getFetchDirection();
} Returns the fetch direction for this
ResultSet object. |
public float getFloat(int columnIndex) throws SQLException {
checkState();
return rs.getFloat(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a float. |
public float getFloat(String columnName) throws SQLException {
return getFloat(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a float. |
public int getHoldability() throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the holdability of this ResultSet object |
public int getInt(int columnIndex) throws SQLException {
checkState();
return rs.getInt(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
an int. |
public int getInt(String columnName) throws SQLException {
return getInt(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
an int. |
public long getLong(int columnIndex) throws SQLException {
checkState();
return rs.getLong(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a long. |
public long getLong(String columnName) throws SQLException {
return getLong(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a long. |
public int[] getMatchColumnIndexes() throws SQLException {
Integer []int_temp = new Integer[iMatchColumns.size()];
int [] i_temp = new int[iMatchColumns.size()];
int i_val;
i_val = ((Integer)iMatchColumns.get(0)).intValue();
if( i_val == -1 ) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString());
}
iMatchColumns.copyInto(int_temp);
for(int i = 0; i < int_temp.length; i++) {
i_temp[i] = (int_temp[i]).intValue();
}
return i_temp;
} Retrieves the column id as int array that was set using
setMatchColumn(int []) for this rowset. |
public String[] getMatchColumnNames() throws SQLException {
String []str_temp = new String[strMatchColumns.size()];
if( strMatchColumns.get(0) == null) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString());
}
strMatchColumns.copyInto(str_temp);
return str_temp;
} Retrieves the column name as String array
that was set using setMatchColumn(String [])
for this rowset. |
public ResultSetMetaData getMetaData() throws SQLException {
checkState();
// It may be the case that JdbcRowSet might not have been
// initialized with ResultSet handle and may be by PreparedStatement
// internally when we set JdbcRowSet.setCommand().
// We may require all the basic properties of setEscapeProcessing
// setMaxFieldSize etc. which an application can use before we call
// execute.
try {
checkState();
} catch(SQLException sqle) {
prepare();
// will return ResultSetMetaData
return ps.getMetaData();
}
return rs.getMetaData();
} Retrieves the number, types and properties of
this rowset's ResultSet object's columns. |
public Reader getNCharacterStream(int columnIndex) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as a
java.io.Reader object.
It is intended for use when
accessing NCHAR,NVARCHAR
and LONGNVARCHAR columns. |
public Reader getNCharacterStream(String columnName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as a
java.io.Reader object.
It is intended for use when
accessing NCHAR,NVARCHAR
and LONGNVARCHAR columns. |
public NClob getNClob(int i) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as a NClob object
in the Java programming language. |
public NClob getNClob(String colName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as a NClob object
in the Java programming language. |
public String getNString(int columnIndex) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as
a String in the Java programming language.
It is intended for use when
accessing NCHAR,NVARCHAR
and LONGNVARCHAR columns. |
public String getNString(String columnName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row
of this ResultSet object as
a String in the Java programming language.
It is intended for use when
accessing NCHAR,NVARCHAR
and LONGNVARCHAR columns. |
public Object getObject(int columnIndex) throws SQLException {
checkState();
return rs.getObject(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
an Object.
This method will return the value of the given column as a
Java object. The type of the Java object will be the default
Java object type corresponding to the column's SQL type,
following the mapping for built-in types specified in the JDBC
specification.
This method may also be used to read datatabase-specific
abstract data types.
In the JDBC 3.0 API, the behavior of method
getObject is extended to materialize
data of SQL user-defined types. When a column contains
a structured or distinct value, the behavior of this method is as
if it were a call to: getObject(columnIndex,
this.getStatement().getConnection().getTypeMap()).
|
public Object getObject(String columnName) throws SQLException {
return getObject(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
an Object.
This method will return the value of the given column as a
Java object. The type of the Java object will be the default
Java object type corresponding to the column's SQL type,
following the mapping for built-in types specified in the JDBC
specification.
This method may also be used to read datatabase-specific
abstract data types.
In the JDBC 3.0 API, the behavior of the method
getObject is extended to materialize
data of SQL user-defined types. When a column contains
a structured or distinct value, the behavior of this method is as
if it were a call to: getObject(columnIndex,
this.getStatement().getConnection().getTypeMap()).
|
public Object getObject(int i,
Map<?> map) throws SQLException {
checkState();
return rs.getObject(i, map);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as an Object.
This method uses the given Map object
for the custom mapping of the
SQL structured or distinct type that is being retrieved. |
public Object getObject(String colName,
Map<?> map) throws SQLException {
return getObject(findColumn(colName), map);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as an Object.
This method uses the specified Map object for
custom mapping if appropriate. |
public T getObject(int columnIndex,
Class<T> type) throws SQLException {
throw new SQLFeatureNotSupportedException("Not supported yet.");
} |
public T getObject(String columnLabel,
Class<T> type) throws SQLException {
throw new SQLFeatureNotSupportedException("Not supported yet.");
} |
public ParameterMetaData getParameterMetaData() throws SQLException {
prepare();
return (ps.getParameterMetaData());
} Retrieves the ParameterMetaData associated with
the connection handle associated this this
JdbcRowSet object. |
protected PreparedStatement getPreparedStatement() {
return ps;
} Gets this JdbcRowSet object's PreparedStatement property |
public Ref getRef(int i) throws SQLException {
checkState();
return rs.getRef(i);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Ref object. |
public Ref getRef(String colName) throws SQLException {
return getRef(findColumn(colName));
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a Ref object. |
protected ResultSet getResultSet() throws SQLException {
checkState();
return rs;
} Gets this JdbcRowSet object's ResultSet property |
public int getRow() throws SQLException {
checkState();
return rs.getRow();
} Retrieves the current row number. The first row is number 1, the
second is number 2, and so on. |
public RowId getRowId(int columnIndex) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row of this
ResultSet object as a java.sql.RowId object in the Java
programming language. |
public RowId getRowId(String columnName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated column in the current row of this
ResultSet object as a java.sql.RowId object in the Java
programming language. |
public RowSetWarning getRowSetWarnings() throws SQLException {
return null;
} Return the RowSetWarning object for the current row of a
JdbcRowSetImpl |
public SQLXML getSQLXML(int columnIndex) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated SQL XML parameter as a
SQLXML object in the Java programming language. |
public SQLXML getSQLXML(String colName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves the value of the designated SQL XML parameter as a
SQLXML object in the Java programming language. |
public short getShort(int columnIndex) throws SQLException {
checkState();
return rs.getShort(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a short. |
public short getShort(String columnName) throws SQLException {
return getShort(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a short. |
public Statement getStatement() throws SQLException {
if(rs != null)
{
return rs.getStatement();
} else {
return null;
}
} Returns the Statement object that produced this
ResultSet object.
If the result set was generated some other way, such as by a
DatabaseMetaData method, this method returns
null. |
public String getString(int columnIndex) throws SQLException {
checkState();
return rs.getString(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a String. |
public String getString(String columnName) throws SQLException {
return getString(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a String. |
public Time getTime(int columnIndex) throws SQLException {
checkState();
return rs.getTime(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Time object in the Java programming language. |
public Time getTime(String columnName) throws SQLException {
return getTime(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Time object in the Java programming language. |
public Time getTime(int columnIndex,
Calendar cal) throws SQLException {
checkState();
return rs.getTime(columnIndex, cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a java.sql.Time
object. This method uses the given calendar to construct an appropriate
millisecond value for the date if the underlying database does not store
timezone information. |
public Time getTime(String columnName,
Calendar cal) throws SQLException {
return getTime(findColumn(columnName), cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a java.sql.Time
object. This method uses the given calendar to construct an appropriate
millisecond value for the date if the underlying database does not store
timezone information. |
public Timestamp getTimestamp(int columnIndex) throws SQLException {
checkState();
return rs.getTimestamp(columnIndex);
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Timestamp object in the Java programming language. |
public Timestamp getTimestamp(String columnName) throws SQLException {
return getTimestamp(findColumn(columnName));
} Gets the value of the designated column in the current row
of this rowset's ResultSet object as
a java.sql.Timestamp object. |
public Timestamp getTimestamp(int columnIndex,
Calendar cal) throws SQLException {
checkState();
return rs.getTimestamp(columnIndex, cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a
java.sql.Timestamp object.
This method uses the given calendar to construct an appropriate millisecond
value for the timestamp if the underlying database does not store
timezone information. |
public Timestamp getTimestamp(String columnName,
Calendar cal) throws SQLException {
return getTimestamp(findColumn(columnName), cal);
} Returns the value of the designated column in the current row
of this rowset's ResultSet object as a
java.sql.Timestamp object.
This method uses the given calendar to construct an appropriate millisecond
value for the timestamp if the underlying database does not store
timezone information. |
public int getType() throws SQLException {
try {
checkState();
} catch(SQLException sqle) {
return super.getType();
}
// If the ResultSet has not been created, then return the default type
// otherwise return the type from the ResultSet.
if(rs == null) {
return super.getType();
} else {
int rstype = rs.getType();
return rstype;
}
} Returns the fetch size for this
ResultSet object. |
public URL getURL(int columnIndex) throws SQLException {
checkState();
return rs.getURL(columnIndex);
} Provide interface coverage for getURL(int) in ResultSet->RowSet |
public URL getURL(String columnName) throws SQLException {
return getURL(findColumn(columnName));
} Provide interface coverage for getURL(String) in ResultSet->RowSet |
public InputStream getUnicodeStream(int columnIndex) throws SQLException {
checkState();
return rs.getUnicodeStream(columnIndex);
} Deprecated! use - getCharacterStream in place of
getUnicodeStream
Gets the value of the designated column in the current row
of this rowset's ResultSet object as
as a stream of Unicode characters.
The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving largeLONGVARCHARvalues. The JDBC driver will
do any necessary conversion from the database format into Unicode.
The byte format of the Unicode stream must be Java UTF-8,
as specified in the Java virtual machine specification.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method
InputStream.available
is called whether there is data available or not. |
public InputStream getUnicodeStream(String columnName) throws SQLException {
return getUnicodeStream(findColumn(columnName));
} Deprecated!
Gets the value of the designated column in the current row
of this rowset's ResultSet object as a stream of
Unicode characters. The value can then be read in chunks from the
stream. This method is particularly
suitable for retrieving large LONGVARCHAR values.
The JDBC driver will
do any necessary conversion from the database format into Unicode.
The byte format of the Unicode stream must be Java UTF-8,
as defined in the Java virtual machine specification.
Note: All the data in the returned stream must be
read prior to getting the value of any other column. The next
call to a getXXX method implicitly closes the stream. Also, a
stream may return 0 when the method available
is called whether there is data available or not. |
public SQLWarning getWarnings() throws SQLException {
checkState();
return rs.getWarnings();
} Returns the first warning reported by calls on this rowset's
ResultSet object.
Subsequent warnings on this rowset's ResultSet object
will be chained to the SQLWarning object that
this method returns.
The warning chain is automatically cleared each time a new
row is read.
Note: This warning chain only covers warnings caused
by ResultSet methods. Any warning caused by
Statement methods
(such as reading OUT parameters) will be chained on the
Statement object. |
protected void initMetaData(RowSetMetaData md,
ResultSetMetaData rsmd) throws SQLException {
int numCols = rsmd.getColumnCount();
md.setColumnCount(numCols);
for (int col=1; col < = numCols; col++) {
md.setAutoIncrement(col, rsmd.isAutoIncrement(col));
md.setCaseSensitive(col, rsmd.isCaseSensitive(col));
md.setCurrency(col, rsmd.isCurrency(col));
md.setNullable(col, rsmd.isNullable(col));
md.setSigned(col, rsmd.isSigned(col));
md.setSearchable(col, rsmd.isSearchable(col));
md.setColumnDisplaySize(col, rsmd.getColumnDisplaySize(col));
md.setColumnLabel(col, rsmd.getColumnLabel(col));
md.setColumnName(col, rsmd.getColumnName(col));
md.setSchemaName(col, rsmd.getSchemaName(col));
md.setPrecision(col, rsmd.getPrecision(col));
md.setScale(col, rsmd.getScale(col));
md.setTableName(col, rsmd.getTableName(col));
md.setCatalogName(col, rsmd.getCatalogName(col));
md.setColumnType(col, rsmd.getColumnType(col));
md.setColumnTypeName(col, rsmd.getColumnTypeName(col));
}
} Initializes the given RowSetMetaData object with the values
in the given ResultSetMetaData object. |
public void insertRow() throws SQLException {
checkState();
rs.insertRow();
notifyRowChanged();
} Inserts the contents of the insert row into this
ResultSet object and into the database
and also notifies listeners that a row has changed.
The cursor must be on the insert row when this method is called. |
public boolean isAfterLast() throws SQLException {
checkState();
return rs.isAfterLast();
} Indicates whether the cursor is after the last row in
this rowset's ResultSet object. |
public boolean isBeforeFirst() throws SQLException {
checkState();
return rs.isBeforeFirst();
} Indicates whether the cursor is before the first row in
this rowset's ResultSet object. |
public boolean isClosed() throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the
method close has been called on it, or if it is automatically closed. |
public boolean isFirst() throws SQLException {
checkState();
return rs.isFirst();
} Indicates whether the cursor is on the first row of
this rowset's ResultSet object. |
public boolean isLast() throws SQLException {
checkState();
return rs.isLast();
} Indicates whether the cursor is on the last row of
this rowset's ResultSet object.
Note: Calling the method isLast may be expensive
because the JDBC driver
might need to fetch ahead one row in order to determine
whether the current row is the last row in the result set. |
public boolean isWrapperFor(Class<?> interfaces) throws SQLException {
return false;
} |
public boolean last() throws SQLException {
checkState();
boolean b = rs.last();
notifyCursorMoved();
return b;
} Moves the cursor to the last row in
this rowset's ResultSet object. |
public void moveToCurrentRow() throws SQLException {
checkState();
rs.moveToCurrentRow();
} Moves the cursor to the remembered cursor position, usually the
current row. This method has no effect if the cursor is not on
the insert row. |
public void moveToInsertRow() throws SQLException {
checkState();
rs.moveToInsertRow();
} Moves the cursor to the insert row. The current cursor position is
remembered while the cursor is positioned on the insert row.
The insert row is a special row associated with an updatable
result set. It is essentially a buffer where a new row may
be constructed by calling the updateXXX methods prior to
inserting the row into the result set.
Only the updateXXX, getXXX,
and insertRow methods may be
called when the cursor is on the insert row. All of the columns in
a result set must be given a value each time this method is
called before calling insertRow.
An updateXXX method must be called before a
getXXX method can be called on a column value. |
public boolean next() throws SQLException {
checkState();
boolean b = rs.next();
notifyCursorMoved();
return b;
} Moves the cursor for this rowset's ResultSet
object down one row from its current position.
A ResultSet cursor is initially positioned
before the first row; the first call to the method
next makes the first row the current row; the
second call makes the second row the current row, and so on.
If an input stream is open for the current row, a call
to the method next will
implicitly close it. A ResultSet object's
warning chain is cleared when a new row is read. |
protected PreparedStatement prepare() throws SQLException {
// get a connection
conn = connect();
try {
Map< String, Class< ? > > aMap = getTypeMap();
if( aMap != null) {
conn.setTypeMap(aMap);
}
ps = conn.prepareStatement(getCommand(),ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
} catch (SQLException ex) {
System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.prepare").toString() +
ex.getLocalizedMessage());
if (ps != null)
ps.close();
if (conn != null)
conn.close();
throw new SQLException(ex.getMessage());
}
return ps;
} |
public boolean previous() throws SQLException {
checkState();
boolean b = rs.previous();
notifyCursorMoved();
return b;
} Moves the cursor to the previous row in this
ResultSet object.
Note: Calling the method previous() is not the same as
calling the method relative(-1) because it
makes sense to call previous() when there is no current row. |
public void refreshRow() throws SQLException {
checkState();
rs.refreshRow();
} Refreshes the current row of this rowset's ResultSet
object with its most recent value in the database. This method
cannot be called when the cursor is on the insert row.
The refreshRow method provides a way for an
application to explicitly tell the JDBC driver to refetch
a row(s) from the database. An application may want to call
refreshRow when caching or prefetching is being
done by the JDBC driver to fetch the latest value of a row
from the database. The JDBC driver may actually refresh multiple
rows at once if the fetch size is greater than one.
All values are refetched subject to the transaction isolation
level and cursor sensitivity. If refreshRow is called after
calling an updateXXX method, but before calling
the method updateRow, then the
updates made to the row are lost. Calling the method
refreshRow frequently will likely slow performance. |
public boolean relative(int rows) throws SQLException {
checkState();
boolean b = rs.relative(rows);
notifyCursorMoved();
return b;
} Moves the cursor a relative number of rows, either positive or negative.
Attempting to move beyond the first/last row in the
result set positions the cursor before/after the
the first/last row. Calling relative(0) is valid, but does
not change the cursor position.
Note: Calling the method relative(1)
is different from calling the method next()
because is makes sense to call next() when there
is no current row,
for example, when the cursor is positioned before the first row
or after the last row of the result set. |
public void rollback() throws SQLException {
conn.rollback();
// Makes the result ste handle null after rollback
// Added as per Rave requirements
ResultSet oldVal = rs;
rs = null;
// propertyChangeSupport.firePropertyChange("ResultSet", oldVal,rs);
} Rolls back all the updates in this JdbcRowSet object by
wrapping the internal Connection object and calling its
rollback method.
This method sets this JdbcRowSet object's private field
rs to null after saving its value to another object.
(The field rs is this JdbcRowSet object's
internal ResultSet object.) |
public void rollback(Savepoint s) throws SQLException {
conn.rollback(s);
} Rollbacks all the updates in the JdbcRowSet back to the
last Savepoint transaction marker. Wraps the internal
Connection object and call it's rollback method |
public boolean rowDeleted() throws SQLException {
checkState();
return rs.rowDeleted();
} Indicates whether a row has been deleted. A deleted row may leave
a visible "hole" in a result set. This method can be used to
detect holes in a result set. The value returned depends on whether
or not this rowset's ResultSet object can detect deletions. |
public boolean rowInserted() throws SQLException {
checkState();
return rs.rowInserted();
} Indicates whether the current row has had an insertion.
The value returned depends on whether or not this
ResultSet object can detect visible inserts. |
public boolean rowUpdated() throws SQLException {
checkState();
return rs.rowUpdated();
} Indicates whether the current row has been updated. The value returned
depends on whether or not the result set can detect updates. |
public void setAsciiStream(String parameterName,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given input stream.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setAsciiStream which takes a length parameter. |
public void setAsciiStream(String parameterName,
InputStream x,
int length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given input stream, which will have
the specified number of bytes.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface. |
public void setAutoCommit(boolean autoCommit) throws SQLException {
// The connection object should be there
// in order to commit the connection handle on or off.
if(conn != null) {
conn.setAutoCommit(autoCommit);
} else {
// Coming here means the connection object is null.
// So generate a connection handle internally, since
// a JdbcRowSet is always connected to a db, it is fine
// to get a handle to the connection.
// Get hold of a connection handle
// and change the autcommit as passesd.
conn = connect();
// After setting the below the conn.getAutoCommit()
// should return the same value.
conn.setAutoCommit(autoCommit);
}
} Sets auto-commit on the internal Connection object with this
JdbcRowSet |
public void setBigDecimal(String parameterName,
BigDecimal x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given
java.math.BigDecimal value.
The driver converts this to an SQL NUMERIC value when
it sends it to the database. |
public void setBinaryStream(String parameterName,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given input stream.
When a very large binary value is input to a LONGVARBINARY
parameter, it may be more practical to send it via a
java.io.InputStream object. The data will be read from the
stream as needed until end-of-file is reached.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setBinaryStream which takes a length parameter. |
public void setBinaryStream(String parameterName,
InputStream x,
int length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given input stream, which will have
the specified number of bytes.
When a very large binary value is input to a LONGVARBINARY
parameter, it may be more practical to send it via a
java.io.InputStream object. The data will be read from the stream
as needed until end-of-file is reached.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface. |
public void setBlob(int parameterIndex,
InputStream inputStream) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a InputStream object.
This method differs from the setBinaryStream (int, InputStream)
This method differs from the setBinaryStream (int, InputStream)
method because it informs the driver that the parameter value should be
sent to the server as a BLOB. When the setBinaryStream method is used,
the driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGVARBINARY or a BLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setBlob which takes a length parameter. |
public void setBlob(String parameterName,
Blob x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Blob object.
The driver converts this to an SQL BLOB value when it
sends it to the database. |
public void setBlob(String parameterName,
InputStream inputStream) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a InputStream object.
This method differs from the setBinaryStream (int, InputStream)
method because it informs the driver that the parameter value should be
sent to the server as a BLOB. When the setBinaryStream method is used,
the driver may have to do extra work to determine whether the parameter
data should be send to the server as a LONGVARBINARY or a BLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setBlob which takes a length parameter. |
public void setBlob(int parameterIndex,
InputStream inputStream,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a InputStream object. The inputstream must contain the number
of characters specified by length otherwise a SQLException will be
generated when the PreparedStatement is executed.
This method differs from the setBinaryStream (int, InputStream, int)
method because it informs the driver that the parameter value should be
sent to the server as a BLOB. When the setBinaryStream method is used,
the driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGVARBINARY or a BLOB |
public void setBlob(String parameterName,
InputStream inputStream,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a InputStream object. The inputstream must contain the number
of characters specified by length, otherwise a SQLException will be
generated when the CallableStatement is executed.
This method differs from the setBinaryStream (int, InputStream, int)
method because it informs the driver that the parameter value should be
sent to the server as a BLOB. When the setBinaryStream method is used,
the driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGVARBINARY or a BLOB |
public void setBoolean(String parameterName,
boolean x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java boolean value.
The driver converts this
to an SQL BIT or BOOLEAN value when it sends it to the database. |
public void setByte(String parameterName,
byte x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java byte value.
The driver converts this
to an SQL TINYINT value when it sends it to the database. |
public void setBytes(String parameterName,
byte[] x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java array of bytes.
The driver converts this to an SQL VARBINARY or
LONGVARBINARY (depending on the argument's size relative
to the driver's limits on VARBINARY values) when it sends
it to the database. |
public void setCharacterStream(String parameterName,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Reader
object.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setCharacterStream which takes a length parameter. |
public void setCharacterStream(String parameterName,
Reader reader,
int length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Reader
object, which is the given number of characters long.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface. |
public void setClob(String parameterName,
Clob x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Clob object.
The driver converts this to an SQL CLOB value when it
sends it to the database. |
public void setClob(String parameterName,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object.
This method differs from the setCharacterStream (int, Reader) method
because it informs the driver that the parameter value should be sent to
the server as a CLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be send to the server as a LONGVARCHAR or a CLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setClob which takes a length parameter. |
public void setClob(int parameterIndex,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object.
This method differs from the setCharacterStream (int, Reader) method
because it informs the driver that the parameter value should be sent to
the server as a CLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGVARCHAR or a CLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setClob which takes a length parameter. |
public void setClob(String parameterName,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The reader must contain the number
of characters specified by length otherwise a SQLException will be
generated when the CallableStatement is executed.
This method differs from the setCharacterStream (int, Reader, int) method
because it informs the driver that the parameter value should be sent to
the server as a CLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be send to the server as a LONGVARCHAR or a CLOB |
public void setClob(int parameterIndex,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The reader must contain the number
of characters specified by length otherwise a SQLException will be
generated when the PreparedStatement is executed.
This method differs from the setCharacterStream (int, Reader, int) method
because it informs the driver that the parameter value should be sent to
the server as a CLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGVARCHAR or a CLOB |
public void setCommand(String command) throws SQLException {
String oldVal;
if (getCommand() != null) {
if(!getCommand().equals(command)) {
oldVal = getCommand();
super.setCommand(command);
ps = null;
rs = null;
propertyChangeSupport.firePropertyChange("command", oldVal,command);
}
}
else {
super.setCommand(command);
propertyChangeSupport.firePropertyChange("command", null,command);
}
} Sets this JdbcRowSet object's command property to
the given String object and clears the parameters, if any,
that were set for the previous command. In addition,
if the command property has previously been set to a
non-null value and it is
different from the String object supplied,
this method sets this JdbcRowSet object's private fields
ps and rs to null.
(The field ps is its PreparedStatement object, and
the field rs is its ResultSet object.)
The command property may not be needed if the RowSet
object gets its data from a source that does not support commands,
such as a spreadsheet or other tabular file.
Thus, this property is optional and may be null. |
public void setConcurrency(int concur) throws SQLException {
int oldVal;
try {
oldVal = getConcurrency();
}catch(NullPointerException ex) {
oldVal = 0;
}
if(oldVal != concur) {
super.setConcurrency(concur);
propertyChangeSupport.firePropertyChange("concurrency",oldVal,concur);
}
} Sets the concurrency for this RowSet object to
the specified concurrency. The default concurrency for any RowSet
object (connected or disconnected) is ResultSet.CONCUR_UPDATABLE,
but this method may be called at any time to change the concurrency. |
protected void setConnection(Connection connection) {
conn = connection;
} Sets this JdbcRowSet object's connection property
to the given Connection object. |
public void setDataSourceName(String dsName) throws SQLException {
String oldVal;
if(getDataSourceName() != null) {
if(!getDataSourceName().equals(dsName)) {
oldVal = getDataSourceName();
super.setDataSourceName(dsName);
conn = null;
ps = null;
rs = null;
propertyChangeSupport.firePropertyChange("dataSourceName",oldVal,dsName);
}
}
else {
super.setDataSourceName(dsName);
propertyChangeSupport.firePropertyChange("dataSourceName",null,dsName);
}
} Sets the dataSourceName property for this JdbcRowSet
object to the given logical name and sets this JdbcRowSet object's
Url property to null. In addition, if the dataSourceName
property has previously been set and is different from the one supplied,
this method sets this JdbcRowSet object's private fields
ps, rs, and conn to null.
(The field ps is its PreparedStatement object,
the field rs is its ResultSet object, and
the field conn is its Connection object.)
The name supplied to this method must have been bound to a
DataSource object in a JNDI naming service so that an
application can do a lookup using that name to retrieve the
DataSource object bound to it. The DataSource
object can then be used to establish a connection to the data source it
represents.
Users should set either the Url property or the dataSourceName property.
If both properties are set, the driver will use the property set most recently. |
public void setDate(String parameterName,
Date x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Date value
using the default time zone of the virtual machine that is running
the application.
The driver converts this
to an SQL DATE value when it sends it to the database. |
public void setDate(String parameterName,
Date x,
Calendar cal) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Date value,
using the given Calendar object. The driver uses
the Calendar object to construct an SQL DATE value,
which the driver then sends to the database. With a
a Calendar object, the driver can calculate the date
taking into account a custom timezone. If no
Calendar object is specified, the driver uses the default
timezone, which is that of the virtual machine running the application. |
public void setDouble(String parameterName,
double x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java double value.
The driver converts this
to an SQL DOUBLE value when it sends it to the database. |
public void setFetchDirection(int direction) throws SQLException {
checkState();
rs.setFetchDirection(direction);
} Gives a hint as to the direction in which the rows in this
ResultSet object will be processed.
The initial value is determined by the
Statement object
that produced this rowset's ResultSet object.
The fetch direction may be changed at any time. |
public void setFetchSize(int rows) throws SQLException {
checkState();
rs.setFetchSize(rows);
} Gives the JDBC driver a hint as to the number of rows that should
be fetched from the database when more rows are needed for this
ResultSet object.
If the fetch size specified is zero, the JDBC driver
ignores the value and is free to make its own best guess as to what
the fetch size should be. The default value is set by the
Statement object
that created the result set. The fetch size may be changed at any time. |
public void setFloat(String parameterName,
float x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java float value.
The driver converts this
to an SQL FLOAT value when it sends it to the database. |
public void setInt(String parameterName,
int x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java int value.
The driver converts this
to an SQL INTEGER value when it sends it to the database. |
public void setLong(String parameterName,
long x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java long value.
The driver converts this
to an SQL BIGINT value when it sends it to the database. |
public void setMatchColumn(int[] columnIdxes) throws SQLException {
for(int j = 0 ; j < columnIdxes.length; j++) {
if( columnIdxes[j] < 0 ) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString());
}
}
for(int i = 0 ;i < columnIdxes.length; i++) {
iMatchColumns.add(i,Integer.valueOf(columnIdxes[i]));
}
} Sets the designated parameter to the given int array.
This forms the basis of the join for the
JoinRowSet as the column which will form the basis of the
join.
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 getMatchColumnIndexes is called. |
public void setMatchColumn(String[] columnNames) throws SQLException {
for(int j = 0; j < columnNames.length; j++) {
if( columnNames[j] == null || columnNames[j].equals("")) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString());
}
}
for( int i = 0; i < columnNames.length; i++) {
strMatchColumns.add(i,columnNames[i]);
}
} Sets the designated parameter to the given String array.
This forms the basis of the join for the
JoinRowSet as the column which will form the basis of the
join.
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 getMatchColumn is called. |
public void setMatchColumn(int columnIdx) throws SQLException {
// validate, if col is ok to be set
if(columnIdx < 0) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString());
} else {
// set iMatchColumn
iMatchColumns.set(0, Integer.valueOf(columnIdx));
//strMatchColumn = null;
}
} Sets the designated parameter to the given int
object. This forms the basis of the join for the
JoinRowSet as the column which will form the basis of the
join.
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 getMatchColumn is called. |
public void setMatchColumn(String columnName) throws SQLException {
// validate, if col is ok to be set
if(columnName == null || (columnName= columnName.trim()).equals("")) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString());
} else {
// set strMatchColumn
strMatchColumns.set(0, columnName);
//iMatchColumn = -1;
}
} Sets the designated parameter to the given String
object. This forms the basis of the join for the
JoinRowSet as the column which will form the basis of the
join.
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 getMatchColumn is called. |
public void setMaxRows(int mRows) throws SQLException {
int oldVal;
try {
oldVal = getMaxRows();
}catch(NullPointerException ex) {
oldVal = 0;
}
if(oldVal != mRows) {
super.setMaxRows(mRows);
propertyChangeSupport.firePropertyChange("maxRows",oldVal,mRows);
}
} Sets the maximum number of rows that this RowSet object may contain to
the given number. If this limit is exceeded, the excess rows are
silently dropped. |
public void setNCharacterStream(int parameterIndex,
Reader value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter in this RowSet object's command
to a Reader object. The
Reader reads the data till end-of-file is reached. The
driver does the necessary conversion from Java character format to
the national character set in the database.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setNCharacterStream which takes a length parameter. |
public void setNCharacterStream(String parameterName,
Reader value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The
Reader reads the data till end-of-file is reached. The
driver does the necessary conversion from Java character format to
the national character set in the database.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setNCharacterStream which takes a length parameter. |
public void setNCharacterStream(int parameterIndex,
Reader value,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The
Reader reads the data till end-of-file is reached. The
driver does the necessary conversion from Java character format to
the national character set in the database. |
public void setNCharacterStream(String parameterName,
Reader value,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The
Reader reads the data till end-of-file is reached. The
driver does the necessary conversion from Java character format to
the national character set in the database. |
public void setNClob(String parameterName,
NClob value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a java.sql.NClob object. The object
implements the java.sql.NClob interface. This NClob
object maps to a SQL NCLOB. |
public void setNClob(int parameterIndex,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object.
This method differs from the setCharacterStream (int, Reader) method
because it informs the driver that the parameter value should be sent to
the server as a NCLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGNVARCHAR or a NCLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setNClob which takes a length parameter. |
public void setNClob(String parameterName,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object.
This method differs from the setCharacterStream (int, Reader) method
because it informs the driver that the parameter value should be sent to
the server as a NCLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be send to the server as a LONGNVARCHAR or a NCLOB
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
setNClob which takes a length parameter. |
public void setNClob(int parameterIndex,
NClob value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a java.sql.NClob object. The driver converts this to
a
SQL NCLOB value when it sends it to the database. |
public void setNClob(String parameterName,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to a Reader object. The reader must contain the number
of characters specified by length otherwise a SQLException will be
generated when the CallableStatement is executed.
This method differs from the setCharacterStream (int, Reader, int) method
because it informs the driver that the parameter value should be sent to
the server as a NCLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be send to the server as a LONGNVARCHAR or a NCLOB |
public void setNClob(int parameterIndex,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} of characters specified by length otherwise a SQLException will becontain the number
generated when the PreparedStatement is executed.
This method differs from the setCharacterStream (int, Reader, int) method
because it informs the driver that the parameter value should be sent to
the server as a NCLOB. When the setCharacterStream method is used, the
driver may have to do extra work to determine whether the parameter
data should be sent to the server as a LONGNVARCHAR or a NCLOB |
public void setNString(int parameterIndex,
String value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated paramter to the given String object.
The driver converts this to a SQL NCHAR or
NVARCHAR or LONGNVARCHAR value
(depending on the argument's
size relative to the driver's limits on NVARCHAR values)
when it sends it to the database. |
public void setNString(String parameterName,
String value) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated paramter to the given String object.
The driver converts this to a SQL NCHAR or
NVARCHAR or LONGNVARCHAR |
public void setNull(String parameterName,
int sqlType) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} |
public void setNull(String parameterName,
int sqlType,
String typeName) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to SQL NULL.
This version of the method setNull should
be used for user-defined types and REF type parameters. Examples
of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
named array types.
Note: To be portable, applications must give the
SQL type code and the fully-qualified SQL type name when specifying
a NULL user-defined or REF parameter. In the case of a user-defined type
the name is the type name of the parameter itself. For a REF
parameter, the name is the type name of the referenced type. If
a JDBC driver does not need the type code or type name information,
it may ignore it.
Although it is intended for user-defined and Ref parameters,
this method may be used to set a null parameter of any JDBC type.
If the parameter does not have a user-defined or REF type, the given
typeName is ignored. |
public void setObject(String parameterName,
Object x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the value of the designated parameter with the given object.
The second parameter must be of type Object; therefore, the
java.lang equivalent objects should be used for built-in types.
The JDBC specification specifies a standard mapping from
Java Object types to SQL types. The given argument
will be converted to the corresponding SQL type before being
sent to the database.
Note that this method may be used to pass datatabase-
specific abstract data types, by using a driver-specific Java
type.
If the object is of a class implementing the interface SQLData,
the JDBC driver should call the method SQLData.writeSQL
to write it to the SQL data stream.
If, on the other hand, the object is of a class implementing
Ref, Blob, Clob, NClob,
Struct, java.net.URL,
or Array, the driver should pass it to the database as a
value of the corresponding SQL type.
This method throws an exception if there is an ambiguity, for example, if the
object is of a class implementing more than one of the interfaces named above. |
public void setObject(String parameterName,
Object x,
int targetSqlType) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the value of the designated parameter with the given object.
This method is like the method setObject
above, except that it assumes a scale of zero. |
public void setObject(String parameterName,
Object x,
int targetSqlType,
int scale) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the value of the designated parameter with the given object. The second
argument must be an object type; for integral values, the
java.lang equivalent objects should be used.
The given Java object will be converted to the given targetSqlType
before being sent to the database.
If the object has a custom mapping (is of a class implementing the
interface SQLData),
the JDBC driver should call the method SQLData.writeSQL to write it
to the SQL data stream.
If, on the other hand, the object is of a class implementing
Ref, Blob, Clob, NClob,
Struct, java.net.URL,
or Array, the driver should pass it to the database as a
value of the corresponding SQL type.
Note that this method may be used to pass datatabase-
specific abstract data types. |
protected void setParams() throws SQLException {
if(rs == null) {
setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
setConcurrency(ResultSet.CONCUR_UPDATABLE);
}
else {
setType(rs.getType());
setConcurrency(rs.getConcurrency());
}
} |
public void setPassword(String password) {
String oldVal;
if ( getPassword() != null) {
if(!getPassword().equals(password)) {
oldVal = getPassword();
super.setPassword(password);
conn = null;
ps = null;
rs = null;
propertyChangeSupport.firePropertyChange("password",oldVal,password);
}
}
else{
super.setPassword(password);
propertyChangeSupport.firePropertyChange("password",null,password);
}
} Sets the password property for this JdbcRowSet object
to the given String object. Because it
is not serialized, the password property is set at run time before
calling the method execute. Its default valus is
null. In addition,
if the password property is already set with a
non-null value and that value is different from the one being set,
this method sets this JdbcRowSet object's private fields
ps, rs, and conn to null.
(The field ps is its PreparedStatement object,
rs is its ResultSet object, and
conn is its Connection object.)
Setting these fields to null ensures that only current
values will be used. |
protected void setPreparedStatement(PreparedStatement preparedStatement) {
ps = preparedStatement;
} Sets this JdbcRowSet object's preparedtsatement property
to the given PreparedStatemennt object. |
protected void setProperties(PreparedStatement ps) throws SQLException {
try {
ps.setEscapeProcessing(getEscapeProcessing());
} catch (SQLException ex) {
System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setescapeprocessing").toString() +
ex.getLocalizedMessage());
}
try {
ps.setMaxFieldSize(getMaxFieldSize());
} catch (SQLException ex) {
System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxfieldsize").toString() +
ex.getLocalizedMessage());
}
try {
ps.setMaxRows(getMaxRows());
} catch (SQLException ex) {
System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxrows").toString() +
ex.getLocalizedMessage());
}
try {
ps.setQueryTimeout(getQueryTimeout());
} catch (SQLException ex) {
System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setquerytimeout").toString() +
ex.getLocalizedMessage());
}
} |
protected void setResultSet(ResultSet resultSet) {
rs = resultSet;
} Sets this JdbcRowSet object's resultset property
to the given ResultSet object. |
public void setRowId(int parameterIndex,
RowId x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.RowId object. The
driver converts this to a SQL ROWID value when it sends it
to the database |
public void setRowId(String parameterName,
RowId x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.RowId object. The
driver converts this to a SQL ROWID when it sends it to the
database. |
public void setSQLXML(int parameterIndex,
SQLXML xmlObject) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.SQLXML object. The driver converts this to an
SQL XML value when it sends it to the database. |
public void setSQLXML(String parameterName,
SQLXML xmlObject) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.SQLXML object. The driver converts this to an
SQL XML value when it sends it to the database. |
public void setShort(String parameterName,
short x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java short value.
The driver converts this
to an SQL SMALLINT value when it sends it to the database. |
public void setString(String parameterName,
String x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given Java String value.
The driver converts this
to an SQL VARCHAR or LONGVARCHAR value
(depending on the argument's
size relative to the driver's limits on VARCHAR values)
when it sends it to the database. |
public void setTime(String parameterName,
Time x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Time value.
The driver converts this
to an SQL TIME value when it sends it to the database. |
public void setTime(String parameterName,
Time x,
Calendar cal) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Time value,
using the given Calendar object. The driver uses
the Calendar object to construct an SQL TIME value,
which the driver then sends to the database. With a
a Calendar object, the driver can calculate the time
taking into account a custom timezone. If no
Calendar object is specified, the driver uses the default
timezone, which is that of the virtual machine running the application. |
public void setTimestamp(String parameterName,
Timestamp x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Timestamp value.
The driver
converts this to an SQL TIMESTAMP value when it sends it to the
database. |
public void setTimestamp(String parameterName,
Timestamp x,
Calendar cal) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.sql.Timestamp value,
using the given Calendar object. The driver uses
the Calendar object to construct an SQL TIMESTAMP value,
which the driver then sends to the database. With a
a Calendar object, the driver can calculate the timestamp
taking into account a custom timezone. If no
Calendar object is specified, the driver uses the default
timezone, which is that of the virtual machine running the application. |
public void setTransactionIsolation(int transIso) throws SQLException {
int oldVal;
try {
oldVal = getTransactionIsolation();
}catch(NullPointerException ex) {
oldVal = 0;
}
if(oldVal != transIso) {
super.setTransactionIsolation(transIso);
propertyChangeSupport.firePropertyChange("transactionIsolation",oldVal,transIso);
}
} Sets the transaction isolation property for this JDBC RowSet object to the given
constant. The DBMS will use this transaction isolation level for
transactions if it can.
For RowSet implementations such as
the CachedRowSet that operate in a disconnected environment,
the SyncProvider object being used
offers complementary locking and data integrity options. The
options described below are pertinent only to connected RowSet
objects (JdbcRowSet objects). |
public void setType(int type) throws SQLException {
int oldVal;
try {
oldVal = getType();
}catch(SQLException ex) {
oldVal = 0;
}
if(oldVal != type) {
super.setType(type);
propertyChangeSupport.firePropertyChange("type",oldVal,type);
}
} Sets the type for this RowSet object to the specified type.
The default type is ResultSet.TYPE_SCROLL_INSENSITIVE. |
public void setURL(int parameterIndex,
URL x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Sets the designated parameter to the given java.net.URL value.
The driver converts this to an SQL DATALINK value
when it sends it to the database. |
public void setUrl(String url) throws SQLException {
String oldVal;
if(getUrl() != null) {
if(!getUrl().equals(url)) {
oldVal = getUrl();
super.setUrl(url);
conn = null;
ps = null;
rs = null;
propertyChangeSupport.firePropertyChange("url", oldVal, url);
}
}
else {
super.setUrl(url);
propertyChangeSupport.firePropertyChange("url", null, url);
}
} Sets the Url property for this JdbcRowSet object
to the given String object and sets the dataSource name
property to null. In addition, if the Url property has
previously been set to a non null value and its value
is different from the value to be set,
this method sets this JdbcRowSet object's private fields
ps, rs, and conn to null.
(The field ps is its PreparedStatement object,
the field rs is its ResultSet object, and
the field conn is its Connection object.)
The Url property is a JDBC URL that is used when
the connection is created using a JDBC technology-enabled driver
("JDBC driver") and the DriverManager.
The correct JDBC URL for the specific driver to be used can be found
in the driver documentation. Although there are guidelines for for how
a JDBC URL is formed,
a driver vendor can specify any String object except
one with a length of 0 (an empty string).
Setting the Url property is optional if connections are established using
a DataSource object instead of the DriverManager.
The driver will use either the URL property or the
dataSourceName property to create a connection, whichever was
specified most recently. If an application uses a JDBC URL, it
must load a JDBC driver that accepts the JDBC URL before it uses the
RowSet object to connect to a database. The RowSet
object will use the URL internally to create a database connection in order
to read or write data. |
public void setUsername(String uname) {
String oldVal;
if( getUsername() != null) {
if(!getUsername().equals(uname)) {
oldVal = getUsername();
super.setUsername(uname);
conn = null;
ps = null;
rs = null;
propertyChangeSupport.firePropertyChange("username",oldVal,uname);
}
}
else{
super.setUsername(uname);
propertyChangeSupport.firePropertyChange("username",null,uname);
}
} Sets the username property for this JdbcRowSet object
to the given user name. Because it
is not serialized, the username property is set at run time before
calling the method execute. In addition,
if the username property is already set with a
non-null value and that value is different from the String
object to be set,
this method sets this JdbcRowSet object's private fields
ps, rs, and conn to null.
(The field ps is its PreparedStatement object,
rs is its ResultSet object, and
conn is its Connection object.)
Setting these fields to null ensures that only current
values will be used. |
public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
int i_val;
for( int j= 0 ;j < columnIdxes.length; j++) {
i_val = (Integer.parseInt(iMatchColumns.get(j).toString()));
if(columnIdxes[j] != i_val) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString());
}
}
for( int i = 0;i < columnIdxes.length ;i++) {
iMatchColumns.set(i,Integer.valueOf(-1));
}
} |
public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
for(int j = 0 ;j < columnIdxes.length; j++) {
if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString());
}
}
for(int i = 0 ; i < columnIdxes.length; i++) {
strMatchColumns.set(i,null);
}
} |
public void unsetMatchColumn(int columnIdx) throws SQLException {
// check if we are unsetting the SAME column
if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) ) ) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString());
} else if(strMatchColumns.get(0) != null) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolname").toString());
} else {
// that is, we are unsetting it.
iMatchColumns.set(0, Integer.valueOf(-1));
}
} |
public void unsetMatchColumn(String columnName) throws SQLException {
// check if we are unsetting the same column
columnName = columnName.trim();
if(!((strMatchColumns.get(0)).equals(columnName))) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString());
} else if( ((Integer)(iMatchColumns.get(0))).intValue() > 0) {
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolid").toString());
} else {
strMatchColumns.set(0, null); // that is, we are unsetting it.
}
} |
public T unwrap(Class<T> iface) throws SQLException {
return null;
} |
public void updateArray(int columnIndex,
Array a) throws SQLException {
checkState();
rs.updateArray(columnIndex, a);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
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 #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateArray(String columnName,
Array a) throws SQLException {
updateArray(findColumn(columnName), a);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
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 #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateAsciiStream(int columnIndex,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with an ascii stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateAsciiStream which takes a length parameter. |
public void updateAsciiStream(String columnLabel,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with an ascii stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateAsciiStream which takes a length parameter. |
public void updateAsciiStream(int columnIndex,
InputStream x,
int length) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateAsciiStream(columnIndex, x, length);
} Updates the designated column with an ascii stream value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateAsciiStream(String columnName,
InputStream x,
int length) throws SQLException {
updateAsciiStream(findColumn(columnName), x, length);
} Updates the designated column with an ascii stream value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateAsciiStream(int columnIndex,
InputStream x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with an ascii stream value, which will have
the specified number of bytes.
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. |
public void updateAsciiStream(String columnLabel,
InputStream x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with an ascii stream value, which will have
the specified number of bytes..
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. |
public void updateBigDecimal(int columnIndex,
BigDecimal x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateBigDecimal(columnIndex, x);
} Updates the designated column with a java.math.BigDecimal
value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBigDecimal(String columnName,
BigDecimal x) throws SQLException {
updateBigDecimal(findColumn(columnName), x);
} Updates the designated column with a java.sql.BigDecimal
value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBinaryStream(int columnIndex,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a binary stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateBinaryStream which takes a length parameter. |
public void updateBinaryStream(String columnLabel,
InputStream x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a binary stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateBinaryStream which takes a length parameter. |
public void updateBinaryStream(int columnIndex,
InputStream x,
int length) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateBinaryStream(columnIndex, x, length);
} Updates the designated column with a binary stream value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBinaryStream(String columnName,
InputStream x,
int length) throws SQLException {
updateBinaryStream(findColumn(columnName), x, length);
} Updates the designated column with a binary stream value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBinaryStream(int columnIndex,
InputStream x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a binary stream value, which will have
the specified number of bytes.
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. |
public void updateBinaryStream(String columnLabel,
InputStream x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a binary stream value, which will have
the specified number of bytes.
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. |
public void updateBlob(int columnIndex,
Blob b) throws SQLException {
checkState();
rs.updateBlob(columnIndex, b);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
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 #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateBlob(String columnName,
Blob b) throws SQLException {
updateBlob(findColumn(columnName), b);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
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 #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateBlob(int columnIndex,
InputStream inputStream) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given input stream.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateBlob which takes a length parameter.
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. |
public void updateBlob(String columnLabel,
InputStream inputStream) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given input stream.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateBlob which takes a length parameter.
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. |
public void updateBlob(int columnIndex,
InputStream inputStream,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given input stream, which
will have the specified number of bytes.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateBlob(String columnLabel,
InputStream inputStream,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given input stream, which
will have the specified number of bytes.
When a very large ASCII value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.InputStream. Data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from ASCII to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateBoolean(int columnIndex,
boolean x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateBoolean(columnIndex, x);
} Updates the designated column with a boolean value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBoolean(String columnName,
boolean x) throws SQLException {
updateBoolean(findColumn(columnName), x);
} Updates the designated column with a boolean value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateByte(int columnIndex,
byte x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateByte(columnIndex, x);
} Updates the designated column with a byte value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateByte(String columnName,
byte x) throws SQLException {
updateByte(findColumn(columnName), x);
} Updates the designated column with a byte value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBytes(int columnIndex,
byte[] x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateBytes(columnIndex, x);
} Updates the designated column with a byte array value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateBytes(String columnName,
byte[] x) throws SQLException {
updateBytes(findColumn(columnName), x);
} Updates the designated column with a boolean value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database.
JDBC 2.0
Updates a column with a byte array value.
The updateXXX methods are used to update column values in the
current row, or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or insertRow
methods are called to update the database. |
public void updateCharacterStream(int columnIndex,
Reader x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateCharacterStream which takes a length parameter. |
public void updateCharacterStream(String columnLabel,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value.
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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateCharacterStream which takes a length parameter. |
public void updateCharacterStream(int columnIndex,
Reader x,
int length) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateCharacterStream(columnIndex, x, length);
} Updates the designated column with a character stream value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateCharacterStream(String columnName,
Reader reader,
int length) throws SQLException {
updateCharacterStream(findColumn(columnName), reader, length);
} Updates the designated column with a character stream value.
The updateXXX methods are used to update column values
in the current row or the insert row. The updateXXX
methods do not update the underlying database; instead the
updateRow or insertRow methods are called
to update the database. |
public void updateCharacterStream(int columnIndex,
Reader x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value, which will have
the specified number of bytes.
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. |
public void updateCharacterStream(String columnLabel,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value, which will have
the specified number of bytes.
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. |
public void updateClob(int columnIndex,
Clob c) throws SQLException {
checkState();
rs.updateClob(columnIndex, c);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
double value.
This method updates a column value in either the current row or
the insert row of this rowset, but it does not update the
database. If the cursor is on a row in the rowset, the
method #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateClob(String columnName,
Clob c) throws SQLException {
updateClob(findColumn(columnName), c);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
double value.
This method updates a column value in either the current row or
the insert row of this rowset, but it does not update the
database. If the cursor is on a row in the rowset, the
method #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateClob(int columnIndex,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateClob which takes a length parameter.
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. |
public void updateClob(String columnLabel,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateClob which takes a length parameter.
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. |
public void updateClob(int columnIndex,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object, which is the given number of characters long.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateClob(String columnLabel,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object, which is the given number of characters long.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateDate(int columnIndex,
Date x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateDate(columnIndex, x);
} Updates the designated column with a java.sql.Date value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateDate(String columnName,
Date x) throws SQLException {
updateDate(findColumn(columnName), x);
} Updates the designated column with a java.sql.Date value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateDouble(int columnIndex,
double x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateDouble(columnIndex, x);
} Updates the designated column with a double value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateDouble(String columnName,
double x) throws SQLException {
updateDouble(findColumn(columnName), x);
} Updates the designated column with a double value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateFloat(int columnIndex,
float x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateFloat(columnIndex, x);
} Updates the designated column with a float value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateFloat(String columnName,
float x) throws SQLException {
updateFloat(findColumn(columnName), x);
} Updates the designated column with a float value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateInt(int columnIndex,
int x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateInt(columnIndex, x);
} Updates the designated column with an int value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateInt(String columnName,
int x) throws SQLException {
updateInt(findColumn(columnName), x);
} Updates the designated column with an int value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateLong(int columnIndex,
long x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateLong(columnIndex, x);
} Updates the designated column with a long value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateLong(String columnName,
long x) throws SQLException {
updateLong(findColumn(columnName), x);
} Updates the designated column with a long value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateNCharacterStream(int columnIndex,
Reader x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value. 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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateNCharacterStream which takes a length parameter. |
public void updateNCharacterStream(String columnLabel,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a character stream value. 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.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateNCharacterStream which takes a length parameter. |
public void updateNCharacterStream(int columnIndex,
Reader x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} 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. |
public void updateNCharacterStream(String columnName,
Reader x,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} 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. |
public void updateNClob(int columnIndex,
NClob nClob) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} |
public void updateNClob(String columnName,
NClob nClob) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} This method is used for updating SQL NCLOB type that maps
to java.sql.Types.NCLOB |
public void updateNClob(int columnIndex,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateNClob which takes a length parameter.
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. |
public void updateNClob(String columnLabel,
Reader reader) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
Note: Consult your JDBC driver documentation to determine if
it might be more efficient to use a version of
updateNClob which takes a length parameter.
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. |
public void updateNClob(int columnIndex,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object, which is the given number of characters long.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateNClob(String columnLabel,
Reader reader,
long length) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column using the given Reader
object, which is the given number of characters long.
When a very large UNICODE value is input to a LONGVARCHAR
parameter, it may be more practical to send it via a
java.io.Reader object. The data will be read from the stream
as needed until end-of-file is reached. The JDBC driver will
do any necessary conversion from UNICODE to the database char format.
Note: This stream object can either be a standard
Java stream object or your own subclass that implements the
standard interface.
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. |
public void updateNString(int columnIndex,
String nString) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} This method is used for updating columns that support National Character sets.
It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. |
public void updateNString(String columnName,
String nString) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} This method is used for updating columns that support National Character sets.
It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. |
public void updateNull(int columnIndex) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateNull(columnIndex);
} Gives a nullable column a null value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow
or insertRow methods are called to update the database. |
public void updateNull(String columnName) throws SQLException {
updateNull(findColumn(columnName));
} Updates the designated column with a null value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateObject(int columnIndex,
Object x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateObject(columnIndex, x);
} Updates the designated column with an Object value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateObject(String columnName,
Object x) throws SQLException {
updateObject(findColumn(columnName), x);
} Updates the designated column with an Object value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateObject(int columnIndex,
Object x,
int scale) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateObject(columnIndex, x, scale);
} Updates the designated column with an Object value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateObject(String columnName,
Object x,
int scale) throws SQLException {
updateObject(findColumn(columnName), x, scale);
} Updates the designated column with an Object value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateRef(int columnIndex,
Ref ref) throws SQLException {
checkState();
rs.updateRef(columnIndex, ref);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
double value.
This method updates a column value in either the current row or
the insert row of this rowset, but it does not update the
database. If the cursor is on a row in the rowset, the
method #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateRef(String columnName,
Ref ref) throws SQLException {
updateRef(findColumn(columnName), ref);
} Sets the designated column in either the current row or the insert
row of this JdbcRowSetImpl object with the given
double value.
This method updates a column value in either the current row or
the insert row of this rowset, but it does not update the
database. If the cursor is on a row in the rowset, the
method #updateRow must be called to update the database.
If the cursor is on the insert row, the method #insertRow
must be called, which will insert the new row into both this rowset
and the database. Both of these methods must be called before the
cursor moves to another row. |
public void updateRow() throws SQLException {
checkState();
rs.updateRow();
notifyRowChanged();
} Updates the underlying database with the new contents of the
current row of this rowset's ResultSet object
and notifies listeners that a row has changed.
This method cannot be called when the cursor is on the insert row. |
public void updateRowId(int columnIndex,
RowId x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a RowId value. 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. |
public void updateRowId(String columnName,
RowId x) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a RowId value. 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. |
public void updateSQLXML(int columnIndex,
SQLXML xmlObject) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a java.sql.SQLXML value.
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. |
public void updateSQLXML(String columnName,
SQLXML xmlObject) throws SQLException {
throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
} Updates the designated column with a java.sql.SQLXML value.
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. |
public void updateShort(int columnIndex,
short x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateShort(columnIndex, x);
} Updates the designated column with a short value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateShort(String columnName,
short x) throws SQLException {
updateShort(findColumn(columnName), x);
} Updates the designated column with a short value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateString(int columnIndex,
String x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateString(columnIndex, x);
} Updates the designated column with a String value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateString(String columnName,
String x) throws SQLException {
updateString(findColumn(columnName), x);
} Updates the designated column with a String value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateTime(int columnIndex,
Time x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateTime(columnIndex, x);
} Updates the designated column with a java.sql.Time value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateTime(String columnName,
Time x) throws SQLException {
updateTime(findColumn(columnName), x);
} Updates the designated column with a java.sql.Time value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateTimestamp(int columnIndex,
Timestamp x) throws SQLException {
checkState();
// To check the type and concurrency of the ResultSet
// to verify whether updates are possible or not
checkTypeConcurrency();
rs.updateTimestamp(columnIndex, x);
} Updates the designated column with a java.sql.Timestamp
value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public void updateTimestamp(String columnName,
Timestamp x) throws SQLException {
updateTimestamp(findColumn(columnName), x);
} Updates the designated column with a java.sql.Timestamp
value.
The updateXXX methods are used to update column values in the
current row or the insert row. The updateXXX methods do not
update the underlying database; instead the updateRow or
insertRow methods are called to update the database. |
public boolean wasNull() throws SQLException {
checkState();
return rs.wasNull();
} Reports whether the last column read from this rowset's
ResultSet object had a value of SQL NULL.
Note that you must first call one of the getXXX methods
on a column to try to read its value and then call
the method wasNull to see if the value read was
SQL NULL. |
javax.sql.rowset.BaseRowSet