Quadcap Embeddable Database

com/quadcap/jdbc/ResultSet.java

Go to the documentation of this file.

package com.quadcap.jdbc;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.InputStream;
import java.io.Reader;

import java.util.Calendar;
import java.util.Vector;

import java.math.BigDecimal;
import java.math.BigInteger;

//#ifndef JDK11
import java.util.Map;

import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Ref;
//#endif

import java.sql.Date;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;

import com.quadcap.util.Debug;

import com.quadcap.sql.Column;
import com.quadcap.sql.Cursor;
import com.quadcap.sql.Database;
import com.quadcap.sql.QedResultSet;
import com.quadcap.sql.Row;
import com.quadcap.sql.SelectExpression;
import com.quadcap.sql.Session;

import com.quadcap.sql.types.*;

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.Log;

import com.quadcap.io.AsciiInputStream;
import com.quadcap.io.AsciiReader;
import com.quadcap.io.InputStreamReader;
import com.quadcap.io.ReaderInputStream;

import com.quadcap.util.ConfigNumber;
import com.quadcap.util.Util;

/**
 * This class implements the <code>java.sql.ResultSet</code> interface,
 * and provides facilities for accessing the results of a SQL query.
 * QED supports updateable <code>ResultSet</code>s.
 *
 * <p>TODO: update{BC}lob</p>
 *
 * @author Stan Bailes
 */
public class ResultSet implements QedResultSet {
    /*{com.quadcap.qed.Trace-vars.xml-1056}
     * <config-var>
     *   <config-name>qed.trace.ResultSet</config-name>
     *   <config-dflt>0</config-dflt>
     *   <config-desc>
     *   <pre>
     *     bit 0: API execution
     *     bit 1: findColumn
     *     bit 2: rows
     *     bit 3: row + column -> object
     *     bit 5: updateObject(row, col, obj)
     *    </pre>
     *    </config-desc>
     * </config-var>
     */
    //#ifdef DEBUG
    static final ConfigNumber   trace =
    ConfigNumber.find("qed.trace.ResultSet", "0");
    //#endif

    Statement                           stmt;
    Cursor                              cursor;
    Row                                 row;
    int                                 rowNum          = 0;
    boolean                             onInsertRow     = false;
    boolean                             onUpdateRow     = false;
    boolean                             bf              = false;
    boolean                             rowUpdated      = false;
    boolean                             rowDeleted      = false;

    Row                                 insertRow       = null;
    boolean                             wasNull         = false;
    Object                              lock            = new Object();
    int                                 rowCount        = 0;

    
    /**
     * Constructor that wraps a cursor.  Used internally to QED.
     * @deprecated
     * @param cursor a cursor
     */
    public ResultSet(Cursor cursor) {
        this.cursor = cursor;
    }

    /**
     * My database session/connection
     */
    final private Session getSession() {
        return cursor.getSession();
    }

    /**
     * I have been granted access to The File itself.  I am most humble.
     */
    final private BlockFile getBlockFile() {
        return getSession().getFile();
    }

    /**
     * My "handle" for this op.
     */
    final private long getTransactionId() throws IOException, SQLException {
        return getSession().getTransactionId();
    }

    /**
     * Return the current cursor row.
     */
    final Row getCursorRow() throws SQLException {
        if (onInsertRow) {
            if (insertRow == null) {
                insertRow = new Row(cursor.getColumnCount());
                for (int i = 1; i <= insertRow.size(); i++) {
                    insertRow.set(i, ValueNull.valueNull);
                }
            }
            return insertRow;
        } else if (onUpdateRow) {
            if (insertRow == null) {
                insertRow = new Row(cursor.getColumnCount());
                for (int i = 1; i < insertRow.size(); i++) {
                    insertRow.set(i, row.item(i));
                }
            }
            return insertRow;
        } else {
            if (row == null) {
                row = cursor.getRow();
                //#ifdef DEBUG
                if (trace.bit(2)) {
                    Debug.println("cursor.getRow: " + row);
                }
                //#endif
            }
            return row;
        }
    }

    /**
     * Return the value in the specified column.
     */
    Value getValue(int col) throws SQLException {
        Value v = null;
        Row r = getCursorRow();
        if (r != null) {
            v = r.item(col);
            if (v != null) {
                wasNull = Value.isNull(v);
            } else {
                throw new SQLException("Can't return column " + col);
            }
        } else {
            throw new SQLException("ResultSet isn't positioned on a valid row");
        }
        return v;
    }

    /**
     * Convert the value in the specified column to the given type.
     */
    final Value getValue(int col, Type type) throws SQLException {
        return type.convert(getValue(col));
    }

    /**
     * Return the value in the specified column as a Java "Object"
     * after performing the indicated type conversion.
     */
    public Object getObject(int col, Type type) throws SQLException {
        Value v = getValue(col, type);
        //#ifdef DEBUG
        if (trace.bit(3)) {
            Debug.println("get(" + col + ", " + type.getTypeName() +
                          ") = " + v);
        }
        //#endif
        return v.asJavaObject();
    }

    //------------------------------------------------------------------
    // java.sql.ResultSet implementation
    //------------------------------------------------------------------

    /**
     * Position the resultset to the specified row.  If positive, the
     * row number indicates an offset from the beginning of the 
     * <code>ResultSet</code> (row 1 is the first row).  If negative,
     * the row number indicates an offset from the end of the
     * <code>ResultSet</code> (row -1 is the last row).
     * <p>
     * In general, this release of QED supports absolute positioning 
     * to the first row of the <code>ResultSet</code> only.
     *
     * @param row the row number
     * @return true if we're positioned on a valid row, false if we're
     *  before the first row or after the last row.
     * @exception SQLException if row is zero.
     */
    public boolean absolute(int x) throws SQLException {
        checkScrollable();
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.absolute(" + x + ")");
            //Debug.println("cursor: " + cursor.getClass() + ": " + cursor);
        }
        //#endif
        if (x == 0) {
            throw new SQLException("ResultSet.absolute(0), bad parameter");
        }
        rowNum = x;
        resetRow();
        bf = false;
        return cursor.absolute(rowNum);
    }

    private final void resetRow() {
        onInsertRow = false;
        onUpdateRow = false;
        row = null;
        rowUpdated = false;
        rowDeleted = false;
    }
        

    /**
     * Position the cursor to the end of the <code>ResultSet</code>,
     * after the last row.  Our underlying cursor doesn't support this
     * operation, so we use 'absolute()' to get to the end, then 'next()'
     * to move past the end.
     *
     * @exception SQLException may be thrown.
     */
    public void afterLast() throws SQLException {
        checkScrollable();
        cursor.afterLast();
        resetRow();
        bf = false;
    }
    
    /**
     * Position the cursor to the beginning of the <code>ResultSet</code>,
     * before the first row.
     *
     * @exception SQLException may be thrown.
     */
    public void beforeFirst() throws SQLException { 
        checkScrollable();
        cursor.beforeFirst();
        resetRow();
        bf = true;
    }
    
    /**
     * This function rolls back row updates, as long as
     * <code>updateRow()</code> hasn't been called yet.  
     *
     * @exception SQLException may be thrown
     */
    public void cancelRowUpdates() throws SQLException {
        if (onInsertRow) {
            throw new SQLException("ResultSet.cancelRowUpdates() called " +
                                   "while on insert row");
        }
        resetRow();
    }

    /**
     * Clears all warnings that have been reported on this
     * <code>ResultSet</code> object.
     * QED doesn't currently throw any SQLWarnings,
     * so this operation does nothing.
     */
    public void clearWarnings() throws SQLException {
    }

    /**
     * We will clean up the user's mess for him.
     */
    public void finalize() throws Throwable {
        try {
            if (cursor != null) close();
        } catch (Throwable t) {}
        super.finalize();
    }
    
    /**
     * Close this <code>ResultSet</code> object.  If this is an
     * updatable <code>ResultSet</code>, and the connection that this
     * <code>ResultSet</code> was created from is in <code>autoCommit</code>
     * mode, the transaction is committed at this time.
     *
     * @exception SQLException may be thrown
     */
    public void close() throws SQLException {
        if (cursor == null) return;
        
        Session s = cursor.getSession();

        synchronized (lock) {
            cursor = null;
            if (s != null) {
                try {
                    s.endStatement(false);
                } catch (IOException e) {
                    throw new SQLException(e.toString());
                }
            }
        }
    }

    /**
     * Delete the current row from the <code>ResultSet</code> and the
     * underlying database.
     *
     * @exception SQLException may be thrown
     */
    public void deleteRow() throws SQLException {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.deleteRow()");
        }
        //#endif
        checkUpdatable();
        if (onInsertRow) {
            throw new SQLException(
                "ResultSet.deleteRow(): Can't delete while on insert row");
        }
        cursor.deleteRow();
        rowDeleted = true;
    }

    /**
     * Return the column number of the specified column. 
     *
     * @param column the name of the column
     * @return the number of the column in the resultset.
     */
    public int findColumn(String column) throws SQLException {
        Column col = cursor.getColumn(column.toUpperCase());
        if (col == null) {
            //#ifdef DEBUG
            SelectExpression.showCursor(cursor, true);
            //#endif
            throw new SQLException("Bad column name: " + column,
                                   "42000");
        }
        int coln = col.getColumn();
        //#ifdef DEBUG
        if (trace.bit(1)) {
            Debug.println("ResultSet.findColumn(" + column + ") = " + coln);
        }
        //#endif
        return coln;
    }
    
    /**
     * Position the cursor on the first row of the <code>ResultSet</code>.
     * Return true if the <code>ResultSet</code> has at least one row.
     *
     *
     * @exception SQLException may be thrown
     */
    public boolean first() throws SQLException {
        return absolute(1);
    }
    
    /**
     * Return an <code>InputStream</code> object that can be used to read
     * the specified character value as a stream of ASCII bytes.
     *
     * @param col the column number
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public InputStream getAsciiStream(int col) throws SQLException {
        Value v = getValue(col);
        if (Value.isNull(v)) return null;
        return new AsciiInputStream(getCharacterStream(col));
    }
    
    /**
     * Return an <code>InputStream</code> object that can be used to read
     * the specified character value as a stream of ASCII bytes.
     *
     * @param column the column name
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public InputStream getAsciiStream(String column) throws SQLException {
        return getAsciiStream(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>BigDecimal</code> object.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public BigDecimal getBigDecimal(int col) throws SQLException {
        try {
            ValueScaledInteger v =
                (ValueScaledInteger)getValue(col, TypeDecimal.typeDecimal);
            if (v != null) return v.bigDecimalValue();
        } catch (ClassCastException e) {
            if (wasNull) return null;
        }
        throw new SQLException("Can't return column " + col +
                               " as BigDecimal", "22003");
    }

    /**
     * @deprecated
     */
    public BigDecimal getBigDecimal(int col, int scale) throws SQLException {
        BigDecimal big = getBigDecimal(col);
        return big.setScale(scale);
    }
    
    /**
     * Retrieve the specified column as a <code>BigDecimal</code> object.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public BigDecimal getBigDecimal(String column) throws SQLException {
        return getBigDecimal(findColumn(column));
    }

    /**
     * @deprecated
     */
    public BigDecimal getBigDecimal(String column, int scale)
        throws SQLException
    {
        return getBigDecimal(findColumn(column), scale);
    }
    
    /**
     * Return an <code>InputStream</code> object that can be used to read
     * the specified column value as a stream of bytes.
     *
     * @param col the column number
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public InputStream getBinaryStream(int col) throws SQLException {
        try {
            Value v = getValue(col);
            if (Value.isNull(v)) return null;
            int type = v.getType().getJDBCType();
            switch (type) {
            case Types.CHAR:
            case Types.VARCHAR:
                return ((ValueString)v).getBinaryStream();
            case Types.BINARY:
            case Types.VARBINARY:
                return ((ValueOctets)v).getBinaryStream();
//-//#ifdef JDK11
//-         case Type.BLOB:
//#else
            case Types.BLOB:
//#endif
                return ((ValueBlob)v).getBinaryStream();
//-//#ifdef JDK11
//-         case Type.CLOB:
//#else
            case Types.CLOB:
//#endif
                return ((ValueClob)v).getBinaryStream();
            default:
                throw new ValueException("Can't convert: " + type +
                                         " to binary stream");
            }
        } catch (ValueException e) {
            throw new SQLException("Can't return column " + col +
                                   " as Binary Stream", "22003");
        }
    }
    
    /**
     * Return an <code>InputStream</code> object that can be used to read
     * the specified column value as a stream of bytes.
     *
     * @param column the column name
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public InputStream getBinaryStream(String column) throws SQLException {
        return getBinaryStream(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>boolean</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public boolean getBoolean(int col) throws SQLException {
        Object obj = getObject(col);
        if (obj == null) return false;
        if (obj instanceof Boolean) {
            return ((Boolean)obj).booleanValue();
        }
        Number num = asNumber(obj);
        if (num != null) {
            return num.doubleValue() != 0;
        }
        return obj.toString().toLowerCase().equals("true");
    }
    
    /**
     * Retrieve the specified column as a <code>boolean</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public boolean getBoolean(String column) throws SQLException {
        return getBoolean(findColumn(column));
    }

    /**
     * Are you a number?
     *
     * Any sort of number?
     *
     * Even some fancy schmancy number?
     *
     * Are you?
     *
     * Or not.
     */
    final Number asNumber(Object obj) {
        if (obj instanceof Number) return (Number)obj;
        if (obj instanceof String) {
            try {
                return new Long(obj.toString());
            } catch (NumberFormatException e) {
            }
        }
        if (obj instanceof byte[]) {
            return new BigDecimal(new BigInteger((byte[])obj));
        }
        if (obj instanceof Boolean) {
            int val = ((Boolean)obj).booleanValue() ? 1 : 0;
            return new Integer(val);
        }
        return null;
    }
    
    /**
     * Retrieve the specified column as a <code>byte</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public byte getByte(int col) throws SQLException {
        try {
            ValueByte v = (ValueByte)getValue(col, TypeTinyInt.typeTinyInt);
            if (v != null) return v.byteValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as byte", "22003");
    }
    
    /**
     * Retrieve the specified column as a <code>byte</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public byte getByte(String column) throws SQLException {
        return getByte(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as an array of <code>byte</code>s.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public byte[] getBytes(int col) throws SQLException {
        try {
            Value v1 = getValue(col, TypeVarBinary.typeVarBinary);
            if (wasNull) return null;
            ValueOctets v = (ValueOctets)v1;
            return v.getBytes();
        } catch (Exception e) {
            throw new SQLException("Can't return column " + col +
                                   " as bytes", "22003");
        }
    }
    
    /**
     * Retrieve the specified column as an array of <code>byte</code>s.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public byte[] getBytes(String column) throws SQLException {
        return getBytes(findColumn(column));
    }
    
    /**
     * Return a <code>Reader</code> object that can be used to read
     * the specified column value as a stream of characters.
     *
     * @param col the column number
     * @return a <code>Reader</code>
     * @exception SQLException may be thrown
     */
    public Reader getCharacterStream(int col) throws SQLException {
        try {
            Value v = getValue(col);
            if (Value.isNull(v)) return null;
            int type = v.getType().getJDBCType();
            switch (type) {
            case Types.CHAR:
            case Types.VARCHAR:
                return ((ValueString)v).getCharacterStream();
            case Types.BINARY:
            case Types.VARBINARY:
                return new ByteReader(((ValueOctets)v).getBinaryStream());
            case Types.BLOB:
                return new ByteReader(((ValueBlob)v).getBinaryStream());
            case Types.CLOB:
                return ((ValueClob)v).getCharacterStream();
            default:
                throw new ValueException("Can't convert: " + type +
                                         " to character stream");
            }
        } catch (ValueException e) {
            throw new SQLException("Can't return column " + col +
                                   " as character stream", "22003");
        }
        
    }
    
    /**
     * Return a <code>Reader</code> object that can be used to read
     * the specified column value as a stream of characters.
     *
     * @param column the column name
     * @return a <code>Reader</code>
     * @exception SQLException may be thrown
     */
    public Reader getCharacterStream(String column) throws SQLException {
        return getCharacterStream(findColumn(column));
    }
    
    /**
     * QED doesn't support named cursors, so this method throws a
     * SQLException "not implemented"
     *
     * @return never
     * @exception SQLException not implemented
     */
    public String getCursorName() throws SQLException {
        throw new SQLException("named cursors not supported", "0A000");
    }
    
    /**
     * Retrieve the specified column as a <code>Date</code> object.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Date getDate(int col) throws SQLException {
        Date d = null;
        Value v = getValue(col);
        if (!Value.isNull(v)) {
            try {
                ValueDate vd = (ValueDate)v.convert(TypeDate.typeDate);
                d = new Date(vd.getTime());
            } catch (Exception e) {
                throw new SQLException("Can't convert column " + col +
                                       " to date", "22003");
            }
        }
        return d;
    }
    
    /**
     * Retrieve the specified column as a <code>Date</code> object.
     *
     * @param col the column number
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database date to the local timezone.  The database date is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Date getDate(int col, Calendar c) throws SQLException {
        Date d = getDate(col);
        if (d != null) {
            long t = d.getTime();
            c.setTime(d);
            t += (c.get(Calendar.ZONE_OFFSET) + c.get(Calendar.DST_OFFSET));
            d = new Date(t);
        }
        return d;
    }
    
    /**
     * Retrieve the specified column as a <code>Date</code> object.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Date getDate(String column) throws SQLException {
        return getDate(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>Date</code> object.
     *
     * @param column the column name
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database date to the local timezone.  The database date is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Date getDate(String column, Calendar c) throws SQLException {
        return getDate(findColumn(column), c);
    }
    
    /**
     * Retrieve the specified column as a <code>double</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public double getDouble(int col) throws SQLException {
        try {
            ValueDouble v = (ValueDouble)getValue(col, TypeReal.typeDouble);
            if (v != null) return v.doubleValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as double", "22003");
    }
    
    /**
     * Retrieve the specified column as a <code>double</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public double getDouble(String column) throws SQLException {
        return getDouble(findColumn(column));
    }
    
    /**
     * QED, being an embedded driver, fetches rows only when they are
     * needed, with no performance penalty.  Thus, the fetch size is
     * always <code>one</code>.
     *
     * @return one.
     */
    public int getFetchSize() {
        return 1;
    }
    
    /**
     * Retrieve the specified column as a <code>float</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public float getFloat(int col) throws SQLException {
        try {
            ValueFloat v = (ValueFloat)getValue(col, TypeReal.typeFloat);
            if (v != null) return v.floatValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as float", "22003");
    }
    
    /**
     * Retrieve the specified column as a <code>float</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public float getFloat(String column) throws SQLException {
        return getFloat(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as an <code>int</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public int getInt(int col) throws SQLException {
        try {
            ValueInteger v = (ValueInteger)getValue(col, TypeInt.typeInt);
            if (v != null) return v.intValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as int", "22003");
    }
    
    /**
     * Retrieve the specified column as an <code>int</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public int getInt(String column) throws SQLException {
        return getInt(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>long</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public long getLong(int col) throws SQLException {
        try {
            ValueLong v = (ValueLong)getValue(col, TypeBigInt.typeBigInt);
            if (v != null) return v.longValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as long", "22003");
    }
    
    /**
     * Retrieve the specified column as a <code>long</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public long getLong(String column) throws SQLException {
        return getLong(findColumn(column));
    }
    
    /**
     * Return a <code>ResultSetMetaData</code> object that can be used
     * to obtain information about the columns of this 
     * <code>ResultSet</code>.
     *
     * @return a <code>ResultSetMetaData</code> object that describes
     *  the columns of this <code>ResultSet</code>.
     * @exception SQLException may be thrown
     */
    public java.sql.ResultSetMetaData getMetaData() throws SQLException {
        return new ResultSetMetaData(cursor);
    }

    /**
     * Retrieve the specified column as a Java <code>Object</code>. 
     * The type of the object is based on the underlying SQL datatype,
     * using the conversions as specified by JDBC.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Object getObject(int col) throws SQLException {
        try {
            Value v = getValue(col);
            //#ifdef DEBUG
            if (trace.bit(3)) {
                Debug.println("get(" + col + ") = " + v);
            }
            //#endif
            return v.asJavaObject();
        } catch (SQLException e) {
            throw e;
        } catch (Exception ex) {
            Debug.print(ex);
            throw new SQLException("Invalid column index: " + col, "22003");
        }
    }

    /**
     * Retrieve the specified column as a Java <code>Object</code>. 
     * The type of the object is based on the underlying SQL datatype,
     * using the conversions as specified by JDBC.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Object getObject(String column) throws SQLException {
        return getObject(findColumn(column));
    }

    /**
     * Return the row number of the current row in the
     * <code>ResultSet</code>.
     */
    public int getRow() throws SQLException {
        if (rowNum < 0) {
            int siz = (int)cursor.size();
            if (siz >= 0) {
                rowNum = siz + 1 + rowNum;
            } else {
                throw new SQLException(
                    "Sorry, but the underlying cursor (" +
                    cursor + ") doesn't supply row number information");
            }
        }
        return rowNum;
    }
    
    /**
     * Retrieve the specified column as a <code>short</code>.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public short getShort(int col) throws SQLException {
        try {
            ValueShort v =
                (ValueShort)getValue(col, TypeSmallInt.typeSmallInt);
            if (v != null) return v.shortValue();
        } catch (ClassCastException e) {
            if (wasNull) return 0;
        }
        throw new SQLException("Can't return column " + col +
                               " as short", "22003");
    }
        
    /**
     * Retrieve the specified column as a <code>short</code>.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public short getShort(String column) throws SQLException {
        return getShort(findColumn(column));
    }
   
    /**
     * Attach this result set to its parent statement.
     */
    public void setStatement(java.sql.Statement stmt) {
        this.stmt = (Statement)stmt;
        this.resultSetType = this.stmt.resultSetType;
        this.resultSetConcurrency = this.stmt.resultSetConcurrency;
    }
    
    /**
     * Return the <code>Statement</code> object that generated this
     * <code>ResultSet</code>.
     *
     * @return the <code>Statement</code> object that generated this
     *     <code>ResultSet</code>
     */
    public java.sql.Statement getStatement() {
        return stmt;
    }
    
    /**
     * Retrieve the specified column as a <code>String</code> object.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public String getString(int col) throws SQLException {
        Object obj = getObject(col, TypeVarChar.typeVarChar);
        if (obj == null) return null;
        return obj.toString();
    }
    
    /**
     * Retrieve the specified column as a <code>String</code> object.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public String getString(String column) throws SQLException {
        return getString(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>Time</code> object.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Time getTime(int col) throws SQLException {
        Time t = null;
        Value v = getValue(col);
        if (!Value.isNull(v)) {
            try {
                ValueTime vt = (ValueTime)v.convert(TypeTime.typeTime);
                t = new Time(vt.getTime());
            } catch (Exception e) {
                throw new SQLException("Can't convert column " + col +
                                       " to time", "22003");
            }
        }
        return t;
    }
    
    /**
     * Retrieve the specified column as a <code>Time</code> object.
     *
     * @param col the column number
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database time to the local timezone.  The database time is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Time getTime(int col, Calendar c) throws SQLException {
        Time d = getTime(col);
        if (d != null) {
            long t = d.getTime();
            c.setTime(d);
            t += (c.get(Calendar.ZONE_OFFSET) + c.get(Calendar.DST_OFFSET));
            d = new Time(t);
        }
        return d;
    }
    
    /**
     * Retrieve the specified column as a <code>Time</code> object.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Time getTime(String column) throws SQLException {
        return getTime(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>Time</code> object.
     *
     * @param column the column name
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database time to the local timezone.  The database time is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Time getTime(String column, Calendar c) throws SQLException {
        return getTime(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>Timestamp</code> object.
     *
     * @param col the column number
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Timestamp getTimestamp(int col) throws SQLException {
        Timestamp t = null;
        Value v = getValue(col, TypeTimestamp.typeTimestamp);
        if (!wasNull) {
            try {
                ValueTimestamp vt = (ValueTimestamp)v;
                t = new Timestamp(vt.getTime());
            } catch (ClassCastException e) {
                throw new SQLException("Can't convert column " + col +
                                       " to timestamp", "22003");
            }
        }
        return t;
    }

    /**
     * Retrieve the specified column as a <code>Timestamp</code> object.
     *
     * @param col the column number
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database time to the local timezone.  The database time is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Timestamp getTimestamp(int col, Calendar c) throws SQLException {
        Timestamp d = getTimestamp(col);
        if (d != null) {
            long t = d.getTime();
            c.setTime(d);
            t += (c.get(Calendar.ZONE_OFFSET) + c.get(Calendar.DST_OFFSET));
            Timestamp r = new Timestamp(t);
            r.setNanos(d.getNanos());
            d = r;
        }
        return d;
    }
    
    /**
     * Retrieve the specified column as a <code>Timestamp</code> object.
     *
     * @param column the column name
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Timestamp getTimestamp(String column) throws SQLException {
        return getTimestamp(findColumn(column));
    }
    
    /**
     * Retrieve the specified column as a <code>Timestamp</code> object.
     *
     * @param column the column name
     * @param c a <code>Calendar<code> object that is used for converting
     *  the database time to the local timezone.  The database time is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @return the column's value in the current row
     * @exception SQLException may be thrown
     */
    public Timestamp getTimestamp(String column, Calendar c)
        throws SQLException
    {
        return getTimestamp(findColumn(column), c);
    }
    
    /**
     * @deprecated
     */
    public InputStream getUnicodeStream(int col) throws SQLException {
        return getBinaryStream(col);
    }

    /**
     * @deprecated
     */
    public InputStream getUnicodeStream(String column) throws SQLException {
        return getBinaryStream(column);
    }
    
    /**
     * QED doesn't implement any <code>SQLWarning</code>s, so this
     * function always returns <code>null</code>
     *
     * @return null
     */
    public SQLWarning getWarnings() {
        return null;
    }
    
    /**
     * If this <code>ResultSet</code> is currently positioned on the
     * insert row, then insert the current row into the database.
     *
     * @exception SQLException may be thrown if we're not currently
     *   on the insert row, or if there is an error reported from the
     *   database for the insert operation
     */
    public void insertRow() throws SQLException {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.insertRow()");
        }
        //#endif
        checkUpdatable();
        if (onInsertRow && insertRow != null) {
            cursor.insertRow(insertRow);
            rowUpdated = true;
        } else {
            throw new SQLException("Can't insert -- no insert row");
        }
    }
    
    /**
     * Update the current row (based on previous calls to the
     * <code>updateXXX</code> methods) in the database.
     *
     * @exception SQLException may be thrown if we're currently
     *   on the insert row, or if there is an error reported from the
     *   database for the update operation
     */
    public void updateRow() throws SQLException {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.updateRow()");
        }
        //#endif
        checkUpdatable();
        if (onInsertRow) {
            throw new SQLException(
                "updateRow(): Can't update while on insert row");
        }
        Row rowX = onUpdateRow ? insertRow : row;
        if (rowX != null) {
            cursor.getSession().clearViewCheck();
            cursor.updateRow(rowX);
            rowUpdated = true;
        }
    }
    
    /**
     * Return <b>true</b> if this cursor is positioned after the
     * last row.
     *
     * @exception SQLException may be thrown
     */
    public boolean isAfterLast() throws SQLException {
        checkScrollable();
        return !onInsertRow && rowNum == 0 && !bf;
    }
    
    /**
     * Return <b>true</b> if this cursor is positioned before the
     * first row.
     *
     * @exception SQLException may be thrown
     */
    public boolean isBeforeFirst() throws SQLException {
        checkScrollable();
        return !onInsertRow && rowNum == 0 && bf;
    }
    
    /**
     * Return <b>true</b> if this cursor is positioned on the
     * first row.
     *
     * @exception SQLException may be thrown
     */
    public boolean isFirst() throws SQLException {
        checkScrollable();
        return !onInsertRow && rowNum == 1;
    }
    
    /**
     * Return <b>true</b> if this cursor is positioned on the
     * last row.
     *
     * @exception SQLException may be thrown
     */
    public boolean isLast() throws SQLException {
        checkScrollable();
        if (!onInsertRow) {
            if (rowNum > 0) {
                int siz = (int)cursor.size();
                if (siz > 0) {
                    return rowNum == siz;
                }
            } else if (rowNum < 0) {
                return rowNum == -1;
            }
            if (!next()) {
                return true;
            } else {
                previous();
            }
        }
        return false;
    }

    /**
     * Move to the last row of the <code>ResultSet</code>.
     *
     * @return true if we manage to successfully position the 
     *   <code>ResultSet</code> on the last row
     * @exception SQLException is likely to be thrown ;-)
     */
    public boolean last() throws SQLException {
        return absolute(-1);
    }
    
    /**
     * If the cursor is on the insert row, move it back to the previous
     * position in the <code>ResultSet</code>.  If the cursor is not
     * on the insert row, this function has no effect.
     */
    public void moveToCurrentRow() {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.moveToCurrentRow()");
        }
        //#endif
        onInsertRow = false;
    }
    
    /**
     * Move the cursor to the insert row.
     */
    public void moveToInsertRow() {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("ResultSet.moveToInsertRow()");
        }
        //#endif
        insertRow = null;
        onInsertRow = true;
    }
    
    /**
     * Advance the cursor to the next row in the <code>ResultSet</code>.
     * 
     * @return true if the cursor is positioned on a valid row, false
     *   if the cursor has passed the end of the <code>ResultSet</code>.
     *
     * @exception SQLException may be thrown
     */
    public boolean next() throws