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

説明を見る。

package org.objectweb.cjdbc.driver;

import java.io.IOException;
import java.net.Socket;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Savepoint;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Properties;

import org.objectweb.cjdbc.common.exceptions.NoMoreBackendException;
import org.objectweb.cjdbc.common.sql.AbstractRequest;
import org.objectweb.cjdbc.common.sql.AbstractWriteRequest;
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.filters.AbstractBlobFilter;
import org.objectweb.cjdbc.common.sql.filters.HexaBlobFilter;
import org.objectweb.cjdbc.common.stream.CJDBCInputStream;
import org.objectweb.cjdbc.common.stream.CJDBCOutputStream;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.driver.protocol.CommandCompleted;
import org.objectweb.cjdbc.driver.protocol.Commands;

public class Connection implements java.sql.Connection
{
  // Member variables describing the state of the connection

  protected boolean             autoCommit                    = true;

  protected boolean             isClosed                      = false;

  protected boolean             readOnly                      = false;

  protected int                 isolationLevel                = java.sql.Connection.TRANSACTION_READ_COMMITTED;

  protected long                transactionId                 = 0;

  protected boolean             needSqlSkeleton               = false;

  protected SQLWarning          firstWarning                  = null;

  protected DatabaseMetaData    metaData                      = null;

  protected Driver              driver                        = null;

  protected String              url                           = null;

  protected String              vdbUser                       = null;
  protected String              vdbPassword                   = null;

  protected Socket              socket;

  protected CJDBCInputStream    socketInput;

  protected CJDBCOutputStream   socketOutput;

  private int                   reconnectRetries              = 0;
  // Maximum number of reconnect attempts when an IOException occurs
  // while communicating with the controller
  private static final int      MAX_RECONNECT_ATTEMPTS        = 2;

  private AbstractBlobFilter    blobFilter;

  // Escape processing tuning
  protected boolean             escapeBackslash               = true;
  protected boolean             escapeSingleQuote             = true;

  //Parsing Query values
  protected boolean             driverProcessed               = true;
  public static String          startParamTag                 = "<?";
  public static String          endParamTag                   = "|?>";

  // PreparedStatement.setBoolean values
  protected String              preparedStatementBooleanTrue  = "'1'";
  protected String              preparedStatementBooleanFalse = "'0'";

  protected String              escapeChar                    = "\'";

  protected static final String LINE_SEPARATOR                = System
                                                                  .getProperty("line.separator");

  private boolean               closeSocketOnGC               = true;

  /*****************************************************************************
   * *************** * Constructor and get/set methods * ***********************
   * ****************************************************************************
   */

  public Connection()
  {
  }

  public Connection(Driver driver, Socket socket, CJDBCInputStream in,
      CJDBCOutputStream out, String url, String userName, String password,
      boolean sqlSkeletonNeeded, AbstractBlobFilter filter)
  {
    this.driver = driver;
    this.socket = socket;
    this.socketInput = in;
    this.socketOutput = out;
    this.url = url;
    this.vdbUser = userName;
    this.vdbPassword = password;
    this.needSqlSkeleton = sqlSkeletonNeeded;
    this.blobFilter = filter;
  }

  protected void finalize() throws Throwable
  {
    if (this.closeSocketOnGC)
    {
      Throwable t = null;
      try
      {
        rollback();
      }
      catch (Exception e)
      {
        t = e;
      }
      try
      {
        close();
      }
      catch (Exception e)
      {
        t = e;
      }

      if (t != null)
      {
        throw t;
      }

    }
    super.finalize();
  }

  public String getURL()
  {
    return url;
  }

  public String getUserName()
  {
    return vdbUser;
  }

  public String getPassword()
  {
    return vdbUser;
  }

  public String getConnectedController()
  {
    if (socket == null)
      return null;
    else
      return socket.getInetAddress().getHostName() + ":" + socket.getPort();
  }

  /*****************************************************************************
   * *********************************** * Connection interface methods * *
   * ***********************************
   */

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

  public void close() throws SQLException
  {
    // We synchronize here in the case 2 threads try to call close()
    // concurrently on this connection.
    synchronized (this)
    {
      if (isClosed)
        return;
      else
        isClosed = true;
    }

    try
    {
      autoCommit = true;
      readOnly = false;
      socketOutput.writeInt(Commands.Reset);
      socketOutput.flush();
    }
    catch (Exception e)
    {
      throw new SQLException("Error while closing the connection: " + e);
    }

    synchronized (driver.pendingConnectionClosing)
    {
      if (!driver.connectionClosingThreadisAlive)
      { // First connection to close, start a new closing thread
        ConnectionClosingThread t = new ConnectionClosingThread(driver);
        t.start();
      }
      // Add to the list
      driver.pendingConnectionClosing.add(this);
    }
  }

  public void commit() throws SQLException
  {
    if (autoCommit)
      throw new SQLException("Trying to commit a connection in autocommit mode");

    if (driver == null)
      throw new SQLException("No driver to send the commit request");
    try
    {
      socketOutput.writeInt(Commands.Commit);
      socketOutput.flush();
      // Commit is followed by a BEGIN
      Object r = socketInput.readObject();
      if (r instanceof Long)
        transactionId = ((Long) r).longValue();
      else
        throw new SQLException(
            "Error occured while trying to start transaction after commit on C-JDBC Controller ("
                + r + ")");
    }
    catch (Exception e)
    {
      throw new SQLException("Error occured while commit of transaction '"
          + transactionId + "' was processed by C-JDBC Controller (" + e + ")");
    }
  }

  public java.sql.Statement createStatement() throws SQLException
  {
    return new Statement(this);
  }

  public java.sql.Statement createStatement(int resultSetType,
      int resultSetConcurrency) throws SQLException
  {
    Statement s = new Statement(this);
    s.setResultSetType(resultSetType);
    s.setResultSetConcurrency(resultSetConcurrency);
    return s;
  }

  public boolean getAutoCommit() throws SQLException
  {
    return this.autoCommit;
  }

  public java.sql.DatabaseMetaData getMetaData() throws SQLException
  {
    if (metaData == null)
    {
      metaData = new DatabaseMetaData(this);
    }
    return metaData;
  }

  public String getCatalog() throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the catalog.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetCatalog);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof String)
      {
        return (String) rs;
      }
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException("Connection.getCatalog: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getCatalog: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public ResultSet getCatalogs() throws SQLException
  {

    if (driver == null)
      throw new SQLException("No driver to get the catalogs.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetCatalogs);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException("Connection.getCatalogs: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getCatalogs: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  protected java.sql.ResultSet getProcedures(String catalog,
      String schemaPattern, String procedureNamePattern) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the tables.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetProcedures);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(procedureNamePattern);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException(
            "Connection.getProcedures: Unexpected response (" + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getProcedures: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  protected java.sql.ResultSet getProcedureColumns(String catalog,
      String schemaPattern, String procedureNamePattern,
      String columnNamePattern) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the tables.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetProcedureColumns);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(procedureNamePattern);
      socketOutput.writeUTF(columnNamePattern);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException(
            "Connection.getProcedureColumns: Unexpected response (" + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getProcedureColumns: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public int getTransactionIsolation() throws SQLException
  {
    return isolationLevel;
  }

  public java.util.Map getTypeMap() throws SQLException
  {
    throw new NotImplementedException("getTypeMap()");
  }

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

  public boolean isClosed() throws SQLException
  {
    return isClosed;
  }

  public boolean isReadOnly() throws SQLException
  {
    return readOnly;
  }

  public String nativeSQL(String query) throws SQLException
  {
    return query;
  }

  public java.sql.CallableStatement prepareCall(String sql) throws SQLException
  {
    return prepareCall(sql, java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,
        java.sql.ResultSet.CONCUR_READ_ONLY);
  }

  public java.sql.CallableStatement prepareCall(String sql, int resultSetType,
      int resultSetConcurrency) throws SQLException
  {
    CallableStatement c = new CallableStatement(this, sql);
    c.setResultSetType(resultSetType);
    c.setResultSetConcurrency(resultSetConcurrency);
    return c;
  }

  public java.sql.PreparedStatement prepareStatement(String sql)
      throws SQLException
  {
    return new PreparedStatement(this, sql);
  }

  public java.sql.PreparedStatement prepareStatement(String sql,
      int resultSetType, int resultSetConcurrency) throws SQLException
  {
    PreparedStatement s = new PreparedStatement(this, sql);
    s.setResultSetType(resultSetType);
    s.setResultSetConcurrency(resultSetConcurrency);
    return s;
  }

  public void rollback() throws SQLException
  {
    if (autoCommit)
      throw new SQLException(
          "Trying to rollback a connection in autocommit mode");

    if (driver == null)
      throw new SQLException("No driver to send the rollback request");

    try
    {
      socketOutput.writeInt(Commands.Rollback);
      socketOutput.flush();
      // Rollback is followed by a BEGIN
      Object r = socketInput.readObject();
      if (r instanceof Long)
        transactionId = ((Long) r).longValue();
      else
        throw new SQLException(
            "Error occured while trying to start transaction after rollback on C-JDBC Controller ("
                + r + ")");
    }
    catch (Exception e)
    {
      throw new SQLException("Error occured while rollback of transaction '"
          + transactionId + "' was processed by C-JDBC Controller (" + e + ")");
    }
  }

  public void setAutoCommit(boolean autoCommit) throws SQLException
  {
    if (this.autoCommit == autoCommit)
      return;

    this.autoCommit = autoCommit;
    if (driver == null)
      throw new SQLException("No driver to get a transaction id");

    if (autoCommit)
    {
      transactionId = 0;
      try
      {
        socketOutput.writeInt(Commands.SetAutoCommit);
        socketOutput.flush();
        Object r = socketInput.readObject();
        if (r instanceof Boolean || ((Boolean) r).booleanValue())
          return;
        else
          throw new SQLException(
              "Error occured while trying to change autocommit value on C-JDBC Controller ("
                  + r + ")");
      }
      catch (Exception e)
      {
        throw new SQLException(
            "Error occured while trying to change autocommit value on C-JDBC Controller ("
                + e + ")");
      }
    }
    else
    {

      try
      {
        socketOutput.writeInt(Commands.Begin);
        socketOutput.flush();
        Object r = socketInput.readObject();
        if (r instanceof Long)
          transactionId = ((Long) r).longValue();
        else
          throw new SQLException(
              "Error occured while trying to start transaction on C-JDBC Controller ("
                  + r + ")");
        this.autoCommit = false;
      }
      catch (Exception e)
      {
        throw new SQLException(
            "Error occured while trying to start transaction on C-JDBC Controller ("
                + e + ")");
      }
    }
  }

  public void setCatalog(String catalog) throws SQLException
  {
    if (catalog == null)
      throw new SQLException("Invalid Catalog");
    Hashtable properties = driver.parseURL(url);
    properties.put(Driver.DATABASE_PROPERTY, catalog);
    url = driver.getUrlFromProperties(properties);

    if (driver == null)
      throw new SQLException("No driver to set the catalog.");
    try
    {
      socketOutput.writeInt(Commands.ConnectionSetCatalog);
      socketOutput.writeUTF(catalog);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof Boolean)
      {
        if (((Boolean) rs).booleanValue() == false)
          throw new SQLException("Invalid Catalog");
      }
      else
        throw new SQLException("Connection.setCatalog: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.setCatalog: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public void setReadOnly(boolean readOnly) throws SQLException
  {
    if (autoCommit == false)
      throw new SQLException(
          "setReadOnly cannot be called while in the middle of a transaction.");

    this.readOnly = readOnly;
  }

  public void setTransactionIsolation(int level) throws SQLException
  {
    isolationLevel = level;
  }

  public void setTypeMap(java.util.Map map) throws SQLException
  {
    throw new NotImplementedException("setTypeMap()");
  }

  /*
   * Connection C-JDBC internals
   */

  protected void setConnectionParametersOnRequest(AbstractRequest request)
  {
    request.setIsAutoCommit(autoCommit);
    request.setIsReadOnly(readOnly);
    request.setDriverProcessed(driverProcessed);
  }

  protected java.sql.ResultSet execReadRequest(SelectRequest request)
      throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to send the request '"
          + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH) + "'");
    try
    {
      setConnectionParametersOnRequest(request);
      socketOutput.writeInt(Commands.ExecReadRequest);
      readRequestOnStream(request);
      socketOutput.flush();

      Object in = socketInput.readObject();
      if (in instanceof NoMoreBackendException)
      {
        try
        {
          // If there is only one controller available rethrow the exception
          if (driver.getControllerConfig().size() == 1)
            throw (SQLException) in;
          else
          {
            // otherwise try to connect to an other controller and re-execute
            // the query
            reconnect();
            return execReadRequest(request);
          }
        }
        catch (SQLException e1)
        {
          // We deal with this exception in the follwoing if block
          in = e1;
        }
      }
      if (in instanceof IOException)
      {
        reconnect();
        return execReadRequest(request);
      }
      else if (in instanceof SQLException)
      {
        throw (SQLException) in;
      }
      else if (in instanceof Field[])
      { // Get the ResultSet metadata the row data
        Field[] fields = (Field[]) in;
        ArrayList data = null;
        boolean hasMoreData;
        String cursorName = null;
        try
        {
          data = (ArrayList) socketInput.readObject();
          hasMoreData = socketInput.readBoolean();
          if (hasMoreData)
            cursorName = socketInput.readUTF();
        }
        catch (IOException e)
        {
          reconnect();
          return execReadRequest(request);
        }
        catch (Exception e1)
        {
          throw new SQLException(
              "Connection.execReadRequest: Unexpected response (" + e1
                  + ") for request "
                  + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
        }
        return new org.objectweb.cjdbc.driver.DriverResultSet(fields, data,
            hasMoreData, cursorName);
      }
      else
      {
        throw new SQLException(
            "Connection.execReadRequest: Unexpected response (" + in
                + ") for request "
                + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
      }

    }
    catch (RuntimeException e)
    {
      e.printStackTrace();
      throw new SQLException(
          "Connection.execReadRequest: Error occured while request '"
              + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
              + "' was processed by C-JDBC Controller (" + e + ")");
    }
    catch (IOException e)
    { // Connection failed, try to reconnect and re-exec the query
      try
      {
        reconnect();
        return execReadRequest(request);
      }
      catch (SQLException e1)
      {
        throw new SQLException("Connection lost while executing request '"
            + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
            + "' and automatic reconnect failed (" + e1 + ")");
      }
    }
    catch (ClassNotFoundException e)
    {
      e.printStackTrace();
      throw new SQLException(
          "Connection.execReadRequest: Unexpected response (" + e
              + ") for request "
              + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
  }

  private void reconnect() throws SQLException
  {
    // Get rid of current connection
    try
    {
      this.socket.close();
    }
    catch (IOException ignore)
    {
    }
    try
    {
      this.socketInput.close();
    }
    catch (IOException ignore)
    {
    }
    try
    {
      this.socketOutput.close();
    }
    catch (IOException ignore)
    {
    }
    synchronized (driver.pendingConnectionClosing)
    {
      if (driver.pendingConnectionClosing.remove(this))
        System.out.println("Warning! Closed call before reconnect");
    }

    // Get a new connection
    reconnectRetries++;
    if (reconnectRetries > MAX_RECONNECT_ATTEMPTS)
    {
      reconnectRetries = 0;
      throw new SQLException("Aborting after " + MAX_RECONNECT_ATTEMPTS
          + " attemps.");
    }
    Properties prop = new Properties();
    prop.setProperty(Driver.USER_PROPERTY, vdbUser);
    prop.setProperty(Driver.PASSWORD_PROPERTY, vdbPassword);
    Connection c = (Connection) driver.connect(url, prop);
    c.setCloseSocketOnGC(false);
    this.socket = c.socket;
    this.socketInput = c.socketInput;
    this.socketOutput = c.socketOutput;
    this.isClosed = false;
    try
    {
      socketOutput.writeInt(Commands.RestoreConnectionState);
      socketOutput.writeBoolean(autoCommit);
      if (!autoCommit)
        socketOutput.writeLong(transactionId);
    }
    catch (IOException e)
    {
      throw new SQLException("Failed to reconnect to controller (" + e + ")");
    }
    reconnectRetries = 0;
  }

  protected void setCloseSocketOnGC(boolean closeSocketOnGC)
  {
    this.closeSocketOnGC = closeSocketOnGC;
  }

  protected int execWriteRequest(AbstractWriteRequest request)
      throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to send the request '"
          + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH) + "'");
    try
    {
      setConnectionParametersOnRequest(request);
      socketOutput.writeInt(Commands.ExecWriteRequest);
      writeRequestOnStream(request, false);
      socketOutput.flush();

      Object r = socketInput.readObject();
      if (r instanceof Integer)
        return ((Integer) r).intValue();
      else if (r instanceof SQLException)
        throw (SQLException) r;
      else
        throw new SQLException(
            "Connection.execWriteRequest: Unexpected response (" + r
                + ") for request "
                + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
    catch (IOException e)
    { // Connection failed, try to reconnect and re-exec the query
      try
      {
        reconnect();
        return execWriteRequest(request);
      }
      catch (SQLException e1)
      {
        throw new SQLException("Connection lost while executing request'"
            + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
            + "' and automatic reconnect failed (" + e1 + ")");
      }
    }
    catch (Exception e)
    {
      throw new SQLException("execWriteRequest: Error occured while request '"
          + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
          + "' was processed by C-JDBC Controller (" + e + ")");
    }
  }

  private void readRequestOnStream(SelectRequest request) throws IOException
  {
    /* WRITE SELECT REQUEST BEGIN */
    socketOutput.writeUTF(request.getSQL());
    socketOutput.writeBoolean(request.getEscapeProcessing());
    socketOutput.writeUTF(LINE_SEPARATOR);
    socketOutput.writeInt(request.getTimeout());
    socketOutput.writeBoolean(request.isAutoCommit());
    socketOutput.writeBoolean(request.isDriverProcessed());
    socketOutput.writeInt(request.getMaxRows());
    socketOutput.writeInt(request.getFetchSize());
    String cursor = request.getCursorName();
    if (cursor != null)
    {
      socketOutput.writeBoolean(true);
      socketOutput.writeUTF(cursor);
    }
    else
      socketOutput.writeBoolean(false);
    // If PreparedStatements are not processed by the driver, the controller
    // will need the skeleton.
    if (needSqlSkeleton || !request.isDriverProcessed())
    {
      String skeleton = request.getSqlSkeleton();
      if (skeleton != null)
      {
        socketOutput.writeBoolean(true);
        socketOutput.writeUTF(skeleton);
      }
      else
        socketOutput.writeBoolean(false);
    }
    /* WRITE SELECT REQUEST END */
  }

  private void procedureOnStream(StoredProcedure proc, boolean isRead)
      throws IOException
  {
    /* WRITE PROCEDURE REQUEST BEGIN */
    socketOutput.writeUTF(proc.getSQL());
    socketOutput.writeBoolean(proc.getEscapeProcessing());
    socketOutput.writeUTF(LINE_SEPARATOR);
    socketOutput.writeInt(proc.getTimeout());
    socketOutput.writeBoolean(proc.isAutoCommit());
    socketOutput.writeBoolean(proc.isDriverProcessed());
    if (isRead)
    {
      socketOutput.writeInt(proc.getMaxRows());
      socketOutput.writeInt(proc.getFetchSize());
    }
    // If PreparedStatements are not processed by the driver, the controller
    // will need the skeleton.
    if (needSqlSkeleton || !proc.isDriverProcessed())
    {
      String skeleton = proc.getSqlSkeleton();
      if (skeleton != null)
      {
        socketOutput.writeBoolean(true);
        socketOutput.writeUTF(skeleton);
      }
      else
        socketOutput.writeBoolean(false);
    }
    /* WRITE PROCEDURE REQUEST END */
  }

  private void writeRequestOnStream(AbstractWriteRequest request,
      boolean withKeys) throws IOException
  {
    /* WRITE ABSTRACT WRITE REQUEST BEGIN */
    boolean isCreate = request.isCreate();
    boolean isDelete = request.isDelete();
    boolean isDrop = request.isDrop();
    boolean isInsert = request.isInsert();
    boolean isUpdate = request.isUpdate();
    boolean isAlter = request.isAlter();
    int requestType = -1;
    if (isCreate)
      requestType = Commands.CreateRequest;
    else if (isDelete)
      requestType = Commands.DeleteRequest;
    else if (isDrop)
      requestType = Commands.DropRequest;
    else if (isInsert)
      requestType = Commands.InsertRequest;
    else if (isUpdate)
      requestType = Commands.UpdateRequest;
    else if (isAlter)
      requestType = Commands.AlterRequest;

    socketOutput.writeInt(requestType);
    socketOutput.writeUTF(request.getSQL());
    socketOutput.writeBoolean(request.getEscapeProcessing());
    socketOutput.writeUTF(LINE_SEPARATOR);
    socketOutput.writeInt(request.getTimeout());
    socketOutput.writeBoolean(request.isAutoCommit());
    socketOutput.writeBoolean(request.isDriverProcessed());
    if (withKeys)
    {
      socketOutput.writeInt(request.getMaxRows());
      socketOutput.writeInt(request.getFetchSize());
    }

    // If PreparedStatements are not processed by the driver, the controller
    // will need the skeleton.
    if (needSqlSkeleton || !request.isDriverProcessed())
    {
      String skeleton = request.getSqlSkeleton();
      if (skeleton != null)
      {
        socketOutput.writeBoolean(true);
        socketOutput.writeUTF(skeleton);
      }
      else
        socketOutput.writeBoolean(false);
    }
    /* WRITE ABSTRACT WRITE REQUEST END */
  }

  protected ResultSet execWriteRequestWithKeys(AbstractWriteRequest request)
      throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to send the request '"
          + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH) + "'");
    try
    {
      setConnectionParametersOnRequest(request);
      socketOutput.writeInt(Commands.ExecWriteRequestWithKeys);
      writeRequestOnStream(request, true);
      socketOutput.flush();

      Object in = socketInput.readObject();
      if (in instanceof SQLException)
        throw (SQLException) in;
      else if (in instanceof Field[])
      { // Get the ResultSet metadata the row data
        Field[] fields = (Field[]) in;
        ArrayList data = null;
        boolean hasMoreData;
        String cursorName = null;
        try
        {
          data = (ArrayList) socketInput.readObject();
          hasMoreData = socketInput.readBoolean();
          if (hasMoreData)
            cursorName = socketInput.readUTF();
        }
        catch (Exception e1)
        {
          throw new SQLException(
              "Connection.execWriteRequestWithKeys: Unexpected response (" + e1
                  + ") for request "
                  + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
        }
        return new org.objectweb.cjdbc.driver.DriverResultSet(fields, data,
            hasMoreData, cursorName);
      }
      else
        throw new SQLException(
            "Connection.execWriteRequestWithKeys: Unexpected response (" + in
                + ") for request "
                + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
    catch (Exception e)
    {
      throw new SQLException(
          "execWriteRequestWithKeys: Error occured while request '"
              + request.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
              + "' was processed by C-JDBC Controller (" + e + ")");
    }
  }

  public ResultSet execReadStoredProcedure(StoredProcedure proc)
      throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to send the request '"
          + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH) + "'");
    try
    {
      setConnectionParametersOnRequest(proc);
      socketOutput.writeInt(Commands.ExecReadStoredProcedure);
      procedureOnStream(proc, true);
      socketOutput.flush();

      Object in = socketInput.readObject();
      if (in instanceof SQLException)
        throw (SQLException) in;
      else if (in instanceof Field[])
      { // Get the ResultSet metadata the row data
        Field[] fields = (Field[]) in;
        ArrayList data = null;
        boolean hasMoreData;
        String cursorName = null;
        try
        {
          data = (ArrayList) socketInput.readObject();
          hasMoreData = socketInput.readBoolean();
          if (hasMoreData)
            cursorName = socketInput.readUTF();
        }
        catch (Exception e1)
        {
          throw new SQLException(
              "Connection.execReadStoredProcedure: Unexpected response (" + e1
                  + ") for request "
                  + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
        }
        return new org.objectweb.cjdbc.driver.DriverResultSet(fields, data,
            hasMoreData, cursorName);
      }
      else
        throw new SQLException(
            "Connection.execReadStoredProcedure: Unexpected response (" + in
                + ") for request "
                + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
    catch (RuntimeException e)
    {
      throw new SQLException(
          "Connection.execReadStoredProcedure: Error occured while request '"
              + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
              + "' was processed by C-JDBC Controller (" + e + ")");
    }
    catch (IOException e)
    { // Connection failed, try to reconnect and re-exec the query
      try
      {
        reconnect();
        return execReadStoredProcedure(proc);
      }
      catch (SQLException e1)
      {
        throw new SQLException("Connection lost while executing request'"
            + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
            + "' and automatic reconnect failed (" + e1 + ")");
      }
    }
    catch (ClassNotFoundException e)
    {
      throw new SQLException(
          "Connection.execReadStoredProcedure: Unexpected response (" + e
              + ") for request "
              + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
  }

  protected int execWriteStoredProcedure(StoredProcedure proc)
      throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to send the request '"
          + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH) + "'");
    try
    {
      setConnectionParametersOnRequest(proc);
      socketOutput.writeInt(Commands.ExecWriteStoredProcedure);
      procedureOnStream(proc, false);
      socketOutput.flush();

      Object r = socketInput.readObject();
      if (r instanceof Integer)
        return ((Integer) r).intValue();
      else if (r instanceof SQLException)
        throw (SQLException) r;
      else
        throw new SQLException(
            "Connection.execWriteStoredProcedure: Unexpected response (" + r
                + ") for request "
                + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH));
    }
    catch (Exception e)
    {
      throw new SQLException(
          "execWriteStoredProcedure: Error occured while request '"
              + proc.getSQLShortForm(Constants.SQL_SHORT_FORM_LENGTH)
              + "' was processed by C-JDBC Controller (" + e + ")");
    }
  }

  protected ResultSet getColumns(String catalog, String schemaPattern,
      String tableNamePattern, String columnNamePattern) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the tables.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetColumns);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(tableNamePattern);
      socketOutput.writeUTF(columnNamePattern);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException("Connection.getColumns: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getColumns: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  protected ResultSet getPrimaryKeys(String catalog, String schemaPattern,
      String tableNamePattern) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the tables.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetPrimaryKeys);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(tableNamePattern);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException(
            "Connection.getPrimaryKeys: Unexpected response (" + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getPrimaryKeys: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  protected ResultSet getTables(String catalog, String schemaPattern,
      String tableNamePattern, String[] types) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the tables.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetTables);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(tableNamePattern);
      socketOutput.writeObject(types);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException("Connection.getTables: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getTables: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public String getControllerVersionNumber() throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.GetControllerVersionNumber);
      socketOutput.flush();

      Object s = socketInput.readObject();
      if (s instanceof String)
        return (String) s;
      else
        throw new SQLException(
            "Connection.getControllerVersionNumber: Unexpected response (" + s
                + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getControllerVersionNumber: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

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

  public void setHoldability(int holdability) throws SQLException
  {
    throw new NotImplementedException("setHoldability");
  }

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

  public Savepoint setSavepoint() throws SQLException
  {
    throw new NotImplementedException("setSavepoint");
  }

  public Savepoint setSavepoint(String name) throws SQLException
  {
    throw new NotImplementedException("setSavepoint");
  }

  public void rollback(Savepoint savepoint) throws SQLException
  {
    throw new NotImplementedException("rollback");
  }

  public void releaseSavepoint(Savepoint savepoint) throws SQLException
  {
    throw new NotImplementedException("releaseSavepoint");
  }

  public java.sql.Statement createStatement(int resultSetType,
      int resultSetConcurrency, int resultSetHoldability) throws SQLException
  {
    throw new NotImplementedException("createStatement");
  }

  public java.sql.PreparedStatement prepareStatement(String sql,
      int resultSetType, int resultSetConcurrency, int resultSetHoldability)
      throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  public java.sql.CallableStatement prepareCall(String sql, int resultSetType,
      int resultSetConcurrency, int resultSetHoldability) throws SQLException
  {
    throw new NotImplementedException("prepareCall");
  }

  public java.sql.PreparedStatement prepareStatement(String sql,
      int autoGeneratedKeys) throws SQLException
  {
    PreparedStatement ps = new PreparedStatement(this, sql);
    ps.setGeneratedKeysFlag(autoGeneratedKeys);
    return ps;
  }

  public java.sql.PreparedStatement prepareStatement(String sql,
      int columnIndexes[]) throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  public java.sql.PreparedStatement prepareStatement(String sql,
      String columnNames[]) throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  public AbstractBlobFilter getBlobFilter()
  {
    if (blobFilter == null)
      blobFilter = new HexaBlobFilter();
    return blobFilter;
  }

  public ResultSet getTableTypes() throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the table types.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetTableTypes);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException(
            "Connection.getTableTypes: Unexpected response (" + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getTableTypes: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public ResultSet getTablePrivileges(String catalog, String schemaPattern,
      String tableNamePattern) throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the table privileges.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetTablePrivileges);
      socketOutput.writeUTF(catalog);
      socketOutput.writeUTF(schemaPattern);
      socketOutput.writeUTF(tableNamePattern);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException(
            "Connection.getTablePrivileges: Unexpected response (" + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getTablePrivileges: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public ResultSet getSchemas() throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the schemas.");
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetSchemas);
      socketOutput.flush();

      Object rs = socketInput.readObject();
      if (rs instanceof ResultSet)
        return (ResultSet) rs;
      else if (rs instanceof SQLException)
        throw (SQLException) rs;
      else
        throw new SQLException("Connection.getSchemas: Unexpected response ("
            + rs + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getSchemas: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public String getDatabaseProductName() throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.GetDatabaseProductName);
      socketOutput.flush();

      Object s = socketInput.readObject();
      if (s instanceof String)
        return (String) s;
      else
        throw new SQLException(
            "Connection.GetDatabaseProductName: Unexpected response (" + s
                + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.getDatabaseProductName: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public void fetchNextData(String cursorName, int fetchSize,
      DriverResultSet drsToUpdate) throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.FetchNextResultSetRows);
      socketOutput.writeUTF(cursorName);
      socketOutput.writeInt(fetchSize);
      socketOutput.flush();

      Object data = socketInput.readObject();
      if (data instanceof ArrayList)
      {
        boolean hasMoreData = socketInput.readBoolean();
        drsToUpdate.setData((ArrayList) data);
        drsToUpdate.setHasMoreData(hasMoreData);
      }
      else if (data instanceof SQLException)
        throw (SQLException) data;
      else
        throw new SQLException(
            "Connection.fetchNextData: Unexpected response (" + data + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.fetchNextData: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public void closeRemoteResultSet(String cursorName) throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.CloseRemoteResultSet);
      socketOutput.writeUTF(cursorName);
      socketOutput.flush();

      Object data = socketInput.readObject();
      if (data instanceof CommandCompleted)
        return;
      else if (data instanceof SQLException)
        throw (SQLException) data;
      else
        throw new SQLException(
            "Connection.closeRemoteResultSet: Unexpected response (" + data
                + ")");
    }
    catch (Exception e)
    {
      throw new SQLException(
          "Connection.closeRemoteResultSet: Error occured while request was processed by C-JDBC Controller ("
              + e + ")");
    }
  }

  public String getPreparedStatementBooleanFalse()
  {
    return preparedStatementBooleanFalse;
  }

  public void setPreparedStatementBooleanFalse(String booleanFalse)
  {
    this.preparedStatementBooleanFalse = booleanFalse;
  }

  public String getPreparedStatementBooleanTrue()
  {
    return preparedStatementBooleanTrue;
  }

  public void setPreparedStatementBooleanTrue(String booleanTrue)
  {
    this.preparedStatementBooleanTrue = booleanTrue;
  }

  public boolean isEscapeBackslash()
  {
    return escapeBackslash;
  }

  public void setEscapeBackslash(boolean escapeBackslash)
  {
    this.escapeBackslash = escapeBackslash;
  }

  public boolean isEscapeSingleQuote()
  {
    return escapeSingleQuote;
  }

  public void setEscapeSingleQuote(boolean escapeSingleQuote)
  {
    this.escapeSingleQuote = escapeSingleQuote;
  }

  public void setDriverProcessed(boolean processedByDriver)
  {
    this.driverProcessed = processedByDriver;
  }

  public boolean isDriverProcessed()
  {
    return driverProcessed;
  }

  public void setEscapeChar(String escapeChar)
  {
    this.escapeChar = escapeChar;
  }

  public String getEscapeChar()
  {
    return escapeChar;
  }
}

---