|
|
Glassfish example source code file (ResultSetWrapper.java)
This example Glassfish source code file (ResultSetWrapper.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Glassfish ResultSetWrapper.java source code
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.gjc.spi.base;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
import java.util.Map;
/**
* Abstract class for ResultSet Wrapper <br>
*/
public abstract class ResultSetWrapper implements ResultSet {
protected ResultSet resultSet = null;
protected Statement statement = null;
/**
* Abstract class for wrapping Statement<br>
*
* @param stmt Statement that is to be wrapped<br>
* @param rs ResultSet that is to be wraped<br>
*/
public ResultSetWrapper(Statement stmt, ResultSet rs) {
resultSet = rs;
statement = stmt;
}
/**
* Moves the cursor down one row from its current position.
* A <code>ResultSet cursor is initially positioned
* before the first row; the first call to the method
* <code>next makes the first row the current row; the
* second call makes the second row the current row, and so on.
* <p/>
* <P>If an input stream is open for the current row, a call
* to the method <code>next will
* implicitly close it. A <code>ResultSet object's
* warning chain is cleared when a new row is read.
*
* @return <code>true if the new current row is valid;
* <code>false if there are no more rows
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean next() throws SQLException {
return resultSet.next();
}
/**
* Releases this <code>ResultSet object's database and
* JDBC resources immediately instead of waiting for
* this to happen when it is automatically closed.
* <p/>
* <P>Note: A ResultSet object
* is automatically closed by the
* <code>Statement object that generated it when
* that <code>Statement object is closed,
* re-executed, or is used to retrieve the next result from a
* sequence of multiple results. A <code>ResultSet object
* is also automatically closed when it is garbage collected.
*
* @throws java.sql.SQLException if a database access error occurs
*/
public void close() throws SQLException {
resultSet.close();
}
/**
* Reports whether
* the last column read had a value of SQL <code>NULL.
* Note that you must first call one of the getter methods
* on a column to try to read its value and then call
* the method <code>wasNull to see if the value read was
* SQL <code>NULL.
*
* @return <code>true if the last column value read was SQL
* <code>NULL and false otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean wasNull() throws SQLException {
return resultSet.wasNull();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>String in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public String getString(int columnIndex) throws SQLException {
return resultSet.getString(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>boolean in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>false
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean getBoolean(int columnIndex) throws SQLException {
return resultSet.getBoolean(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>byte in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public byte getByte(int columnIndex) throws SQLException {
return resultSet.getByte(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>short in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public short getShort(int columnIndex) throws SQLException {
return resultSet.getShort(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* an <code>int in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public int getInt(int columnIndex) throws SQLException {
return resultSet.getInt(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>long in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public long getLong(int columnIndex) throws SQLException {
return resultSet.getLong(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>float in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public float getFloat(int columnIndex) throws SQLException {
return resultSet.getFloat(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>double in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public double getDouble(int columnIndex) throws SQLException {
return resultSet.getDouble(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.BigDecimal in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param scale the number of digits to the right of the decimal point
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
* @deprecated
*/
@Deprecated
public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
return resultSet.getBigDecimal(columnIndex, scale);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>byte array in the Java programming language.
* The bytes represent the raw values returned by the driver.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public byte[] getBytes(int columnIndex) throws SQLException {
return resultSet.getBytes(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Date object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Date getDate(int columnIndex) throws SQLException {
return resultSet.getDate(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Time object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Time getTime(int columnIndex) throws SQLException {
return resultSet.getTime(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Timestamp object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Timestamp getTimestamp(int columnIndex) throws SQLException {
return resultSet.getTimestamp(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>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 <char>LONGVARCHAR values.
* The JDBC driver will
* do any necessary conversion from the database format into ASCII.
* <p/>
* <P>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 getter method implicitly closes the stream. Also, a
* stream may return <code>0 when the method
* <code>InputStream.available
* is called whether there is data available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Java input stream that delivers the database column value
* as a stream of one-byte ASCII characters;
* if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getAsciiStream(int columnIndex) throws SQLException {
return resultSet.getAsciiStream(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* as a stream of two-byte Unicode characters. The first byte is
* the high byte; the second byte is the low byte.
* <p/>
* The value can then be read in chunks from the
* stream. This method is particularly
* suitable for retrieving large <code>LONGVARCHARvalues. The
* JDBC driver will do any necessary conversion from the database
* format into Unicode.
* <p/>
* <P>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 getter method implicitly closes the stream.
* Also, a stream may return <code>0 when the method
* <code>InputStream.available
* is called, whether there is data available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Java input stream that delivers the database column value
* as a stream of two-byte Unicode characters;
* if the value is SQL <code>NULL, the value returned is
* <code>null
* @throws java.sql.SQLException if a database access error occurs
* @deprecated use <code>getCharacterStream in place of
* <code>getUnicodeStream
*/
@Deprecated
public InputStream getUnicodeStream(int columnIndex) throws SQLException {
return resultSet.getUnicodeStream(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>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 <code>LONGVARBINARY values.
* <p/>
* <P>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 getter method implicitly closes the stream. Also, a
* stream may return <code>0 when the method
* <code>InputStream.available
* is called whether there is data available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Java input stream that delivers the database column value
* as a stream of uninterpreted bytes;
* if the value is SQL <code>NULL, the value returned is
* <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getBinaryStream(int columnIndex) throws SQLException {
return resultSet.getBinaryStream(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>String in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public String getString(String columnName) throws SQLException {
return resultSet.getString(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>boolean in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>false
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean getBoolean(String columnName) throws SQLException {
return resultSet.getBoolean(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>byte in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public byte getByte(String columnName) throws SQLException {
return resultSet.getByte(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>short in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public short getShort(String columnName) throws SQLException {
return resultSet.getShort(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* an <code>int in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public int getInt(String columnName) throws SQLException {
return resultSet.getInt(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>long in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public long getLong(String columnName) throws SQLException {
return resultSet.getLong(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>float in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public float getFloat(String columnName) throws SQLException {
return resultSet.getFloat(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>double in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>0
* @throws java.sql.SQLException if a database access error occurs
*/
public double getDouble(String columnName) throws SQLException {
return resultSet.getDouble(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.math.BigDecimal in the Java programming language.
*
* @param columnName the SQL name of the column
* @param scale the number of digits to the right of the decimal point
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
* @deprecated
*/
@Deprecated
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
return resultSet.getBigDecimal(columnName, scale);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>byte array in the Java programming language.
* The bytes represent the raw values returned by the driver.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public byte[] getBytes(String columnName) throws SQLException {
return resultSet.getBytes(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Date object in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Date getDate(String columnName) throws SQLException {
return resultSet.getDate(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Time object in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value;
* if the value is SQL <code>NULL,
* the value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Time getTime(String columnName) throws SQLException {
return resultSet.getTime(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as
* a <code>java.sql.Timestamp object.
*
* @param columnName the SQL name of the column
* @return the column value; if the value is SQL <code>NULL, the
* value returned is <code>null
* @throws java.sql.SQLException if a database access error occurs
*/
public Timestamp getTimestamp(String columnName) throws SQLException {
return resultSet.getTimestamp(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>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 <code>LONGVARCHAR values.
* The JDBC driver will
* do any necessary conversion from the database format into ASCII.
* <p/>
* <P>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 getter method implicitly closes the stream. Also, a
* stream may return <code>0 when the method available
* is called whether there is data available or not.
*
* @param columnName the SQL name of the column
* @return a Java input stream that delivers the database column value
* as a stream of one-byte ASCII characters.
* If the value is SQL <code>NULL,
* the value returned is <code>null.
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getAsciiStream(String columnName) throws SQLException {
return resultSet.getAsciiStream(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a stream of two-byte
* Unicode characters. The first byte is the high byte; the second
* byte is the low byte.
* <p/>
* The value can then be read in chunks from the
* stream. This method is particularly
* suitable for retrieving large <code>LONGVARCHAR values.
* The JDBC technology-enabled driver will
* do any necessary conversion from the database format into Unicode.
* <p/>
* <P>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 getter method implicitly closes the stream.
* Also, a stream may return <code>0 when the method
* <code>InputStream.available is called, whether there
* is data available or not.
*
* @param columnName the SQL name of the column
* @return a Java input stream that delivers the database column value
* as a stream of two-byte Unicode characters.
* If the value is SQL <code>NULL, the value returned
* is <code>null.
* @throws java.sql.SQLException if a database access error occurs
* @deprecated use <code>getCharacterStream instead
*/
@Deprecated
public InputStream getUnicodeStream(String columnName) throws SQLException {
return resultSet.getUnicodeStream(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a stream of uninterpreted
* <code>bytes.
* The value can then be read in chunks from the
* stream. This method is particularly
* suitable for retrieving large <code>LONGVARBINARY
* values.
* <p/>
* <P>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 getter method implicitly closes the stream. Also, a
* stream may return <code>0 when the method available
* is called whether there is data available or not.
*
* @param columnName the SQL name of the column
* @return a Java input stream that delivers the database column value
* as a stream of uninterpreted bytes;
* if the value is SQL <code>NULL, the result is null
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getBinaryStream(String columnName) throws SQLException {
return resultSet.getBinaryStream(columnName);
}
/**
* Retrieves the first warning reported by calls on this
* <code>ResultSet object.
* Subsequent warnings on this <code>ResultSet object
* will be chained to the <code>SQLWarning object that
* this method returns.
* <p/>
* <P>The warning chain is automatically cleared each time a new
* row is read. This method may not be called on a <code>ResultSet
* object that has been closed; doing so will cause an
* <code>SQLException to be thrown.
* <p/>
* <B>Note: This warning chain only covers warnings caused
* by <code>ResultSet methods. Any warning caused by
* <code>Statement methods
* (such as reading OUT parameters) will be chained on the
* <code>Statement object.
*
* @return the first <code>SQLWarning object reported or
* <code>null if there are none
* @throws java.sql.SQLException if a database access error occurs or this method is
* called on a closed result set
*/
public SQLWarning getWarnings() throws SQLException {
return resultSet.getWarnings();
}
/**
* Clears all warnings reported on this <code>ResultSet object.
* After this method is called, the method <code>getWarnings
* returns <code>null until a new warning is
* reported for this <code>ResultSet object.
*
* @throws java.sql.SQLException if a database access error occurs
*/
public void clearWarnings() throws SQLException {
resultSet.clearWarnings();
}
/**
* Retrieves the name of the SQL cursor used by this <code>ResultSet
* object.
* <p/>
* <P>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 <code>SELECT statement
* should be of the form <code>SELECT FOR UPDATE. If
* <code>FOR UPDATE is omitted, the positioned updates may fail.
* <p/>
* <P>The JDBC API supports this SQL feature by providing the name of the
* SQL cursor used by a <code>ResultSet object.
* The current row of a <code>ResultSet object
* is also the current row of this SQL cursor.
* <p/>
* <P>Note: If positioned update is not supported, a
* <code>SQLException is thrown.
*
* @return the SQL name for this <code>ResultSet object's cursor
* @throws java.sql.SQLException if a database access error occurs
*/
public String getCursorName() throws SQLException {
return resultSet.getCursorName();
}
/**
* Retrieves the number, types and properties of
* this <code>ResultSet object's columns.
*
* @return the description of this <code>ResultSet object's columns
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSetMetaData getMetaData() throws SQLException {
return resultSet.getMetaData();
}
/**
* <p>Gets the value of the designated column in the current row
* of this <code>ResultSet object as
* an <code>Object in the Java programming language.
* <p/>
* <p>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. If the value is an SQL <code>NULL,
* the driver returns a Java <code>null.
* <p/>
* <p>This method may also be used to read database-specific
* abstract data types.
* <p/>
* In the JDBC 2.0 API, the behavior of method
* <code>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: <code>getObject(columnIndex,
* this.getStatement().getConnection().getTypeMap())</code>.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a <code>java.lang.Object holding the column value
* @throws java.sql.SQLException if a database access error occurs
*/
public Object getObject(int columnIndex) throws SQLException {
return resultSet.getObject(columnIndex);
}
/**
* <p>Gets the value of the designated column in the current row
* of this <code>ResultSet object as
* an <code>Object in the Java programming language.
* <p/>
* <p>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. If the value is an SQL <code>NULL,
* the driver returns a Java <code>null.
* <p/>
* This method may also be used to read database-specific
* abstract data types.
* <p/>
* In the JDBC 2.0 API, the behavior of the method
* <code>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: <code>getObject(columnIndex,
* this.getStatement().getConnection().getTypeMap())</code>.
*
* @param columnName the SQL name of the column
* @return a <code>java.lang.Object holding the column value
* @throws java.sql.SQLException if a database access error occurs
*/
public Object getObject(String columnName) throws SQLException {
return resultSet.getObject(columnName);
}
/**
* Maps the given <code>ResultSet column name to its
* <code>ResultSet column index.
*
* @param columnName the name of the column
* @return the column index of the given column name
* @throws java.sql.SQLException if the <code>ResultSet object
* does not contain <code>columnName or a database access error occurs
*/
public int findColumn(String columnName) throws SQLException {
return resultSet.findColumn(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a
* <code>java.io.Reader object.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a <code>java.io.Reader object that contains the column
* value; if the value is SQL <code>NULL, the value returned is
* <code>null in the Java programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Reader getCharacterStream(int columnIndex) throws SQLException {
return resultSet.getCharacterStream(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a
* <code>java.io.Reader object.
*
* @param columnName the name of the column
* @return a <code>java.io.Reader object that contains the column
* value; if the value is SQL <code>NULL, the value returned is
* <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Reader getCharacterStream(String columnName) throws SQLException {
return resultSet.getCharacterStream(columnName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a
* <code>java.math.BigDecimal with full precision.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value (full precision);
* if the value is SQL <code>NULL, the value returned is
* <code>null in the Java programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
return resultSet.getBigDecimal(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a
* <code>java.math.BigDecimal with full precision.
*
* @param columnName the column name
* @return the column value (full precision);
* if the value is SQL <code>NULL, the value returned is
* <code>null in the Java programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public BigDecimal getBigDecimal(String columnName) throws SQLException {
return resultSet.getBigDecimal(columnName);
}
/**
* Retrieves whether the cursor is before the first row in
* this <code>ResultSet object.
*
* @return <code>true if the cursor is before the first row;
* <code>false if the cursor is at any other position or the
* result set contains no rows
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public boolean isBeforeFirst() throws SQLException {
return resultSet.isBeforeFirst();
}
/**
* Retrieves whether the cursor is after the last row in
* this <code>ResultSet object.
*
* @return <code>true if the cursor is after the last row;
* <code>false if the cursor is at any other position or the
* result set contains no rows
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public boolean isAfterLast() throws SQLException {
return resultSet.isAfterLast();
}
/**
* Retrieves whether the cursor is on the first row of
* this <code>ResultSet object.
*
* @return <code>true if the cursor is on the first row;
* <code>false otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public boolean isFirst() throws SQLException {
return resultSet.isFirst();
}
/**
* Retrieves whether the cursor is on the last row of
* this <code>ResultSet object.
* Note: Calling the method <code>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.
*
* @return <code>true if the cursor is on the last row;
* <code>false otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public boolean isLast() throws SQLException {
return resultSet.isLast();
}
/**
* Moves the cursor to the front of
* this <code>ResultSet object, just before the
* first row. This method has no effect if the result set contains no rows.
*
* @throws java.sql.SQLException if a database access error
* occurs or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public void beforeFirst() throws SQLException {
resultSet.beforeFirst();
}
/**
* Moves the cursor to the end of
* this <code>ResultSet object, just after the
* last row. This method has no effect if the result set contains no rows.
*
* @throws java.sql.SQLException if a database access error
* occurs or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public void afterLast() throws SQLException {
resultSet.afterLast();
}
/**
* Moves the cursor to the first row in
* this <code>ResultSet object.
*
* @return <code>true if the cursor is on a valid row;
* <code>false if there are no rows in the result set
* @throws java.sql.SQLException if a database access error
* occurs or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean first() throws SQLException {
return resultSet.first();
}
/**
* Moves the cursor to the last row in
* this <code>ResultSet object.
*
* @return <code>true if the cursor is on a valid row;
* <code>false if there are no rows in the result set
* @throws java.sql.SQLException if a database access error
* occurs or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean last() throws SQLException {
return resultSet.last();
}
/**
* Retrieves the current row number. The first row is number 1, the
* second number 2, and so on.
*
* @return the current row number; <code>0 if there is no current row
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public int getRow() throws SQLException {
return resultSet.getRow();
}
/**
* Moves the cursor to the given row number in
* this <code>ResultSet object.
* <p/>
* <p>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.
* <p/>
* <p>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
* <code>absolute(-1) positions the
* cursor on the last row; calling the method <code>absolute(-2)
* moves the cursor to the next-to-last row, and so on.
* <p/>
* <p>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.
* <p/>
* <p>Note: Calling absolute(1) is the same
* as calling <code>first(). Calling absolute(-1)
* is the same as calling <code>last().
*
* @param row the number of the row to which the cursor should move.
* A positive number indicates the row number counting from the
* beginning of the result set; a negative number indicates the
* row number counting from the end of the result set
* @return <code>true if the cursor is on the result set;
* <code>false otherwise
* @throws java.sql.SQLException if a database access error
* occurs, or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean absolute(int row) throws SQLException {
return resultSet.absolute(row);
}
/**
* 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 <code>relative(0) is valid, but does
* not change the cursor position.
* <p/>
* <p>Note: Calling the method relative(1)
* is identical to calling the method <code>next() and
* calling the method <code>relative(-1) is identical
* to calling the method <code>previous().
*
* @param rows an <code>int specifying the number of rows to
* move from the current row; a positive number moves the cursor
* forward; a negative number moves the cursor backward
* @return <code>true if the cursor is on a row;
* <code>false otherwise
* @throws java.sql.SQLException if a database access error occurs,
* there is no current row, or the result set type is
* <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean relative(int rows) throws SQLException {
return resultSet.relative(rows);
}
/**
* Moves the cursor to the previous row in this
* <code>ResultSet object.
*
* @return <code>true if the cursor is on a valid row;
* <code>false if it is off the result set
* @throws java.sql.SQLException if a database access error
* occurs or the result set type is <code>TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean previous() throws SQLException {
return resultSet.previous();
}
/**
* Gives a hint as to the direction in which the rows in this
* <code>ResultSet object will be processed.
* The initial value is determined by the
* <code>Statement object
* that produced this <code>ResultSet object.
* The fetch direction may be changed at any time.
*
* @param direction an <code>int specifying the suggested
* fetch direction; one of <code>ResultSet.FETCH_FORWARD,
* <code>ResultSet.FETCH_REVERSE, or
* <code>ResultSet.FETCH_UNKNOWN
* @throws java.sql.SQLException if a database access error occurs or
* the result set type is <code>TYPE_FORWARD_ONLY and the fetch
* direction is not <code>FETCH_FORWARD
* @see java.sql.Statement#setFetchDirection
* @see #getFetchDirection
* @since 1.2
*/
public void setFetchDirection(int direction) throws SQLException {
resultSet.setFetchDirection(direction);
}
/**
* Retrieves the fetch direction for this
* <code>ResultSet object.
*
* @return the current fetch direction for this <code>ResultSet object
* @throws java.sql.SQLException if a database access error occurs
* @see #setFetchDirection
* @since 1.2
*/
public int getFetchDirection() throws SQLException {
return resultSet.getFetchDirection();
}
/**
* 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
* <code>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
* <code>Statement object
* that created the result set. The fetch size may be changed at any time.
*
* @param rows the number of rows to fetch
* @throws java.sql.SQLException if a database access error occurs or the
* condition <code>0 <= rows <= Statement.getMaxRows() is not satisfied
* @see #getFetchSize
* @since 1.2
*/
public void setFetchSize(int rows) throws SQLException {
resultSet.setFetchSize(rows);
}
/**
* Retrieves the fetch size for this
* <code>ResultSet object.
*
* @return the current fetch size for this <code>ResultSet object
* @throws java.sql.SQLException if a database access error occurs
* @see #setFetchSize
* @since 1.2
*/
public int getFetchSize() throws SQLException {
return resultSet.getFetchSize();
}
/**
* Retrieves the type of this <code>ResultSet object.
* The type is determined by the <code>Statement object
* that created the result set.
*
* @return <code>ResultSet.TYPE_FORWARD_ONLY,
* <code>ResultSet.TYPE_SCROLL_INSENSITIVE,
* or <code>ResultSet.TYPE_SCROLL_SENSITIVE
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public int getType() throws SQLException {
return resultSet.getType();
}
/**
* Retrieves the concurrency mode of this <code>ResultSet object.
* The concurrency used is determined by the
* <code>Statement object that created the result set.
*
* @return the concurrency type, either
* <code>ResultSet.CONCUR_READ_ONLY
* or <code>ResultSet.CONCUR_UPDATABLE
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public int getConcurrency() throws SQLException {
return resultSet.getConcurrency();
}
/**
* Retrieves whether the current row has been updated. The value returned
* depends on whether or not the result set can detect updates.
*
* @return <code>true if both (1) the row has been visibly updated
* by the owner or another and (2) updates are detected
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#updatesAreDetected
* @since 1.2
*/
public boolean rowUpdated() throws SQLException {
return resultSet.rowUpdated();
}
/**
* Retrieves whether the current row has had an insertion.
* The value returned depends on whether or not this
* <code>ResultSet object can detect visible inserts.
*
* @return <code>true if a row has had an insertion
* and insertions are detected; <code>false otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#insertsAreDetected
* @since 1.2
*/
public boolean rowInserted() throws SQLException {
return resultSet.rowInserted();
}
/**
* Retrieves 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 <code>ResultSet object can detect deletions.
*
* @return <code>true if a row was deleted and deletions are detected;
* <code>false otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#deletesAreDetected
* @since 1.2
*/
public boolean rowDeleted() throws SQLException {
return resultSet.rowDeleted();
}
/**
* Gives a nullable column a null value.
* <p/>
* 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 <code>updateRow
* or <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateNull(int columnIndex) throws SQLException {
resultSet.updateNull(columnIndex);
}
/**
* Updates the designated column with a <code>boolean 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
resultSet.updateBoolean(columnIndex, x);
}
/**
* Updates the designated column with a <code>byte 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateByte(int columnIndex, byte x) throws SQLException {
resultSet.updateByte(columnIndex, x);
}
/**
* Updates the designated column with a <code>short 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateShort(int columnIndex, short x) throws SQLException {
resultSet.updateShort(columnIndex, x);
}
/**
* Updates the designated column with an <code>int 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateInt(int columnIndex, int x) throws SQLException {
resultSet.updateInt(columnIndex, x);
}
/**
* Updates the designated column with a <code>long 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateLong(int columnIndex, long x) throws SQLException {
resultSet.updateLong(columnIndex, x);
}
/**
* Updates the designated column with a <code>float 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateFloat(int columnIndex, float x) throws SQLException {
resultSet.updateFloat(columnIndex, x);
}
/**
* Updates the designated column with a <code>double 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateDouble(int columnIndex, double x) throws SQLException {
resultSet.updateDouble(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.math.BigDecimal
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
resultSet.updateBigDecimal(columnIndex, x);
}
/**
* Updates the designated column with a <code>String 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateString(int columnIndex, String x) throws SQLException {
resultSet.updateString(columnIndex, x);
}
/**
* Updates the designated column with a <code>byte array 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBytes(int columnIndex, byte x[]) throws SQLException {
resultSet.updateBytes(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Date 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateDate(int columnIndex, Date x) throws SQLException {
resultSet.updateDate(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Time 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateTime(int columnIndex, Time x) throws SQLException {
resultSet.updateTime(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Timestamp
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
resultSet.updateTimestamp(columnIndex, x);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
resultSet.updateAsciiStream(columnIndex, x, length);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
resultSet.updateBinaryStream(columnIndex, x, length);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
resultSet.updateCharacterStream(columnIndex, x, length);
}
/**
* Updates the designated column with an <code>Object 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param scale for <code>java.sql.Types.DECIMA
* or <code>java.sql.Types.NUMERIC types,
* this is the number of digits after the decimal point. For all other
* types this value will be ignored.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
resultSet.updateObject(columnIndex, x, scale);
}
/**
* Updates the designated column with an <code>Object 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateObject(int columnIndex, Object x) throws SQLException {
resultSet.updateObject(columnIndex, x);
}
/**
* Updates the designated column with a <code>null 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateNull(String columnName) throws SQLException {
resultSet.updateNull(columnName);
}
/**
* Updates the designated column with a <code>boolean 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBoolean(String columnName, boolean x) throws SQLException {
resultSet.updateBoolean(columnName, x);
}
/**
* Updates the designated column with a <code>byte 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateByte(String columnName, byte x) throws SQLException {
resultSet.updateByte(columnName, x);
}
/**
* Updates the designated column with a <code>short 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateShort(String columnName, short x) throws SQLException {
resultSet.updateShort(columnName, x);
}
/**
* Updates the designated column with an <code>int 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateInt(String columnName, int x) throws SQLException {
resultSet.updateInt(columnName, x);
}
/**
* Updates the designated column with a <code>long 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateLong(String columnName, long x) throws SQLException {
resultSet.updateLong(columnName, x);
}
/**
* Updates the designated column with a <code>float 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateFloat(String columnName, float x) throws SQLException {
resultSet.updateFloat(columnName, x);
}
/**
* Updates the designated column with a <code>double 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateDouble(String columnName, double x) throws SQLException {
resultSet.updateDouble(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.BigDecimal
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
resultSet.updateBigDecimal(columnName, x);
}
/**
* Updates the designated column with a <code>String 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateString(String columnName, String x) throws SQLException {
resultSet.updateString(columnName, x);
}
/**
* Updates the designated column with a byte array value.
* <p/>
* 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 <code>updateRow
* or <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBytes(String columnName, byte x[]) throws SQLException {
resultSet.updateBytes(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Date 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateDate(String columnName, Date x) throws SQLException {
resultSet.updateDate(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Time 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateTime(String columnName, Time x) throws SQLException {
resultSet.updateTime(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Timestamp
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateTimestamp(String columnName, Timestamp x) throws SQLException {
resultSet.updateTimestamp(columnName, x);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException {
resultSet.updateAsciiStream(columnName, x, length);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException {
resultSet.updateBinaryStream(columnName, x, length);
}
/**
* 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param reader the <code>java.io.Reader object containing
* the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException {
resultSet.updateCharacterStream(columnName, reader, length);
}
/**
* Updates the designated column with an <code>Object 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param scale for <code>java.sql.Types.DECIMAL
* or <code>java.sql.Types.NUMERIC types,
* this is the number of digits after the decimal point. For all other
* types this value will be ignored.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateObject(String columnName, Object x, int scale) throws SQLException {
resultSet.updateObject(columnName, x, scale);
}
/**
* Updates the designated column with an <code>Object 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void updateObject(String columnName, Object x) throws SQLException {
resultSet.updateObject(columnName, x);
}
/**
* Inserts the contents of the insert row into this
* <code>ResultSet object and into the database.
* The cursor must be on the insert row when this method is called.
*
* @throws java.sql.SQLException if a database access error occurs,
* if this method is called when the cursor is not on the insert row,
* or if not all of non-nullable columns in
* the insert row have been given a value
* @since 1.2
*/
public void insertRow() throws SQLException {
resultSet.insertRow();
}
/**
* Updates the underlying database with the new contents of the
* current row of this <code>ResultSet object.
* This method cannot be called when the cursor is on the insert row.
*
* @throws java.sql.SQLException if a database access error occurs or
* if this method is called when the cursor is on the insert row
* @since 1.2
*/
public void updateRow() throws SQLException {
resultSet.updateRow();
}
/**
* Deletes the current row from this <code>ResultSet object
* and from the underlying database. This method cannot be called when
* the cursor is on the insert row.
*
* @throws java.sql.SQLException if a database access error occurs
* or if this method is called when the cursor is on the insert row
* @since 1.2
*/
public void deleteRow() throws SQLException {
resultSet.deleteRow();
}
/**
* Refreshes the current row with its most recent value in
* the database. This method cannot be called when
* the cursor is on the insert row.
* <p/>
* <P>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 <code>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.
* <p/>
* <P> All values are refetched subject to the transaction isolation
* level and cursor sensitivity. If <code>refreshRow is called after
* calling an updater method, but before calling
* the method <code>updateRow, then the
* updates made to the row are lost. Calling the method
* <code>refreshRow frequently will likely slow performance.
*
* @throws java.sql.SQLException if a database access error
* occurs or if this method is called when the cursor is on the insert row
* @since 1.2
*/
public void refreshRow() throws SQLException {
resultSet.refreshRow();
}
/**
* Cancels the updates made to the current row in this
* <code>ResultSet object.
* This method may be called after calling an
* updater method(s) and before calling
* the method <code>updateRow to roll back
* the updates made to a row. If no updates have been made or
* <code>updateRow has already been called, this method has no
* effect.
*
* @throws java.sql.SQLException if a database access error
* occurs or if this method is called when the cursor is
* on the insert row
* @since 1.2
*/
public void cancelRowUpdates() throws SQLException {
resultSet.cancelRowUpdates();
}
/**
* Moves the cursor to the insert row. The current cursor position is
* remembered while the cursor is positioned on the insert row.
* <p/>
* 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 updater methods prior to
* inserting the row into the result set.
* <p/>
* Only the updater, getter,
* and <code>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 <code>insertRow.
* An updater method must be called before a
* getter method can be called on a column value.
*
* @throws java.sql.SQLException if a database access error occurs
* or the result set is not updatable
* @since 1.2
*/
public void moveToInsertRow() throws SQLException {
resultSet.moveToInsertRow();
}
/**
* 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.
*
* @throws java.sql.SQLException if a database access error occurs
* or the result set is not updatable
* @since 1.2
*/
public void moveToCurrentRow() throws SQLException {
resultSet.moveToCurrentRow();
}
/**
* Retrieves the <code>Statement object that produced this
* <code>ResultSet object.
* If the result set was generated some other way, such as by a
* <code>DatabaseMetaData method, this method returns
* <code>null.
*
* @return the <code>Statment object that produced
* this <code>ResultSet object or null
* if the result set was produced some other way
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Statement getStatement() throws SQLException {
return statement;
}
/**
* Returns the actual statement that produced this resultset <br>
*
* @return Statement
* @throws SQLException
*/
public Statement getActualStatement() throws SQLException {
return resultSet.getStatement();
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as an Object
* in the Java programming language.
* If the value is an SQL <code>NULL,
* the driver returns a Java <code>null.
* This method uses the given <code>Map object
* for the custom mapping of the
* SQL structured or distinct type that is being retrieved.
*
* @param i the first column is 1, the second is 2, ...
* @param map a <code>java.util.Map object that contains the mapping
* from SQL type names to classes in the Java programming language
* @return an <code>Object in the Java programming language
* representing the SQL value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Object getObject(int i, Map<String, Class map) throws SQLException {
return resultSet.getObject(i, map);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Ref object
* in the Java programming language.
*
* @param i the first column is 1, the second is 2, ...
* @return a <code>Ref object representing an SQL REF
* value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Ref getRef(int i) throws SQLException {
return resultSet.getRef(i);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Blob object
* in the Java programming language.
*
* @param i the first column is 1, the second is 2, ...
* @return a <code>Blob object representing the SQL
* <code>BLOB value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Blob getBlob(int i) throws SQLException {
return resultSet.getBlob(i);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Clob object
* in the Java programming language.
*
* @param i the first column is 1, the second is 2, ...
* @return a <code>Clob object representing the SQL
* <code>CLOB value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Clob getClob(int i) throws SQLException {
return resultSet.getClob(i);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as an Array object
* in the Java programming language.
*
* @param i the first column is 1, the second is 2, ...
* @return an <code>Array object representing the SQL
* <code>ARRAY value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Array getArray(int i) throws SQLException {
return resultSet.getArray(i);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as an Object
* in the Java programming language.
* If the value is an SQL <code>NULL,
* the driver returns a Java <code>null.
* This method uses the specified <code>Map object for
* custom mapping if appropriate.
*
* @param colName the name of the column from which to retrieve the value
* @param map a <code>java.util.Map object that contains the mapping
* from SQL type names to classes in the Java programming language
* @return an <code>Object representing the SQL value in the
* specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Object getObject(String colName, Map<String, Class map) throws SQLException {
return resultSet.getObject(colName, map);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Ref object
* in the Java programming language.
*
* @param colName the column name
* @return a <code>Ref object representing the SQL REF
* value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Ref getRef(String colName) throws SQLException {
return resultSet.getRef(colName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Blob object
* in the Java programming language.
*
* @param colName the name of the column from which to retrieve the value
* @return a <code>Blob object representing the SQL BLOB
* value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Blob getBlob(String colName) throws SQLException {
return resultSet.getBlob(colName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a Clob object
* in the Java programming language.
*
* @param colName the name of the column from which to retrieve the value
* @return a <code>Clob object representing the SQL CLOB
* value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Clob getClob(String colName) throws SQLException {
return resultSet.getClob(colName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as an Array object
* in the Java programming language.
*
* @param colName the name of the column from which to retrieve the value
* @return an <code>Array object representing the SQL ARRAY value in
* the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Array getArray(String colName) throws SQLException {
return resultSet.getArray(colName);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Date object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the date if the underlying database does not store
* timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param cal the <code>java.util.Calendar object
* to use in constructing the date
* @return the column value as a <code>java.sql.Date object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Date getDate(int columnIndex, Calendar cal) throws SQLException {
return resultSet.getDate(columnIndex, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Date object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the date if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column from which to retrieve the value
* @param cal the <code>java.util.Calendar object
* to use in constructing the date
* @return the column value as a <code>java.sql.Date object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Date getDate(String columnName, Calendar cal) throws SQLException {
return resultSet.getDate(columnName, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Time object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the time if the underlying database does not store
* timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param cal the <code>java.util.Calendar object
* to use in constructing the time
* @return the column value as a <code>java.sql.Time object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Time getTime(int columnIndex, Calendar cal) throws SQLException {
return resultSet.getTime(columnIndex, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Time object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the time if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column
* @param cal the <code>java.util.Calendar object
* to use in constructing the time
* @return the column value as a <code>java.sql.Time object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Time getTime(String columnName, Calendar cal) throws SQLException {
return resultSet.getTime(columnName, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Timestamp object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the timestamp if the underlying database does not store
* timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param cal the <code>java.util.Calendar object
* to use in constructing the timestamp
* @return the column value as a <code>java.sql.Timestamp object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
return resultSet.getTimestamp(columnIndex, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.sql.Timestamp object
* in the Java programming language.
* This method uses the given calendar to construct an appropriate millisecond
* value for the timestamp if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column
* @param cal the <code>java.util.Calendar object
* to use in constructing the date
* @return the column value as a <code>java.sql.Timestamp object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
return resultSet.getTimestamp(columnName, cal);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.net.URL
* object in the Java programming language.
*
* @param columnIndex the index of the column 1 is the first, 2 is the second,...
* @return the column value as a <code>java.net.URL object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs,
* or if a URL is malformed
* @since 1.4
*/
public URL getURL(int columnIndex) throws SQLException {
return resultSet.getURL(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row
* of this <code>ResultSet object as a java.net.URL
* object in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value as a <code>java.net.URL object;
* if the value is SQL <code>NULL,
* the value returned is <code>null in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* or if a URL is malformed
* @since 1.4
*/
public URL getURL(String columnName) throws SQLException {
return resultSet.getURL(columnName);
}
/**
* Updates the designated column with a <code>java.sql.Ref 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateRef(int columnIndex, Ref x) throws SQLException {
resultSet.updateRef(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Ref 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateRef(String columnName, Ref x) throws SQLException {
resultSet.updateRef(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Blob 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateBlob(int columnIndex, Blob x) throws SQLException {
resultSet.updateBlob(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Blob 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateBlob(String columnName, Blob x) throws SQLException {
resultSet.updateBlob(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Clob 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateClob(int columnIndex, Clob x) throws SQLException {
resultSet.updateClob(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Clob 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateClob(String columnName, Clob x) throws SQLException {
resultSet.updateClob(columnName, x);
}
/**
* Updates the designated column with a <code>java.sql.Array 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateArray(int columnIndex, Array x) throws SQLException {
resultSet.updateArray(columnIndex, x);
}
/**
* Updates the designated column with a <code>java.sql.Array 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 <code>updateRow or
* <code>insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void updateArray(String columnName, Array x) throws SQLException {
resultSet.updateArray(columnName, x);
}
}
Other Glassfish examples (source code examples)
Here is a short list of links related to this Glassfish ResultSetWrapper.java source code file:
|
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
