org.drizzle.jdbc.DrizzleResultSet Maven / Gradle / Ivy
Show all versions of drizzle-jdbc Show documentation
/*
* Drizzle-JDBC
*
* Copyright (c) 2009-2011, Marcus Eriksson
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
* conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the driver nor the names of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.drizzle.jdbc;
import org.drizzle.jdbc.internal.SQLExceptionMapper;
import org.drizzle.jdbc.internal.common.*;
import org.drizzle.jdbc.internal.common.queryresults.DrizzleQueryResult;
import org.drizzle.jdbc.internal.common.queryresults.NoSuchColumnException;
import org.drizzle.jdbc.internal.common.queryresults.QueryResult;
import org.drizzle.jdbc.internal.common.queryresults.ResultSetType;
import org.drizzle.jdbc.internal.common.queryresults.SelectQueryResult;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* . User: marcuse Date: Jan 19, 2009 Time: 10:25:00 PM
*/
public class DrizzleResultSet implements ResultSet {
public final static DrizzleResultSet EMPTY = createEmptyResultSet();
private final QueryResult queryResult;
private final Statement statement;
private final Protocol protocol;
// dont want these, but jdbc forces them with "lastGetWasNull" etc...
private boolean isClosed;
private boolean lastGetWasNull;
public DrizzleResultSet(final QueryResult dqr, final Statement statement, final Protocol protocol) {
this.queryResult = dqr;
this.statement = statement;
isClosed = false;
this.protocol = protocol;
}
private static DrizzleResultSet createEmptyResultSet() {
final List colList = Collections.emptyList();
final List> voList = Collections.emptyList();
final QueryResult qr = new DrizzleQueryResult(colList, voList, (short) 0);
return new DrizzleResultSet(qr, null, null);
}
public boolean next() throws SQLException {
return queryResult.getResultSetType() == ResultSetType.SELECT
&& ((SelectQueryResult) queryResult).next();
}
public void close() throws SQLException {
this.isClosed = true;
if (this.queryResult != null) {
this.queryResult.close();
}
}
/**
* Reports whether the last column read had a value of SQL 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 wasNull to see if
* the value read was SQL NULL.
*
* @return true if the last column value read was SQL NULL and false
* otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
*/
public boolean wasNull() throws SQLException {
return lastGetWasNull;
}
public String getString(final int i) throws SQLException {
return getValueObject(i).getString();
}
public int getInt(final int i) throws SQLException {
return getValueObject(i).getInt();
}
public int getInt(final String s) throws SQLException {
return getValueObject(s).getInt();
}
private ValueObject getValueObject(final int i) throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT) {
final ValueObject vo;
try {
vo = ((SelectQueryResult) queryResult).getValueObject(i - 1);
} catch (NoSuchColumnException e) {
throw SQLExceptionMapper.getSQLException("No such column: " + i, e);
}
this.lastGetWasNull = vo.isNull();
return vo;
}
throw SQLExceptionMapper.getSQLException("Cannot get data from update-result sets");
}
private ValueObject getValueObject(final String column) throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT) {
final ValueObject vo;
try {
vo = ((SelectQueryResult) queryResult).getValueObject(column);
} catch (NoSuchColumnException e) {
throw SQLExceptionMapper.getSQLException("No such column: " + column, e);
}
this.lastGetWasNull = vo.isNull();
return vo;
}
throw SQLExceptionMapper.getSQLException("Cannot get data from update-result sets");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* long in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is 0
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public long getLong(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getLong();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* float in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is 0
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public float getFloat(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getFloat();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* double in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is 0
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public double getDouble(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getDouble();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.math.BigDecimal in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @deprecated
*/
public BigDecimal getBigDecimal(final String columnLabel, final int scale) throws SQLException {
return getValueObject(columnLabel).getBigDecimal();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* byte array in the Java programming language. The bytes represent the raw values returned by the
* driver.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public byte[] getBytes(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getBytes();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.sql.Date object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Date getDate(final String columnLabel) throws SQLException {
try {
return getValueObject(columnLabel).getDate();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse date", e);
}
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.sql.Time object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Time getTime(final String columnLabel) throws SQLException {
try {
return getValueObject(columnLabel).getTime();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse column as time, was: \"" +
getValueObject(columnLabel).getString() +
"\"", e);
}
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.sql.Timestamp object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Timestamp getTimestamp(final String columnLabel) throws SQLException {
try {
return getValueObject(columnLabel).getTimestamp();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse column as timestamp, was: \"" +
getValueObject(columnLabel).getString() +
"\"", e);
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 getter method implicitly closes the stream. Also, a stream may return 0 when the
* method available is called whether there is data available or not.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the 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 NULL, the value returned is null.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public InputStream getAsciiStream(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getInputStream();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a stream
* of two-byte Unicode characters. The first byte is the high byte; the second byte is the low byte.
*
* The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large
* LONGVARCHAR values. The JDBC technology-enabled driver will do any necessary conversion from the
* database format into Unicode.
*
* Note: All the data in the returned stream must be read prior to getting the value of any other column.
* The next call to a getter 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the 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 NULL, the value returned is null.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @deprecated use getCharacterStream instead
*/
public InputStream getUnicodeStream(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getInputStream();
}
/**
* Retrieves the value of the designated column in the current row of this 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 getter method implicitly closes the stream. Also, a stream may return 0 when the
* method available is called whether there is data available or not.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the 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 NULL, the result is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public InputStream getBinaryStream(final String columnLabel) throws SQLException {
if(protocol.supportsPBMS()) {
try {
return getValueObject(columnLabel).getPBMSStream(protocol);
} catch (QueryException e) {
throw SQLExceptionMapper.get(e);
} catch (IOException e) {
throw SQLExceptionMapper.getSQLException("Could not read back the data using http", e);
}
} else {
return getValueObject(columnLabel).getBinaryInputStream();
}
}
/**
* Retrieves the first warning reported by calls on this ResultSet object. Subsequent warnings on this
* 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. This method may not be called on a
* ResultSet object that has been closed; doing so will cause an SQLException to be
* thrown.
*
* 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.
*
* @return the first SQLWarning object reported or 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 new SQLWarning(String.valueOf(queryResult.getWarnings()) + " warning(s)");
}
/**
* Clears all warnings reported on this ResultSet object. After this method is called, the method
* getWarnings returns null until a new warning is reported for this
* ResultSet object.
*
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
*/
public void clearWarnings() throws SQLException {
//TODO: implement!
}
/**
* Retrieves the name of the SQL cursor used by this 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 FOR UPDATE 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.
*
* @return the SQL name for this ResultSet object's cursor
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
*/
public String getCursorName() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Cursors not supported");
}
/**
* Retrieves the number, types and properties of this ResultSet object's columns.
*
* @return the description of this ResultSet object's columns
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
*/
public ResultSetMetaData getMetaData() throws SQLException {
return new DrizzleResultSetMetaData(queryResult.getColumnInformation());
}
/**
*
Gets the value of the designated column in the current row of this ResultSet object as an
* Object in the Java programming language.
*
* 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 NULL, the driver returns a Java
* null.
*
* This method may also be used to read database-specific abstract data types.
*
* In the JDBC 2.0 API, the behavior of method getObject is extended to materialize data of SQL
* user-defined types.
*
* If Connection.getTypeMap does not throw a SQLFeatureNotSupportedException, then 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()).
*
* If Connection.getTypeMap does throw a SQLFeatureNotSupportedException, then structured
* values are not supported, and distinct values are mapped to the default Java class as determined by the
* underlying SQL type of the DISTINCT type.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a java.lang.Object holding the column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Object getObject(final int columnIndex) throws SQLException {
try {
return getValueObject(columnIndex).getObject();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not get object: " + e.getMessage(), e);
}
}
/**
* Gets the value of the designated column in the current row of this ResultSet object.
* @param columnIndex the first column is 1, the second is 2, ...
* @param type The Java object type of the column to be retrieved.
* @return an object of the specified type holding the column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public T getObject(final int columnIndex, Class type) throws SQLException {
return (T)(getObject(columnIndex));
}
/**
* Gets the value of the designated column in the current row of this ResultSet object as an
* Object in the Java programming language.
*
* 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 NULL, the driver returns a Java
* null.
*
* This method may also be used to read database-specific abstract data types.
*
* In the JDBC 2.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()).
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a java.lang.Object holding the column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Object getObject(final String columnLabel) throws SQLException {
try {
return getValueObject(columnLabel).getObject();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not get object: " + e.getMessage(), e);
}
}
/**
* Gets the value of the designated column in the current row of this ResultSet object.
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* @param type The Java object type of the column to be retrieved.
* @return an object of the specified type holding the column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public T getObject(final String columnLabel, Class type) throws SQLException {
return (T)(getObject(columnLabel));
}
/**
* Maps the given ResultSet column label to its ResultSet column index.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column index of the given column name
* @throws java.sql.SQLException if the ResultSet object does not contain a column labeled
* columnLabel, a database access error occurs or this method is called
* on a closed result set
*/
public int findColumn(final String columnLabel) throws SQLException {
if (this.queryResult.getResultSetType() == ResultSetType.SELECT) {
try {
return ((SelectQueryResult) queryResult).getColumnId(columnLabel) + 1;
} catch (NoSuchColumnException e) {
throw SQLExceptionMapper.getSQLException("No such column: " + columnLabel, e);
}
}
throw SQLExceptionMapper.getSQLException("Cannot get column id of update result sets");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.io.Reader object.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a java.io.Reader object that contains the column value; if the value is SQL
* NULL, the value returned is null in the Java programming language.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Reader getCharacterStream(final int columnIndex) throws SQLException {
return new StringReader(getValueObject(columnIndex).getString());
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.io.Reader object.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a java.io.Reader object that contains the column value; if the value is SQL
* NULL, the value returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Reader getCharacterStream(final String columnLabel) throws SQLException {
return new StringReader(getValueObject(columnLabel).getString());
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is
* null in the Java programming language.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public BigDecimal getBigDecimal(final int columnIndex) throws SQLException {
return getValueObject(columnIndex).getBigDecimal();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.math.BigDecimal with full precision.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value (full precision); if the value is SQL NULL, the value returned is
* null in the Java programming language.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public BigDecimal getBigDecimal(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getBigDecimal();
}
/**
* Retrieves whether the cursor is before the first row in this ResultSet object.
*
* Note:Support for the isBeforeFirst method is optional for ResultSets
* with a result set type of TYPE_FORWARD_ONLY
*
* @return true if the cursor is before the first row; 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 or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean isBeforeFirst() throws SQLException {
return !(queryResult.getResultSetType() == ResultSetType.MODIFY || queryResult.getRows() == 0)
&& ((SelectQueryResult) queryResult).getRowPointer() == -1;
}
/**
* Retrieves whether the cursor is after the last row in this ResultSet object.
*
* Note:Support for the isAfterLast method is optional for ResultSets
* with a result set type of TYPE_FORWARD_ONLY
*
* @return true if the cursor is after the last row; 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 or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean isAfterLast() throws SQLException {
return queryResult.getResultSetType() != ResultSetType.MODIFY
&& ((SelectQueryResult) queryResult).getRowPointer() >= queryResult.getRows();
}
/**
* Retrieves whether the cursor is on the first row of this ResultSet object.
*
* Note:Support for the isFirst method is optional for ResultSets with a
* result set type of TYPE_FORWARD_ONLY
*
* @return true if the cursor is on the first row; false otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean isFirst() throws SQLException {
return queryResult.getResultSetType() != ResultSetType.MODIFY
&& ((SelectQueryResult) queryResult).getRowPointer() == 0;
}
/**
* Retrieves whether the cursor is on the last row of this 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.
*
* Note: Support for the isLast method is optional for ResultSets with a
* result set type of TYPE_FORWARD_ONLY
*
* @return true if the cursor is on the last row; false otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean isLast() throws SQLException {
return queryResult.getResultSetType() != ResultSetType.MODIFY
&& ((SelectQueryResult) queryResult).getRowPointer() == queryResult.getRows() - 1;
}
/**
* Moves the cursor to the front of this 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; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void beforeFirst() throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT) {
((SelectQueryResult) queryResult).moveRowPointerTo(-1);
}
}
/**
* Moves the cursor to the end of this 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; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void afterLast() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Cannot move after last row");
}
/**
* Moves the cursor to the first row in this ResultSet object.
*
* @return true if the cursor is on a valid row; false if there are no rows in the result
* set
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean first() throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT && queryResult.getRows() > 0) {
((SelectQueryResult) queryResult).moveRowPointerTo(0);
return true;
}
return false;
}
/**
* Moves the cursor to the last row in this ResultSet object.
*
* @return true if the cursor is on a valid row; false if there are no rows in the result
* set
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean last() throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT && queryResult.getRows() > 0) {
((SelectQueryResult) queryResult).moveRowPointerTo(queryResult.getRows() - 1);
return true;
}
return false;
}
/**
* Retrieves the current row number. The first row is number 1, the second number 2, and so on.
*
* Note:Support for the getRow method is optional for ResultSets with a
* result set type of TYPE_FORWARD_ONLY
*
* @return the current row number; 0 if there is no current row
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public int getRow() throws SQLException {
if (queryResult.getResultSetType() == ResultSetType.SELECT) {
return ((SelectQueryResult) queryResult).getRowPointer() + 1;//+1 since first row is 1, not 0
}
return 0;
}
/**
* Moves the cursor to the given row number in this 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().
*
* @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 true if the cursor is moved to a position in this ResultSet object;
* false if the cursor is before the first row or after the last row
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean absolute(final int row) throws SQLException {
if (queryResult.getResultSetType() != ResultSetType.SELECT) {
return false;
}
final SelectQueryResult sqr = (SelectQueryResult) queryResult;
if (sqr.getRows() > 0) {
if (row >= 0 && row <= sqr.getRows()) {
sqr.moveRowPointerTo(row - 1);
return true;
}
if (row < 0) {
sqr.moveRowPointerTo(sqr.getRows() + row);
}
return true;
}
return false;
}
/**
* 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 identical to calling the method next() and
* calling the method relative(-1) is identical to calling the method previous().
*
* @param rows an 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 true if the cursor is on a row; false otherwise
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean relative(final int rows) throws SQLException {
if (queryResult.getResultSetType() != ResultSetType.SELECT) {
return false;
}
final SelectQueryResult sqr = (SelectQueryResult) queryResult;
if (queryResult.getRows() > 0) {
final int newPos = sqr.getRowPointer() + rows;
if (newPos > -1 && newPos <= queryResult.getRows()) {
sqr.moveRowPointerTo(newPos);
return true;
}
}
return false;
}
/**
* Moves the cursor to the previous row in this ResultSet object.
*
* When a call to the previous method returns false, the cursor is positioned before the
* first row. Any invocation of a ResultSet method which requires a current row will result in a
* SQLException being thrown.
*
* If an input stream is open for the current row, a call to the method previous will implicitly close
* it. A ResultSet object's warning change is cleared when a new row is read.
*
*
* @return true if the cursor is now positioned on a valid row; false if the cursor is
* positioned before the first row
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public boolean previous() throws SQLException {
if (queryResult.getResultSetType() != ResultSetType.SELECT) {
return false;
}
final SelectQueryResult sqr = (SelectQueryResult) queryResult;
if (sqr.getRows() >= 0) {
sqr.moveRowPointerTo(sqr.getRowPointer() - 1);
return true;
}
return false;
}
/**
* 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 ResultSet
* object. The fetch direction may be changed at any time.
*
* @param direction an int specifying the suggested fetch direction; one of
* ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or
* ResultSet.FETCH_UNKNOWN
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the result set type is TYPE_FORWARD_ONLY and the fetch direction is
* not FETCH_FORWARD
* @see java.sql.Statement#setFetchDirection
* @see #getFetchDirection
* @since 1.2
*/
public void setFetchDirection(final int direction) throws SQLException {
// todo: ignored for now
}
/**
* Retrieves the fetch direction for this ResultSet object.
*
* @return the current fetch direction for this ResultSet object
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @see #setFetchDirection
* @since 1.2
*/
public int getFetchDirection() throws SQLException {
return ResultSet.FETCH_UNKNOWN;
}
/**
* 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.
*
* @param rows the number of rows to fetch
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set or
* the condition rows >= 0 is not satisfied
* @see #getFetchSize
* @since 1.2
*/
public void setFetchSize(final int rows) throws SQLException {
// ignored - we fetch 'em all!
}
/**
* Retrieves the fetch size for this ResultSet object.
*
* @return the current fetch size for this ResultSet object
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @see #setFetchSize
* @since 1.2
*/
public int getFetchSize() throws SQLException {
return 0;
}
/**
* Retrieves the type of this ResultSet object. The type is determined by the Statement
* object that created the result set.
*
* @return ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @since 1.2
*/
public int getType() throws SQLException {
return ResultSet.TYPE_SCROLL_INSENSITIVE;
}
/**
* Retrieves the concurrency mode of this ResultSet object. The concurrency used is determined by the
* Statement object that created the result set.
*
* @return the concurrency type, either ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @since 1.2
*/
public int getConcurrency() throws SQLException {
return ResultSet.CONCUR_READ_ONLY;
}
/**
* Retrieves whether the current row has been updated. The value returned depends on whether or not the result set
* can detect updates.
*
* Note: Support for the rowUpdated method is optional with a result set concurrency
* of CONCUR_READ_ONLY
*
* @return true if the current row is detected to have been visibly updated by the owner or another;
* false otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @see java.sql.DatabaseMetaData#updatesAreDetected
* @since 1.2
*/
public boolean rowUpdated() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Detecting row updates are not supported");
}
/**
* Retrieves whether the current row has had an insertion. The value returned depends on whether or not this
* ResultSet object can detect visible inserts.
*
* Note: Support for the rowInserted method is optional with a result set concurrency
* of CONCUR_READ_ONLY
*
* @return true if the current row is detected to have been inserted; false otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @see java.sql.DatabaseMetaData#insertsAreDetected
* @since 1.2
*/
public boolean rowInserted() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Detecting inserts are not supported");
}
/**
* 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
* ResultSet object can detect deletions.
*
* Note: Support for the rowDeleted method is optional with a result set concurrency
* of CONCUR_READ_ONLY
*
* @return true if the current row is detected to have been deleted by the owner or another;
* false otherwise
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @see java.sql.DatabaseMetaData#deletesAreDetected
* @since 1.2
*/
public boolean rowDeleted() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Row deletes are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are
* called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateNull(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBoolean(final int columnIndex, final boolean x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateByte(final int columnIndex, final byte x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateShort(final int columnIndex, final short x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateInt(final int columnIndex, final int x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateLong(final int columnIndex, final long x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateFloat(final int columnIndex, final float x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateDouble(final int columnIndex, final double x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the
* database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateString(final int columnIndex, final String x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBytes(final int columnIndex, final byte[] x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateDate(final int columnIndex, final Date x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateTime(final int columnIndex, final Time x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the
* database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateAsciiStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBinaryStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateCharacterStream(final int columnIndex, final Reader x, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* If the second argument is an InputStream then the stream must contain the number of bytes specified
* by scaleOrLength. If the second argument is a Reader then the reader must contain the number of
* characters specified by scaleOrLength. If these conditions are not true the driver will generate a
* SQLException when the statement is executed.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param scaleOrLength for an object of java.math.BigDecimal , this is the number of digits after the
* decimal point. For Java Object types InputStream and Reader, this
* is the length of the data in the stream or reader. For all other types, this value will be
* ignored.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateObject(final int columnIndex, final Object x, final int scaleOrLength) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateObject(final int columnIndex, final Object x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateNull(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBoolean(final String columnLabel, final boolean x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateByte(final String columnLabel, final byte x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateShort(final String columnLabel, final short x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateInt(final String columnLabel, final int x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateLong(final String columnLabel, final long x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateFloat(final String columnLabel, final float x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateDouble(final String columnLabel, final double x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the
* database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBigDecimal(final String columnLabel, final BigDecimal x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateString(final String columnLabel, final String x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are
* called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBytes(final String columnLabel, final byte[] x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateDate(final String columnLabel, final Date x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateTime(final String columnLabel, final Time x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the
* database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateTimestamp(final String columnLabel, final Timestamp x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateAsciiStream(final String columnLabel, final InputStream x, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateBinaryStream(final String columnLabel, final InputStream x, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader the java.io.Reader object containing the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateCharacterStream(final String columnLabel, final Reader reader, final int length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* If the second argument is an InputStream then the stream must contain the number of bytes specified
* by scaleOrLength. If the second argument is a Reader then the reader must contain the number of
* characters specified by scaleOrLength. If these conditions are not true the driver will generate a
* SQLException when the statement is executed.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @param scaleOrLength for an object of java.math.BigDecimal , this is the number of digits after the
* decimal point. For Java Object types InputStream and Reader, this
* is the length of the data in the stream or reader. For all other types, this value will be
* ignored.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateObject(final String columnLabel, final Object x, final int scaleOrLength) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with an 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateObject(final String columnLabel, final Object x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Inserts the contents of the insert row into this 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; the result set concurrency is
* CONCUR_READ_ONLY, this method is called on a closed result set, 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 non-null value
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void insertRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the underlying database with the new contents of the current row of this 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; the result set concurrency is
* CONCUR_READ_ONLY; this method is called on a closed result set or if
* this method is called when the cursor is on the insert row
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void updateRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Deletes the current row from this 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; the result set concurrency is
* CONCUR_READ_ONLY; this method is called on a closed result set or if
* this method is called when the cursor is on the insert row
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void deleteRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* 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 updater 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.
*
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set;
* the result set type is TYPE_FORWARD_ONLY or if this method is called
* when the cursor is on the insert row
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method or this method is not supported for
* the specified result set type and result set concurrency.
* @since 1.2
*/
public void refreshRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Row refresh is not supported");
}
/**
* Cancels the updates made to the current row in this ResultSet object. This method may be called
* after calling an updater 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.
*
* @throws java.sql.SQLException if a database access error occurs; this method is called on a closed result set;
* the result set concurrency is CONCUR_READ_ONLY or if this method is
* called when the cursor is on the insert row
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void cancelRowUpdates() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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 updater methods prior to inserting the row into the result set.
*
* Only the updater, getter, 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 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; this method is called on a closed result set or
* the result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void moveToInsertRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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; this method is called on a closed result set or
* the result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public void moveToCurrentRow() throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Retrieves 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 may return
* null.
*
* @return the Statment object that produced this ResultSet object or null if
* the result set was produced some other way
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @since 1.2
*/
public Statement getStatement() throws SQLException {
return this.statement;
}
/**
* According to the JDBC4 spec, this is only required for UDT's, and since drizzle does not support UDTs, this
* method ignores the map parameter
*
* Retrieves the value of the designated column in the current row of this ResultSet object as an
* Object in the Java programming language. If the value is an SQL NULL, the driver
* returns a Java null. This method uses the given Map object for the custom mapping of
* the SQL structured or distinct type that is being retrieved.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param map a java.util.Map object that contains the mapping from SQL type names to classes
* in the Java programming language
* @return an Object in the Java programming language representing the SQL value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Object getObject(final int columnIndex, final Map> map) throws SQLException {
return getObject(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Ref object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Ref object representing an SQL REF value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Ref getRef(final int columnIndex) throws SQLException {
// TODO: figure out what REF's are and implement this method
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Blob object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Blob object representing the SQL BLOB value in the specified column
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Blob getBlob(final int columnIndex) throws SQLException {
return new DrizzleBlob(getValueObject(columnIndex).getBytes());
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Clob object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a Clob object representing the SQL CLOB value in the specified column
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Clob getClob(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("CLOBs are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as an
* Array object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return an Array object representing the SQL ARRAY value in the specified column
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Array getArray(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Arrays are not supported");
}
/**
* According to the JDBC4 spec, this is only required for UDT's, and since drizzle does not support UDTs, this
* method ignores the map parameter
*
* Retrieves the value of the designated column in the current row of this ResultSet object as an
* Object in the Java programming language. If the value is an SQL NULL, the driver
* returns a Java null. This method uses the specified Map object for custom mapping if
* appropriate.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param map a java.util.Map object that contains the mapping from SQL type names to classes
* in the Java programming language
* @return an Object representing the SQL value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Object getObject(final String columnLabel, final Map> map) throws SQLException {
//TODO: implement this
throw SQLExceptionMapper.getFeatureNotSupportedException("Type map getting is not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Ref object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a Ref object representing the SQL REF value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Ref getRef(final String columnLabel) throws SQLException {
// TODO see getRef(int)
throw SQLExceptionMapper.getFeatureNotSupportedException("Getting REFs not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Blob object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a Blob object representing the SQL BLOB value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Blob getBlob(final String columnLabel) throws SQLException {
return new DrizzleBlob(getValueObject(columnLabel).getBytes());
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* Clob object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a Clob object representing the SQL CLOB value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Clob getClob(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("CLOBs not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as an
* Array object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return an Array object representing the SQL ARRAY value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.2
*/
public Array getArray(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Arrays are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this 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 java.util.Calendar object to use in constructing the date
* @return the column value as a java.sql.Date object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Date getDate(final int columnIndex, final Calendar cal) throws SQLException {
try {
return getValueObject(columnIndex).getDate(cal);
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as date");
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param cal the java.util.Calendar object to use in constructing the date
* @return the column value as a java.sql.Date object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Date getDate(final String columnLabel, final Calendar cal) throws SQLException {
try {
return getValueObject(columnLabel).getDate(cal);
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as date");
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 java.util.Calendar object to use in constructing the time
* @return the column value as a java.sql.Time object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Time getTime(final int columnIndex, final Calendar cal) throws SQLException {
return getValueObject(columnIndex).getTime(cal);
}
/**
* Retrieves the value of the designated column in the current row of this 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 columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param cal the java.util.Calendar object to use in constructing the time
* @return the column value as a java.sql.Time object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Time getTime(final String columnLabel, final Calendar cal) throws SQLException {
return getValueObject(columnLabel).getTime(cal);
}
/**
* Retrieves the value of the designated column in the current row of this 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 java.util.Calendar object to use in constructing the timestamp
* @return the column value as a java.sql.Timestamp object; if the value is SQL NULL, the
* value returned is null in the Java programming language
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Timestamp getTimestamp(final int columnIndex, final Calendar cal) throws SQLException {
try {
final Timestamp result = getValueObject(columnIndex).getTimestamp(cal);
if (result == null) {
return null;
}
return new Timestamp(result.getTime());
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as time");
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param cal the java.util.Calendar object to use in constructing the date
* @return the column value as a java.sql.Timestamp object; if the value is SQL NULL, the
* value returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid or if a database access error occurs or this method
* is called on a closed result set
* @since 1.2
*/
public Timestamp getTimestamp(final String columnLabel, final Calendar cal) throws SQLException {
try {
final Timestamp result = getValueObject(columnLabel).getTimestamp(cal);
if (result == null) {
return null;
}
return new Timestamp(result.getTime());
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as time");
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 java.net.URL object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; this method is
* called on a closed result set or if a URL is malformed
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public URL getURL(final int columnIndex) throws SQLException {
try {
return new URL(getValueObject(columnIndex).getString());
} catch (MalformedURLException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as URL");
}
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* java.net.URL object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value as a java.net.URL object; if the value is SQL NULL, the value
* returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; this method is
* called on a closed result set or if a URL is malformed
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public URL getURL(final String columnLabel) throws SQLException {
try {
return new URL(getValueObject(columnLabel).getString());
} catch (MalformedURLException e) {
throw SQLExceptionMapper.getSQLException("Could not parse as URL");
}
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateRef(final int columnIndex, final Ref x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateRef(final String columnLabel, final Ref x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateBlob(final int columnIndex, final Blob x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateBlob(final String columnLabel, final Blob x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateClob(final int columnIndex, final Clob x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateClob(final String columnLabel, final Clob x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateArray(final int columnIndex, final Array x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a 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 updateRow or insertRow methods are called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.4
*/
public void updateArray(final String columnLabel, final Array x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @param columnIndex the first column is 1, the second 2, ...
* @return the column value; if the value is a SQL NULL the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.RowId getRowId(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("RowIDs not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value ; if the value is a SQL NULL the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.RowId getRowId(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("RowIDs not supported");
}
/**
* 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.
*
* @param columnIndex the first column is 1, the second 2, ...
* @param x the column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateRowId(final int columnIndex, final java.sql.RowId x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateRowId(final String columnLabel, final java.sql.RowId x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Retrieves the holdability of this ResultSet object
*
* @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
* @throws java.sql.SQLException if a database access error occurs or this method is called on a closed result set
* @since 1.6
*/
public int getHoldability() throws SQLException {
return ResultSet.HOLD_CURSORS_OVER_COMMIT;
}
/**
* 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.
*
* @return true if this ResultSet object is closed; false if it is still open
* @throws java.sql.SQLException if a database access error occurs
* @since 1.6
*/
public boolean isClosed() throws SQLException {
return isClosed;
}
/**
* Updates the designated column with a String value. It is intended for use when updating
* NCHAR,NVARCHAR and LONGNVARCHAR columns. The updater methods are used to
* update column values in the current row or the insert row. The updater methods do not update the underlying
* database; instead the updateRow or insertRow methods are called to update the
* database.
*
* @param columnIndex the first column is 1, the second 2, ...
* @param nString the value for the column to be updated
* @throws java.sql.SQLException if the columnIndex is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; the result set concurrency is
* CONCUR_READ_ONLY or if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNString(final int columnIndex, final String nString) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a String value. It is intended for use when updating
* NCHAR,NVARCHAR and LONGNVARCHAR columns. The updater methods are used to
* update column values in the current row or the insert row. The updater methods do not update the underlying
* database; instead the updateRow or insertRow methods are called to update the
* database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param nString the value for the column to be updated
* @throws java.sql.SQLException if the columnLabel is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; the result set concurrency is
* CONCUR_READ_ONLY or if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNString(final String columnLabel, final String nString) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a java.sql.NClob 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.
*
* @param columnIndex the first column is 1, the second 2, ...
* @param nClob the value for the column to be updated
* @throws java.sql.SQLException if the columnIndex is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final int columnIndex, final java.sql.NClob nClob) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Updates the designated column with a java.sql.NClob 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param nClob the value for the column to be updated
* @throws java.sql.SQLException if the columnLabel is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final String columnLabel, final java.sql.NClob nClob) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* NClob object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a NClob object representing the SQL NCLOB value in the specified column
* @throws java.sql.SQLException if the columnIndex is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set or if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.NClob getNClob(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("NClobs are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* NClob object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a NClob object representing the SQL NCLOB value in the specified column
* @throws java.sql.SQLException if the columnLabel is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set or if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.NClob getNClob(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("NClobs are not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet as a
* java.sql.SQLXML object in the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a SQLXML object that maps an SQL XML value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.SQLXML getSQLXML(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("SQLXML not supported");
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet as a
* java.sql.SQLXML object in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a SQLXML object that maps an SQL XML value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public java.sql.SQLXML getSQLXML(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("SQLXML not supported");
}
/**
* 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.
*
*
* @param columnIndex the first column is 1, the second 2, ...
* @param xmlObject the value for the column to be updated
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; this method is
* called on a closed result set; the java.xml.transform.Result,
* Writer or OutputStream has not been closed for the
* SQLXML object; if there is an error processing the XML value or the
* result set concurrency is CONCUR_READ_ONLY. The getCause
* method of the exception may provide a more detailed exception, for example, if the
* stream does not contain valid XML.
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateSQLXML(final int columnIndex, final java.sql.SQLXML xmlObject) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("SQLXML not supported");
}
/**
* 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.
*
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param xmlObject the column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; this method is
* called on a closed result set; the java.xml.transform.Result,
* Writer or OutputStream has not been closed for the
* SQLXML object; if there is an error processing the XML value or the
* result set concurrency is CONCUR_READ_ONLY. The getCause
* method of the exception may provide a more detailed exception, for example, if the
* stream does not contain valid XML.
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateSQLXML(final String columnLabel, final java.sql.SQLXML xmlObject) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("SQLXML not supported");
}
/**
* 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public String getNString(final int columnIndex) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("NString not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public String getNString(final String columnLabel) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("NString not supported");
}
/**
* 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a java.io.Reader object that contains the column value; if the value is SQL
* NULL, the value returned is null in the Java programming language.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public Reader getNCharacterStream(final int columnIndex) throws SQLException {
return getCharacterStream(columnIndex);
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return a java.io.Reader object that contains the column value; if the value is SQL
* NULL, the value returned is null in the Java programming language
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public Reader getNCharacterStream(final String columnLabel) throws SQLException {
return getCharacterStream(columnLabel);
}
/**
* Updates the designated column with a character stream value, which will have the specified number of bytes. The
* driver does the necessary conversion from Java character format to the national character set in the database. It
* is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR
* columns.
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNCharacterStream(final int columnIndex, final Reader x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a character stream value, which will have the specified number of bytes. The
* driver does the necessary conversion from Java character format to the national character set in the database. It
* is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR
* columns.
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader the java.io.Reader object containing the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateAsciiStream(final int columnIndex, final InputStream x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBinaryStream(final int columnIndex, final InputStream x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @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 the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateCharacterStream(final int columnIndex, final Reader x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateAsciiStream(final String columnLabel, final InputStream x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBinaryStream(final String columnLabel, final InputStream x, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader the java.io.Reader object containing the new column value
* @param length the length of the stream
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given input stream, 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param inputStream An object that contains the data to set the parameter value to.
* @param length the number of bytes in the parameter data.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBlob(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given input stream, 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param inputStream An object that contains the data to set the parameter value to.
* @param length the number of bytes in the parameter data.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBlob(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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 JDBC driver will do any necessary conversion from
* UNICODE to the database char format.
*
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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 JDBC driver will do any necessary conversion from
* UNICODE to the database char format.
*
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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 JDBC driver will do any necessary conversion from
* UNICODE to the database char format.
*
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnIndex the first column is 1, the second 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws java.sql.SQLException if the columnIndex is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set, if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* 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 JDBC driver will do any necessary conversion from
* UNICODE to the database char format.
*
*
* The updater methods are used to update column values in the current row or the insert row. The updater methods
* do not update the underlying database; instead the updateRow or insertRow methods are
* called to update the database.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader An object that contains the data to set the parameter value to.
* @param length the number of characters in the parameter data.
* @throws java.sql.SQLException if the columnLabel is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a character stream value. The data will be read from the stream as needed
* until end-of-stream is reached. 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNCharacterStream(final int columnIndex, final Reader x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a character stream value. The data will be read from the stream as needed
* until end-of-stream is reached. 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader the java.io.Reader object containing the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with an ascii stream value. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateAsciiStream(final int columnIndex, final InputStream x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a binary stream value. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBinaryStream(final int columnIndex, final InputStream x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a character stream value. The data will be read from the stream as needed
* until end-of-stream is reached.
*
* 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.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateCharacterStream(final int columnIndex, final Reader x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with an ascii stream value. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateAsciiStream(final String columnLabel, final InputStream x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a binary stream value. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param x the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBinaryStream(final String columnLabel, final InputStream x) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column with a character stream value. The data will be read from the stream as needed
* until end-of-stream is reached.
*
* 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.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader the java.io.Reader object containing the new column value
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given input stream. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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 updateBlob which takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param inputStream An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBlob(final int columnIndex, final InputStream inputStream) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given input stream. The data will be read from the stream as needed until
* end-of-stream is reached.
*
* 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 updateBlob which takes a length parameter.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param inputStream An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateBlob(final String columnLabel, final InputStream inputStream) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given Reader object. The data will be read from the stream
* as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the
* database char format.
*
*
* 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 updateClob which takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateClob(final int columnIndex, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given Reader object. The data will be read from the stream
* as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the
* database char format.
*
*
* 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 updateClob which takes a length parameter.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs; the result set
* concurrency is CONCUR_READ_ONLY or this method is called on a closed
* result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateClob(final String columnLabel, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given Reader
*
* The data will be read from the stream as needed until end-of-stream is reached. The JDBC driver will do any
* necessary conversion from UNICODE to the database char format.
*
*
* 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 updateNClob which takes a length parameter.
*
* @param columnIndex the first column is 1, the second 2, ...
* @param reader An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnIndex is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set, if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final int columnIndex, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
/**
* Updates the designated column using the given Reader object. The data will be read from the stream
* as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the
* database char format.
*
*
* 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 updateNClob which takes a length parameter.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @param reader An object that contains the data to set the parameter value to.
* @throws java.sql.SQLException if the columnLabel is not valid; if the driver does not support national character
* sets; if the driver can detect that a data conversion error could occur; this
* method is called on a closed result set; if a database access error occurs or the
* result set concurrency is CONCUR_READ_ONLY
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @since 1.6
*/
public void updateNClob(final String columnLabel, final Reader reader) throws SQLException {
throw SQLExceptionMapper.getFeatureNotSupportedException("Updates not supported");
}
public boolean getBoolean(final int i) throws SQLException {
return getValueObject(i).getBoolean();
}
public byte getByte(final int i) throws SQLException {
return getValueObject(i).getByte();
}
public short getShort(final int i) throws SQLException {
return getValueObject(i).getShort();
}
public long getLong(final int i) throws SQLException {
return getValueObject(i).getLong();
}
public float getFloat(final int i) throws SQLException {
return getValueObject(i).getFloat();
}
public double getDouble(final int i) throws SQLException {
return getValueObject(i).getDouble();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @deprecated
*/
public BigDecimal getBigDecimal(final int columnIndex, final int scale) throws SQLException {
return getValueObject(columnIndex).getBigDecimal();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public byte[] getBytes(final int columnIndex) throws SQLException {
return getValueObject(columnIndex).getBytes();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Date getDate(final int columnIndex) throws SQLException {
try {
return getValueObject(columnIndex).getDate();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse field as date", e);
}
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Time getTime(final int columnIndex) throws SQLException {
try {
return getValueObject(columnIndex).getTime();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse column as time, was: \"" +
getValueObject(columnIndex).getString() +
"\"", e);
}
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* 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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public Timestamp getTimestamp(final int columnIndex) throws SQLException {
try {
return getValueObject(columnIndex).getTimestamp();
} catch (ParseException e) {
throw SQLExceptionMapper.getSQLException("Could not parse field as date");
}
}
/**
* Retrieves the value of the designated column in the current row of this 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 getter 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.
*
* @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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public InputStream getAsciiStream(final int columnIndex) throws SQLException {
return getValueObject(columnIndex).getInputStream();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as as a
* stream of two-byte 3 characters. The first byte is the high byte; the second byte is the low byte.
*
* The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large
* LONGVARCHARvalues. The JDBC driver will do any necessary conversion from the database format into
* Unicode.
*
* Note: All the data in the returned stream must be read prior to getting the value of any other column.
* The next call to a getter 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.
*
* @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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
* @throws java.sql.SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @deprecated use getCharacterStream in place of getUnicodeStream
*/
public InputStream getUnicodeStream(final int columnIndex) throws SQLException {
return getValueObject(columnIndex).getInputStream();
}
/**
* Retrieves the value of the designated column in the current row of this 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 getter 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.
*
* @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 NULL, the value returned is null
* @throws java.sql.SQLException if the columnIndex is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public InputStream getBinaryStream(final int columnIndex) throws SQLException {
if(protocol.supportsPBMS()) {
try {
return getValueObject(columnIndex).getPBMSStream(protocol);
} catch (QueryException e) {
throw SQLExceptionMapper.get(e);
} catch (IOException e) {
throw SQLExceptionMapper.getSQLException("Could not read back the data using http", e);
}
}
return getValueObject(columnIndex).getBinaryInputStream();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* String in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is null
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public String getString(final String columnLabel) throws SQLException {
final ValueObject vo = getValueObject(columnLabel);
return vo.getString();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* boolean in the Java programming language.
*
* If the designated column has a datatype of CHAR or VARCHAR and contains a "0" or has a datatype of BIT,
* TINYINT, SMALLINT, INTEGER or BIGINT and contains a 0, a value of false is returned. If the
* designated column has a datatype of CHAR or VARCHAR and contains a "1" or has a datatype of BIT, TINYINT,
* SMALLINT, INTEGER or BIGINT and contains a 1, a value of true is returned.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is false
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public boolean getBoolean(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getBoolean();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* byte in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is 0
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public byte getByte(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getByte();
}
/**
* Retrieves the value of the designated column in the current row of this ResultSet object as a
* short in the Java programming language.
*
* @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
* specified, then the label is the name of the column
* @return the column value; if the value is SQL NULL, the value returned is 0
* @throws java.sql.SQLException if the columnLabel is not valid; if a database access error occurs or this method
* is called on a closed result set
*/
public short getShort(final String columnLabel) throws SQLException {
return getValueObject(columnLabel).getShort();
}
/**
* Returns an object that implements the given interface to allow access to non-standard methods, or standard
* methods not exposed by the proxy.
*
* If the receiver implements the interface then the result is the receiver or a proxy for the receiver. If the
* receiver is a wrapper and the wrapped object implements the interface then the result is the wrapped object or a
* proxy for the wrapped object. Otherwise return the the result of calling unwrap recursively on the
* wrapped object or a proxy for that result. If the receiver is not a wrapper and does not implement the interface,
* then an SQLException is thrown.
*
* @param iface A Class defining an interface that the result must implement.
* @return an object that implements the interface. May be a proxy for the actual implementing object.
* @throws java.sql.SQLException If no object found that implements the interface
* @since 1.6
*/
public T unwrap(final Class iface) throws SQLException {
return null;
}
/**
* Returns true if this either implements the interface argument or is directly or indirectly a wrapper for an
* object that does. Returns false otherwise. If this implements the interface then return true, else if this is a
* wrapper then return the result of recursively calling isWrapperFor on the wrapped object. If this
* does not implement the interface and is not a wrapper, return false. This method should be implemented as a
* low-cost operation compared to unwrap so that callers can use this method to avoid expensive
* unwrap calls that may fail. If this method returns true then calling unwrap with the
* same argument should succeed.
*
* @param iface a Class defining an interface.
* @return true if this implements the interface or directly or indirectly wraps an object that does.
* @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper for an object with
* the given interface.
* @since 1.6
*/
public boolean isWrapperFor(final Class iface) throws SQLException {
return false;
}
}