maxRows value. This is set to -1 if no max rows
* are set.
*/
private int maxRows;
/**
* The data of the last fetch operation.
*/
private FetchChunk currentChunk;
/**
* The status of the position, i.e. one of the POSITION_XXX constants.
*/
protected int positionState;
/**
* The status of the current chunk.
*/
private int positionStateOfChunk;
private boolean fromMetaData; // was a metadata operation ?
private boolean lastWasNull; // was last getXXX null ?
private boolean isClosed; // is this result set closed?
private boolean empty; // is this result set totally empty
private int fetchDirection; // the fetchdirection (relatively ignored)
private Vector openStreams; // a vector of all streams that went outside.
private int rowsInResultSet; // the number of rows in this result set, or -1 if not known
private int safeFetchSize; // The fetch size that is known to be good.
// This one is used when going backwards in the result set.
private boolean safeFetchSizeDetermined;
private int largestKnownAbsPos; // largest known absolute position to be inside.
private int maxRowsOutSideResult; // flag: -1 -> maxrows is inside the result
// 0 -> unknown
// 1 -> maxrows is outside the result
protected int modifiedKernelPos; // contains 0 if the kernel pos is not modified
// or the current kernel position.
private int cursorType; // Flags if the cursor should not be dropped on close.
/**
* Creates a new result set object. The position will be before the first row,
* and the preferred direction will be ResultSet.FETCH_FORWARD.
* @param connection the current connection.
* @param fetchInfo short info and column names.
* @param statement the statement that produced this result set.
* @param fetchSize the maximum number of rows to fetch at once, use -1
* for default fetch size.
* @param maxRows the last row to fetch, use 0 to disable.
*/
ResultSetSapDB(ConnectionSapDB connection,
FetchInfo fetchInfo,
StatementSapDB statement,
int fetchSize,
int maxRows,
int cursorType,
ReplyPacket reply)
throws SQLException
{
super(connection);
this.fetchInfo=fetchInfo;
this.statement=statement;
if(fetchSize>=1) {
this.fetchSize=fetchSize;
} else {
this.fetchSize=DEFAULT_FETCHSIZE;
}
this.maxRows=maxRows;
this.isClosed=false;
this.fetchDirection=FETCH_FORWARD;
initializeFields();
openStreams=new java.util.Vector(5);
this.cursorType = cursorType;
if (reply != null){
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_FIRST, // fetch first is forward
1, // absolute start position
reply, // reply packet
fetchInfo.getRecordSize(), // the size for data part navigation
maxRows, // the current maxRows setting, for determining the last
// condition in that case
this.rowsInResultSet
));
positionState = POSITION_BEFORE_FIRST;
}
}
protected void initializeFields()
{
this.currentChunk=null;
this.positionState=POSITION_BEFORE_FIRST;
this.positionStateOfChunk=POSITION_NOT_AVAILABLE;
this.empty=false;
this.safeFetchSize=1;
this.safeFetchSizeDetermined = false;
this.largestKnownAbsPos=1;
this.maxRowsOutSideResult=0;
this.rowsInResultSet = -1;
this.modifiedKernelPos = 0;
}
/**
* Creates a new result set from separate fetch informations.
* @param connection the current connection.
* @param infos short infos of columns and fields.
* @param columnNames the names of the columns.
* @param statement the statement that produced this result set.
* @param fetchSize the maximum number of rows to fetch at once.
* @param maxRows the last row to fetch.
*/
ResultSetSapDB(ConnectionSapDB connection,
String cursorName,
DBTechTranslator[] infos,
String[] columnNames,
StatementSapDB statement,
int fetchSize,
int maxRows,
int cursorType,
ReplyPacket reply)
throws SQLException
{
this(connection, new FetchInfo(connection, cursorName, infos, columnNames, statement.isPacketEncodingUnicode()),
statement, fetchSize, maxRows, cursorType, reply);
}
//----------------------------------------------------------------------
// java.sql.ResultSetSet interface
//----------------------------------------------------------------------
/**
*
*
* 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
* @param b
* @return true if the cursor is on the result set;
* false otherwise
* @exception SQLException if a database access error
* occurs, or the result set type is TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean absolute(int row)
throws SQLException {
return absolute(row, false);
}
public boolean absolute(int row, boolean backward)
throws SQLException
{
clearWarnings();
assertNotClosed();
assertNotForwardOnly();
if(row==0) {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_ROW_ISNULL),
"21000");
}
// don't make anything if it is empty, just tell that we did shoot
// out of the boundary
if(this.empty) {
if(row > 0) {
this.positionState=POSITION_AFTER_LAST;
return false;
} else {
this.positionState=POSITION_BEFORE_FIRST;
return false;
}
}
if(row > 0) {
// trap 1: maxrows set.
if(maxRowIsSet() && row > maxRows) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
// trap 2: result count known.
if(rowsInResultSetKnown() && row > rowsInResultSet) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
// if we are somewhere out there, and there was no last chunk, force the fetch
if(positionStateOfChunk!=POSITION_INSIDE) {
boolean result=fetchAbsoluteUp(row, backward);
if(!result) this.positionState=POSITION_AFTER_LAST;
return result;
} else {
// ok, we are in a state where we have a chunk.
// if this chunk contains our row, we are happy and do nothing
if(currentChunk.setRow(row)) {
this.positionState=POSITION_INSIDE;
return true;
} else {
// otherwise we cannot avoid doing a fetch
boolean result = fetchAbsoluteUp(row, backward);
if(!result) this.positionState=POSITION_AFTER_LAST;
return result;
}
}
} else {
// trap: if the rows in the result set are known,
// invert the row, and come back.
if(rowsInResultSetKnown()) {
int invertedPos=invertPosition(row);
if(invertedPos <=0) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
} else {
return absolute(invertedPos);
}
}
// if there is nothing to do leave here
if(maxRowIsSet() && -row > maxRows) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
}
// check of chunk present, then do physical fetch if not
if(positionStateOfChunk!=POSITION_INSIDE) {
boolean result= fetchAbsoluteDown(row);
if(!result) this.positionState=POSITION_BEFORE_FIRST;
return result;
} else {
if(currentChunk.setRow(row)) {
this.positionState=POSITION_INSIDE;
return true;
} else {
boolean result= fetchAbsoluteDown(row);
if(!result) this.positionState=POSITION_BEFORE_FIRST;
return result;
}
}
}
}
/**
*
* Moves the cursor down one row from its current position.
* A ResultSet cursor is initially positioned
* before the first row; the first call to the method
* next makes the first row the current row; the
* second call makes the second row the current row, and so on.
*
*
If an input stream is open for the current row, a call
* to the method next will
* implicitly close it. A ResultSet object's
* warning chain is cleared when a new row is read.
*
* @return true if the new current row is valid;
* false if there are no more rows
* @exception SQLException if a database access error occurs
*/
public boolean next()
throws SQLException
{
clearWarnings();
assertNotClosed();
// if we have nothing, there is nothing to do.
if(this.empty) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
boolean result=false;
// at first we have to close all input streams
closeOpenStreams();
// if we are outside, ...
if(positionState==POSITION_BEFORE_FIRST) {
// ... check whether we still have it
if(positionStateOfChunk==POSITION_INSIDE &&
currentChunk.containsRow(1)) {
currentChunk.setRow(1);
this.positionState=POSITION_INSIDE;
result = true;
} else {
result = fetchFirst();
}
} else if(positionState==POSITION_INSIDE) {
if(currentChunk.move(1)) {
result=true;
} else {
if(currentChunk.isLast()) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
result = fetchNextChunk();
}
} else if(positionState==POSITION_AFTER_LAST) {
//
}
// in case we did a repositioning, we have to clear
// the warnings
if(result) {
clearWarnings();
}
return result;
}
/**
* 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
* @exception SQLException if a database access error occurs,
* there is no current row, or the result set type is
* TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean relative(int relativePos)
throws SQLException {
return this.relative(relativePos, true);
}
public boolean relative(int relativePos, boolean throwException)
throws SQLException
{
clearWarnings();
assertNotClosed();
assertNotForwardOnly();
if(this.empty) {
if (throwException){
throw new JDBCDriverException
(MessageTranslator.translate(MessageKey.WARNING_EMPTY_RESULTSET));
} else {
return false;
}
}
if(positionState!=POSITION_INSIDE) {
if (throwException){
if(positionState==POSITION_BEFORE_FIRST) {
throw new JDBCDriverException
(MessageTranslator.translate(MessageKey.ERROR_RESULTSET_BEFOREFIRST));
} else {
throw new JDBCDriverException
(MessageTranslator.translate(MessageKey.ERROR_RESULTSET_AFTERLAST));
}
} else {
return false;
}
} else {
int internal = getInternalRow();
if(internal>0) {
if(internal + relativePos <= 0) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
} else {
return absolute(internal + relativePos, relativePos < 0);
}
} else {
if(internal + relativePos >= 0) {
this.positionState=POSITION_AFTER_LAST;
return false;
} else {
return absolute(internal + relativePos, relativePos < 0);
}
}
}
}
/**
* Moves the cursor to the previous row in this
* ResultSet object.
*
* @return true if the cursor is on a valid row;
* false if it is off the result set
* @exception SQLException if a database access error
* occurs or the result set type is TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean previous()
throws SQLException
{
clearWarnings();
assertNotClosed();
if(positionState==POSITION_AFTER_LAST) {
return absolute(-1);
} else {
return this.relative(-1, false);
}
}
/**
* 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
* @exception SQLException if a database access error
* occurs or the result set type is TYPE_FORWARD_ONLY
*
*/
public boolean first()
throws SQLException
{
clearWarnings();
assertNotClosed();
assertNotForwardOnly();
// if we have nothing, there is nothing to do.
if(this.empty) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
// like in next()
closeOpenStreams();
boolean result=false;
if(positionStateOfChunk == POSITION_INSIDE &&
currentChunk.containsRow(1)) {
currentChunk.setRow(1);
this.positionState=POSITION_INSIDE;
result = true;
} else {
result=fetchFirst();
}
if(result) {
clearWarnings();
}
return result;
}
/**
*
* 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
* @exception SQLException if a database access error
* occurs or the result set type is TYPE_FORWARD_ONLY
* @since 1.2
*/
public boolean last()
throws SQLException
{
clearWarnings();
assertNotClosed();
assertNotForwardOnly();
// if we have nothing, there is nothing to do.
if(this.empty) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
// like in next()
closeOpenStreams();
boolean result=false;
if(positionStateOfChunk==POSITION_INSIDE &&
currentChunk.setRow(-1)) {
this.positionState=POSITION_INSIDE;
result=true;
} else {
result = fetchLast();
}
if(result) {
clearWarnings();
}
return result;
}
public void afterLast()
throws SQLException
{
assertNotForwardOnly();
assertNotClosed();
this.positionState=POSITION_AFTER_LAST;
}
public void beforeFirst()
throws SQLException
{
clearWarnings();
assertNotForwardOnly();
assertNotClosed();
this.positionState=POSITION_BEFORE_FIRST;
}
public boolean isFirst()
throws SQLException
{
assertNotClosed();
return currentChunk!=null && !this.empty && currentChunk.isFirst()
&& currentChunk.isAtLowerBound();
}
public boolean isLast()
throws SQLException
{
assertNotClosed();
return currentChunk!=null && !this.empty && currentChunk.isLast()
&& currentChunk.isAtUpperBound();
}
public boolean isBeforeFirst()
throws SQLException
{
assertNotClosed();
return (!this.empty && this.positionState==POSITION_BEFORE_FIRST);
}
public boolean isAfterLast()
throws SQLException
{
assertNotClosed();
return (!this.empty && this.positionState==POSITION_AFTER_LAST);
}
/**
* Retrieves whether the retrieved data value was NULL.
*/
public boolean wasNull()
throws SQLException
{
assertNotClosed();
return this.lastWasNull;
}
/**
* Closes this result set. Further operations are not allowed.
*/
public void close()
throws SQLException
{
this.close (false);
}
public void close(boolean keepCursorOpen)
throws SQLException
{
clearWarnings();
if (this.fetchInfo != null){
if (cursorType == StatementSapDB.Cursor_forward_only
&& ( this.currentChunk == null
|| !this.currentChunk.isLast()
)
){
cursorType = StatementSapDB.Cursor_in_use;
}
if( !keepCursorOpen
&& (cursorType == StatementSapDB.Cursor_in_use
|| cursorType == StatementSapDB.Cursor_Resurrected)
) {
this.connection.dropCursor(this.fetchInfo.getCursorName());
}
}
this.cursorType = StatementSapDB.Cursor_not_used;
this.isClosed = true;
this.currentChunk=null;
this.fetchInfo=null;
}
public int findColumn(String columnName)
throws SQLException
{
this.assertNotClosed ();
return this.findColumnInfo (columnName).getColIndex () + 1;
}
/**
*
*
* Gets an SQL ARRAY value from the current row of this ResultSet object.
*
* @param i the first column is 1, the second is 2, ...
* @return an Array object representing the SQL ARRAY value in
* the specified column
*/
public Array getArray(int i) throws SQLException {
throw new NotSupportedException
(MessageTranslator.translate(MessageKey.ERROR_ARRAY_UNSUPPORTED),
this);
}
/**
*
*
* Gets an SQL ARRAY value in the current row of this ResultSet object.
*
* @param colName the name of the column from which to retrieve the value
* @return an Array object representing the SQL ARRAY value in
* the specified column
*/
public Array getArray(String colName) throws SQLException
{
throw new NotSupportedException
(MessageTranslator.translate(MessageKey.ERROR_ARRAY_UNSUPPORTED),
this);
}
/**
* getAsciiStream method comment.
*/
public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
InputStream is= this.findColumnInfo (columnIndex)
.getAsciiStream (this, this.getCurrentRecord (), this.getReplyData());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
* getAsciiStream method comment.
*/
public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
InputStream is=this.findColumnInfo (columnName)
.getAsciiStream (this, this.getCurrentRecord (), this.getReplyData());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
*
*
* Gets the value of a column in the current row as a java.math.BigDecimal
* object 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 result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.math.BigDecimal getBigDecimal(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getBigDecimal (this, this.getCurrentRecord ());
}
/**
* getBigDecimal method comment.
*/
public java.math.BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
return this.findColumnInfo (columnIndex).getBigDecimal (scale, this, this.getCurrentRecord ());
}
/**
*
*
* Gets the value of a column in the current row as a java.math.BigDecimal
* object with full precision.
* @param columnName the column name
* @return the column value (full precision); if the value is SQL NULL,
* the result is null
* @exception java.sql.SQLException if a database access error occurs
*
*/
public java.math.BigDecimal getBigDecimal(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getBigDecimal (this, this.getCurrentRecord ());
}
/**
* getBigDecimal method comment.
*/
public java.math.BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
return this.findColumnInfo (columnName).getBigDecimal (scale, this, this.getCurrentRecord ());
}
/**
* getBinaryStream method comment.
*/
public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
InputStream is= this.findColumnInfo (columnIndex)
.getBinaryStream (this, this.getCurrentRecord (), this.getReplyData());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
* getBinaryStream method comment.
*/
public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
InputStream is= this.findColumnInfo (columnName)
.getBinaryStream (this, this.getCurrentRecord (), this.getReplyData());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
*
*
* Gets a BLOB value in the current row of this ResultSet object.
*
* @param i the first column is 1, the second is 2, ...
* @return a Blob object representing the SQL BLOB value in
* the specified column
*/
public Blob getBlob(int i) throws SQLException {
return this.findColumnInfo (i)
.getBlob (this, this.getCurrentRecord (), this.getReplyData());
}
/**
*
*
* Gets a BLOB value in the current row of this ResultSet object.
*
* @param colName the name of the column from which to retrieve the value
* @return a Blob object representing the SQL BLOB value in
* the specified column
*/
public Blob getBlob(String colName) throws SQLException {
return this.findColumnInfo (colName)
.getBlob (this, this.getCurrentRecord (), this.getReplyData());
}
/**
* getBoolean method comment.
*/
public boolean getBoolean(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getBoolean (this, this.getCurrentRecord ());
}
/**
* getBoolean method comment.
*/
public boolean getBoolean(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getBoolean (this, this.getCurrentRecord ());
}
/**
* getByte method comment.
*/
public byte getByte(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getByte (this, this.getCurrentRecord ());
}
/**
* getByte method comment.
*/
public byte getByte(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getByte (this, this.getCurrentRecord ());
}
/**
* getBytes method comment.
*/
public byte[] getBytes(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getBytes (this, this.getCurrentRecord ());
}
/**
* getBytes method comment.
*/
public byte[] getBytes(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getBytes (this, this.getCurrentRecord ());
}
/**
*
*
*
Gets the value of a column in the current row as a java.io.Reader. * @param columnIndex the first column is 1, the second is 2, ... */ public java.io.Reader getCharacterStream(int columnIndex) throws SQLException { Reader r=this.findColumnInfo (columnIndex) .getCharacterStream (this, this.getCurrentRecord (), this.getReplyData()); if(r!=null) { this.openStreams.addElement(r); } return r; } /** * * *
Gets the value of a column in the current row as a java.io.Reader.
* @param columnName the name of the column
* @return the value in the specified column as a java.io.Reader
*/
public java.io.Reader getCharacterStream(String columnName) throws SQLException {
Reader r=this.findColumnInfo (columnName)
.getCharacterStream (this, this.getCurrentRecord (), this.getReplyData());
if(r!=null) {
this.openStreams.addElement(r);
}
return r;
}
/**
*
*
* Gets a CLOB value in the current row of this ResultSet object.
*
* @param i the first column is 1, the second is 2, ...
* @return a Clob object representing the SQL CLOB value in
* the specified column
*/
public Clob getClob(int i) throws SQLException {
return this.findColumnInfo (i)
.getClob (this, this.getCurrentRecord (), this.getReplyData());
}
/**
*
*
* Gets a CLOB value in the current row of this ResultSet object.
*
* @param colName the name of the column from which to retrieve the value
* @return a Clob object representing the SQL CLOB value in
* the specified column
*/
public Clob getClob(String colName) throws SQLException {
return this.findColumnInfo (colName)
.getClob (this, this.getCurrentRecord (), this.getReplyData());
}
/**
*
*
* Returns the concurrency mode of this result set. The concurrency
* used is determined by the statement that created the result set.
*
* @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE
* @exception java.sql.SQLException if a database access error occurs
*/
public int getConcurrency() throws SQLException {
return java.sql.ResultSet.CONCUR_READ_ONLY;
}
/**
* getDate method comment.
*/
public java.sql.Date getDate(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getDate (this, this.getCurrentRecord (),null);
}
/**
*
*
* Gets the value of a column in the current row as a java.sql.Date
* object. This method uses the given calendar to construct an appropriate millisecond
* value for the Date if the underlying database does not store
* timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param cal the calendar to use in constructing the date
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Date getDate(int columnIndex, java.util.Calendar cal)
throws SQLException
{
return this.findColumnInfo (columnIndex).getDate (this, this.getCurrentRecord (),cal);
}
/**
* getDate method comment.
*/
public java.sql.Date getDate(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getDate (this, this.getCurrentRecord (),null);
}
/**
* Gets the value of a column in the current row as a java.sql.Date
* object. This method uses the given calendar to construct an appropriate millisecond
* value for the Date, if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column from which to retrieve the value
* @param cal the calendar to use in constructing the date
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Date getDate(String columnName, java.util.Calendar cal) throws SQLException {
return this.findColumnInfo (columnName).getDate (this, this.getCurrentRecord (),cal);
}
/**
* getDouble method comment.
*/
public double getDouble(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getDouble (this, this.getCurrentRecord ());
}
/**
* getDouble method comment.
*/
public double getDouble(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getDouble (this, this.getCurrentRecord ());
}
public int getFetchDirection() throws SQLException {
return this.fetchDirection;
}
public void setFetchDirection(int direction) throws SQLException {
assertNotClosed();
switch (direction) {
case java.sql.ResultSet.FETCH_REVERSE:
case java.sql.ResultSet.FETCH_UNKNOWN:
assertNotForwardOnly();
case java.sql.ResultSet.FETCH_FORWARD:
this.fetchDirection=direction;
break;
default:
throw new InvalidArgumentValue ("direction", "FETCH_FORWARD, FETCH_REVERSE, FETCH_UNKNOWN");
}
}
public int getFetchSize()
throws SQLException
{
assertNotClosed();
return fetchSize;
}
public void setFetchSize(int fetchSize)
throws SQLException
{
this.assertNotClosed();
if(fetchSize>=0) {
this.fetchSize=fetchSize;
this.safeFetchSize=Math.min(this.safeFetchSize, fetchSize);
if(this.safeFetchSize <= this.fetchSize && this.safeFetchSize != 1) {
this.safeFetchSizeDetermined = true;
}
} else {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_INVALID_FETCHSIZE,
Integer.toString(fetchSize)),
"22003");
}
}
public boolean rowUpdated() throws SQLException {
assertNotClosed();
return false;
}
public boolean rowInserted() throws SQLException {
assertNotClosed();
return false;
}
public boolean rowDeleted() throws SQLException {
assertNotClosed();
return false;
}
/**
* getFloat method comment.
*/
public float getFloat(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getFloat (this, this.getCurrentRecord ());
}
/**
* getFloat method comment.
*/
public float getFloat(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getFloat (this, this.getCurrentRecord ());
}
/**
* getInt method comment.
*/
public int getInt(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getInt (this, this.getCurrentRecord ());
}
/**
* getInt method comment.
*/
public int getInt(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getInt (this, this.getCurrentRecord ());
}
/**
* getLong method comment.
*/
public long getLong(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getLong (this, this.getCurrentRecord ());
}
/**
* getLong method comment.
*/
public long getLong(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getLong (this, this.getCurrentRecord ());
}
/**
* getMetaData method comment.
*/
public ResultSetMetaData getMetaData() throws SQLException {
assertNotClosed();
return new ResultSetMetaDataSapDB (this.fetchInfo.getColInfo());
}
/**
* getObject method comment.
*/
public Object getObject(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getObject (this, this.getCurrentRecord ());
}
/**
*
*
* Returns the value of a column in the current row as a Java object.
* This method uses the given Map object
* for the custom mapping of the
* SQL structured or distinct type that is being retrieved.
*
* @param i the first column is 1, the second is 2, ...
* @param map the mapping from SQL type names to Java classes
* @return an object representing the SQL value
*/
public Object getObject(int i, Map map) throws SQLException {
throw new NotImplemented ();
}
/**
* getObject method comment.
*/
public Object getObject(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getObject (this, this.getCurrentRecord ());
}
/**
*
*
* Returns the value in the specified column as a Java object.
* This method uses the specified Map object for
* custom mapping if appropriate.
*
* @param colName the name of the column from which to retrieve the value
* @param map the mapping from SQL type names to Java classes
* @return an object representing the SQL value in the specified column
*/
public Object getObject(String colName, Map map) throws SQLException {
throw new NotImplemented ();
}
/**
*
*
* Gets a REF(<structured-type>) column value from the current row.
*
* @param i the first column is 1, the second is 2, ...
* @return a Ref object representing an SQL REF value
*/
public Ref getRef(int i) throws SQLException {
throw new NotSupportedException
(MessageTranslator.translate(MessageKey.ERROR_REF_UNSUPPORTED),
this);
}
/**
*
*
* Gets a REF(<structured-type>) column value from the current row.
*
* @param colName the column name
* @return a Ref object representing the SQL REF value in
* the specified column
*/
public Ref getRef(String colName) throws SQLException {
throw new NotSupportedException
(MessageTranslator.translate(MessageKey.ERROR_REF_UNSUPPORTED),
this);
}
/**
*
*
*
Retrieves the current row number. The first row is number 1, the
* second number 2, and so on.
*
* @return the current row number; 0 if there is no current row
* @exception java.sql.SQLException if a database access error occurs
*/
public int getRow() throws SQLException {
assertNotClosed();
if(this.positionState!=POSITION_INSIDE) {
return 0;
}
int internalRow=getInternalRow();
// System.out.println("INTERNAL ROW IS : " + internalRow);
if(internalRow<0) {
getRowsInResult();
absolute(internalRow);
internalRow=getInternalRow(); // now positive
}
return internalRow;
}
public int getInternalRow()
{
if(currentChunk!=null) {
return currentChunk.getLogicalPos();
} else {
return 0;
}
}
public void traceChunk()
{
System.err.println(currentChunk.traceString());
}
/**
* getShort method comment.
*/
public short getShort(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getShort (this, this.getCurrentRecord ());
}
/**
* getShort method comment.
*/
public short getShort(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getShort (this, this.getCurrentRecord ());
}
/**
*
*
* Returns the Statement that produced this ResultSet object.
* If the result set was generated some other way, such as by a
* DatabaseMetaData method, this method returns null.
*
* @return the Statment that produced the result set or
* null if the result set was produced some other way
* @exception java.sql.SQLException if a database access error occurs
*/
public Statement getStatement() throws SQLException {
assertNotClosed();
// Std. compliance requires to return null if
// this is a result set from a meta data operation.
if(fromMetaData) {
return null;
}
return this.statement;
}
/**
* getString method comment.
*/
public String getString(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getString (this, this.getCurrentRecord ());
}
/**
* getString method comment.
*/
public String getString(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getString (this, this.getCurrentRecord ());
}
/**
* getTime method comment.
*/
public Time getTime(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getTime (this, this.getCurrentRecord (), null);
}
/**
* Gets the value of a column in the current row as a java.sql.Time
* object. 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 calendar to use in constructing the time
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Time getTime(int columnIndex, java.util.Calendar cal) throws SQLException {
return this.findColumnInfo (columnIndex).getTime (this, this.getCurrentRecord (), cal);
}
/**
* getTime method comment.
*/
public Time getTime(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getTime (this, this.getCurrentRecord (), null);
}
/**
* Gets the value of a column in the current row as a java.sql.Time
* object. This method uses the given calendar to construct an appropriate millisecond
* value for the Time if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column
* @param cal the calendar to use in constructing the time
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Time getTime(String columnName, java.util.Calendar cal) throws SQLException {
return this.findColumnInfo (columnName).getTime (this, this.getCurrentRecord (), cal);
}
/**
* getTimestamp method comment.
*/
public Timestamp getTimestamp(int columnIndex) throws SQLException {
return this.findColumnInfo (columnIndex).getTimestamp (this, this.getCurrentRecord (), null);
}
/**
* Gets the value of a column in the current row as a java.sql.Timestamp
* object. This method uses the given calendar to construct an appropriate millisecond
* value for the Timestamp if the underlying database does not store
* timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param cal the calendar to use in constructing the timestamp
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Timestamp getTimestamp(int columnIndex, java.util.Calendar cal)
throws java.sql.SQLException
{
return this.findColumnInfo (columnIndex).getTimestamp (this, this.getCurrentRecord (), cal);
}
/**
* getTimestamp method comment.
*/
public Timestamp getTimestamp(String columnName) throws SQLException {
return this.findColumnInfo (columnName).getTimestamp (this, this.getCurrentRecord (), null);
}
/**
* Gets the value of a column in the current row as a java.sql.Timestamp
* object. This method uses the given calendar to construct an appropriate millisecond
* value for the Timestamp if the underlying database does not store
* timezone information.
*
* @param columnName the SQL name of the column
* @param cal the calendar to use in constructing the timestamp
* @return the column value; if the value is SQL NULL, the result is null
* @exception java.sql.SQLException if a database access error occurs
*/
public java.sql.Timestamp getTimestamp(String columnName, java.util.Calendar cal)
throws java.sql.SQLException
{
return this.findColumnInfo (columnName).getTimestamp (this, this.getCurrentRecord (), cal);
}
/**
*
*
* Returns the type of this result set. The type is determined by
* the statement that created the result set.
*
* @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or
* TYPE_SCROLL_SENSITIVE
* @exception java.sql.SQLException if a database access error occurs
*/
public int getType() throws SQLException {
return this.statement.getResultSetType();
}
/**
* getUnicodeStream method comment.
*/
public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
InputStream is= this.findColumnInfo (columnIndex).getUnicodeStream (this, this.getCurrentRecord ());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
* getUnicodeStream method comment.
*/
public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
InputStream is = this.findColumnInfo (columnName).getUnicodeStream (this, this.getCurrentRecord ());
if(is!=null) {
this.openStreams.addElement(is);
}
return is;
}
/**
*
* @exception java.sql.SQLException The exception description.
*/
public Object [] getValues () throws SQLException {
int colinfo_length;
Object [] result = new Object [colinfo_length=this.fetchInfo.numberOfColumns()];
for (int i = 0; i < colinfo_length; ++i) {
result [i] = this.getObject (i + 1);
}
return result;
}
/**
*
*
* Updates a column with an ascii stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateAsciiStream(int columnIndex,
java.io.InputStream x,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an ascii stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateAsciiStream(String columnName,
java.io.InputStream x,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a BigDecimal value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBigDecimal(int columnIndex, java.math.BigDecimal x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a BigDecimal value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBigDecimal(String columnName, java.math.BigDecimal x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a binary stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBinaryStream(int columnIndex,
java.io.InputStream x,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a binary stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBinaryStream(String columnName,
java.io.InputStream x,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a boolean value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a boolean value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBoolean(String columnName, boolean x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a byte value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateByte(int columnIndex, byte x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a byte value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateByte(String columnName, byte x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a byte array value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBytes(int columnIndex, byte x[]) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a byte array value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateBytes(String columnName, byte x[]) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a character stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param length the length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateCharacterStream(int columnIndex,
java.io.Reader x,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a character stream value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param length of the stream
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateCharacterStream(String columnName,
java.io.Reader reader,
int length) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Date value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateDate(int columnIndex, java.sql.Date x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Date value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateDate(String columnName, java.sql.Date x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Double value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateDouble(int columnIndex, double x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a double value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateDouble(String columnName, double x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a float value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateFloat(int columnIndex, float x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a float value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateFloat(String columnName, float x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an integer value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateInt(int columnIndex, int x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an integer value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateInt(String columnName, int x) throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a long value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateLong(int columnIndex, long x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a long value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateLong(String columnName, long x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Give a nullable column a null value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateNull(int columnIndex) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a null value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateNull(String columnName) throws SQLException {
this.throwNotUpdatable();
}
public void updateDefault(String columnName) throws SQLException {
this.throwNotUpdatable();
}
public void updateDefault(int columnIndex) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an Object value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateObject(int columnIndex, Object x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an Object value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
* this is the number of digits after the decimal. For all other
* types this value will be ignored.
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateObject(int columnIndex, Object x, int scale)
throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an Object value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateObject(String columnName, Object x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with an Object value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
* this is the number of digits after the decimal. For all other
* types this value will be ignored.
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateObject(String columnName, Object x, int scale)
throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates the underlying database with the new contents of the
* current row. Cannot be called when on the insert row.
*
* @exception java.sql.SQLException if a database access error occurs or
* if called when on the insert row
*/
public void updateRow() throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a short value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateShort(int columnIndex, short x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a short value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateShort(String columnName, short x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a String value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateString(int columnIndex, String x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a String value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateString(String columnName, String x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Time value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Time value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateTime(String columnName, java.sql.Time x) throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Timestamp value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Updates a column with a Timestamp value.
*
* The updateXXX methods are used to update column values in the
* current row, or the insert row. The updateXXX methods do not
* update the underlying database; instead the updateRow or insertRow
* methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception java.sql.SQLException if a database access error occurs
*/
public void updateTimestamp(String columnName, java.sql.Timestamp x)
throws SQLException
{
this.throwNotUpdatable();
}
/**
*
*
* Inserts the contents of the insert row into the result set and
* the database. Must be on the insert row when this method is called.
*
* @exception java.sql.SQLException if a database access error occurs,
* if called when not on the insert row, or if not all of non-nullable columns in
* the insert row have been given a value
*/
public void insertRow() throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Deletes the current row from the result set and the underlying
* database. Cannot be called when on the insert row.
*
* @exception java.sql.SQLException if a database access error occurs or if
* called when on the insert row.
*/
public void deleteRow() throws SQLException {
this.throwNotUpdatable();
}
/**
*
* Refreshes the current row with its most recent value in
* the database. Cannot be called when 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 updateXXX, but before calling updateRow, then the
* updates made to the row are lost. Calling the method refreshRow frequently
* will likely slow performance.
*
* @exception java.sql.SQLException if a database access error occurs or if
* called when on the insert row
*/
public void refreshRow()
throws SQLException
{
assertNotClosed();
int internalPos=getInternalRow();
initializeFields();
absolute(internalPos);
}
/**
*
*
* Cancels the updates made to a row.
* This method may be called after calling an
* updateXXX method(s) and before calling updateRow to rollback
* the updates made to a row. If no updates have been made or
* updateRow has already been called, then this method has no
* effect.
*
* @exception java.sql.SQLException if a database access error occurs or if
* called when on the insert row
*
*/
public void cancelRowUpdates() throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* 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.
*
* @exception java.sql.SQLException if a database access error occurs
* or the result set is not updatable
*/
public void moveToCurrentRow() throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* Moves the cursor to the insert row. The current cursor position is
* remembered while the cursor is positioned on the insert row.
*
* The insert row is a special row associated with an updatable
* result set. It is essentially a buffer where a new row may
* be constructed by calling the updateXXX methods prior to
* inserting the row into the result set.
*
* Only the updateXXX, getXXX,
* and insertRow methods may be
* called when the cursor is on the insert row. All of the columns in
* a result set must be given a value each time this method is
* called before calling insertRow.
* The method updateXXX must be called before a
* getXXX method can be called on a column value.
*
* @exception java.sql.SQLException if a database access error occurs
* or the result set is not updatable
*/
public void moveToInsertRow() throws SQLException {
this.throwNotUpdatable();
}
/**
*
*
* 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.
*
*
Note: If positioned update is not supported, a
* SQLException is thrown.
*
* @return the SQL name for this ResultSet object's cursor
* @exception SQLException if a database access error occurs
*/
public String getCursorName() throws SQLException
{
assertNotClosed();
return this.fetchInfo.getCursorName();
}
//----------------------------------------------------------------------
// SQLParamController interface
//----------------------------------------------------------------------
/**
* Get the data part of the curren reply packet.
* @return the data part of the reply packet, as StructuredMem.
*/
public StructuredMem getReplyData()
{
if(currentChunk!=null) {
return currentChunk.getReplyData();
} else {
return null;
}
}
/**
* Set the flag that a null value was found.
* @param lastWasNull The flag for the null detection.
*/
public void setLastWasNull(boolean lastWasNull)
{
this.lastWasNull=lastWasNull;
}
/**
* Sets whether this result set had its origin in a meta data
* operation, and thus the statement don't have to be exposed.
* @param fromMetaData Whether this statement was produced by a
* DatabaseMetaData operation.
*/
void setFromMetaData(boolean fromMetaData)
{
this.fromMetaData=fromMetaData;
}
/**
* Sets whether this result set is empty.
* @param empty the emptiness flag.
*/
void setEmpty(boolean empty)
{
this.empty=empty;
}
void setRowsInResultSet(int rows)
throws SQLException
{
if(maxRows > 0)
this.rowsInResultSet=Math.min(rows, this.maxRows);
else
this.rowsInResultSet = rows;
}
// ----------------------------------------------------------------------
// Internal methods
//----------------------------------------------------------------------
/**
* Fetch the next chunk, moving forward over the result set.
*/
private boolean fetchNextChunk()
throws SQLException
{
ReplyPacket reply;
int usedFetchSize=this.fetchSize;
int usedOffset=1;
if(currentChunk.isForward()) {
// in case we come to an end, we may have to limit the fetch size.
if(maxRowIsSet()) {
usedFetchSize=Math.min(this.maxRows - currentChunk.getEnd() + 1, usedFetchSize);
}
if(modifiedKernelPos != 0) {
usedOffset += currentChunk.getEnd() - modifiedKernelPos;
}
} else {
// if an update destroyed the cursor position, we have to honor this ...
if(modifiedKernelPos==0) {
usedOffset += currentChunk.getEnd() - currentChunk.getKernelPos();
} else {
usedOffset += currentChunk.getEnd() - modifiedKernelPos;
}
}
// else {
// // kernel sits on the opposite edge of the chunk, honor this
// usedOffset+=currentChunk.size();
// }
try {
if (this.getType()==ResultSet.TYPE_FORWARD_ONLY){
reply=this.fetchInfo.executeFetchNext(usedFetchSize);
} else {
reply=this.fetchInfo.executeFetchRelative(usedOffset, usedFetchSize);
}
} catch(SQLException sqlEx) {
if(sqlEx.getErrorCode()==100) {
// fine, we are at the end.
this.currentChunk.setLast(true);
this.updateRowStatistics();
// but invalidate it, as it is
// thrown away by the kernel
this.currentChunk=null;
this.positionStateOfChunk=POSITION_NOT_AVAILABLE;
this.positionState=POSITION_AFTER_LAST;
return false;
}
throw sqlEx;
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_RELATIVE_UP,
this.currentChunk.getEnd() + 1,
reply,
this.fetchInfo.getRecordSize(),
this.maxRows,
this.rowsInResultSet));
return true;
}
private boolean fetchLast()
throws SQLException
{
ReplyPacket reply;
// in case a max row is set, fetching the last is totally different
// thing
if(!maxRowIsSet() || maxRowsOutSideResult==1) {
try {
// we have to use the safe fetch size here.
reply=this.fetchInfo.executeFetchLast(safeFetchSize);
} catch(SQLException sqlEx) {
if(sqlEx.getErrorCode() == 100) {
this.empty=true;
this.positionState=POSITION_AFTER_LAST;
this.currentChunk=null;
return false;
} else {
throw sqlEx;
}
}
// If we did know a safe fetch size for LAST, we may have landed
// before the position we wanted to fetch. In this case the chunk
// starts a few rows before the end
try {
reply.findPart(PartKind.Data_C);
} catch(PartNotFound pnf) {
throw new InternalJDBCError("Fetch operation delivered no data part");
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_LAST,
- reply.partArguments(), // absolute start position
reply, // reply packet
fetchInfo.getRecordSize(), // the size for data part navigation
0, // already ensured that there is no maxRows
this.rowsInResultSet
)
);
currentChunk.moveToUpperBound(); // what we really want is the last position inside
// this chunk, as this is the position of the last record.
return true;
} else {
// we have the good and the messy way. We may know how many
// records are inside, and thus make something senseful.
if(rowsInResultSetKnown()) {
// determined to what position we have to fetch
int usedFetchSize=this.safeFetchSize;
int usedPhysicalRow=this.rowsInResultSet - usedFetchSize + 1;
try {
reply = this.fetchInfo.executeFetchAbsolute(usedPhysicalRow, usedFetchSize);
} catch(SQLException sqlEx) {
if(sqlEx.getErrorCode() == 100) {
// something wicked happened. we had a valid
// value for the rows, and it was not good.
// erase the value for the rows, and retry.
this.rowsInResultSet=-1;
return fetchLast();
} else {
throw sqlEx;
}
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_UP,
usedPhysicalRow,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
currentChunk.moveToUpperBound(); // It does not matter whether we
// did get a few less records, just position at the last.
return true;
} else {
try {
// try a fetch at the position the user wants.
// if this does not find anything, try the next one ...
reply=this.fetchInfo.executeFetchAbsolute(maxRows, 1);
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_UP,
maxRows,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
currentChunk.moveToUpperBound();
return true;
} catch(SQLException sqlEx) {
if(sqlEx.getErrorCode()!=100) {
throw sqlEx;
}
}
this.maxRowsOutSideResult=1; // set indicator
return fetchLast(); // recursive call will trap in other condition
}
}
}
/**
* Executes a FETCH FIRST, and stores the result internally.
* @return true if the cursor is positioned correctly.
*/
private boolean fetchFirst()
throws SQLException
{
ReplyPacket reply;
int usedFetchSize=this.fetchSize;
// avoid fetching too much by limiting the fetch size.
if(maxRowIsSet()) {
usedFetchSize=Math.min(usedFetchSize, this.maxRows);
}
try {
if (this.statement.resultSetType == ResultSet.TYPE_FORWARD_ONLY){
reply=this.fetchInfo.executeFetchNext(usedFetchSize);
} else {
reply=this.fetchInfo.executeFetchFirst(usedFetchSize);
}
} catch(SQLExceptionSapDB sqlEx) {
if(sqlEx.getErrorCode() == 100) {
this.empty=true;
this.positionState=POSITION_AFTER_LAST;
this.currentChunk=null;
} else {
throw sqlEx;
}
return false;
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_FIRST, // fetch first is forward
1, // absolute start position
reply, // reply packet
fetchInfo.getRecordSize(), // the size for data part navigation
maxRows, // the current maxRows setting, for determining the last
// condition in that case
this.rowsInResultSet
));
return true;
}
/**
* Executes an absolute fetch, to the physical row given.
* @param physicalRow the physical row. It is assumed that this is
* is < 0, and within the possibly set maxRows limit.
* @return true if the fetch did position at the row.
*/
private boolean fetchAbsoluteDown(int physicalRow)
throws SQLException
{
if(maxRowIsSet()) {
if(maxRowsOutSideResult == -1) {
if(rowsInResultSet==-1) {
throw new InternalJDBCError(MessageTranslator.translate(MessageKey.ERROR_ASSERTION_MAXROWS_IN_RESULT));
}
int absrow=maxRows + physicalRow +1;
if(absrow <= 0) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
}
return absolute(absrow);
} else if(maxRowsOutSideResult == 0) {
try {
ReplyPacket reply=this.fetchInfo.executeFetchAbsolute(this.maxRows, 1);
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_UP,
maxRows,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
currentChunk.moveToUpperBound();
} catch(SQLException sqlEx) {
if(sqlEx.getErrorCode() != 100) {
throw sqlEx;
}
this.maxRowsOutSideResult=1;
return absolute(physicalRow);
}
this.maxRowsOutSideResult=-1;
return absolute(physicalRow);
} else {
ReplyPacket reply=null;
try {
reply=this.fetchInfo.executeFetchAbsolute(physicalRow, this.fetchSize);
} catch(SQLExceptionSapDB sqlEx) {
if(sqlEx.getErrorCode()==100) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
} else {
throw sqlEx;
}
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_DOWN,
physicalRow,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
if(!currentChunk.setRow(physicalRow)) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
}
return true;
}
} else {
ReplyPacket reply=null;
try {
reply=this.fetchInfo.executeFetchAbsolute(physicalRow, this.fetchSize);
} catch(SQLExceptionSapDB sqlEx) {
if(sqlEx.getErrorCode()==100) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
} else {
throw sqlEx;
}
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_DOWN,
physicalRow,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
if(!currentChunk.setRow(physicalRow)) {
this.positionState=POSITION_BEFORE_FIRST;
return false;
}
return true;
}
}
/**
* Executes an absolute fetch, to the physical row given.
* @param physicalRow the physical row. It is assumed that it is > 0, and
* less than maxrows/rowsInResultSet
* @param backward Whether this positioning is done on the way backward.
* @return true if the fetch did position at the row, false otherwise.
*/
private boolean fetchAbsoluteUp(int physicalRow, boolean backward )
throws SQLException
{
ReplyPacket reply;
// now check where is the end ... at least
// the end we know - actually the end may be earlier,
// if there is an unchecked maxRows out there.
int maxKnownEnd;
if(maxRowIsSet()) {
if(rowsInResultSetKnown()) {
maxKnownEnd=Math.min(this.maxRows, this.rowsInResultSet);
} else {
maxKnownEnd=this.maxRows;
}
} else {
if(rowsInResultSetKnown()) {
maxKnownEnd=this.rowsInResultSet;
} else {
maxKnownEnd=Integer.MAX_VALUE;
}
}
int usedFetchSize=this.fetchSize;
int usedPhysicalRow=physicalRow;
// The backward navigation is only honored when the 'safe fetch size'
// is determined.
if(backward && safeFetchSizeDetermined) {
usedFetchSize = this.safeFetchSize;
usedPhysicalRow = physicalRow - usedFetchSize + 1;
if(usedPhysicalRow <= 0) {
usedPhysicalRow = 1;
}
// System.out.println("ABSOLUTE " + usedPhysicalRow + " FETCHSIZE " + usedFetchSize);
} else {
// if we would definitely shoot above the end,
// we have to modify our query ... we have
// to move back the real row so that our window
// just finishes at the end of the result
// physical row can be only made less using this attempt.
// we make this only if the used fetch size is safe,
// as otherwise we possibly do not get the expected row.
if(physicalRow + usedFetchSize > maxKnownEnd
&& usedFetchSize <= this.safeFetchSize) {
usedPhysicalRow = maxKnownEnd - usedFetchSize + 1;
}
}
try {
reply=this.fetchInfo.executeFetchAbsolute(usedPhysicalRow, usedFetchSize);
} catch(SQLExceptionSapDB sqlEx) {
if(sqlEx.getErrorCode() == 100) {
// don't touch the chunk, in case we may need it ...
// as the the row is >0, we are after the last
this.positionState=POSITION_AFTER_LAST;
} else {
throw sqlEx;
}
return false;
}
setCurrentChunk(new FetchChunk(FetchChunk.TYPE_ABSOLUTE_UP,
usedPhysicalRow,
reply,
fetchInfo.getRecordSize(),
maxRows,
this.rowsInResultSet));
// if we moved the window, to avoid fetching behind the last,
// we need to adjust the logical position.
if(usedPhysicalRow != physicalRow) {
if(!currentChunk.setRow(physicalRow)) {
this.positionState=POSITION_AFTER_LAST;
return false;
}
}
return true;
}
/**
* Check whether to honor maxRows.
*/
private boolean maxRowIsSet()
{
return maxRows!=0;
}
/**
* Check whether the number of rows is there.
*/
private boolean rowsInResultSetKnown()
{
return rowsInResultSet!=-1;
}
/**
* Asserts that the result set is not a FORWARD_ONLY result.
*/
private void assertNotForwardOnly()
throws SQLException
{
if(this.getType()==ResultSet.TYPE_FORWARD_ONLY) {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_RESULTSET_FORWARDONLY));
}
}
/**
* Asserts that the result set is not closed.
*/
protected void assertNotClosed()
throws SQLException
{
super.assertOpen();
if(this.isClosed) {
throw new ObjectIsClosedException(this);
}
}
final protected DBTechTranslator findColumnInfo(String columnName)
throws SQLException
{
assertNotClosed();
DBTechTranslator info=this.fetchInfo.getColumnInfo(columnName);
if(info==null) {
throw new InvalidColumnException (columnName, this);
}
return info;
}
final protected DBTechTranslator[] getColInfo() throws SQLException
{
return this.fetchInfo.getColInfo();
}
final protected int numberOfColumns()
{
return fetchInfo.numberOfColumns();
}
final protected StructuredMem getCurrentRecord()
throws SQLException
{
if(positionState==POSITION_BEFORE_FIRST) {
throw new JDBCDriverException
(MessageTranslator.translate(MessageKey.ERROR_RESULTSET_BEFOREFIRST));
}
if(positionState==POSITION_AFTER_LAST) {
throw new JDBCDriverException(MessageTranslator.translate(MessageKey.ERROR_RESULTSET_AFTERLAST));
}
return currentChunk.getCurrentRecord();
}
private DBTechTranslator findColumnInfo (int colIndex)
throws SQLException
{
assertNotClosed();
DBTechTranslator info;
try {
info = this.getColInfo() [colIndex - 1];
}
catch (ArrayIndexOutOfBoundsException exc) {
throw new InvalidColumnException (colIndex, this);
}
return info;
}
/**
* Helper method for indicating that the result is read-only.
*
* @exception JDBCDriverException always.
*/
private void throwNotUpdatable()
throws JDBCDriverException
{
throw new JDBCDriverException (MessageTranslator.translate(MessageKey.ERROR_RESULTSET_NOTUPDATABLE), this);
}
/**
* Helper method that closes the accumulated outgoing streams
* and readers if a cursor is moved.
*/
private void closeOpenStreams()
{
Enumeration e=openStreams.elements();
while(e.hasMoreElements()) {
try {
Object o=e.nextElement();
try {
InputStream is=(InputStream)o;
is.close();
} catch(ClassCastException ccx) {
Reader r=(Reader)o;
r.close();
}
} catch(IOException io_ex) {
// ignore
}
}
openStreams.clear();
}
/**
* Updates the current chunk.
* Also consistently:
*
POSITION_INSIDE