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

説明を見る。

package org.objectweb.cjdbc.driver;

import java.sql.BatchUpdateException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.util.Vector;

import org.objectweb.cjdbc.common.sql.AbstractWriteRequest;
import org.objectweb.cjdbc.common.sql.AlterRequest;
import org.objectweb.cjdbc.common.sql.CreateRequest;
import org.objectweb.cjdbc.common.sql.DeleteRequest;
import org.objectweb.cjdbc.common.sql.DropRequest;
import org.objectweb.cjdbc.common.sql.InsertRequest;
import org.objectweb.cjdbc.common.sql.NotImplementedException;
import org.objectweb.cjdbc.common.sql.SelectRequest;
import org.objectweb.cjdbc.common.sql.StoredProcedure;
import org.objectweb.cjdbc.common.sql.UpdateRequest;

public class Statement implements java.sql.Statement
{
  protected Connection         connection        = null;

  private Vector               batch             = null;

  private SQLWarning           warnings          = null;

  private java.sql.ResultSet   result            = null;

  private int                  updateCount       = -1;

  private int                  timeout           = 0;

  private int                  fetchSize         = 0;
  private String               cursorName;

  private int                  resultSetType;

  private int                  maxFieldSize      = 0;

  private int                  maxRows           = 0;

  protected boolean            escapeProcessing  = true;

  protected java.sql.ResultSet generatedKeys     = null;
  protected int                generatedKeysFlag = java.sql.Statement.NO_GENERATED_KEYS;

  public Statement(Connection c)
  {
    connection = c;
    resultSetType = java.sql.ResultSet.TYPE_FORWARD_ONLY;
  }

  public void addBatch(String sql) throws SQLException
  {
    if (batch == null)
      batch = new Vector();
    batch.addElement(sql.trim());
  }

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

  public void clearBatch() throws SQLException
  {
    if (batch != null)
      batch.removeAllElements();
  }

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

  public int[] executeBatch() throws SQLException
  {
    if (batch == null || batch.isEmpty())
      throw new SQLException("Error: batch is empty");

    int size = batch.size();
    int[] result = new int[size];
    int i = 0;

    try
    {
      for (i = 0; i < size; i++)
        result[i] = this.executeUpdate((String) batch.elementAt(i));
      return result;
    }
    catch (SQLException e)
    {
      String message = "Batch failed for request " + i + ": "
          + batch.elementAt(i) + " (" + e + ")";

      int[] updateCounts = new int[i];
      System.arraycopy(result, 0, updateCounts, 0, i);

      throw new BatchUpdateException(message, updateCounts);
    }
    finally
    {
      batch.removeAllElements();
    }
  }

  public void close() throws SQLException
  {
    // Force the ResultSet to close
    if (result != null)
      result.close();

    // Disasociate it from us (For Garbage Collection)
    result = null;
    connection = null;
  }

  public boolean execute(String sql) throws SQLException
  {
    if (sql.regionMatches(true, 0, "select", 0, 6)
        || (sql.regionMatches(true, 0, "{call", 0, 5)))
    {
      result = executeQuery(sql);
      return true;
    }
    else
    {
      updateCount = executeUpdate(sql);
      return false;
    }
  }

  public java.sql.ResultSet executeQuery(String sql) throws SQLException
  {
    return executeQuery(null, sql.trim());
  }

  protected java.sql.ResultSet executeQuery(String sqlSkeleton, String sqlQuery)
      throws SQLException
  {
    updateCount = -1; // invalidate the last write result
    if (result != null)
    { // Discard the previous result
      result.close();
      result = null;
    }

    if (sqlQuery.regionMatches(true, 0, "select", 0, 6))
    {
      SelectRequest request = new SelectRequest(sqlQuery, escapeProcessing,
          timeout, connection.LINE_SEPARATOR);
      if (connection.needSqlSkeleton)
        request.setSqlSkeleton(sqlSkeleton);
      request.setMaxRows(maxRows);
      request.setFetchSize(fetchSize);
      request.setCursorName(cursorName);
      result = connection.execReadRequest(request);
    }
    else if (sqlQuery.regionMatches(true, 0, "{call", 0, 5))
    {
      StoredProcedure proc = new StoredProcedure(sqlQuery, escapeProcessing,
          timeout, connection.LINE_SEPARATOR);
      proc.setMaxRows(maxRows);
      result = connection.execReadStoredProcedure(proc);
    }
    else
      throw new SQLException(
          "executeQuery only accepts statements starting with 'select' or '{call' ("
              + sqlQuery + ")");

    if (result instanceof DriverResultSet)
      ((DriverResultSet) result).setStatement(this);
    return result;
  }

  public int executeUpdate(String sql) throws SQLException
  {
    return executeUpdateWithSkeleton(null, sql.trim());
  }

  protected int executeUpdateWithSkeleton(String sqlSkeleton, String sqlQuery)
      throws SQLException
  {
    if (result != null)
    { // Discard the previous result
      result.close();
      result = null;
    }

    // Check that the command starts with
    // insert/update/delete/create/drop/{call
    String lower = sqlQuery.substring(0,
        6 < sqlQuery.length() ? 6 : sqlQuery.length()).toLowerCase();
    AbstractWriteRequest request;
    if (lower.equals("insert"))
      request = new InsertRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.equals("update"))
      request = new UpdateRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.equals("delete"))
      request = new DeleteRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.startsWith("create"))
      request = new CreateRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.startsWith("drop"))
      request = new DropRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.startsWith("alter"))
      request = new AlterRequest(sqlQuery, escapeProcessing, timeout,
          connection.LINE_SEPARATOR);
    else if (lower.startsWith("{call"))
    { // Call stored procedure and return
      updateCount = connection.execWriteStoredProcedure(new StoredProcedure(
          sqlQuery, escapeProcessing, timeout, connection.LINE_SEPARATOR));
      return updateCount;
    }
    else
      throw new SQLException(
          "executeUpdate only accepts statements starting with insert/update/delete/create/drop/{call ("
              + sqlQuery + ")");

    if (connection.needSqlSkeleton)
      request.setSqlSkeleton(sqlSkeleton);

    if (generatedKeysFlag == Statement.RETURN_GENERATED_KEYS)
    { // Get the auto generated key back
      generatedKeys = connection.execWriteRequestWithKeys(request);

      /*
       * Usually it is one autoincrement field and one generated key but if it
       * is not acceptable - better way to make another function for return
       * count of updates Or leave execWriteRequestWithKeys to return count and
       * add function for return ResultSet
       */
      return 1;
    }
    else
    { // No generated keys
      updateCount = connection.execWriteRequest(request);
      return updateCount;
    }
  }

  public java.sql.Connection getConnection() throws SQLException
  {
    return connection;
  }

  public int getFetchDirection() throws SQLException
  {
    throw new NotImplementedException("getFetchDirection()");
  }

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

  public int getMaxFieldSize() throws SQLException
  {
    return maxFieldSize;
  }

  public int getMaxRows() throws SQLException
  {
    return maxRows;
  }

  public boolean getMoreResults() throws SQLException
  {
    if (result != null)
      result.close();
    updateCount = -1;
    return false;
  }

  public int getQueryTimeout() throws SQLException
  {
    return timeout;
  }

  public java.sql.ResultSet getResultSet() throws SQLException
  {
    return result;
  }

  public int getResultSetConcurrency() throws SQLException
  {
    return java.sql.ResultSet.CONCUR_READ_ONLY;
  }

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

  public int getUpdateCount() throws SQLException
  {
    return updateCount;
  }

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

  public void setCursorName(String name) throws SQLException
  {
    cursorName = name;
  }

  public void setEscapeProcessing(boolean enable) throws SQLException
  {
    escapeProcessing = enable;
  }

  public void setFetchDirection(int direction) throws SQLException
  {
  }

  public void setFetchSize(int rows) throws SQLException
  {
    fetchSize = rows;
  }

  public void setMaxFieldSize(int max) throws SQLException
  {
    maxFieldSize = max;
  }

  public void setMaxRows(int max) throws SQLException
  {
    maxRows = max;
  }

  public void setQueryTimeout(int seconds) throws SQLException
  {
    timeout = seconds;
  }

  public void setResultSetConcurrency(int value) throws SQLException
  {
    if (value != java.sql.ResultSet.CONCUR_READ_ONLY)
      throw new SQLException(
          "CONCUR_READ_ONLY is the only supported conccurency mode");
  }

  public void setResultSetType(int value) throws SQLException
  {
    if (value == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE)
      throw new SQLException(
          "TYPE_SCROLL_SENSITIVE is not a supported ResultSet type");
    resultSetType = value;
  }

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

  public boolean getMoreResults(int current) throws SQLException
  {
    throw new NotImplementedException("getMoreResults");
  }

  public java.sql.ResultSet getGeneratedKeys() throws SQLException
  {
    return generatedKeys;
  }

  public int executeUpdate(String sql, int autoGeneratedKeys)
      throws SQLException
  {
    generatedKeysFlag = autoGeneratedKeys;
    return executeUpdate(sql);
  }

  public int executeUpdate(String sql, int columnIndexes[]) throws SQLException
  {
    throw new NotImplementedException("executeUpdate");
  }

  public int executeUpdate(String sql, String columnNames[])
      throws SQLException
  {
    throw new NotImplementedException("executeUpdate");
  }

  public boolean execute(String sql, int autoGeneratedKeys) throws SQLException
  {
    generatedKeysFlag = autoGeneratedKeys;
    return execute(sql);
  }

  public boolean execute(String sql, int columnIndexes[]) throws SQLException
  {
    throw new NotImplementedException("execute");
  }

  public boolean execute(String sql, String columnNames[]) throws SQLException
  {
    throw new NotImplementedException("execute");
  }

  public int getResultSetHoldability() throws SQLException
  {
    throw new NotImplementedException("getResultSetHoldability");
  }

}

---