/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/amber/query/ResultSetImpl.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.amber.query;

import com.caucho.amber.entity.AmberEntityHome;
import com.caucho.amber.entity.Entity;
import com.caucho.amber.entity.EntityItem;
import com.caucho.amber.expr.AmberExpr;
import com.caucho.amber.expr.LoadEntityExpr;
import com.caucho.amber.manager.AmberConnection;
import com.caucho.amber.type.EntityType;
import com.caucho.util.L10N;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * The JDBC statement implementation.
 */
public class ResultSetImpl implements ResultSet {
  private static final Logger log
    = Logger.getLogger(ResultSetImpl.class.getName());
  private static final L10N L = new L10N(ResultSetImpl.class);

  public static final int CACHE_CHUNK_SIZE = 64;

  private UserQuery _userQuery;
  private ResultSet _rs;
  private ArrayList<FromItem> _fromList;
  private ArrayList<AmberExpr> _resultList;
  private Map<AmberExpr, String> _joinFetchMap;
  private AmberConnection _session;

  private QueryCacheKey _cacheKey;
  private ResultSetCacheChunk _cacheChunk;
  private ResultSetMetaData _cacheMetaData;
  private boolean _isCache;

  private int _firstResult;
  private int _maxResults = Integer.MAX_VALUE / 2;
  private int _row;

  private int _numberOfLoadingColumns = 1;

  public ResultSetImpl()
  {
  }

  /**
   * Returns the join fetch map.
   */
  public Map<AmberExpr, String> getJoinFetchMap()
  {
    return _joinFetchMap;
  }

  /**
   * Sets the user query
   */
  public void setUserQuery(UserQuery userQuery)
  {
    _userQuery = userQuery;
  }

  /**
   * Sets the result set.
   */
  public void setResultSet(ResultSet rs)
    throws SQLException
  {
    _rs = rs;

    if (rs != null)
      _cacheMetaData = rs.getMetaData();
  }

  /**
   * Sets the result set and meta data.
   */
  public void setResultSet(ResultSet rs,
                           ResultSetMetaData metaData)
  {
    _rs = rs;
    _cacheMetaData = metaData;
  }

  /**
   * Sets the query.
   */
  public void setQuery(AmberSelectQuery query)
  {
    _fromList = query.getFromList();
    _resultList = query.getResultList();
    _joinFetchMap = query.getJoinFetchMap();
  }

  /**
   * Sets the session.
   */
  public void setSession(AmberConnection aConn)
  {
    _session = aConn;
  }

  /**
   * Sets the first cache chunk
   */
  public void setCacheChunk(ResultSetCacheChunk cacheChunk,
                            ResultSetMetaData metaData)
  {
    _cacheChunk = cacheChunk;
    _cacheMetaData = metaData;
    _isCache = true;
  }

  /**
   * Sets the first result.
   */
  public void setFirstResult(int first)
  {
    _firstResult = first;
  }

  /**
   * Sets the max result.
   */
  public void setMaxResults(int max)
  {
    if (max < 0)
      _maxResults = Integer.MAX_VALUE / 2;
    else
      _maxResults = max;
  }

  /**
   * Fills the cache chunk.
   */
  public void fillCacheChunk(ResultSetCacheChunk cacheChunk)
    throws SQLException
  {
    int size = CACHE_CHUNK_SIZE;
    int maxSize = Integer.MAX_VALUE / 2;
    int i = 0;

    ResultSetCacheChunk tail = cacheChunk;

    // max length of the cached value
    for (; maxSize-- > 0; i++) {
      if (_rs.next()) {
        if (size <= i) {
          i = 0;

          ResultSetCacheChunk next = new ResultSetCacheChunk(tail);
          tail.setNext(next);
          tail = next;
        }

        tail.newRow();

        int len = _resultList.size();
        int offset = 0;

        for (int j = 0; j < len; j++) {
          int index = getColumn(j + 1);

          AmberExpr expr = _resultList.get(j);

          if (expr instanceof LoadEntityExpr) {
            LoadEntityExpr entityExpr = (LoadEntityExpr) expr;

            Object obj = entityExpr.getCacheObject(_session,
                                                   _rs,
                                                   index + offset,
                                                   _joinFetchMap);

            tail.setValue(i, j, obj);

            // jpa/11z1
            offset += entityExpr.getIndex();
          }
          else {
            Object obj = expr.getCacheObject(_session,
                                             _rs,
                                             index + offset);

            tail.setValue(i, j, obj);
          }
        }
      }
      else {
        tail.setLast(true);
        return;
      }
    }

    /*
      if (! _rs.next()) {
      tail.setLast(true);
      }
    */
  }

  /**
   * Initialize
   */
  public void init()
    throws SQLException
  {
    _numberOfLoadingColumns = 1;

    while (_row < _firstResult && next()) {
    }
  }

  public void setRow(int row)
  {
    _row = row;
  }

  /**
   * Returns the current row number.
   */
  public int getRow()
    throws SQLException
  {
    return _row;
  }

  /**
   * Returns true before the first row.
   */
  public boolean isBeforeFirst()
    throws SQLException
  {
    return _rs.isBeforeFirst();
  }

  /**
   * Returns true if this is the first row.
   */
  public boolean isFirst()
    throws SQLException
  {
    return _rs.isFirst();
  }

  /**
   * Returns true if this is the last row.
   */
  public boolean isLast()
    throws SQLException
  {
    return _rs.isLast();
  }

  /**
   * Returns true if this is after the last row.
   */
  public boolean isAfterLast()
    throws SQLException
  {
    return _rs.isAfterLast();
  }

  /**
   * Returns the statement for the result.
   */
  public java.sql.Statement getStatement()
    throws SQLException
  {
    return _rs.getStatement();
  }

  /**
   * Returns the metadata.
   */
  public java.sql.ResultSetMetaData getMetaData()
    throws SQLException
  {
    if (_rs == null)
      return _cacheMetaData;
    else {
      _cacheMetaData = _rs.getMetaData();

      return _cacheMetaData;
    }
  }

  /**
   * Returns the warnings.
   */
  public SQLWarning getWarnings()
    throws SQLException
  {
    return _rs.getWarnings();
  }

  /**
   * Clears the warnings.
   */
  public void clearWarnings()
    throws SQLException
  {
    _rs.clearWarnings();
  }

  /**
   * Returns the cursor name.
   */
  public String getCursorName()
    throws SQLException
  {
    return _rs.getCursorName();
  }

  /**
   * Sets the fetch size.
   */
  public void setFetchSize(int size)
    throws SQLException
  {
    _rs.setFetchSize(size);
  }

  /**
   * Gets the fetch size.
   */
  public int getFetchSize()
    throws SQLException
  {
    return _rs.getFetchSize();
  }

  /**
   * Gets the fetch direction.
   */
  public int getFetchDirection()
    throws SQLException
  {
    return _rs.getFetchDirection();
  }

  /**
   * Sets the fetch direction.
   */
  public void setFetchDirection(int dir)
    throws SQLException
  {
    _rs.setFetchDirection(dir);
  }

  /**
   * Gets the concurrency.
   */
  public int getConcurrency()
    throws SQLException
  {
    return _rs.getConcurrency();
  }

  /**
   * Returns the next row.
   */
  public boolean next()
    throws SQLException
  {
    if (_firstResult + _maxResults <= _row)
      return false;

    int row = _row++;
    ResultSetCacheChunk cacheChunk = _cacheChunk;

    if (cacheChunk == null)
      return _rs != null ? _rs.next() : false;
    else if (row < cacheChunk.getRowCount()) {
      return true;
    }
    else {
      ResultSetCacheChunk next = cacheChunk.getNext();
      if (next != null) {
        _cacheChunk = next;
        return true;
      }

      _isCache = false;
      _cacheChunk = null;

      // jpa/1433
      /*
      if (cacheChunk.isLast()) {
        _maxResults = 0;
        return false;
      }
      else
      */
      if (_rs != null) {
        boolean result = _rs.next();

        return result;
      }
      /*
      else if (_userQuery != null) {
        _rs = _userQuery.executeQuery(row, -1);

        _cacheMetaData = _rs.getMetaData();

        return _rs.next();
      }
      */
      else {
        return false;
      }
    }
  }

  /**
   * Returns the previous row.
   */
  public boolean previous()
    throws SQLException
  {
    if (_row <= _firstResult)
      return false;

    _row--;

    return _rs.previous();
  }

  /**
   * Move relative.
   */
  public boolean relative(int delta)
    throws SQLException
  {
    return _rs.relative(delta);
  }

  /**
   * Move absolute.
   */
  public boolean absolute(int delta)
    throws SQLException
  {
    return _rs.absolute(delta);
  }

  /**
   * Moves before the first row.
   */
  public void beforeFirst()
    throws SQLException
  {
    _rs.beforeFirst();
  }

  /**
   * Move to first
   */
  public boolean first()
    throws SQLException
  {
    return _rs.first();
  }

  /**
   * Move to last
   */
  public boolean last()
    throws SQLException
  {
    return _rs.last();
  }

  /**
   * Moves after the last row.
   */
  public void afterLast()
    throws SQLException
  {
    _rs.afterLast();
  }

  /**
   * Returns true if the last column read was null.
   */
  public boolean wasNull()
    throws SQLException
  {
    return _rs.wasNull();
  }

  /**
   * Returns the type of the last column.
   */
  public int getType()
    throws SQLException
  {
    return _rs.getType();
  }

  /**
   * Returns the external column id corresponding to the column name.
   */
  public int findColumn(String columnName)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Returns the boolean value for the column.
   */
  public boolean getBoolean(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getBoolean(_row - 1, column - 1);
    else
      return _rs.getBoolean(column);
  }

  /**
   * Returns the boolean value for the column.
   */
  public boolean getBoolean(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getBoolean(_row - 1, column - 1);
    else
      return _rs.getBoolean(column);
  }

  /**
   * Returns the byte value for the column.
   */
  public byte getByte(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getByte(_row - 1, column - 1);
    else
      return _rs.getByte(column);
  }

  /**
   * Returns the byte value for the column.
   */
  public byte getByte(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getByte(_row - 1, column - 1);
    else
      return _rs.getByte(column);
  }

  /**
   * Returns the short value for the column.
   */
  public short getShort(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getShort(_row - 1, column - 1);
    else
      return _rs.getShort(column);
  }

  /**
   * Returns the short value for the column.
   */
  public short getShort(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getShort(_row - 1, column - 1);
    else
      return _rs.getShort(column);
  }

  /**
   * Returns the int value for the column.
   */
  public int getInt(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getInt(_row - 1, column - 1);
    else
      return _rs.getInt(column);
  }

  /**
   * Returns the int value for the column.
   */
  public int getInt(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getInt(_row - 1, column - 1);
    else
      return _rs.getInt(column);
  }

  /**
   * Returns the long value for the column.
   */
  public long getLong(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getLong(_row - 1, column - 1);
    else
      return _rs.getLong(column);
  }

  /**
   * Returns the long value for the column.
   */
  public long getLong(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getLong(_row - 1, column - 1);
    else
      return _rs.getLong(column);
  }

  /**
   * Returns the float value for the column.
   */
  public float getFloat(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getFloat(_row - 1, column - 1);
    else
      return _rs.getFloat(column);
  }

  /**
   * Returns the float value for the column.
   */
  public float getFloat(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getFloat(_row - 1, column - 1);
    else
      return _rs.getFloat(column);
  }

  /**
   * Returns the double value for the column.
   */
  public double getDouble(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getDouble(_row - 1, column - 1);
    else
      return _rs.getDouble(column);
  }

  /**
   * Returns the double value for the column.
   */
  public double getDouble(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getDouble(_row - 1, column - 1);
    else
      return _rs.getDouble(column);
  }

  /**
   * Returns the string value for the column.
   */
  public String getString(int column)
    throws SQLException
  {
    if (_cacheChunk != null)
      return _cacheChunk.getString(_row - 1, column - 1);
    else
      return _rs.getString(column);
  }

  /**
   * Returns the string value for the column.
   */
  public String getString(String columnName)
    throws SQLException
  {
    int column = getColumn(columnName);

    if (_cacheChunk != null)
      return _cacheChunk.getString(_row - 1, column - 1);
    else
      return _rs.getString(column);
  }

  /**
   * Returns the bytes value for the column.
   */
  public byte []getBytes(int column)
    throws SQLException
  {
    return _rs.getBytes(getColumn(column));
  }

  /**
   * Returns the bytes value for the column.
   */
  public byte []getBytes(String column)
    throws SQLException
  {
    return _rs.getBytes(getColumn(column));
  }

  /**
   * Returns the column value as a date.
   */
  public java.sql.Date getDate(int column)
    throws SQLException
  {
    return _rs.getDate(getColumn(column));
  }

  /**
   * Returns the column value as a date.
   */
  public java.sql.Date getDate(String column)
    throws SQLException
  {
    return _rs.getDate(getColumn(column));
  }

  /**
   * Returns the column value as a date.
   */
  public java.sql.Date getDate(int column, Calendar cal)
    throws SQLException
  {
    return _rs.getDate(getColumn(column), cal);
  }

  /**
   * Returns the column value as a date.
   */
  public java.sql.Date getDate(String column, Calendar cal)
    throws SQLException
  {
    return _rs.getDate(getColumn(column), cal);
  }

  /**
   * Returns the time value for the column.
   */
  public Time getTime(int column)
    throws SQLException
  {
    return _rs.getTime(getColumn(column));
  }

  /**
   * Returns the time value for the column.
   */
  public Time getTime(String column)
    throws SQLException
  {
    return _rs.getTime(getColumn(column));
  }

  /**
   * Returns the time value for the column.
   */
  public Time getTime(int column, Calendar cal)
    throws SQLException
  {
    return _rs.getTime(getColumn(column), cal);
  }

  /**
   * Returns the time value for the column.
   */
  public Time getTime(String column, Calendar cal)
    throws SQLException
  {
    return _rs.getTime(getColumn(column), cal);
  }

  /**
   * Returns the column as a timestamp.
   */
  public Timestamp getTimestamp(int column)
    throws SQLException
  {
    return _rs.getTimestamp(getColumn(column));
  }

  /**
   * Returns the column as a timestamp.
   */
  public Timestamp getTimestamp(String column)
    throws SQLException
  {
    return _rs.getTimestamp(getColumn(column));
  }

  /**
   * Returns the column as a timestamp.
   */
  public Timestamp getTimestamp(int column, Calendar cal)
    throws SQLException
  {
    return _rs.getTimestamp(getColumn(column), cal);
  }

  /**
   * Returns the column as a timestamp.
   */
  public Timestamp getTimestamp(String column, Calendar cal)
    throws SQLException
  {
    return _rs.getTimestamp(getColumn(column), cal);
  }

  /**
   * Returns a ref value for the column.
   */
  public Ref getRef(int column)
    throws SQLException
  {
    return _rs.getRef(getColumn(column));
  }

  /**
   * Returns a ref value for the column.
   */
  public Ref getRef(String column)
    throws SQLException
  {
    return _rs.getRef(getColumn(column));
  }

  /**
   * Returns a clob value for the column.
   */
  public Clob getClob(int column)
    throws SQLException
  {
    return _rs.getClob(getColumn(column));
  }

  /**
   * Returns a clob value for the column.
   */
  public Clob getClob(String column)
    throws SQLException
  {
    return _rs.getClob(getColumn(column));
  }

  /**
   * Returns a blob value for the column.
   */
  public Blob getBlob(int column)
    throws SQLException
  {
    return _rs.getBlob(getColumn(column));
  }

  /**
   * Returns a blob value for the column.
   */
  public Blob getBlob(String column)
    throws SQLException
  {
    return _rs.getBlob(getColumn(column));
  }

  /**
   * Returns a character stream for the column.
   */
  public Reader getCharacterStream(int column)
    throws SQLException
  {
    return _rs.getCharacterStream(getColumn(column));
  }

  /**
   * Returns a character stream for the column.
   */
  public Reader getCharacterStream(String column)
    throws SQLException
  {
    return _rs.getCharacterStream(getColumn(column));
  }

  /**
   * Returns a binary stream for the column.
   */
  public InputStream getBinaryStream(int column)
    throws SQLException
  {
    return _rs.getBinaryStream(getColumn(column));
  }

  /**
   * Returns a binary stream for the column.
   */
  public InputStream getBinaryStream(String column)
    throws SQLException
  {
    return _rs.getBinaryStream(getColumn(column));
  }

  /**
   * Returns an ascii stream for the column.
   */
  public InputStream getAsciiStream(int column)
    throws SQLException
  {
    return _rs.getAsciiStream(getColumn(column));
  }

  /**
   * Returns an ascii stream for the column.
   */
  public InputStream getAsciiStream(String column)
    throws SQLException
  {
    return _rs.getAsciiStream(getColumn(column));
  }

  /**
   * Returns a unicode stream for the column.
   */
  public InputStream getUnicodeStream(int column)
    throws SQLException
  {
    return _rs.getUnicodeStream(getColumn(column));
  }

  /**
   * Returns a unicode stream for the column.
   */
  public InputStream getUnicodeStream(String column)
    throws SQLException
  {
    return _rs.getUnicodeStream(getColumn(column));
  }

  /**
   * Returns an array value for the column.
   */
  public Array getArray(int column)
    throws SQLException
  {
    return _rs.getArray(getColumn(column));
  }

  /**
   * Returns an array value for the column.
   */
  public Array getArray(String column)
    throws SQLException
  {
    return _rs.getArray(getColumn(column));
  }

  /**
   * Returns a URL value for the column.
   */
  public URL getURL(int column)
    throws SQLException
  {
    return _rs.getURL(getColumn(column));
  }

  /**
   * Returns a URL value for the column.
   */
  public URL getURL(String column)
    throws SQLException
  {
    return _rs.getURL(getColumn(column));
  }

  /**
   * Returns a big decimal value for the column.
   */
  public BigDecimal getBigDecimal(int column)
    throws SQLException
  {
    return _rs.getBigDecimal(getColumn(column));
  }

  /**
   * Returns a big decimal value for the column.
   */
  public BigDecimal getBigDecimal(String column)
    throws SQLException
  {
    return _rs.getBigDecimal(getColumn(column));
  }

  /**
   * Returns a big decimal value for the column.
   */
  public BigDecimal getBigDecimal(int column, int digit)
    throws SQLException
  {
    return _rs.getBigDecimal(getColumn(column), digit);
  }

  /**
   * Returns a big decimal value for the column.
   */
  public BigDecimal getBigDecimal(String column, int digit)
    throws SQLException
  {
    return _rs.getBigDecimal(getColumn(column), digit);
  }

  /**
   * Returns the object value for the column.
   */
  public Object getObject(int column)
    throws SQLException
  {
    ResultSetCacheChunk cacheChunk = _cacheChunk;

    Object value = null;

    if (cacheChunk != null) {
      if (log.isLoggable(Level.FINER))
        log.finer(L.l("amber Query returning cached getObject({0})", column));

      Object obj = cacheChunk.getObject(_row - 1, column - 1);

      if (obj instanceof EntityItem) {
        EntityItem entityItem = (EntityItem) obj;

        if (_session.isJPA())
          return _session.getEntity(entityItem);
        else
          return _session.loadProxy(entityItem);
        
        /*
        Entity entity = entityItem.getEntity();

        int index = getColumn(column);

        AmberExpr expr = _resultList.get(column - 1);

        EntityType entityType = entity.__caucho_getEntityType();

        boolean forceLoad = false;

        // jpa/0gf1
        // XXX: assert.
        if (expr instanceof LoadEntityExpr) {
          LoadEntityExpr entityExpr = (LoadEntityExpr) expr;

          if (entityType != entityExpr.getEntityType()) {
            forceLoad = true;
            entityType = entityExpr.getEntityType();
          }
        }

        if (entityType.getParentType() == null && ! forceLoad) {
          value = _session.loadProxy(entityType,
                                     entity.__caucho_getPrimaryKey());
        }
        else {
          // jpa/0l4a
          value = _session.loadFromHome(entityType.getBeanClass().getName(),
                                        entity.__caucho_getPrimaryKey());
        }

        _numberOfLoadingColumns = entityItem.getNumberOfLoadingColumns();
        */
      }
      else {
        value = obj;
      }
    }
    else {
      int index = getColumn(column);

      AmberExpr expr = _resultList.get(column - 1);

      if (_session == null)
        throw new NullPointerException();

      value = expr.getObject(_session, _rs, index);

      /*
      if (expr instanceof LoadEntityExpr) {
        if (log.isLoggable(Level.FINER))
          log.log(Level.FINER, L.l("ResultSetImpl expr is instance of LoadEntityExpr"));

        LoadEntityExpr entityExpr = (LoadEntityExpr) expr;
        _numberOfLoadingColumns = entityExpr.getIndex();
      }
      */
    }

    // jpa/0o40, jpa/1160
    if (value instanceof Entity) {
      Entity entity = (Entity) value;

      if (_session.isActiveTransaction())
        _session.setTransactionalState(entity);

      // jpa/1160
      // Should always add the entity to the context
      // and detach the entities after the result
      // list is fully retrieved. See manager.QueryImpl

      // XXX: should already be handled
      // _session.addEntity(entity);

      if (! _session.isJPA())
        return _session.loadProxy(entity.__caucho_getCacheItem());
    }

    return value;
  }

  /**
   * Returns the object value for the column.
   */
  public EntityItem findEntityItem(int column)
    throws SQLException
  {
    ResultSetCacheChunk cacheChunk = _cacheChunk;

    if (cacheChunk != null) {
      Object obj = cacheChunk.getObject(_row - 1, column - 1);

      if (obj instanceof EntityItem) {
        return (EntityItem) obj;
      }
      else
        throw new SQLException(L.l("'{0}' is an unexpected type.",
                                   obj));
    }
    else {
      int index = getColumn(column);

      AmberExpr expr = _resultList.get(column - 1);

      EntityItem item = expr.findItem(_session, _rs, index);

      return item;
    }
    /*
      FromItem item = _fromList.get(column - 1);
      AmberEntityHome home = item.getEntityHome();

      return home.load(_session, _rs, index);
    */
  }

  /**
   * Returns the object value for the column.
   */
  public Object getObject(String column)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Returns the object value for the column.
   */
  public Object getKey(int column)
    throws SQLException
  {
    int index = getColumn(column);

    FromItem item = _fromList.get(column - 1);
    AmberEntityHome home = item.getEntityHome();

    Object key = home.getEntityType().getId().getObject(_rs, index);

    return key;
  }

  /**
   * Returns the object value for the column.
   */
  public Object getObject(int column, Map<String,Class<?>> map)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Returns the object value for the column.
   */
  public Object getObject(String column, Map<String,Class<?>> map)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a string column in the row.
   */
  public void updateString(String column, String value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a string column in the row.
   */
  public void updateString(int column, String value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an object column in the row.
   */
  public void updateObject(String column, Object value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an object column in the row.
   */
  public void updateObject(int column, Object value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an object column in the row.
   */
  public void updateObject(String column, Object value, int scale)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an object column in the row.
   */
  public void updateObject(int column, Object value, int scale)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a timestamp column in the row.
   */
  public void updateTimestamp(String column, Timestamp timestamp)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a timestamp column in the row.
   */
  public void updateTimestamp(int column, Timestamp timestamp)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a time column in the row.
   */
  public void updateTime(String column, Time time)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a time column in the row.
   */
  public void updateTime(int column, Time time)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a date column in the row.
   */
  public void updateDate(String column, java.sql.Date date)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a date column in the row.
   */
  public void updateDate(int column, java.sql.Date date)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a clob column in the row.
   */
  public void updateClob(String column, Clob clob)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a clob column in the row.
   */
  public void updateClob(int column, Clob clob)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a blob column in the row.
   */
  public void updateBlob(String column, Blob blob)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a blob column in the row.
   */
  public void updateBlob(int column, Blob blob)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an array column in the row.
   */
  public void updateArray(String column, Array array)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an array column in the row.
   */
  public void updateArray(int column, Array array)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a big decimal column in the row.
   */
  public void updateBigDecimal(String column, BigDecimal decimal)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a big decimal column in the row.
   */
  public void updateBigDecimal(int column, BigDecimal decimal)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a ref column in the row.
   */
  public void updateRef(String column, Ref ref)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a ref column in the row.
   */
  public void updateRef(int column, Ref ref)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a character stream.
   */
  public void updateCharacterStream(String column, Reader x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a character stream.
   */
  public void updateCharacterStream(int column, Reader x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a binary stream.
   */
  public void updateBinaryStream(String column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a binary stream.
   */
  public void updateBinaryStream(int column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an ascii stream.
   */
  public void updateAsciiStream(String column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating an ascii stream.
   */
  public void updateAsciiStream(int column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a unicode stream.
   */
  public void updateUnicodeStream(String column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating a unicode stream.
   */
  public void updateUnicodeStream(int column, InputStream x, int length)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating bytes.
   */
  public void updateBytes(String column, byte []value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating bytes.
   */
  public void updateBytes(int column, byte []value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating boolean.
   */
  public void updateBoolean(String column, boolean value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating boolean.
   */
  public void updateBoolean(int column, boolean value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating byte.
   */
  public void updateByte(String column, byte value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating byte.
   */
  public void updateByte(int column, byte value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating short.
   */
  public void updateShort(String column, short value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating short.
   */
  public void updateShort(int column, short value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating int.
   */
  public void updateInt(String column, int value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating int.
   */
  public void updateInt(int column, int value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating long.
   */
  public void updateLong(String column, long value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating long.
   */
  public void updateLong(int column, long value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating float.
   */
  public void updateFloat(String column, float value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating float.
   */
  public void updateFloat(int column, float value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating double.
   */
  public void updateDouble(String column, double value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating double.
   */
  public void updateDouble(int column, double value)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating null.
   */
  public void updateNull(String column)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating null.
   */
  public void updateNull(int column)
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * updates the row
   */
  public void updateRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * cancels the row updates.
   */
  public void cancelRowUpdates()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * refreshes the row
   */
  public void refreshRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * move to the current row
   */
  public void moveToCurrentRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * Updating
   */
  public boolean rowUpdated()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * True if the row was inserted.
   */
  public boolean rowInserted()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * move to insert the row
   */
  public void moveToInsertRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * insert the row
   */
  public void insertRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * True if the row was deleted.
   */
  public boolean rowDeleted()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  /**
   * delete the row
   */
  public void deleteRow()
    throws SQLException
  {
    throw new UnsupportedOperationException();
  }

  public int getNumberOfLoadingColumns()
  {
    return _numberOfLoadingColumns;
  }

  private int getColumn(String name)
  {
    throw new UnsupportedOperationException();
  }

  private int getColumn(int index)
  {
    return index;
  }

  public void close()
  {
    ResultSet rs = _rs;
    _rs = null;

    if (rs != null) {
      try {
        rs.close();
      } catch (SQLException e) {
        log.log(Level.FINE, e.toString(), e);
      }
    }
  }

    public RowId getRowId(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public RowId getRowId(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateRowId(int columnIndex, RowId x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateRowId(String columnLabel, RowId x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public int getHoldability() throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public boolean isClosed() throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNString(int columnIndex, String nString) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNString(String columnLabel, String nString) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public NClob getNClob(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public NClob getNClob(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public SQLXML getSQLXML(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public SQLXML getSQLXML(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String getNString(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public String getNString(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Reader getNCharacterStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Reader getNCharacterStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateClob(int columnIndex, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateClob(String columnLabel, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public <T> T unwrap(Class<T> iface) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}
