src/org/objectweb/cjdbc/driver/DriverResultSet.java

説明を見る。

package org.objectweb.cjdbc.driver;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Hashtable;

import org.objectweb.cjdbc.common.sql.NotImplementedException;

public class DriverResultSet
    implements
      java.sql.ResultSet,
      java.io.Serializable,
      java.lang.Cloneable
{
  protected int                 currentRow            = -1;
  protected int                 nbOfRows              = -1;
  protected int                 nbOfColumns           = -1;
  protected ArrayList           data;
  private boolean               hasMoreData;
  protected int                 fetchDirection        = FETCH_FORWARD;
  protected int                 fetchSize             = 0;
  private String                cursorName;

  protected Field[]             fields;
  protected boolean             wasNullFlag           = false;
  protected transient Hashtable columnNameToIndex     = null;
  protected transient Hashtable fullColumnNameToIndex = null;

  protected int                 resultSetType         = 0;
  protected int                 resultSetConcurrency  = 0;
  protected SQLWarning          warnings              = null;
  protected transient Statement owningStatement;

  private boolean               isClosed              = true;

  private static final String   UPDATEABLE_MESSAGE    = "ResultSet not updateable. The "
                                                          + "query that generated this result set must select only one table, and must "
                                                          + "select all primary keys from that table. See the JDBC 2.1 API Specification, "
                                                          + "section 5.6 for more details.";

  //---------------------------------------------------------------------
  // Traversal/Positioning
  //---------------------------------------------------------------------

  public boolean next() throws java.sql.SQLException
  {
    checkIfClosed();

    if (nbOfRows == 0)
      return false;
    else
    {
      if (currentRow + 1 >= nbOfRows)
      {
        if (hasMoreData)
        {
          owningStatement.connection.fetchNextData(cursorName, fetchSize, this);
          currentRow = 0;
          if (data == null)
          {
            nbOfRows = 0;
            return false;
          }
          else
          {
            nbOfRows = data.size();
            return true;
          }
        }
        // force scroll past end
        currentRow = nbOfRows;
        return false;
      }
      else
      {
        clearWarnings();
        currentRow++;
        return true;
      }
    }
  }

  public boolean prev() throws SQLException
  {
    checkIfClosed();
    if (currentRow - 1 >= 0)
    {
      currentRow--;
      return true;
    }
    else
      return false;
  }

  public boolean isBeforeFirst() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;
    else
      return (currentRow == -1);
  }

  public boolean isAfterLast() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;
    else
      return (currentRow >= nbOfRows);
  }

  public boolean isFirst() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;
    else
      return (currentRow == 0);
  }

  public boolean isLast() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;
    else
      return (currentRow == nbOfRows - 1);
  }

  public void beforeFirst() throws SQLException
  {
    checkIfClosed();
    currentRow = -1;
  }

  public void afterLast() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows != 0)
      currentRow = nbOfRows;
  }

  public boolean first() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;

    currentRow = 0;
    return true;
  }

  public boolean last() throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;

    currentRow = nbOfRows - 1;
    return true;
  }

  public int getRow() throws SQLException
  {
    checkIfClosed();
    if (currentRow < 0 || currentRow >= nbOfRows || nbOfRows == 0)
      return 0;
    else
      return currentRow + 1;
  }

  public boolean absolute(int row) throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;
    else
    {
      if (row == 0)
        throw new SQLException("Cannot absolute position to row 0");

      if (row == 1)
        return first();
      else if (row == -1)
        return last();
      else if (row > nbOfRows)
      {
        afterLast();
        return false;
      }
      else
      {
        if (row < 0)
        { // adjust to reflect after end of result set
          int newRowPosition = nbOfRows + row + 1;

          if (newRowPosition <= 0)
          {
            beforeFirst();
            return false;
          }
          else
            return absolute(newRowPosition);
        }
        else
        {
          row--; // adjust for index difference
          currentRow = row;
          return true;
        }
      }
    }
  }

  public boolean relative(int rows) throws SQLException
  {
    checkIfClosed();
    if (nbOfRows == 0)
      return false;

    return absolute(currentRow + rows + 1);
  }

  public boolean previous() throws SQLException
  {
    return prev();
  }

  public void setFetchDirection(int direction) throws SQLException
  {
    if (direction != FETCH_FORWARD && direction != FETCH_REVERSE)
      throw new SQLException("Illegal value for fetch direction");
    else
      fetchDirection = direction;
  }

  public int getFetchDirection() throws SQLException
  {
    return fetchDirection;
  }

  public void setFetchSize(int rows) throws SQLException
  {
    if (rows < 0 || rows > nbOfRows)
      throw new SQLException("Value must be between 0 and getMaxRows()");
    fetchSize = rows;
  }

  public int getFetchSize() throws SQLException
  {
    return fetchSize;
  }

  //
  //---------------------------------------------------------------------
  // Getter's and Setter's
  //---------------------------------------------------------------------
  //

  public String getString(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;

    return (((Object[]) data.get(currentRow))[columnIndex - 1]).toString();
  }

  public boolean getBoolean(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return false;
    else
    {
      Object object = (((Object[]) data.get(currentRow))[columnIndex - 1]);
      String stringVal = object.toString();

      if ((stringVal != null) && (stringVal.length() > 0))
      {
        stringVal = stringVal.toLowerCase();

        // first we check the connection values to be consistent
        if (owningStatement.connection.getPreparedStatementBooleanTrue()
            .equals(stringVal))
        {
          return true;
        }
        else if (owningStatement.connection.getPreparedStatementBooleanFalse()
            .equals(stringVal))
        {
          return false;
        }

        // now we check some other possible string representations of boolean
        else if ("t".equals(stringVal))
        {
          return true;
        }
        else if ("f".equals(stringVal))
        {
          return false;
        }
        else if ("true".equals(stringVal))
        {
          return true;
        }
        else if ("false".equals(stringVal))
        {
          return false;
        }
        else if ("1".equals(stringVal))
        {
          return true;
        }
        else if ("0".equals(stringVal))
        {
          return false;
        }

        else if ("y".equals(stringVal))
        {
          return true;
        }
        else if ("n".equals(stringVal))
        {
          return false;
        }
        else if ("yes".equals(stringVal))
        {
          return true;
        }
        else if ("no".equals(stringVal))
        {
          return false;
        }

        // we didn't find anything reasonable and throw an exception
        throw new SQLException("column value " + stringVal
            + " could not be converted to boolean");
      }
      else
      {
        return false;
      }
    }
  }

  public short getShort(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof Number)
      {
        return ((Number) obj).shortValue();
      }

      // the object is not of type number we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Short.parseShort(string);
      }
      catch (NumberFormatException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid short number");
      }
    }
  }

  public int getInt(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof Number)
      {
        return ((Number) obj).intValue();
      }

      // the object is not of type number we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Integer.parseInt(string);
      }
      catch (NumberFormatException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid int number");
      }
    }
  }

  public long getLong(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof Number)
      {
        return ((Number) obj).longValue();
      }

      // the object is not of type number we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Long.parseLong(string);
      }
      catch (NumberFormatException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid long number");
      }
    }
  }

  public float getFloat(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof Number)
      {
        return ((Number) obj).floatValue();
      }

      // the object is not of type number we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Float.parseFloat(string);
      }
      catch (NumberFormatException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid float number");
      }
    }
  }

  public double getDouble(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof Number)
      {
        return ((Number) obj).doubleValue();
      }

      // the object is not of type number we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Double.parseDouble(string);
      }
      catch (NumberFormatException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid double number");
      }
    }
  }

  public BigDecimal getBigDecimal(int columnIndex, int scale)
      throws SQLException
  {
    BigDecimal bigDecimal = getBigDecimal(columnIndex);
    if (bigDecimal == null)
      return null;
    else
      return bigDecimal.setScale(scale);
  }

  public byte[] getBytes(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;

    Object o = ((Object[]) data.get(currentRow))[columnIndex - 1];
    byte[] tmp;
    if (o instanceof java.lang.String)
    {
      tmp = ((String) o).getBytes();
    }
    else
    {
      tmp = (byte[]) o;
    }
    //return Blob.rescapeblock(tmp);
    return owningStatement.connection.getBlobFilter().decode(tmp);
  }

  public java.sql.Date getDate(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
    {
      return null;
    }
    else
    {
      // we may be reading a timestamp column and have to convert it to date
      // the client is asking for the date field only, we have to make sure
      // hour,minutes,... are cleared
      String dateString = ((Object[]) data.get(currentRow))[columnIndex - 1]
          .toString();
      if (dateString.length() == 10)
        return java.sql.Date.valueOf(dateString);
      else
      {
        return java.sql.Date.valueOf(dateString.substring(0, 10));
      }
    }
  }

  public Time getTime(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof java.util.Date)
      {
        java.util.Date time = (java.util.Date) obj;
        // the driver returns the format of the column, but we are asking for
        // the
        // time values only.
        String timeString = time.toString();
        if (timeString.length() == 8)
        {
          // ok we have got a timefield of the format HH:mm:ss, exactly the way
          // we
          // need it, no further processing is required
          return new Time(time.getTime());
        }

        // we have got the date fields too and have to clear the year, month and
        // date field
        Calendar cal = Calendar.getInstance();
        cal.setTime(time);
        cal.clear(Calendar.YEAR);
        cal.clear(Calendar.MONTH);
        cal.clear(Calendar.DATE);
        cal.clear(Calendar.MILLISECOND);
        return new Time(cal.getTimeInMillis());
      }
      // the object is not of type date we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Time.valueOf(string);
      }
      catch (IllegalArgumentException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid time");
      }
    }
  }

  public Timestamp getTimestamp(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof java.util.Date)
      {
        return new Timestamp(((java.util.Date) obj).getTime());
      }

      // the object is not of type timestamp we parse the string representation
      try
      {
        String string = obj.toString();
        string = string.trim();
        return Timestamp.valueOf(string);
      }
      catch (IllegalArgumentException e)
      {
        throw new SQLException("the value " + obj.toString()
            + " is not a valid timestamp");
      }
    }
  }

  public InputStream getAsciiStream(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    return getBinaryStream(columnIndex);
  }

  public InputStream getUnicodeStream(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    return getBinaryStream(columnIndex);
  }

  public InputStream getBinaryStream(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    byte b[] = getBytes(columnIndex);
    if (b != null)
      return new ByteArrayInputStream(b);
    else
      return null; // SQL NULL
  }

  public String getString(String columnName) throws SQLException
  {
    return this.getString(findColumn(columnName));
  }

  public boolean getBoolean(String columnName) throws SQLException
  {
    return getBoolean(findColumn(columnName));
  }

  public byte getByte(String columnName) throws SQLException
  {
    return getByte(findColumn(columnName));
  }

  public short getShort(String columnName) throws SQLException
  {
    return getShort(findColumn(columnName));
  }

  public int getInt(String columnName) throws SQLException
  {
    return getInt(findColumn(columnName));
  }

  public long getLong(String columnName) throws SQLException
  {
    return getLong(findColumn(columnName));
  }

  public float getFloat(String columnName) throws SQLException
  {
    return getFloat(findColumn(columnName));
  }

  public double getDouble(String columnName) throws SQLException
  {
    return getDouble(findColumn(columnName));
  }

  public BigDecimal getBigDecimal(String columnName, int scale)
      throws SQLException
  {
    return getBigDecimal(findColumn(columnName), scale);
  }

  public byte[] getBytes(String columnName) throws SQLException
  {
    return getBytes(findColumn(columnName));
  }

  public java.sql.Date getDate(String columnName) throws SQLException
  {
    return getDate(findColumn(columnName));
  }

  public Time getTime(String columnName) throws SQLException
  {
    return getTime(findColumn(columnName));
  }

  public Timestamp getTimestamp(String columnName) throws SQLException
  {
    return getTimestamp(findColumn(columnName));
  }

  public InputStream getAsciiStream(String columnName) throws SQLException
  {
    return getAsciiStream(findColumn(columnName));
  }

  public InputStream getUnicodeStream(String columnName) throws SQLException
  {
    return getUnicodeStream(findColumn(columnName));
  }

  public InputStream getBinaryStream(String columnName) throws SQLException
  {
    return getBinaryStream(findColumn(columnName));
  }

  public java.sql.SQLWarning getWarnings() throws SQLException
  {
    return warnings;
  }

  public void clearWarnings() throws SQLException
  {
    warnings = null;
  }

  public String getCursorName() throws SQLException
  {
    throw new NotImplementedException("getCursorName()");
  }

  public Object getObject(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;
    else
    {
      Object o = ((Object[]) data.get(currentRow))[columnIndex - 1];

      if (o instanceof byte[])
        return owningStatement.connection.getBlobFilter().decode((byte[]) o);
      else
        return o;
    }
  }

  public Object getObject(String columnName) throws SQLException
  {
    return getObject(findColumn(columnName));
  }

  //--------------------------JDBC 2.0-----------------------------------

  public java.io.Reader getCharacterStream(int columnIndex) throws SQLException
  {
    char[] data = getString(columnIndex).toCharArray();
    return new java.io.CharArrayReader(data);
  }

  public java.io.Reader getCharacterStream(String columnName)
      throws SQLException
  {
    return getCharacterStream(findColumn(columnName));
  }

  public BigDecimal getBigDecimal(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;
    else
    {
      Object obj = ((Object[]) data.get(currentRow))[columnIndex - 1];
      if (obj instanceof BigDecimal)
        return (BigDecimal) obj;
      else if (obj instanceof Long)
      {
        return new BigDecimal(((Long) obj).longValue());
      }
      else if (obj instanceof BigInteger)
      {
        return new BigDecimal(((BigInteger) obj));
      }
      else if (obj instanceof Short)
      {
        return new BigDecimal(((Short) obj).shortValue());
      }
      else if (obj instanceof Integer)
      {
        return new BigDecimal(((Integer) obj).intValue());
      }
      else if (obj instanceof String)
      {
        return new BigDecimal((String) obj);
      }
      else if (obj instanceof Number)
      {
        // float and double have to be converted via string
        // othwerwise we produce errors
        // javadoc for BigDecimal :
        // Note: the results of this constructor can be somewhat unpredictable.
        // One might assume that new BigDecimal(.1) is exactly equal to .1, but
        // it is actually equal to
        // .1000000000000000055511151231257827021181583404541015625. This is so
        // because .1 cannot be represented exactly as a double (or, for that
        // matter, as a binary fraction of any finite length). Thus, the long
        // value that is being passed in to the constructor is not exactly equal
        // to .1, appearances nonwithstanding.

        // The (String) constructor, on the other hand, is perfectly
        // predictable: new BigDecimal(".1") is exactly equal to .1, as one
        // would expect. Therefore, it is generally recommended that the
        // (String) constructor be used in preference to this one.
        return new BigDecimal(obj.toString());
      }
      else
      {
        throw new SQLException("Type " + obj.getClass().getName()
            + " is not compatible with BigDecimal");
      }
    }
  }

  public BigDecimal getBigDecimal(String columnName) throws SQLException
  {
    return getBigDecimal(findColumn(columnName));
  }

  public Object getObject(int i, java.util.Map map) throws SQLException
  {
    throw new NotImplementedException("getObject(int, java.util.Map)");
  }

  public java.sql.Ref getRef(int i) throws SQLException
  {
    throw new NotImplementedException("getRef");
  }

  public java.sql.Blob getBlob(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;

    Object o = (((Object[]) data.get(currentRow))[columnIndex - 1]);
    // Test if the type of the Blob is indeed a Blob else we assume these are
    // just bytes.
    if (o instanceof Blob)
      return (java.sql.Blob) o;
    else
      return new Blob(getBytes(columnIndex));
  }

  public java.sql.Clob getClob(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;
    Object o = (((Object[]) data.get(currentRow))[columnIndex - 1]);
    // Test if the type of the Clob is indeed a Clob or just a String
    //throw new SQLException("Class:"+o.getClass());
    if (o instanceof String)
      return new Clob((String) o);
    else if (o instanceof Clob)
      return (java.sql.Clob) o;
    else
      return new Clob(new String(o.toString()));
  }

  public java.sql.Array getArray(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return null;

    return (java.sql.Array) (((Object[]) data.get(currentRow))[columnIndex - 1]);
  }

  public Object getObject(String colName, java.util.Map map)
      throws SQLException
  {
    throw new NotImplementedException("getObject(String, java.util.Map)");
  }

  public java.sql.Ref getRef(String colName) throws SQLException
  {
    throw new NotImplementedException("getRef(String)");
  }

  public java.sql.Blob getBlob(String colName) throws SQLException
  {
    return getBlob(findColumn(colName));
  }

  public java.sql.Clob getClob(String colName) throws SQLException
  {
    return getClob(findColumn(colName));
  }

  public java.sql.Array getArray(String colName) throws SQLException
  {
    return getArray(findColumn(colName));
  }

  public java.sql.Date getDate(int columnIndex, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getDate(int, Calendar)");
  }

  public java.sql.Date getDate(String columnName, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getDate(String, Calendar)");
  }

  public java.sql.Time getTime(int columnIndex, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getTime(int, Calendar)");
  }

  public java.sql.Time getTime(String columnName, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getTime(String, Calendar)");
  }

  public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getTimestamp(int, Calendar)");
  }

  public java.sql.Timestamp getTimestamp(String columnName, Calendar cal)
      throws SQLException
  {
    throw new NotImplementedException("getTimestamp(String, Calendar)");
  }

  //---------------------------------------------------------------------
  // Updates
  //---------------------------------------------------------------------

  public boolean rowUpdated() throws SQLException
  {
    throw new NotImplementedException("rowUpdated");
  }

  public boolean rowInserted() throws SQLException
  {
    throw new NotImplementedException("rowInserted");
  }

  public boolean rowDeleted() throws SQLException
  {
    throw new NotImplementedException("rowDeleted");
  }

  public void updateNull(int columnIndex) throws SQLException
  {
    throw new NotImplementedException("updateNull");
  }

  public void updateBoolean(int columnIndex, boolean x) throws SQLException
  {
    throw new NotImplementedException("updateBoolean");
  }

  public void updateByte(int columnIndex, byte x) throws SQLException
  {
    throw new NotImplementedException("updateByte");
  }

  public void updateShort(int columnIndex, short x) throws SQLException
  {
    throw new NotImplementedException("updateShort");
  }

  public void updateInt(int columnIndex, int x) throws SQLException
  {
    throw new NotImplementedException("updateInt");
  }

  public void updateLong(int columnIndex, long x) throws SQLException
  {
    throw new NotImplementedException("updateLong");
  }

  public void updateFloat(int columnIndex, float x) throws SQLException
  {
    throw new NotImplementedException("updateFloat");
  }

  public void updateDouble(int columnIndex, double x) throws SQLException
  {
    throw new NotImplementedException("updateDouble");
  }

  public void updateBigDecimal(int columnIndex, BigDecimal x)
      throws SQLException
  {
    throw new NotImplementedException("updateBigDecimal");
  }

  public void updateString(int columnIndex, String x) throws SQLException
  {
    throw new NotImplementedException("updateString");
  }

  public void updateBytes(int columnIndex, byte x[]) throws SQLException
  {
    throw new NotImplementedException("updateBytes");
  }

  public void updateDate(int columnIndex, java.sql.Date x) throws SQLException
  {
    throw new NotImplementedException("updateDate");
  }

  public void updateTime(int columnIndex, java.sql.Time x) throws SQLException
  {
    throw new NotImplementedException("updateTime");
  }

  public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
      throws SQLException
  {
    throw new NotImplementedException("updateTimestamp");
  }

  public void updateAsciiStream(int columnIndex, java.io.InputStream x,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateAsciiStream");
  }

  public void updateBinaryStream(int columnIndex, java.io.InputStream x,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateBinaryStream");
  }

  public void updateCharacterStream(int columnIndex, java.io.Reader x,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateCharacterStream");
  }

  public void updateObject(int columnIndex, Object x, int scale)
      throws SQLException
  {
    throw new NotImplementedException("updateObject");
  }

  public void updateObject(int columnIndex, Object x) throws SQLException
  {
    throw new NotImplementedException("updateObject");
  }

  public void updateNull(String columnName) throws SQLException
  {
    throw new NotImplementedException("updateNull");
  }

  public void updateBoolean(String columnName, boolean x) throws SQLException
  {
    throw new NotImplementedException("updateBoolean");
  }

  public void updateByte(String columnName, byte x) throws SQLException
  {
    throw new NotImplementedException("updateByte");
  }

  public void updateShort(String columnName, short x) throws SQLException
  {
    throw new NotImplementedException("updateShort");
  }

  public void updateInt(String columnName, int x) throws SQLException
  {
    throw new NotImplementedException("updateInt");
  }

  public void updateLong(String columnName, long x) throws SQLException
  {
    throw new NotImplementedException("updateLong");
  }

  public void updateFloat(String columnName, float x) throws SQLException
  {
    throw new NotImplementedException("updateFloat");
  }

  public void updateDouble(String columnName, double x) throws SQLException
  {
    throw new NotImplementedException("updateDouble");
  }

  public void updateBigDecimal(String columnName, BigDecimal x)
      throws SQLException
  {
    throw new NotImplementedException("updateBigDecimal");
  }

  public void updateString(String columnName, String x) throws SQLException
  {
    throw new NotImplementedException("updateString");
  }

  public void updateBytes(String columnName, byte x[]) throws SQLException
  {
    throw new NotImplementedException("updateBytes");
  }

  public void updateDate(String columnName, java.sql.Date x)
      throws SQLException
  {
    throw new NotImplementedException("updateDate");
  }

  public void updateTime(String columnName, java.sql.Time x)
      throws SQLException
  {
    throw new NotImplementedException("updateTime");
  }

  public void updateTimestamp(String columnName, java.sql.Timestamp x)
      throws SQLException
  {
    throw new NotImplementedException("updateTimestamp");
  }

  public void updateAsciiStream(String columnName, java.io.InputStream x,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateAsciiStream");
  }

  public void updateBinaryStream(String columnName, java.io.InputStream x,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateBinaryStream");
  }

  public void updateCharacterStream(String columnName, java.io.Reader reader,
      int length) throws SQLException
  {
    throw new NotImplementedException("updateCharacterStream");
  }

  public void updateObject(String columnName, Object x, int scale)
      throws SQLException
  {
    throw new NotImplementedException("updateObject");
  }

  public void updateObject(String columnName, Object x) throws SQLException
  {
    throw new NotImplementedException("updateObject");
  }

  public void insertRow() throws SQLException
  {
    throw new NotImplementedException("insertRow");
  }

  public void updateRow() throws SQLException
  {
    throw new NotImplementedException("updateRow");
  }

  public void deleteRow() throws SQLException
  {
    throw new NotImplementedException("deleteRow");
  }

  public void refreshRow() throws SQLException
  {
    throw new NotImplementedException("refreshRow");
  }

  public void cancelRowUpdates() throws SQLException
  {
    throw new NotImplementedException("cancelRowUpdates");
  }

  public void moveToInsertRow() throws SQLException
  {
    throw new NotImplementedException("moveToInsertRow");
  }

  public void moveToCurrentRow() throws SQLException
  {
    throw new NotImplementedException("moveToCurrentRow");
  }

  //
  // ------------------------------------------
  // ResultSet meta-data related functions
  // ------------------------------------------
  //

  public int getType() throws SQLException
  {
    return resultSetType;
  }

  public int getConcurrency() throws SQLException
  {
    return CONCUR_READ_ONLY;
  }

  public void close() throws SQLException
  {
    if (hasMoreData)
      owningStatement.connection.closeRemoteResultSet(cursorName);
    isClosed = true;
  }

  public boolean wasNull() throws SQLException
  {
    return wasNullFlag;
  }

  public java.sql.Statement getStatement() throws SQLException
  {
    return owningStatement;
  }

  protected void setResultSetType(int typeFlag)
  {
    resultSetType = typeFlag;
  }

  protected void setResultSetConcurrency(int concurrencyFlag)
  {
    resultSetConcurrency = concurrencyFlag;
    // Issue warning is asked for updateable result set, but result set is not
    // updatable
    if (concurrencyFlag == CONCUR_UPDATABLE)
      warnings = new java.sql.SQLWarning(UPDATEABLE_MESSAGE);
  }

  protected void setData(ArrayList newData)
  {
    data = newData;
  }

  protected void setHasMoreData(boolean hasMore)
  {
    hasMoreData = hasMore;
  }

  public java.sql.ResultSetMetaData getMetaData() throws SQLException
  {
    return new ResultSetMetaData(this);
  }

  public int findColumn(String columnName) throws SQLException
  {
    if (columnNameToIndex == null)
      buildIndexMapping();

    Integer index = (Integer) columnNameToIndex.get(columnName);

    if (index == null)
      index = (Integer) fullColumnNameToIndex.get(columnName);

    if (index != null)
      return index.intValue() + 1;
    else
    {
      // Try this inefficient way, now
      String columnNameUC = columnName.toUpperCase();
      for (int i = 0; i < nbOfColumns; i++)
      {
        if (fields[i].getFieldName().toUpperCase().equals(columnNameUC))
          return i + 1;
        else if (fields[i].getFullName().toUpperCase().equals(columnNameUC))
          return i + 1;
      }
      throw new java.sql.SQLException("Column '" + columnName + "' not found.");
    }
  }

  // ****************************************************************
  //
  //                       END OF PUBLIC INTERFACE
  //
  // ****************************************************************

  public DriverResultSet(Field[] fields, ArrayList resultData)
  {
    currentRow = -1;
    this.fields = fields;
    data = resultData;
    if (data == null)
      nbOfRows = 0;
    else
      nbOfRows = data.size();
    nbOfColumns = fields.length;
    isClosed = false;
  }

  public DriverResultSet(Field[] fields, ArrayList resultData,
      boolean crsHasMoreData, String cursorName)
  {
    this(fields, resultData);
    this.cursorName = cursorName;
    hasMoreData = crsHasMoreData;
  }

  protected void setStatement(Statement stmt) throws SQLException
  {
    owningStatement = stmt;
    fetchSize = stmt.getFetchSize();
  }

  private void buildIndexMapping()
  {
    int numFields = nbOfColumns;

    columnNameToIndex = new Hashtable();
    fullColumnNameToIndex = new Hashtable();

    for (int i = 0; i < numFields; i++)
    {
      Integer index = new Integer(i);

      String columnName = fields[i].getFieldName();
      String fullColumnName = fields[i].getFullName();
      if (columnName != null)
      {
        columnNameToIndex.put(fields[i].getFieldName(), index);
        columnNameToIndex.put(fields[i].getFieldName().toUpperCase(), index);
        columnNameToIndex.put(fields[i].getFieldName().toLowerCase(), index);
      }

      if (fullColumnName != null)
      {
        fullColumnNameToIndex.put(fields[i].getFullName(), index);
        fullColumnNameToIndex.put(fields[i].getFullName().toUpperCase(), index);
        fullColumnNameToIndex.put(fields[i].getFullName().toLowerCase(), index);
      }
    }
  }

  private void checkRowAndColPosAndSetNullFlag(int columnIndex)
      throws SQLException
  {
    checkIfClosed();

    if (currentRow < 0)
      throw new SQLException("Before start of result set");

    if (currentRow == nbOfRows)
      throw new SQLException("After end of result set");

    if (fields == null)
      throw new java.sql.SQLException("Query generated no fields for ResultSet");

    if (columnIndex < 1 || columnIndex > nbOfColumns)
      throw new java.sql.SQLException("Column Index out of range ( "
          + columnIndex + " > " + nbOfColumns + ").");

    try
    {
      if (((Object[]) data.get(currentRow))[columnIndex - 1] == null)
        wasNullFlag = true;
      else
        wasNullFlag = false;
    }
    catch (NullPointerException e)
    {
      wasNullFlag = true;
    }
  }

  private void checkIfClosed() throws SQLException
  {
    if (isClosed)
      throw new SQLException("Trying to access a closed ResultSet");
  }

  //-------------------------- JDBC 3.0
  // ----------------------------------------

  public java.net.URL getURL(int columnIndex) throws SQLException
  {
    throw new NotImplementedException("getURL");
  }

  public java.net.URL getURL(String columnName) throws SQLException
  {
    throw new NotImplementedException("getURL");
  }

  public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException
  {
    throw new NotImplementedException("updateRef");
  }

  public void updateRef(String columnName, java.sql.Ref x) throws SQLException
  {
    throw new NotImplementedException("updateRef");
  }

  public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException
  {
    throw new NotImplementedException("updateBlob");
  }

  public void updateBlob(String columnName, java.sql.Blob x)
      throws SQLException
  {
    throw new NotImplementedException("updateBlob");
  }

  public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException
  {
    throw new NotImplementedException("updateClob");
  }

  public void updateClob(String columnName, java.sql.Clob x)
      throws SQLException
  {
    throw new NotImplementedException("updateClob");
  }

  public void updateArray(int columnIndex, java.sql.Array x)
      throws SQLException
  {
    throw new NotImplementedException("updateArray");
  }

  public void updateArray(String columnName, java.sql.Array x)
      throws SQLException
  {
    throw new NotImplementedException("updateArray");
  }

  public byte getByte(int columnIndex) throws SQLException
  {
    checkRowAndColPosAndSetNullFlag(columnIndex);

    if (wasNullFlag)
      return 0;
    else
      return ((Byte) (((Object[]) data.get(currentRow))[columnIndex - 1]))
          .byteValue();
  }

  public String toString()
  {
    return nbOfRows + " rows - " + nbOfColumns + " columns - current row:"
        + currentRow + " - hasMoreData:" + hasMoreData + " - isClosed:"
        + isClosed;
  }
}

---