package org.postgresql.jdbc2;

// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver.
// If you make any modifications to this file, you must make sure that the
// changes are also made (if relevent) to the related JDBC 1 class in the
// org.postgresql.jdbc1 package.


import java.lang.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.sql.*;
import org.postgresql.Field;
import org.postgresql.largeobject.*;
import org.postgresql.util.*;

/**
 * A ResultSet provides access to a table of data generated by executing a
 * Statement.  The table rows are retrieved in sequence.  Within a row its
 * column values can be accessed in any order.
 *
 * <P>A ResultSet maintains a cursor pointing to its current row of data.
 * Initially the cursor is positioned before the first row.  The 'next'
 * method moves the cursor to the next row.
 *
 * <P>The getXXX methods retrieve column values for the current row.  You can
 * retrieve values either using the index number of the column, or by using
 * the name of the column.  In general using the column index will be more
 * efficient.  Columns are numbered from 1.
 *
 * <P>For maximum portability, ResultSet columns within each row should be read
 * in left-to-right order and each column should be read only once.
 *
 *<P> For the getXXX methods, the JDBC driver attempts to convert the
 * underlying data to the specified Java type and returns a suitable Java
 * value.  See the JDBC specification for allowable mappings from SQL types
 * to Java types with the ResultSet getXXX methods.
 *
 * <P>Column names used as input to getXXX methods are case insenstive.  When
 * performing a getXXX using a column name, if several columns have the same
 * name, then the value of the first matching column will be returned.  The
 * column name option is designed to be used when column names are used in the
 * SQL Query.  For columns that are NOT explicitly named in the query, it is
 * best to use column numbers.  If column names were used there is no way for
 * the programmer to guarentee that they actually refer to the intended
 * columns.
 *
 * <P>A ResultSet is automatically closed by the Statement that generated it
 * when that Statement is closed, re-executed, or is used to retrieve the
 * next result from a sequence of multiple results.
 *
 * <P>The number, types and properties of a ResultSet's columns are provided by
 * the ResultSetMetaData object returned by the getMetaData method.
 *
 * @see ResultSetMetaData
 * @see java.sql.ResultSet
 */
public class ResultSet extends org.postgresql.ResultSet implements java.sql.ResultSet
{
  protected org.postgresql.jdbc2.Statement statement;

  /**
   * StringBuffer used by getTimestamp
   */
  private StringBuffer sbuf;

  /**
   * Create a new ResultSet - Note that we create ResultSets to
   * represent the results of everything.
   *
   * @param fields an array of Field objects (basically, the
   *	ResultSet MetaData)
   * @param tuples Vector of the actual data
   * @param status the status string returned from the back end
   * @param updateCount the number of rows affected by the operation
   * @param cursor the positioned update/delete cursor name
   */
  public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID)
  {
      super(conn,fields,tuples,status,updateCount,insertOID);
  }

  /**
   * Create a new ResultSet - Note that we create ResultSets to
   * represent the results of everything.
   *
   * @param fields an array of Field objects (basically, the
   *	ResultSet MetaData)
   * @param tuples Vector of the actual data
   * @param status the status string returned from the back end
   * @param updateCount the number of rows affected by the operation
   * @param cursor the positioned update/delete cursor name
   */
  public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
  {
      super(conn,fields,tuples,status,updateCount,0);
  }

  /**
   * A ResultSet is initially positioned before its first row,
   * the first call to next makes the first row the current row;
   * the second call makes the second row the current row, etc.
   *
   * <p>If an input stream from the previous row is open, it is
   * implicitly closed.  The ResultSet's warning chain is cleared
   * when a new row is read
   *
   * @return true if the new current is valid; false if there are no
   *	more rows
   * @exception SQLException if a database access error occurs
   */
  public boolean next() throws SQLException
  {
    if (++current_row >= rows.size())
      return false;
    this_row = (byte [][])rows.elementAt(current_row);
    return true;
  }

  /**
   * In some cases, it is desirable to immediately release a ResultSet
   * database and JDBC resources instead of waiting for this to happen
   * when it is automatically closed.  The close method provides this
   * immediate release.
   *
   * <p><B>Note:</B> A ResultSet is automatically closed by the Statement
   * the Statement that generated it when that Statement is closed,
   * re-executed, or is used to retrieve the next result from a sequence
   * of multiple results.  A ResultSet is also automatically closed
   * when it is garbage collected.
   *
   * @exception SQLException if a database access error occurs
   */
  public void close() throws SQLException
  {
    //release resources held (memory for tuples)
    if(rows!=null) {
      rows.setSize(0);
      rows=null;
    }
  }

  /**
   * A column may have the value of SQL NULL; wasNull() reports whether
   * the last column read had this special value.  Note that you must
   * first call getXXX on a column to try to read its value and then
   * call wasNull() to find if the value was SQL NULL
   *
   * @return true if the last column read was SQL NULL
   * @exception SQLException if a database access error occurred
   */
  public boolean wasNull() throws SQLException
  {
    return wasNullFlag;
  }

  /**
   * Get the value of a column in the current row as a Java String
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return the column value, null for SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public String getString(int columnIndex) throws SQLException
  {
    if (columnIndex < 1 || columnIndex > fields.length)
      throw new PSQLException("postgresql.res.colrange");

    wasNullFlag = (this_row[columnIndex - 1] == null);
    if(wasNullFlag)
      return null;

    String encoding = connection.getEncoding();
    if (encoding == null)
        return new String(this_row[columnIndex - 1]);
    else {
        try {
            return new String(this_row[columnIndex - 1], encoding);
        } catch (UnsupportedEncodingException unse) {
            throw new PSQLException("postgresql.res.encoding", unse);
        }
    }
  }

  /**
   * Get the value of a column in the current row as a Java boolean
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return the column value, false for SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public boolean getBoolean(int columnIndex) throws SQLException
  {
    String s = getString(columnIndex);

    if (s != null)
      {
	int c = s.charAt(0);
	return ((c == 't') || (c == 'T') || (c == '1'));
      }
    return false;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java byte.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public byte getByte(int columnIndex) throws SQLException
  {
    String s = getString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Byte.parseByte(s);
	  } catch (NumberFormatException e) {
	    throw new PSQLException("postgresql.res.badbyte",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java short.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public short getShort(int columnIndex) throws SQLException
  {
    String s = getFixedString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Short.parseShort(s);
	  } catch (NumberFormatException e) {
	    throw new PSQLException("postgresql.res.badshort",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java int.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public int getInt(int columnIndex) throws SQLException
  {
    String s = getFixedString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Integer.parseInt(s);
	  } catch (NumberFormatException e) {
	    throw new PSQLException ("postgresql.res.badint",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java long.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public long getLong(int columnIndex) throws SQLException
  {
    String s = getFixedString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Long.parseLong(s);
	  } catch (NumberFormatException e) {
	    throw new PSQLException ("postgresql.res.badlong",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java float.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public float getFloat(int columnIndex) throws SQLException
  {
    String s = getFixedString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Float.valueOf(s).floatValue();
	  } catch (NumberFormatException e) {
	    throw new PSQLException ("postgresql.res.badfloat",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java double.
   *
   * @param columnIndex the first column is 1, the second is 2,...
   * @return the column value; 0 if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public double getDouble(int columnIndex) throws SQLException
  {
    String s = getFixedString(columnIndex);

    if (s != null)
      {
	try
	  {
	    return Double.valueOf(s).doubleValue();
	  } catch (NumberFormatException e) {
	    throw new PSQLException ("postgresql.res.baddouble",s);
	  }
      }
    return 0;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a
   * java.math.BigDecimal object
   *
   * @param columnIndex  the first column is 1, the second is 2...
   * @param scale the number of digits to the right of the decimal
   * @return the column value; if the value is SQL NULL, null
   * @exception SQLException if a database access error occurs
   * @deprecated
   */
  public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
  {
    String s = getFixedString(columnIndex);
    BigDecimal val;

    if (s != null)
      {

        try
          {
	    val = new BigDecimal(s);
	  } catch (NumberFormatException e) {
	    throw new PSQLException ("postgresql.res.badbigdec",s);
	  }
	if (scale==-1) return val;
	  try
	    {
	      return val.setScale(scale);
	    } catch (ArithmeticException e) {
	      throw new PSQLException ("postgresql.res.badbigdec",s);
	    }
      }
    return null;		// SQL NULL
  }

  /**
   * Get the value of a column in the current row as a Java byte array.
   *
   * <p>In normal use, the bytes represent the raw values returned by the
   * backend. However, if the column is an OID, then it is assumed to
   * refer to a Large Object, and that object is returned as a byte array.
   *
   * <p><b>Be warned</b> If the large object is huge, then you may run out
   * of memory.
   *
   * @param columnIndex the first column is 1, the second is 2, ...
   * @return the column value; if the value is SQL NULL, the result
   *	is null
   * @exception SQLException if a database access error occurs
   */
  public byte[] getBytes(int columnIndex) throws SQLException
  {
    if (columnIndex < 1 || columnIndex > fields.length)
      throw new PSQLException("postgresql.res.colrange");
    wasNullFlag = (this_row[columnIndex - 1] == null);

    // Handle OID's as BLOBS
    if(!wasNullFlag)
      if( fields[columnIndex - 1].getOID() == 26) {
	LargeObjectManager lom = connection.getLargeObjectAPI();
	LargeObject lob = lom.open(getInt(columnIndex));
	byte buf[] = lob.read(lob.size());
	lob.close();
	return buf;
      }

    return this_row[columnIndex - 1];
  }

  /**
   * Get the value of a column in the current row as a java.sql.Date
   * object
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return the column value; null if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public java.sql.Date getDate(int columnIndex) throws SQLException
  {
    String s = getString(columnIndex);
    if(s==null)
      return null;

    return java.sql.Date.valueOf(s);
  }

  /**
   * Get the value of a column in the current row as a java.sql.Time
   * object
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return the column value; null if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public Time getTime(int columnIndex) throws SQLException
  {
    String s = getString(columnIndex);

    if(s==null)
      return null; // SQL NULL

    return java.sql.Time.valueOf(s);
  }

  /**
   * Get the value of a column in the current row as a
   * java.sql.Timestamp object
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return the column value; null if SQL NULL
   * @exception SQLException if a database access error occurs
   */
  public Timestamp getTimestamp(int columnIndex) throws SQLException
  {
    String s = getString(columnIndex);
    if(s==null)
	return null;

    boolean subsecond;
    //if string contains a '.' we have fractional seconds
    if (s.indexOf('.') == -1) {
      subsecond = false;
    } else {
      subsecond = true;
    }

    //here we are modifying the string from ISO format to a format java can understand
    //java expects timezone info as 'GMT-08:00' instead of '-08' in postgres ISO format
    //and java expects three digits if fractional seconds are present instead of two for postgres
    //so this code strips off timezone info and adds on the GMT+/-...
    //as well as adds a third digit for partial seconds if necessary
    synchronized(this) {
      // We must be synchronized here incase more theads access the ResultSet
      // bad practice but possible. Anyhow this is to protect sbuf and
      // SimpleDateFormat objects

      // First time?
      if(sbuf==null)
        sbuf = new StringBuffer();

      sbuf.setLength(0);
      sbuf.append(s);

      char sub = sbuf.charAt(sbuf.length()-3);
      if (sub == '+' || sub == '-') {
        sbuf.setLength(sbuf.length()-3);
        if (subsecond)  {
          sbuf.append('0').append("GMT").append(s.substring(s.length()-3)).append(":00");
        } else {
          sbuf.append("GMT").append(s.substring(s.length()-3)).append(":00");
        }
      } else if (subsecond) {
        sbuf.append('0');
      }

      // could optimize this a tad to remove too many object creations...
      SimpleDateFormat df = null;

      if (sbuf.length()>23 && subsecond) {
        df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSzzzzzzzzz");
      } else if (sbuf.length()>23 && !subsecond) {
        df = new SimpleDateFormat("yyyy-MM-dd HH:mm:sszzzzzzzzz");
      } else if (sbuf.length()>10 && subsecond) {
        df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      } else if (sbuf.length()>10 && !subsecond) {
        df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      } else {
        df = new SimpleDateFormat("yyyy-MM-dd");
      }

      try {
          return new Timestamp(df.parse(sbuf.toString()).getTime());
      } catch(ParseException e) {
          throw new PSQLException("postgresql.res.badtimestamp",new Integer(e.getErrorOffset()),s);
      }
    }
  }

  /**
   * A column value can be retrieved as a stream of ASCII characters
   * and then read in chunks from the stream.  This method is
   * particular suitable for retrieving large LONGVARCHAR values.
   * The JDBC driver will do any necessary conversion from the
   * database format into ASCII.
   *
   * <p><B>Note:</B> All the data in the returned stream must be read
   * prior to getting the value of any other column.  The next call
   * to a get method implicitly closes the stream.  Also, a stream
   * may return 0 for available() whether there is data available
   * or not.
   *
   *<p> We implement an ASCII stream as a Binary stream - we should really
   * do the data conversion, but I cannot be bothered to implement this
   * right now.
   *
   * @param columnIndex the first column is 1, the second is 2, ...
   * @return a Java InputStream that delivers the database column
   * 	value as a stream of one byte ASCII characters.  If the
   *	value is SQL NULL then the result is null
   * @exception SQLException if a database access error occurs
   * @see getBinaryStream
   */
  public InputStream getAsciiStream(int columnIndex) throws SQLException
  {
    return getBinaryStream(columnIndex);
  }

  /**
   * A column value can also be retrieved as a stream of Unicode
   * characters. We implement this as a binary stream.
   *
   * ** DEPRECATED IN JDBC 2 **
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return a Java InputStream that delivers the database column value
   * 	as a stream of two byte Unicode characters.  If the value is
   *	SQL NULL, then the result is null
   * @exception SQLException if a database access error occurs
   * @see getAsciiStream
   * @see getBinaryStream
   * @deprecated in JDBC2.0
   */
  public InputStream getUnicodeStream(int columnIndex) throws SQLException
  {
    return getBinaryStream(columnIndex);
  }

  /**
   * A column value can also be retrieved as a binary strea.  This
   * method is suitable for retrieving LONGVARBINARY values.
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return a Java InputStream that delivers the database column value
   * as a stream of bytes.  If the value is SQL NULL, then the result
   * is null
   * @exception SQLException if a database access error occurs
   * @see getAsciiStream
   * @see getUnicodeStream
   */
  public InputStream getBinaryStream(int columnIndex) throws SQLException
  {
    // New in 7.1 Handle OID's as BLOBS so return the input stream
    if(!wasNullFlag)
      if( fields[columnIndex - 1].getOID() == 26) {
	LargeObjectManager lom = connection.getLargeObjectAPI();
	LargeObject lob = lom.open(getInt(columnIndex));
        return lob.getInputStream();
      }

    // Not an OID so fake the stream
    byte b[] = getBytes(columnIndex);

    if (b != null)
      return new ByteArrayInputStream(b);
    return null;		// SQL NULL
  }

  /**
   * The following routines simply convert the columnName into
   * a columnIndex and then call the appropriate routine above.
   *
   * @param columnName is the SQL name of the column
   * @return the column value
   * @exception SQLException if a database access error occurs
   */
  public String getString(String columnName) throws SQLException
  {
    return 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));
  }

    /**
     * @deprecated
     */
  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));
  }

    /**
     *
     * ** DEPRECATED IN JDBC 2 **
     *
     * @deprecated
     */
  public InputStream getUnicodeStream(String columnName) throws SQLException
  {
    return getUnicodeStream(findColumn(columnName));
  }

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

  /**
   * The first warning reported by calls on this ResultSet is
   * returned.  Subsequent ResultSet warnings will be chained
   * to this SQLWarning.
   *
   * <p>The warning chain is automatically cleared each time a new
   * row is read.
   *
   * <p><B>Note:</B> This warning chain only covers warnings caused by
   * ResultSet methods.  Any warnings caused by statement methods
   * (such as reading OUT parameters) will be chained on the
   * Statement object.
   *
   * @return the first SQLWarning or null;
   * @exception SQLException if a database access error occurs.
   */
  public SQLWarning getWarnings() throws SQLException
  {
    return warnings;
  }

  /**
   * After this call, getWarnings returns null until a new warning
   * is reported for this ResultSet
   *
   * @exception SQLException if a database access error occurs
   */
  public void clearWarnings() throws SQLException
  {
    warnings = null;
  }

  /**
   * Get the name of the SQL cursor used by this ResultSet
   *
   * <p>In SQL, a result table is retrieved though a cursor that is
   * named.  The current row of a result can be updated or deleted
   * using a positioned update/delete statement that references
   * the cursor name.
   *
   * <p>JDBC supports this SQL feature by providing the name of the
   * SQL cursor used by a ResultSet.  The current row of a ResulSet
   * is also the current row of this SQL cursor.
   *
   * <p><B>Note:</B> If positioned update is not supported, a SQLException
   * is thrown.
   *
   * @return the ResultSet's SQL cursor name.
   * @exception SQLException if a database access error occurs
   */
  public String getCursorName() throws SQLException
  {
    return connection.getCursorName();
  }

  /**
   * The numbers, types and properties of a ResultSet's columns are
   * provided by the getMetaData method
   *
   * @return a description of the ResultSet's columns
   * @exception SQLException if a database access error occurs
   */
  public java.sql.ResultSetMetaData getMetaData() throws SQLException
  {
    return new ResultSetMetaData(rows, fields);
  }

  /**
   * Get the value of a column in the current row as a Java object
   *
   * <p>This method will return the value of the given column as a
   * Java object.  The type of the Java object will be the default
   * Java Object type corresponding to the column's SQL type, following
   * the mapping specified in the JDBC specification.
   *
   * <p>This method may also be used to read database specific abstract
   * data types.
   *
   * @param columnIndex the first column is 1, the second is 2...
   * @return a Object holding the column value
   * @exception SQLException if a database access error occurs
   */
  public Object getObject(int columnIndex) throws SQLException
  {
    Field field;

    if (columnIndex < 1 || columnIndex > fields.length)
      throw new PSQLException("postgresql.res.colrange");

    wasNullFlag = (this_row[columnIndex - 1] == null);
    if(wasNullFlag)
      return null;

    field = fields[columnIndex - 1];

    // some fields can be null, mainly from those returned by MetaData methods
    if(field==null) {
      wasNullFlag=true;
      return null;
    }

    switch (field.getSQLType())
      {
      case Types.BIT:
	return new Boolean(getBoolean(columnIndex));
      case Types.SMALLINT:
	return new Integer(getInt(columnIndex));
      case Types.INTEGER:
	return new Integer(getInt(columnIndex));
      case Types.BIGINT:
	return new Long(getLong(columnIndex));
      case Types.NUMERIC:
	return getBigDecimal
	    (columnIndex, (field.mod==-1)?-1:((field.mod-4) & 0xffff));
      case Types.REAL:
	return new Float(getFloat(columnIndex));
      case Types.DOUBLE:
	return new Double(getDouble(columnIndex));
      case Types.CHAR:
      case Types.VARCHAR:
	return getString(columnIndex);
      case Types.DATE:
	return getDate(columnIndex);
      case Types.TIME:
	return getTime(columnIndex);
      case Types.TIMESTAMP:
	return getTimestamp(columnIndex);
      default:
	return connection.getObject(field.getTypeName(), getString(columnIndex));
      }
  }

  /**
   * Get the value of a column in the current row as a Java object
   *
   *<p> This method will return the value of the given column as a
   * Java object.  The type of the Java object will be the default
   * Java Object type corresponding to the column's SQL type, following
   * the mapping specified in the JDBC specification.
   *
   * <p>This method may also be used to read database specific abstract
   * data types.
   *
   * @param columnName is the SQL name of the column
   * @return a Object holding the column value
   * @exception SQLException if a database access error occurs
   */
  public Object getObject(String columnName) throws SQLException
  {
    return getObject(findColumn(columnName));
  }

  /**
   * Map a ResultSet column name to a ResultSet column index
   *
   * @param columnName the name of the column
   * @return the column index
   * @exception SQLException if a database access error occurs
   */
  public int findColumn(String columnName) throws SQLException
  {
    int i;

    for (i = 0 ; i < fields.length; ++i)
      if (fields[i].name.equalsIgnoreCase(columnName))
	return (i+1);
    throw new PSQLException ("postgresql.res.colname",columnName);
  }

    // ** JDBC 2 Extensions **

    public boolean absolute(int index) throws SQLException
    {
	// index is 1-based, but internally we use 0-based indices
	int internalIndex;

	if (index==0)
	    throw new SQLException("Cannot move to index of 0");

	//if index<0, count from the end of the result set, but check
	//to be sure that it is not beyond the first index
	if (index<0)
	    if (index>=-rows.size())
		internalIndex=rows.size()+index;
	    else {
		beforeFirst();
		return false;
	    }

	//must be the case that index>0,
	//find the correct place, assuming that
	//the index is not too large
	if (index<=rows.size())
	    internalIndex = index-1;
	else {
	    afterLast();
	    return false;
	}

	current_row=internalIndex;
	this_row = (byte [][])rows.elementAt(internalIndex);
	return true;
    }

    public void afterLast() throws SQLException
    {
	if (rows.size() > 0)
		current_row = rows.size();
    }

    public void beforeFirst() throws SQLException
    {
	if (rows.size() > 0)
		current_row = -1;
    }

    public void cancelRowUpdates() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void deleteRow() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public boolean first() throws SQLException
    {
	if (rows.size() <= 0)
	    return false;
	current_row = 0;
	this_row = (byte [][])rows.elementAt(current_row);
	return true;
    }

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

    public Array getArray(int i) throws SQLException
    {
	throw org.postgresql.Driver.notImplemented();
    }

    public java.math.BigDecimal getBigDecimal(int columnIndex) throws SQLException
    {
      // Now must call BigDecimal with a scale otherwise JBuilder barfs
      return getBigDecimal(columnIndex,0);
    }

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

    public Blob getBlob(String columnName) throws SQLException
    {
	return getBlob(findColumn(columnName));
    }

    public Blob getBlob(int i) throws SQLException
    {
	return new org.postgresql.largeobject.PGblob(connection,getInt(i));
    }

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

    public java.io.Reader getCharacterStream(int i) throws SQLException
    {
      // New in 7.1
      try {
        String encoding = connection.getEncoding();
        if(encoding==null)
          return new InputStreamReader(getBinaryStream(i));
        return new InputStreamReader(getBinaryStream(i),encoding);
      } catch (UnsupportedEncodingException unse) {
        throw new PSQLException("postgresql.res.encoding", unse);
      }
    }

    /**
     * New in 7.1
     */
    public Clob getClob(String columnName) throws SQLException
    {
	return getClob(findColumn(columnName));
    }

    /**
     * New in 7.1
     */
    public Clob getClob(int i) throws SQLException
    {
	return new org.postgresql.largeobject.PGclob(connection,getInt(i));
    }

    public int getConcurrency() throws SQLException
    {
        // New in 7.1 - The standard ResultSet class will now return
        // CONCUR_READ_ONLY. A sub-class will overide this if the query was
        // updateable.
	return CONCUR_READ_ONLY;
    }

    public java.sql.Date getDate(int i,java.util.Calendar cal) throws SQLException
    {
      // new in 7.1: If I read the specs, this should use cal only if we don't
      // store the timezone, and if we do, then act just like getDate()?
      // for now...
      return getDate(i);
    }

    public Time getTime(int i,java.util.Calendar cal) throws SQLException
    {
      // new in 7.1: If I read the specs, this should use cal only if we don't
      // store the timezone, and if we do, then act just like getTime()?
      // for now...
      return getTime(i);
    }

    public Timestamp getTimestamp(int i,java.util.Calendar cal) throws SQLException
    {
      // new in 7.1: If I read the specs, this should use cal only if we don't
      // store the timezone, and if we do, then act just like getDate()?
      // for now...
      return getTimestamp(i);
    }

    public java.sql.Date getDate(String c,java.util.Calendar cal) throws SQLException
    {
	return getDate(findColumn(c),cal);
    }

    public Time getTime(String c,java.util.Calendar cal) throws SQLException
    {
	return getTime(findColumn(c),cal);
    }

    public Timestamp getTimestamp(String c,java.util.Calendar cal) throws SQLException
    {
	return getTimestamp(findColumn(c),cal);
    }

    public int getFetchDirection() throws SQLException
    {
      // new in 7.1: PostgreSQL normally sends rows first->last
      return FETCH_FORWARD;
    }

    public int getFetchSize() throws SQLException
    {
      // new in 7.1: In this implementation we return the entire result set, so
      // here return the number of rows we have. Sub-classes can return a proper
      // value
      return rows.size();
    }

    public Object getObject(String columnName,java.util.Map map) throws SQLException
    {
	return getObject(findColumn(columnName),map);
    }

    /**
     * This checks against map for the type of column i, and if found returns
     * an object based on that mapping. The class must implement the SQLData
     * interface.
     */
    public Object getObject(int i,java.util.Map map) throws SQLException
    {
      /* In preparation
      SQLInput s = new PSQLInput(this,i);
      String t = getTypeName(i);
      SQLData o = (SQLData) map.get(t);
      // If the type is not in the map, then pass to the existing code
      if(o==null)
        return getObject(i);
      o.readSQL(s,t);
      return o;
      */throw org.postgresql.Driver.notImplemented();
    }

    public Ref getRef(String columnName) throws SQLException
    {
	return getRef(findColumn(columnName));
    }

    public Ref getRef(int i) throws SQLException
    {
      // new in 7.1: The backend doesn't yet have SQL3 REF types
      throw new PSQLException("postgresql.psqlnotimp");
    }

    public int getRow() throws SQLException
    {
	return current_row + 1;
    }

    // This one needs some thought, as not all ResultSets come from a statement
    public java.sql.Statement getStatement() throws SQLException
    {
      return statement;
    }

    public int getType() throws SQLException
    {
	// New in 7.1. This implementation allows scrolling but is not able to
        // see any changes. Sub-classes may overide this to return a more
        // meaningful result.
        return TYPE_SCROLL_INSENSITIVE;
    }

    public void insertRow() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public boolean isAfterLast() throws SQLException
    {
	return (current_row >= rows.size()  && rows.size() > 0);
    }

    public boolean isBeforeFirst() throws SQLException
    {
	return (current_row < 0 && rows.size() > 0);
    }

    public boolean isFirst() throws SQLException
    {
	return (current_row == 0 && rows.size() >= 0);
    }

    public boolean isLast() throws SQLException
    {
	return (current_row == rows.size() -1  && rows.size() > 0);
    }

    public boolean last() throws SQLException
    {
	if (rows.size() <= 0)
	    return false;
	current_row = rows.size() - 1;
	this_row = (byte [][])rows.elementAt(current_row);
	return true;
    }

    public void moveToCurrentRow() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void moveToInsertRow() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public boolean previous() throws SQLException
    {
	if (--current_row < 0)
	    return false;
	this_row = (byte [][])rows.elementAt(current_row);
	return true;
    }

    public void refreshRow() throws SQLException
    {
      throw new PSQLException("postgresql.notsensitive");
    }

    // Peter: Implemented in 7.0
    public boolean relative(int rows) throws SQLException
    {
	//have to add 1 since absolute expects a 1-based index
	return absolute(current_row+1+rows);
    }

    public boolean rowDeleted() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
      return false; // javac complains about not returning a value!
    }

    public boolean rowInserted() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
      return false; // javac complains about not returning a value!
    }

    public boolean rowUpdated() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
      return false; // javac complains about not returning a value!
    }

    public void setFetchDirection(int direction) throws SQLException
    {
      // In 7.1, the backend doesn't yet support this
      throw new PSQLException("postgresql.psqlnotimp");
    }

    public void setFetchSize(int rows) throws SQLException
    {
      // Sub-classes should implement this as part of their cursor support
      throw org.postgresql.Driver.notImplemented();
    }

    public void updateAsciiStream(int columnIndex,
				  java.io.InputStream x,
				  int length
				  ) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

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

    public void updateBigDecimal(int columnIndex,
				  java.math.BigDecimal x
				  ) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateBigDecimal(String columnName,
				  java.math.BigDecimal x
				  ) throws SQLException
    {
      updateBigDecimal(findColumn(columnName),x);
    }

    public void updateBinaryStream(int columnIndex,
				  java.io.InputStream x,
				  int length
				  ) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

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

    public void updateBoolean(int columnIndex,boolean x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateBoolean(String columnName,boolean x) throws SQLException
    {
	updateBoolean(findColumn(columnName),x);
    }

    public void updateByte(int columnIndex,byte x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateByte(String columnName,byte x) throws SQLException
    {
	updateByte(findColumn(columnName),x);
    }

    public void updateBytes(String columnName,byte[] x) throws SQLException
    {
	updateBytes(findColumn(columnName),x);
    }

    public void updateBytes(int columnIndex,byte[] x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateCharacterStream(int columnIndex,
				      java.io.Reader x,
				      int length
				      ) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateCharacterStream(String columnName,
				      java.io.Reader x,
				      int length
				      ) throws SQLException
    {
	updateCharacterStream(findColumn(columnName),x,length);
    }

    public void updateDate(int columnIndex,java.sql.Date x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateDate(String columnName,java.sql.Date x) throws SQLException
    {
	updateDate(findColumn(columnName),x);
    }

    public void updateDouble(int columnIndex,double x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateDouble(String columnName,double x) throws SQLException
    {
	updateDouble(findColumn(columnName),x);
    }

    public void updateFloat(int columnIndex,float x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateFloat(String columnName,float x) throws SQLException
    {
	updateFloat(findColumn(columnName),x);
    }

    public void updateInt(int columnIndex,int x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateInt(String columnName,int x) throws SQLException
    {
	updateInt(findColumn(columnName),x);
    }

    public void updateLong(int columnIndex,long x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateLong(String columnName,long x) throws SQLException
    {
	updateLong(findColumn(columnName),x);
    }

    public void updateNull(int columnIndex) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateNull(String columnName) throws SQLException
    {
	updateNull(findColumn(columnName));
    }

    public void updateObject(int columnIndex,Object x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateObject(String columnName,Object x) throws SQLException
    {
	updateObject(findColumn(columnName),x);
    }

    public void updateObject(int columnIndex,Object x,int scale) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateObject(String columnName,Object x,int scale) throws SQLException
    {
	updateObject(findColumn(columnName),x,scale);
    }

    public void updateRow() throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateShort(int columnIndex,short x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateShort(String columnName,short x) throws SQLException
    {
	updateShort(findColumn(columnName),x);
    }

    public void updateString(int columnIndex,String x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateString(String columnName,String x) throws SQLException
    {
	updateString(findColumn(columnName),x);
    }

    public void updateTime(int columnIndex,Time x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateTime(String columnName,Time x) throws SQLException
    {
	updateTime(findColumn(columnName),x);
    }

    public void updateTimestamp(int columnIndex,Timestamp x) throws SQLException
    {
      // only sub-classes implement CONCUR_UPDATEABLE
      notUpdateable();
    }

    public void updateTimestamp(String columnName,Timestamp x) throws SQLException
    {
	updateTimestamp(findColumn(columnName),x);
    }

    // helper method. Throws an SQLException when an update is not possible
    public void notUpdateable() throws SQLException
    {
      throw new PSQLException("postgresql.noupdate");
    }

    /**
     * This is called by Statement to register itself with this statement.
     * It's used currently by getStatement() but may also with the new core
     * package.
     */
    public void setStatement(org.postgresql.jdbc2.Statement statement) {
      this.statement=statement;
    }

}

