1 files changed, 932 insertions, 0 deletions
diff --git a/sqlite-jdbc/src/main/java/SQLite/JDBC2y/JDBCResultSet.java b/sqlite-jdbc/src/main/java/SQLite/JDBC2y/JDBCResultSet.java
new file mode 100644
index 0000000..06384eb
--- /dev/null
+++ b/sqlite-jdbc/src/main/java/SQLite/JDBC2y/JDBCResultSet.java
@@ -0,0 +1,932 @@
+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");
+    }
+
+}