package SQLite.JDBC2y;
import java.sql.*;
import java.math.BigDecimal;
public class JDBCResultSet implements java.sql.ResultSet {
/**
* Current row to be retrieved.
*/
private int row;
/**
* Table returned by Database.get_table()
*/
protected SQLite.TableResult tr;
/**
* Statement from which result set was produced.
*/
private JDBCStatement s;
/**
* Meta data for result set or null.
*/
private JDBCResultSetMetaData m;
/**
* Last result cell retrieved or null.
*/
private String lastg;
public JDBCResultSet(SQLite.TableResult tr, JDBCStatement s) {
this.tr = tr;
this.s = s;
this.m = null;
this.lastg = null;
this.row = -1;
}
public boolean next() throws SQLException {
if (tr == null) {
return false;
}
row++;
return row < tr.nrows;
}
public int findColumn(String columnName) throws SQLException {
JDBCResultSetMetaData m = (JDBCResultSetMetaData) getMetaData();
return m.findColByName(columnName);
}
public int getRow() throws SQLException {
if (tr == null) {
throw new SQLException("no rows");
}
return row + 1;
}
public boolean previous() throws SQLException {
if (tr == null) {
return false;
}
if (row >= 0) {
row--;
}
return row >= 0;
}
public boolean absolute(int row) throws SQLException {
if (tr == null) {
return false;
}
if (row < 0) {
row = tr.nrows + 1 + row;
}
row--;
if (row < 0 || row > tr.nrows) {
return false;
}
this.row = row;
return true;
}
public boolean relative(int row) throws SQLException {
if (tr == null) {
return false;
}
if (this.row + row < 0 || this.row + row >= tr.nrows) {
return false;
}
this.row += row;
return true;
}
public void setFetchDirection(int dir) throws SQLException {
throw new SQLException("not supported");
}
public int getFetchDirection() throws SQLException {
throw new SQLException("not supported");
}
public void setFetchSize(int fsize) throws SQLException {
throw new SQLException("not supported");
}
public int getFetchSize() throws SQLException {
throw new SQLException("not supported");
}
public String getString(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
return lastg;
}
public String getString(String columnName) throws SQLException {
int col = findColumn(columnName);
return getString(col);
}
public int getInt(int columnIndex) throws SQLException {
Integer i = internalGetInt(columnIndex);
if (i != null) {
return i.intValue();
}
return 0;
}
private Integer internalGetInt(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return Integer.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public int getInt(String columnName) throws SQLException {
int col = findColumn(columnName);
return getInt(col);
}
public boolean getBoolean(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public boolean getBoolean(String columnName) throws SQLException {
throw new SQLException("not supported");
}
public ResultSetMetaData getMetaData() throws SQLException {
if (m == null) {
m = new JDBCResultSetMetaData(this);
}
return m;
}
public short getShort(int columnIndex) throws SQLException {
Short s = internalGetShort(columnIndex);
if (s != null) {
return s.shortValue();
}
return 0;
}
private Short internalGetShort(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return Short.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public short getShort(String columnName) throws SQLException {
int col = findColumn(columnName);
return getShort(col);
}
public java.sql.Time getTime(int columnIndex) throws SQLException {
return internalGetTime(columnIndex, null);
}
private java.sql.Time internalGetTime(int columnIndex,
java.util.Calendar cal)
throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return java.sql.Time.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public java.sql.Time getTime(String columnName) throws SQLException {
int col = findColumn(columnName);
return getTime(col);
}
public java.sql.Time getTime(int columnIndex, java.util.Calendar cal)
throws SQLException {
return internalGetTime(columnIndex, cal);
}
public java.sql.Time getTime(String columnName, java.util.Calendar cal)
throws SQLException{
int col = findColumn(columnName);
return getTime(col, cal);
}
public java.sql.Timestamp getTimestamp(int columnIndex)
throws SQLException{
return internalGetTimestamp(columnIndex, null);
}
private java.sql.Timestamp internalGetTimestamp(int columnIndex,
java.util.Calendar cal)
throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return java.sql.Timestamp.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public java.sql.Timestamp getTimestamp(String columnName)
throws SQLException{
int col = findColumn(columnName);
return getTimestamp(col);
}
public java.sql.Timestamp getTimestamp(int columnIndex,
java.util.Calendar cal)
throws SQLException {
return internalGetTimestamp(columnIndex, cal);
}
public java.sql.Timestamp getTimestamp(String columnName,
java.util.Calendar cal)
throws SQLException {
int col = findColumn(columnName);
return getTimestamp(col, cal);
}
public java.sql.Date getDate(int columnIndex) throws SQLException {
return internalGetDate(columnIndex, null);
}
private java.sql.Date internalGetDate(int columnIndex,
java.util.Calendar cal)
throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return java.sql.Date.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public java.sql.Date getDate(String columnName) throws SQLException {
int col = findColumn(columnName);
return getDate(col);
}
public java.sql.Date getDate(int columnIndex, java.util.Calendar cal)
throws SQLException{
return internalGetDate(columnIndex, cal);
}
public java.sql.Date getDate(String columnName, java.util.Calendar cal)
throws SQLException{
int col = findColumn(columnName);
return getDate(col, cal);
}
public double getDouble(int columnIndex) throws SQLException {
Double d = internalGetDouble(columnIndex);
if (d != null) {
return d.doubleValue();
}
return 0;
}
private Double internalGetDouble(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return Double.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public double getDouble(String columnName) throws SQLException {
int col = findColumn(columnName);
return getDouble(col);
}
public float getFloat(int columnIndex) throws SQLException {
Float f = internalGetFloat(columnIndex);
if (f != null) {
return f.floatValue();
}
return 0;
}
private Float internalGetFloat(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return Float.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public float getFloat(String columnName) throws SQLException {
int col = findColumn(columnName);
return getFloat(col);
}
public long getLong(int columnIndex) throws SQLException {
Long l = internalGetLong(columnIndex);
if (l != null) {
return l.longValue();
}
return 0;
}
private Long internalGetLong(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
try {
return Long.valueOf(lastg);
} catch (java.lang.Exception e) {
lastg = null;
}
return null;
}
public long getLong(String columnName) throws SQLException {
int col = findColumn(columnName);
return getLong(col);
}
@Deprecated
public java.io.InputStream getUnicodeStream(int columnIndex)
throws SQLException {
throw new SQLException("not supported");
}
@Deprecated
public java.io.InputStream getUnicodeStream(String columnName)
throws SQLException {
throw new SQLException("not supported");
}
public java.io.InputStream getAsciiStream(String columnName)
throws SQLException {
throw new SQLException("not supported");
}
public java.io.InputStream getAsciiStream(int columnIndex)
throws SQLException {
throw new SQLException("not supported");
}
public BigDecimal getBigDecimal(String columnName)
throws SQLException {
throw new SQLException("not supported");
}
@Deprecated
public BigDecimal getBigDecimal(String columnName, int scale)
throws SQLException {
throw new SQLException("not supported");
}
public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
@Deprecated
public BigDecimal getBigDecimal(int columnIndex, int scale)
throws SQLException {
throw new SQLException("not supported");
}
public java.io.InputStream getBinaryStream(int columnIndex)
throws SQLException {
throw new SQLException("not supported");
}
public java.io.InputStream getBinaryStream(String columnName)
throws SQLException {
throw new SQLException("not supported");
}
public byte getByte(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public byte getByte(String columnName) throws SQLException {
throw new SQLException("not supported");
}
public byte[] getBytes(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
byte ret[] = null;
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
if (lastg != null) {
ret = SQLite.StringEncoder.decode(lastg);
}
return ret;
}
public byte[] getBytes(String columnName) throws SQLException {
int col = findColumn(columnName);
return getBytes(col);
}
public String getCursorName() throws SQLException {
return null;
}
public Object getObject(int columnIndex) throws SQLException {
if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) {
throw new SQLException("column " + columnIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[columnIndex - 1];
Object ret = lastg;
if (tr instanceof TableResultX) {
switch (((TableResultX) tr).sql_type[columnIndex - 1]) {
case Types.SMALLINT:
ret = internalGetShort(columnIndex);
break;
case Types.INTEGER:
ret = internalGetInt(columnIndex);
break;
case Types.DOUBLE:
ret = internalGetDouble(columnIndex);
break;
case Types.FLOAT:
ret = internalGetFloat(columnIndex);
break;
case Types.BIGINT:
ret = internalGetLong(columnIndex);
break;
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
ret = getBytes(columnIndex);
break;
case Types.NULL:
ret = null;
break;
/* defaults to String below */
}
}
return ret;
}
public Object getObject(String columnName) throws SQLException {
int col = findColumn(columnName);
return getObject(col);
}
public Object getObject(int columnIndex, java.util.Map map)
throws SQLException {
throw new SQLException("not supported");
}
public Object getObject(String columnIndex, java.util.Map map)
throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Ref getRef(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Ref getRef(String columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Blob getBlob(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Blob getBlob(String columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Clob getClob(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Clob getClob(String columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Array getArray(int columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.sql.Array getArray(String columnIndex) throws SQLException {
throw new SQLException("not supported");
}
public java.io.Reader getCharacterStream(int columnIndex)
throws SQLException {
throw new SQLException("not supported");
}
public java.io.Reader getCharacterStream(String columnName)
throws SQLException {
throw new SQLException("not supported");
}
public SQLWarning getWarnings() throws SQLException {
throw new SQLException("not supported");
}
public boolean wasNull() throws SQLException {
return lastg == null;
}
public void clearWarnings() throws SQLException {
throw new SQLException("not supported");
}
public boolean isFirst() throws SQLException {
if (tr == null) {
return true;
}
return row == 0;
}
public boolean isBeforeFirst() throws SQLException {
if (tr == null || tr.nrows <= 0) {
return false;
}
return row < 0;
}
public void beforeFirst() throws SQLException {
if (tr == null) {
return;
}
row = -1;
}
public boolean first() throws SQLException {
if (tr == null || tr.nrows <= 0) {
return false;
}
row = 0;
return true;
}
public boolean isAfterLast() throws SQLException {
if (tr == null || tr.nrows <= 0) {
return false;
}
return row >= tr.nrows;
}
public void afterLast() throws SQLException {
if (tr == null) {
return;
}
row = tr.nrows;
}
public boolean isLast() throws SQLException {
if (tr == null) {
return true;
}
return row == tr.nrows - 1;
}
public boolean last() throws SQLException {
if (tr == null || tr.nrows <= 0) {
return false;
}
row = tr.nrows -1;
return true;
}
public int getType() throws SQLException {
return TYPE_SCROLL_INSENSITIVE;
}
public int getConcurrency() throws SQLException {
return CONCUR_READ_ONLY;
}
public boolean rowUpdated() throws SQLException {
throw new SQLException("not supported");
}
public boolean rowInserted() throws SQLException {
throw new SQLException("not supported");
}
public boolean rowDeleted() throws SQLException {
throw new SQLException("not supported");
}
public void insertRow() throws SQLException {
throw new SQLException("not supported");
}
public void updateRow() throws SQLException {
throw new SQLException("not supported");
}
public void deleteRow() throws SQLException {
throw new SQLException("not supported");
}
public void refreshRow() throws SQLException {
throw new SQLException("not supported");
}
public void cancelRowUpdates() throws SQLException {
throw new SQLException("not supported");
}
public void moveToInsertRow() throws SQLException {
throw new SQLException("not supported");
}
public void moveToCurrentRow() throws SQLException {
throw new SQLException("not supported");
}
public void updateNull(int colIndex) throws SQLException {
throw new SQLException("not supported");
}
public void updateBoolean(int colIndex, boolean b) throws SQLException {
throw new SQLException("not supported");
}
public void updateByte(int colIndex, byte b) throws SQLException {
throw new SQLException("not supported");
}
public void updateShort(int colIndex, short b) throws SQLException {
throw new SQLException("not supported");
}
public void updateInt(int colIndex, int b) throws SQLException {
throw new SQLException("not supported");
}
public void updateLong(int colIndex, long b) throws SQLException {
throw new SQLException("not supported");
}
public void updateFloat(int colIndex, float f) throws SQLException {
throw new SQLException("not supported");
}
public void updateDouble(int colIndex, double f) throws SQLException {
throw new SQLException("not supported");
}
public void updateBigDecimal(int colIndex, BigDecimal f)
throws SQLException {
throw new SQLException("not supported");
}
public void updateString(int colIndex, String s) throws SQLException {
throw new SQLException("not supported");
}
public void updateBytes(int colIndex, byte[] s) throws SQLException {
throw new SQLException("not supported");
}
public void updateDate(int colIndex, java.sql.Date d) throws SQLException {
throw new SQLException("not supported");
}
public void updateTime(int colIndex, java.sql.Time t) throws SQLException {
throw new SQLException("not supported");
}
public void updateTimestamp(int colIndex, java.sql.Timestamp t)
throws SQLException {
throw new SQLException("not supported");
}
public void updateAsciiStream(int colIndex, java.io.InputStream in, int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateBinaryStream(int colIndex, java.io.InputStream in, int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateCharacterStream(int colIndex, java.io.Reader in, int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateObject(int colIndex, Object obj) throws SQLException {
throw new SQLException("not supported");
}
public void updateObject(int colIndex, Object obj, int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateNull(String colIndex) throws SQLException {
throw new SQLException("not supported");
}
public void updateBoolean(String colIndex, boolean b) throws SQLException {
throw new SQLException("not supported");
}
public void updateByte(String colIndex, byte b) throws SQLException {
throw new SQLException("not supported");
}
public void updateShort(String colIndex, short b) throws SQLException {
throw new SQLException("not supported");
}
public void updateInt(String colIndex, int b) throws SQLException {
throw new SQLException("not supported");
}
public void updateLong(String colIndex, long b) throws SQLException {
throw new SQLException("not supported");
}
public void updateFloat(String colIndex, float f) throws SQLException {
throw new SQLException("not supported");
}
public void updateDouble(String colIndex, double f) throws SQLException {
throw new SQLException("not supported");
}
public void updateBigDecimal(String colIndex, BigDecimal f)
throws SQLException {
throw new SQLException("not supported");
}
public void updateString(String colIndex, String s) throws SQLException {
throw new SQLException("not supported");
}
public void updateBytes(String colIndex, byte[] s) throws SQLException {
throw new SQLException("not supported");
}
public void updateDate(String colIndex, java.sql.Date d)
throws SQLException {
throw new SQLException("not supported");
}
public void updateTime(String colIndex, java.sql.Time t)
throws SQLException {
throw new SQLException("not supported");
}
public void updateTimestamp(String colIndex, java.sql.Timestamp t)
throws SQLException {
throw new SQLException("not supported");
}
public void updateAsciiStream(String colIndex, java.io.InputStream in,
int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateBinaryStream(String colIndex, java.io.InputStream in,
int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateCharacterStream(String colIndex, java.io.Reader in,
int s)
throws SQLException {
throw new SQLException("not supported");
}
public void updateObject(String colIndex, Object obj)
throws SQLException {
throw new SQLException("not supported");
}
public void updateObject(String colIndex, Object obj, int s)
throws SQLException {
throw new SQLException("not supported");
}
public Statement getStatement() throws SQLException {
if (s == null) {
throw new SQLException("stale result set");
}
return s;
}
public void close() throws SQLException {
s = null;
tr = null;
lastg = null;
row = -1;
}
public java.net.URL getURL(int colIndex) throws SQLException {
if (tr == null || colIndex < 1 || colIndex > tr.ncolumns) {
throw new SQLException("column " + colIndex + " not found");
}
String rd[] = (String []) tr.rows.elementAt(row);
lastg = rd[colIndex - 1];
java.net.URL url = null;
if (lastg == null) {
return url;
}
try {
url = new java.net.URL(lastg);
} catch (java.lang.Exception e) {
url = null;
}
return url;
}
public java.net.URL getURL(String colIndex) throws SQLException {
int col = findColumn(colIndex);
return getURL(col);
}
public void updateRef(int colIndex, java.sql.Ref x) throws SQLException {
throw new SQLException("not supported");
}
public void updateRef(String colIndex, java.sql.Ref x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateBlob(int colIndex, java.sql.Blob x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateBlob(String colIndex, java.sql.Blob x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateClob(int colIndex, java.sql.Clob x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateClob(String colIndex, java.sql.Clob x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateArray(int colIndex, java.sql.Array x)
throws SQLException {
throw new SQLException("not supported");
}
public void updateArray(String colIndex, java.sql.Array x)
throws SQLException {
throw new SQLException("not supported");
}
}
|
