/*
Copyright (C) 2002 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package com.mysql.jdbc;
import java.io.IOException;
import java.sql.SQLException;
/**
* Allows streaming of MySQL data.
*
* @author dgan
* @version $Id: RowDataDynamic.java,v 1.8.2.6 2003/12/24 05:16:24 mmatthew Exp $
*/
public class RowDataDynamic implements RowData {
private MysqlIO io;
private byte[][] nextRow;
private boolean isAfterEnd = false;
private boolean isAtEnd = false;
private boolean streamerClosed = false;
private int columnCount;
private int index = -1;
private long lastSuccessfulReadTimeMs = 0;
private long netWriteTimeoutMs = 0;
private ResultSet owner;
/**
* Creates a new RowDataDynamic object.
*
* @param io DOCUMENT ME!
* @param colCount DOCUMENT ME!
*
* @throws SQLException DOCUMENT ME!
*/
public RowDataDynamic(MysqlIO io, int colCount) throws SQLException {
this.io = io;
this.columnCount = colCount;
nextRecord();
}
/**
* Returns true if we got the last element.
*
* @return true if after last row
*
* @throws SQLException if a database error occurs
*/
public boolean isAfterLast() throws SQLException {
return isAfterEnd;
}
/**
* Only works on non dynamic result sets.
*
* @param index row number to get at
*
* @return row data at index
*
* @throws SQLException if a database error occurs
*/
public byte[][] getAt(int index) throws SQLException {
notSupported();
return null;
}
/**
* Returns if iteration has not occured yet.
*
* @return true if before first row
*
* @throws SQLException if a database error occurs
*/
public boolean isBeforeFirst() throws SQLException {
return index < 0;
}
/**
* Moves the current position in the result set to the given row number.
*
* @param rowNumber row to move to
*
* @throws SQLException if a database error occurs
*/
public void setCurrentRow(int rowNumber) throws SQLException {
notSupported();
}
/**
* @see com.mysql.jdbc.RowData#setOwner(com.mysql.jdbc.ResultSet)
*/
public void setOwner(ResultSet rs) {
this.owner = rs;
}
/**
* @see com.mysql.jdbc.RowData#getOwner()
*/
public ResultSet getOwner() {
return this.owner;
}
/**
* Returns the current position in the result set as a row number.
*
* @return the current row number
*
* @throws SQLException if a database error occurs
*/
public int getCurrentRowNumber() throws SQLException {
notSupported();
return -1;
}
/**
* Returns true if the result set is dynamic. This means that move back and
* move forward won't work because we do not hold on to the records.
*
* @return true if this result set is streaming from the server
*/
public boolean isDynamic() {
return true;
}
/**
* Has no records.
*
* @return true if no records
*
* @throws SQLException if a database error occurs
*/
public boolean isEmpty() throws SQLException {
notSupported();
return false;
}
/**
* Are we on the first row of the result set?
*
* @return true if on first row
*
* @throws SQLException if a database error occurs
*/
public boolean isFirst() throws SQLException {
notSupported();
return false;
}
/**
* Are we on the last row of the result set?
*
* @return true if on last row
*
* @throws SQLException if a database error occurs
*/
public boolean isLast() throws SQLException {
notSupported();
return false;
}
/**
* Adds a row to this row data.
*
* @param row the row to add
*
* @throws SQLException if a database error occurs
*/
public void addRow(byte[][] row) throws SQLException {
notSupported();
}
/**
* Moves to after last.
*
* @throws SQLException if a database error occurs
*/
public void afterLast() throws SQLException {
notSupported();
}
/**
* Moves to before first.
*
* @throws SQLException if a database error occurs
*/
public void beforeFirst() throws SQLException {
notSupported();
}
/**
* Moves to before last so next el is the last el.
*
* @throws SQLException if a database error occurs
*/
public void beforeLast() throws SQLException {
notSupported();
}
/**
* We're done.
*
* @throws SQLException if a database error occurs
*/
public void close() throws SQLException {
//drain the rest of the records.
int count = 0;
while (this.hasNext()) {
this.next();
count++;
if (count == 100) {
Thread.yield();
count = 0;
}
}
}
/**
* Returns true if another row exsists.
*
* @return true if more rows
*
* @throws SQLException if a database error occurs
*/
public boolean hasNext() throws SQLException {
boolean hasNext = (nextRow != null);
if (!hasNext && !streamerClosed) {
io.closeStreamer(this);
streamerClosed = true;
}
return hasNext;
}
/**
* Moves the current position relative 'rows' from the current position.
*
* @param rows the relative number of rows to move
*
* @throws SQLException if a database error occurs
*/
public void moveRowRelative(int rows) throws SQLException {
notSupported();
}
/**
* Returns the next row.
*
* @return the next row value
*
* @throws SQLException if a database error occurs
*/
public byte[][] next() throws SQLException {
index++;
byte[][] ret = nextRow;
nextRecord();
return ret;
}
/**
* Removes the row at the given index.
*
* @param index the row to move to
*
* @throws SQLException if a database error occurs
*/
public void removeRow(int index) throws SQLException {
notSupported();
}
/**
* Only works on non dynamic result sets.
*
* @return the size of this row data
*/
public int size() {
return RESULT_SET_SIZE_UNKNOWN;
}
private void nextRecord() throws SQLException {
try {
if (!isAtEnd) {
nextRow = io.nextRow((int) columnCount);
if (nextRow == null) {
isAtEnd = true;
}
this.lastSuccessfulReadTimeMs = System.currentTimeMillis();
} else {
isAfterEnd = true;
}
} catch (SQLException sqlEx) {
// don't wrap SQLExceptions
throw sqlEx;
} catch (IOException ioEx) {
long timeSinceLastReadMs = System.currentTimeMillis() - this.lastSuccessfulReadTimeMs;
String exceptionType = ioEx.getClass().getName();
String exceptionMessage = ioEx.getMessage();
exceptionMessage += "\n\nNested Stack Trace:\n";
exceptionMessage += Util.stackTraceToString(ioEx);
throw new java.sql.SQLException(
"IOException while retrieving next record in streaming result set."
+ "(Check for deadlock "
+ " or retrieval exceeding 'net_write_timeout' seconds. Last "
+ "successful record read was " + timeSinceLastReadMs + " ms ago, and"
+ "'net_write_timeout' is configured in the server as " + this.netWriteTimeoutMs
+ " ms.) : "
+ exceptionType + " message given: " + exceptionMessage, SQLError.SQL_STATE_GENERAL_ERROR);
} catch (Exception ex) {
String exceptionType = ex.getClass().getName();
String exceptionMessage = ex.getMessage();
exceptionMessage += "\n\nNested Stack Trace:\n";
exceptionMessage += Util.stackTraceToString(ex);
throw new java.sql.SQLException(
"Error retrieving record: Unexpected Exception: "
+ exceptionType + " message given: " + exceptionMessage, SQLError.SQL_STATE_GENERAL_ERROR);
}
}
private void notSupported() throws SQLException {
throw new OperationNotSupportedException();
}
class OperationNotSupportedException extends SQLException {
OperationNotSupportedException() {
super("Operation not supported for streaming result sets", SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
}
}
}