src/org/objectweb/cjdbc/controller/virtualdatabase/ControllerResultSet.java

説明を見る。

package org.objectweb.cjdbc.controller.virtualdatabase;

import java.io.Serializable;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;

import org.objectweb.cjdbc.common.sql.AbstractRequest;
import org.objectweb.cjdbc.common.sql.SelectRequest;
import org.objectweb.cjdbc.controller.cache.metadata.MetadataCache;
import org.objectweb.cjdbc.driver.Field;

public class ControllerResultSet implements Serializable
{
  private ArrayList data              = null;
  private Field[]   fields            = null;
  private String    cursorName        = null;
  private int       fetchSize         = 0;
  private ResultSet dbResultSet       = null;
  private boolean   dbResultSetClosed = true;
  private boolean   hasMoreData       = false;
  private int       maxRows           = 0;

  public ControllerResultSet(AbstractRequest request, java.sql.ResultSet rs,
      MetadataCache metadataCache) throws SQLException
  {
    try
    {
      if (rs == null)
        throw new SQLException("Null ResultSet");

      // This is already a result coming from another controller.
      //if (rs instanceof org.objectweb.cjdbc.driver.ResultSet)
      //  return (org.objectweb.cjdbc.driver.ResultSet) rs;

      // Build the ResultSet metaData
      int nbColumn;
      if (metadataCache != null)
        fields = metadataCache.getMetadata(request);

      if (fields == null)
      { // Metadata Cache miss
        // Build the fields from the MetaData
        java.sql.ResultSetMetaData metaData = rs.getMetaData();
        if (metaData == null)
          throw new SQLException("unable to fetch metadata");
        nbColumn = metaData.getColumnCount();
        fields = new Field[nbColumn];
        for (int i = 0; i < nbColumn; i++)
        {
          // 1st column is 1
          String columnName = metaData.getColumnName(i + 1);
          if (metadataCache != null)
          { // Check Field cache
            fields[i] = metadataCache.getField(columnName);
            if (fields[i] != null)
              continue; // Cache hit
          }
          // Field cache miss
          String tableName = null;
          try
          {
            tableName = metaData.getTableName(i + 1);
          }
          catch (Exception ignore)
          {
          }
          int columnDisplaySize = 0;
          try
          {
            columnDisplaySize = metaData.getColumnDisplaySize(i + 1);
          }
          catch (Exception ignore)
          {
          }
          int columnType = -1;
          try
          {
            columnType = metaData.getColumnType(i + 1);
          }
          catch (Exception ignore)
          {
          }
          String columnTypeName = null;
          try
          {
            columnTypeName = metaData.getColumnTypeName(i + 1);
          }
          catch (Exception ignore)
          {
          }
          String columnClassName = null;
          try
          {
            columnClassName = metaData.getColumnClassName(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isAutoIncrement = false;
          try
          {
            isAutoIncrement = metaData.isAutoIncrement(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isCaseSensitive = false;
          try
          {
            isCaseSensitive = metaData.isCaseSensitive(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isCurrency = false;
          try
          {
            isCurrency = metaData.isCurrency(i + 1);
          }
          catch (Exception ignore)
          {
          }
          int isNullable = ResultSetMetaData.columnNullableUnknown;
          try
          {
            isNullable = metaData.isNullable(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isReadOnly = false;
          try
          {
            isReadOnly = metaData.isReadOnly(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isWritable = false;
          try
          {
            isWritable = metaData.isWritable(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isDefinitelyWritable = false;
          try
          {
            isReadOnly = metaData.isDefinitelyWritable(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isSearchable = false;
          try
          {
            isSearchable = metaData.isSearchable(i + 1);
          }
          catch (Exception ignore)
          {
          }
          boolean isSigned = false;
          try
          {
            isSigned = metaData.isSigned(i + 1);
          }
          catch (Exception ignore)
          {
          }
          int precision = 0;
          try
          {
            precision = metaData.getPrecision(i + 1);
          }
          catch (Exception ignore)
          {
          }
          int scale = 0;
          try
          {
            scale = metaData.getScale(i + 1);
          }
          catch (Exception ignore)
          {
          }
          fields[i] = new Field(tableName, columnName, columnDisplaySize,
              columnType, columnTypeName, columnClassName, isAutoIncrement,
              isCaseSensitive, isCurrency, isNullable, isReadOnly, isWritable,
              isDefinitelyWritable, isSearchable, isSigned, precision, scale);

          if (metadataCache != null)
            // Add field to cache
            metadataCache.addField(columnName, fields[i]);
        }
      }
      else
        nbColumn = fields.length;

      // Build the ResultSet data
      if (rs.next())
      {
        if (request instanceof SelectRequest)
        {
          SelectRequest select = (SelectRequest) request;
          cursorName = select.getCursorName();
          fetchSize = select.getFetchSize();
        }
        maxRows = request.getMaxRows();
        if (maxRows == 0)
          maxRows = Integer.MAX_VALUE; // Infinite number of rows

        // Note that fetchData updates the data field
        dbResultSet = rs;
        fetchData();
        if (hasMoreData && (cursorName == null))
          cursorName = String.valueOf(dbResultSet.hashCode());
      }
      else
      {
        hasMoreData = false;
        dbResultSet = null;
        dbResultSetClosed = true;
        rs.close();
      }
    }
    catch (SQLException e)
    {
      throw new SQLException("Error while building C-JDBC ResultSet (" + e
          + ")");
    }
  }

  public ArrayList fetchData(int fetchSize) throws SQLException
  {
    this.fetchSize = fetchSize;
    return fetchData();
  }

  public ArrayList fetchData() throws SQLException
  {
    if (dbResultSet == null)
      return null;

    Object[] row;
    // We directly update the data field
    data = new ArrayList();
    int toFetch;
    if (fetchSize > 0)
    {
      toFetch = fetchSize < maxRows ? fetchSize : maxRows;
      maxRows -= toFetch;
    }
    else
      toFetch = maxRows;
    int nbColumn = fields.length;
    Object object;
    do
    {
      row = new Object[nbColumn];
      for (int i = 0; i < nbColumn; i++)
      {
        object = dbResultSet.getObject(i + 1);
        // Convert database native Clob and Blob to C-JDBC Clob/Blobs that are
        // Serializable
        if (object!=null)
        {
          if (object instanceof java.sql.Clob)
          {
            java.sql.Clob clob = (java.sql.Clob) object;
            object = clob.getSubString(1, (int) clob.length());
          }
          else if (object instanceof java.sql.Blob)
          {
            java.sql.Blob blob = (java.sql.Blob) object;
            object = blob.getBytes(1, (int) blob.length());
          }
        }
        row[i] = object;
      }
      data.add(row);
      toFetch--;
      hasMoreData = dbResultSet.next();
    }
    while (hasMoreData && (toFetch > 0));
    if (hasMoreData && (fetchSize > 0) && (maxRows > 0))
    { // More data to fetch later on
      maxRows += toFetch;
      dbResultSetClosed = false;
    }
    else
    {
      hasMoreData = false;
      dbResultSet.close();
      dbResultSet = null;
      dbResultSetClosed = true;
    }
    return data;
  }

  public ArrayList getData()
  {
    return data;
  }

  public Field[] getFields()
  {
    return fields;
  }

  public String getCursorName()
  {
    return cursorName;
  }

  public boolean hasMoreData()
  {
    return hasMoreData;
  }

  public void closeResultSet()
  {
    if ((dbResultSet != null) && !dbResultSetClosed)
    {
      try
      {
        dbResultSet.close();
      }
      catch (SQLException ignore)
      {
      }
      dbResultSet = null; // to allow GC to work properly
    }
  }

}

---