Connection.java

/**
 * C-JDBC: Clustered JDBC.
 * Copyright (C) 2002-2004 French National Institute For Research In Computer
 * Science And Control (INRIA).
 * Contact: c-jdbc@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or any later
 * version.
 * 
 * This library 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. See the GNU Lesser General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * Initial developer(s): Emmanuel Cecchet. 
 * Contributor(s): Julie Marguerite, Guillaume Bort, Duncan Smith, Vadim Kassin, Nicolas Modrzyk, Jaco Swart
 */

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;

/**
 * This <code>Connection</code> class implements a virtual connection that is
 * just used to store the needed information when the real connection will have
 * to be established by the Controller to execute a query.
 * <p>
 * This code has been inspired from the PostgreSQL JDBC driver by Peter T.
 * Mount.
 * 
 * @author <a href="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
 * @author <a href="mailto:Julie.Marguerite@inria.fr">Julie Marguerite </a>
 * @author <a href="mailto:vadim@kase.kz">Vadim Kassin </a>
 * @author <a href="mailto:duncan@mightybot.com">Duncan Smith </a>
 * @author <a href="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
 * @author <a href="mailto:jaco.swart@iblocks.co.uk">Jaco Swart </a>
 * @version 1.0
 */
public class Connection implements java.sql.Connection
{
  // Member variables describing the state of the connection

  /** Commit mode of the connection (<code>true</code>= automatic). */
  protected boolean autoCommit = true;

  /** Status of the connection. */
  protected boolean isClosed = false;

  /** Is the connection in read-only mode ? */
  protected boolean readOnly = false;

  /** Has a write request been executed in the current transaction? */
  boolean writeExecutedInTransaction = false;

  /** Isolation level. */
  protected int isolationLevel = java.sql.Connection.TRANSACTION_READ_COMMITTED;

  /** transaction identifier. */
  protected long transactionId = 0;

  /** Does the controller require the SQL skeleton? */
  protected boolean needSqlSkeleton = false;

  /** List of <code>Warnings</code> for this connection. */
  protected SQLWarning firstWarning = null;

  /** Meta-data of C-JDBC connections. */
  protected DatabaseMetaData metaData = null;

  /** Driver that created us. */
  protected Driver driver = null;

  /** C-JDBC URL of the database. */
  protected String url = null;

  /** Virtual database user used for this connection. */
  protected String vdbUser = null;
  protected String vdbPassword = null;

  /** Connection with the controller. */
  protected Socket socket;

  /** Socket input stream. */
  protected CJDBCInputStream socketInput;

  /** Socket output stream. */
  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;

  /** Tag maker for PreparedStatement parameters */
  public static final String TAG_MARKER = "!%";
  /** Escape for tag maker */
  public static final String TAG_MARKER_ESCAPE = TAG_MARKER + ";";
  /** Tag for PreparedStatement parameters start delimiter */
  public static final String START_PARAM_TAG = "<" + TAG_MARKER;
  /** Tag for PreparedStatement parameters end delimiter */
  public static final String END_PARAM_TAG = "|" + TAG_MARKER + ">";

  // 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 * ***********************
   * ****************************************************************************
   */

  /**
   * Creates a new <code>Connection</code> instance.
   */
  public Connection()
  {
  }

  /**
   * Creates a new <code>Connection</code> instance.
   * 
   * @param driver calling driver
   * @param socket connection with the controller
   * @param in socket input stream
   * @param out socket output stream
   * @param url C-JDBC URL of the database
   * @param userName user login
   * @param password user password
   * @param sqlSkeletonNeeded true if SQL skeletons must be sent to the
   *                 controller
   * @param filter to use to encode and decode blobs
   */
  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;
  }

  /**
   * @see java.lang.Object#finalize()
   */
  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();
  }

  /**
   * Gets the C-JDBC URL of the database of the connection.
   * 
   * @return value of url.
   */
  public String getURL()
  {
    return url;
  }

  /**
   * Gets the user name used to login to the database.
   * 
   * @return login name
   */
  public String getUserName()
  {
    return vdbUser;
  }

  /**
   * Gets the password used to login to the database.
   * 
   * @return password
   */
  public String getPassword()
  {
    return vdbPassword;
  }

  /**
   * Get the controller description to which this connection is connected to
   * 
   * @return <code>String</code> like <code>localhost:25322</code> or null
   *               if not connected
   */
  public String getConnectedController()
  {
    if (socket == null)
      return null;
    else
      return socket.getInetAddress().getHostName() + ":" + socket.getPort();
  }

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

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

  /**
   * Releases the connection. In fact, the connection is marked to be released
   * but will be effectively closed by the <code>ConnectionClosingThread</code>
   * if the connection has not been reused before.
   * 
   * @exception SQLException if an error occurs
   */
  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);
    }
  }

  /**
   * Makes all changes made since the previous commit/rollback permanent and
   * releases any database locks currently held by the <code>Connection</code>.
   * This method should only be used when auto-commit has been disabled. (If
   * <code>autoCommit</code>==<code>true</code>, then we throw an
   * SQLException).
   * 
   * @exception SQLException if a database access error occurs or the connection
   *                      is in autocommit mode
   * @see Connection#setAutoCommit
   */
  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();
      writeExecutedInTransaction = false;
      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 + ")");
    }
  }

  /**
   * SQL statements without parameters are normally executed using
   * <code>Statement</code> objects. If the same SQL statement is executed
   * many times, it is more efficient to use a <code>PreparedStatement</code>.
   * The <code>ResultSet</code> will be
   * <code>TYPE_FORWARD_ONLY</cde>/<code>CONCUR_READ_ONLY</code>.
   *    *
   * @return a new <code>Statement</code> object
   * @exception SQLException passed through from the constructor
   */
  public java.sql.Statement createStatement() throws SQLException
  {
    return new Statement(this);
  }

  /**
   * SQL statements without parameters are normally executed using
   * <code>Statement</code> objects. If the same SQL statement is executed
   * many times, it is more efficient to use a <code>PreparedStatement</code>.
   * 
   * @param resultSetType resultSetType to use
   * @param resultSetConcurrency resultSetConcurrency to use
   * @return a new <code>Statement</code> object
   * @exception SQLException passed through from the constructor
   */
  public java.sql.Statement createStatement(int resultSetType,
      int resultSetConcurrency) throws SQLException
  {
    Statement s = new Statement(this);
    s.setResultSetType(resultSetType);
    s.setResultSetConcurrency(resultSetConcurrency);
    return s;
  }

  /**
   * Gets the current auto-commit state.
   * 
   * @return current state of the auto-commit mode
   * @exception SQLException (why?)
   * @see Connection#setAutoCommit
   */
  public boolean getAutoCommit() throws SQLException
  {
    return this.autoCommit;
  }

  /**
   * A connection's database is able to provide information describing its
   * tables, its supported SQL grammar, its stored procedures, the capabilities
   * of this connection, etc. This information is made available through a
   * DatabaseMetaData object.
   * 
   * @return a <code>DatabaseMetaData</code> object for this connection
   * @exception SQLException if a database access error occurs
   */
  public java.sql.DatabaseMetaData getMetaData() throws SQLException
  {
    if (metaData == null)
    {
      metaData = new DatabaseMetaData(this);
    }
    return metaData;
  }

  /**
   * Return current catalog name.
   * 
   * @return name of the current <code>VirtualDatabase</code>
   * @throws SQLException if any error occurs
   * @see java.sql.Connection#getCatalog()
   */
  public String getCatalog() throws SQLException
  {
    if (driver == null)
      throw new SQLException("No driver to get the catalog.");
    try
    {
      socketOutput.writeInt(Commands.ConnectionGetCatalog);
      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 + ")");
    }
  }

  /**
   * getCatalogs definition.
   * 
   * @return instace of <code>ResultSet<code>
   * @throws SQLException if fails (include ANY exception that can be thrown in the code)
   */
  public ResultSet getCatalogs() throws SQLException
  {

    if (driver == null)
      throw new SQLException("No driver to get the catalogs.");
    try
    {
      socketOutput.writeInt(Commands.ConnectionGetCatalogs);
      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 + ")");
    }
  }

  /**
   * Gets this Connection's current transaction isolation mode.
   * 
   * @return the current <code>TRANSACTION_*</code> mode value
   * @exception SQLException if a database access error occurs
   */
  public int getTransactionIsolation() throws SQLException
  {
    return isolationLevel;
  }

  /**
   * C-JDBC does NOT support type map.
   * 
   * @return an exception
   * @exception SQLException not supported
   */
  public java.util.Map getTypeMap() throws SQLException
  {
    throw new NotImplementedException("getTypeMap()");
  }

  /**
   * The first warning reported by calls on this connection is returned. <B>
   * Note: </B> Sebsequent warnings will be changed to this SQLWarning
   * 
   * @return the first SQLWarning or null
   * @exception SQLException if a database access error occurs
   */
  public SQLWarning getWarnings() throws SQLException
  {
    return firstWarning;
  }

  /**
   * Returns <code>true</code> if the connection is closed (no real meaning
   * from C-JDBC point of view)
   * 
   * @return <code>true</code> if connection has never been opened or
   *               <code>close()</code> has been called
   * @exception SQLException if an error occurs
   */
  public boolean isClosed() throws SQLException
  {
    return isClosed;
  }

  /**
   * Tests to see if the connection is in read only Mode. Note that we cannot
   * really put the database in read only mode, but we pretend we can by
   * returning the value of the <code>readOnly</code> flag.
   * 
   * @return <code>true</code> if the connection is read only
   * @exception SQLException if a database access error occurs
   */
  public boolean isReadOnly() throws SQLException
  {
    return readOnly;
  }

  /**
   * As we can't know for sure which database will execute this request (now or
   * later), we can't translate it in the native query language of the
   * underlying DBMS. Therefore the query is returned unchanged.
   * 
   * @param query the query to change
   * @return the original query
   * @exception SQLException never
   */
  public String nativeSQL(String query) throws SQLException
  {
    return query;
  }

  /**
   * Creates a CallableStatement that contains sql and produces a ResultSet that
   * is TYPE_SCROLL_INSENSITIVE and CONCUR_READ_ONLY.
   * 
   * @param sql SQL request
   * @return nothing
   * @exception SQLException not supported
   */
  public java.sql.CallableStatement prepareCall(String sql) throws SQLException
  {
    return prepareCall(sql, java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,
        java.sql.ResultSet.CONCUR_READ_ONLY);
  }

  /**
   * Stored procedure call are not yet supported by C-JDBC.
   * 
   * @param sql a <code>String</code> value
   * @param resultSetType an <code>int</code> value
   * @param resultSetConcurrency an <code>int</code> value
   * @return nothing
   * @exception SQLException not supported
   */
  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;
  }

  /**
   * A SQL statement with or without <code>IN</code> parameters can be
   * pre-compiled and stored in a PreparedStatement object. This object can then
   * be used to efficiently execute this statement multiple times.
   * 
   * @param sql a SQL statement that may contain one or more '?' IN * parameter
   *                 placeholders
   * @return a new <code>PreparedStatement</code> object containing the
   *               pre-compiled statement.
   * @exception SQLException if a database access error occurs.
   */
  public java.sql.PreparedStatement prepareStatement(String sql)
      throws SQLException
  {
    return new PreparedStatement(this, sql);
  }

  /**
   * A SQL statement with or without IN parameters can be pre-compiled and
   * stored in a <code>PreparedStatement</code> object. This object can then
   * be used to efficiently execute this statement multiple times.
   * 
   * @param sql a SQL statement that may contain one or more '?' IN
   * @param resultSetType <code>ResultSetType</code> to use
   * @param resultSetConcurrency <code>ResultSetConcurrency</code> to use
   * @return a new <code>PreparedStatement</code> object
   * @exception SQLException passed through from the constructor
   */
  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;
  }

  /**
   * Drops all changes made since the previous commit/rollback and releases any
   * database locks currently held by this connection. If the connection was in
   * autocommit mode, we throw a SQLException.
   * 
   * @exception SQLException if a database access error occurs or the connection
   *                      is in autocommit mode
   * @see Connection#commit
   */
  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
      writeExecutedInTransaction = false;
      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 + ")");
    }
  }

  /**
   * If a connection is in auto-commit mode, then all its SQL statements will be
   * executed and committed as individual transactions. Otherwise, its SQL
   * statements are grouped into transactions that are terminated by either
   * {@link #commit()}or {@link #rollback()}. By default, new connections are
   * in auto-commit mode. The commit occurs when the statement completes or the
   * next execute occurs, whichever comes first. In the case of statements
   * returning a <code>ResultSet</code>, the statement completes when the
   * last row of the <code>ResultSet</code> has been retrieved or the
   * <code>ResultSet</code> has been closed. In advanced cases, a single
   * statement may return multiple results as well as output parameter values.
   * Here the commit occurs when all results and output param values have been
   * retrieved.
   * 
   * @param autoCommit <code>true</code> enables auto-commit;
   *                 <code>false</code> disables it
   * @exception SQLException if a database access error occurs
   */
  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();
        writeExecutedInTransaction = false;
        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 + ")");
      }
    }
  }

  /**
   * Change the current catalog
   * 
   * @param catalog a <code>String</code> value
   * @exception SQLException if fails or if catalog name is invalid
   */
  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 + ")");
    }
  }

  /**
   * You can put a connection in read-only mode as a hint to enable database
   * optimizations
   * <p>
   * <B>Note: </B> setReadOnly cannot be called while in the middle of a
   * transaction with write requests.
   * 
   * @param readOnly <code>true</code> enables read-only mode;
   *                 <code>false</code> disables it
   * @exception SQLException if a database access error occurs
   */
  public void setReadOnly(boolean readOnly) throws SQLException
  {
    if ((autoCommit == false) && writeExecutedInTransaction)
      throw new SQLException(
          "setReadOnly cannot be called in a transaction that has executed write requests.");

    this.readOnly = readOnly;
  }

  /**
   * You can call this method to try to change the transaction isolation level
   * using one of the TRANSACTION_* values.
   * <p>
   * <B>Note: </B> this method cannot be called while in the middle of a
   * transaction.
   * 
   * @param level one of the TRANSACTION_* isolation values with * the exception
   *                 of TRANSACTION_NONE; some databases may * not support other values
   * @exception SQLException if a database access error occurs
   * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel
   */
  public void setTransactionIsolation(int level) throws SQLException
  {
    isolationLevel = level;
  }

  /**
   * C-JDBC does NOT support type map.
   * 
   * @param map ignored
   * @exception SQLException not supported
   */
  public void setTypeMap(java.util.Map map) throws SQLException
  {
    throw new NotImplementedException("setTypeMap()");
  }

  /*
   * Connection C-JDBC internals
   */

  /**
   * Set the autocommit mode and read-only status on this request.
   * 
   * @param request The request to set
   */
  protected void setConnectionParametersOnRequest(AbstractRequest request)
  {
    request.setIsAutoCommit(autoCommit);
    request.setIsReadOnly(readOnly);
    request.setDriverProcessed(driverProcessed);
  }

  /**
   * Performs a read request and return the reply.
   * 
   * @param request the read request to execute
   * @return a <code>java.sql.ResultSet</code> value
   * @exception SQLException if an error occurs
   */
  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;
  }

  /**
   * Sets the closeSocketOnGC value.
   * 
   * @param closeSocketOnGC The closeSocketOnGC to set.
   */
  protected void setCloseSocketOnGC(boolean closeSocketOnGC)
  {
    this.closeSocketOnGC = closeSocketOnGC;
  }

  /**
   * Performs a write request and return the number of rows affected.
   * 
   * @param request the write request to execute
   * @return number of rows affected
   * @exception SQLException if an error occurs
   */
  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 (SQLException e)
    {
      throw e;
    }
    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 + ")");
    }
  }

  /**
   * Serialize a read request on the output stream by sending only the needed
   * parameters to reconstruct it on the controller
   * 
   * @param request the read request to send
   * @throws IOException if fails
   */
  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 */
  }

  /**
   * Serialize a procedure on the output stream by sending only the needed
   * parameters to reconstruct it on the controller
   * 
   * @param proc the procedure to send
   * @param isRead true if this is a read stored procedure
   * @throws IOException if fails
   */
  private void procedureOnStream(StoredProcedure proc, boolean isRead)
      throws IOException
  {
    if (!isRead)
      writeExecutedInTransaction = true;

    /* 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 */
  }

  /**
   * Serialize a write request on the output stream by sending only the needed
   * parameters to reconstruct it on the controller
   * 
   * @param request the write request to send
   * @param withKeys true if this request expect keys to be returned (as a
   *                 ResultSet)
   * @throws IOException if fails
   */
  private void writeRequestOnStream(AbstractWriteRequest request,
      boolean withKeys) throws IOException
  {
    if (!autoCommit)
      writeExecutedInTransaction = true;

    /* 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 */
  }

  /**
   * Performs a write request and return the number of rows affected.
   * 
   * @param request the write request to execute
   * @return auto generated keys
   * @exception SQLException if an error occurs
   */
  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 + ")");
    }
  }

  /**
   * Call a stored procedure that returns a ResultSet.
   * 
   * @param proc the stored procedure call
   * @return a <code>java.sql.ResultSet</code> value
   * @exception SQLException if an error occurs
   */
  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));
    }
  }

  /**
   * Call a stored procedure that performs an update.
   * 
   * @param proc the stored procedure call
   * @return number of rows affected
   * @exception SQLException if an error occurs
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * @see java.sql.DatabaseMetaData#getPrimaryKeys
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * @see org.objectweb.cjdbc.driver.DatabaseMetaData#getTables(String, String,
   *           String, String[])
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * Retrieve a metadata from the controller
   * 
   * @param key the name of the metadata to retrieve
   * @return an Object that will be an <tt>Integer</tt> or <tt>Boolean</tt>
   *               or <tt>String</tt>
   * @throws SQLException if fails
   */
  public Object getStaticMetadata(String key) throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.DatabaseStaticMetadata);
      socketOutput.writeUTF(key);
      socketOutput.flush();

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

  }

  /**
   * Get the C-JDBC controller version number.
   * 
   * @return a String containing the controller version
   * @exception SQLException if an error occurs
   */
  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-----------------------------

  /**
   * Changes the holdability of <code>ResultSet</code> objects created using
   * this <code>Connection</code> object to the given holdability.
   * 
   * @param holdability a <code>ResultSet</code> holdability constant; one of
   *                 <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
   *                 <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
   * @throws SQLException if a database access occurs, the given parameter is
   *                  not a <code>ResultSet</code> constant indicating holdability,
   *                  or the given holdability is not supported
   * @see #getHoldability
   * @see ResultSet
   * @since JDK 1.4
   */
  public void setHoldability(int holdability) throws SQLException
  {
    throw new NotImplementedException("setHoldability");
  }

  /**
   * Retrieves the current holdability of <code>ResultSet</code> objects
   * created using this <code>Connection</code> object.
   * 
   * @return the holdability, one of
   *               <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
   *               <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
   * @throws SQLException if a database access occurs
   * @see #setHoldability
   * @see ResultSet
   * @since JDK 1.4
   */
  public int getHoldability() throws SQLException
  {
    throw new NotImplementedException("getHoldability");
  }

  /**
   * Creates an unnamed savepoint in the current transaction and returns the new
   * <code>Savepoint</code> object that represents it.
   * 
   * @return the new <code>Savepoint</code> object
   * @exception SQLException if a database access error occurs or this
   *                      <code>Connection</code> object is currently in auto-commit
   *                      mode
   * @see Savepoint
   * @since JDK 1.4
   */
  public Savepoint setSavepoint() throws SQLException
  {
    throw new NotImplementedException("setSavepoint");
  }

  /**
   * Creates a savepoint with the given name in the current transaction and
   * returns the new <code>Savepoint</code> object that represents it.
   * 
   * @param name a <code>String</code> containing the name of the savepoint
   * @return the new <code>Savepoint</code> object
   * @exception SQLException if a database access error occurs or this
   *                      <code>Connection</code> object is currently in auto-commit
   *                      mode
   * @see Savepoint
   * @since JDK 1.4
   */
  public Savepoint setSavepoint(String name) throws SQLException
  {
    throw new NotImplementedException("setSavepoint");
  }

  /**
   * Undoes all changes made after the given <code>Savepoint</code> object was
   * set.
   * <p>
   * This method should be used only when auto-commit has been disabled.
   * 
   * @param savepoint the <code>Savepoint</code> object to roll back to
   * @exception SQLException if a database access error occurs, the
   *                      <code>Savepoint</code> object is no longer valid, or this
   *                      <code>Connection</code> object is currently in auto-commit
   *                      mode
   * @see Savepoint
   * @see #rollback()
   * @since JDK 1.4
   */
  public void rollback(Savepoint savepoint) throws SQLException
  {
    throw new NotImplementedException("rollback");
  }

  /**
   * Removes the given <code>Savepoint</code> object from the current
   * transaction. Any reference to the savepoint after it have been removed will
   * cause an <code>SQLException</code> to be thrown.
   * 
   * @param savepoint the <code>Savepoint</code> object to be removed
   * @exception SQLException if a database access error occurs or the given
   *                      <code>Savepoint</code> object is not a valid savepoint in
   *                      the current transaction
   * @since JDK 1.4
   */
  public void releaseSavepoint(Savepoint savepoint) throws SQLException
  {
    throw new NotImplementedException("releaseSavepoint");
  }

  /**
   * Creates a <code>Statement</code> object that will generate
   * <code>ResultSet</code> objects with the given type, concurrency, and
   * holdability.
   * <p>
   * This method is the same as the <code>createStatement</code> method above,
   * but it allows the default result set type, concurrency, and holdability to
   * be overridden.
   * 
   * @param resultSetType one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.TYPE_FORWARD_ONLY</code>,
   *                 <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
   *                 <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
   * @param resultSetConcurrency one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.CONCUR_READ_ONLY</code> or
   *                 <code>ResultSet.CONCUR_UPDATABLE</code>
   * @param resultSetHoldability one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
   *                 <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
   * @return a new <code>Statement</code> object that will generate
   *               <code>ResultSet</code> objects with the given type, concurrency,
   *               and holdability
   * @exception SQLException if a database access error occurs or the given
   *                      parameters are not <code>ResultSet</code> constants
   *                      indicating type, concurrency, and holdability
   * @see ResultSet
   * @since JDK 1.4
   */
  public java.sql.Statement createStatement(int resultSetType,
      int resultSetConcurrency, int resultSetHoldability) throws SQLException
  {
    throw new NotImplementedException("createStatement");
  }

  /**
   * Creates a <code>PreparedStatement</code> object that will generate
   * <code>ResultSet</code> objects with the given type, concurrency, and
   * holdability.
   * <p>
   * This method is the same as the <code>prepareStatement</code> method
   * above, but it allows the default result set type, concurrency, and
   * holdability to be overridden.
   * 
   * @param sql a <code>String</code> object that is the SQL statement to be
   *                 sent to the database; may contain one or more ? IN parameters
   * @param resultSetType one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.TYPE_FORWARD_ONLY</code>,
   *                 <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
   *                 <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
   * @param resultSetConcurrency one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.CONCUR_READ_ONLY</code> or
   *                 <code>ResultSet.CONCUR_UPDATABLE</code>
   * @param resultSetHoldability one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
   *                 <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
   * @return a new <code>PreparedStatement</code> object, containing the
   *               pre-compiled SQL statement, that will generate
   *               <code>ResultSet</code> objects with the given type, concurrency,
   *               and holdability
   * @exception SQLException if a database access error occurs or the given
   *                      parameters are not <code>ResultSet</code> constants
   *                      indicating type, concurrency, and holdability
   * @see ResultSet
   * @since JDK 1.4
   */
  public java.sql.PreparedStatement prepareStatement(String sql,
      int resultSetType, int resultSetConcurrency, int resultSetHoldability)
      throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  /**
   * Creates a <code>CallableStatement</code> object that will generate
   * <code>ResultSet</code> objects with the given type and concurrency. This
   * method is the same as the <code>prepareCall</code> method above, but it
   * allows the default result set type, result set concurrency type and
   * holdability to be overridden.
   * 
   * @param sql a <code>String</code> object that is the SQL statement to be
   *                 sent to the database; may contain on or more ? parameters
   * @param resultSetType one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.TYPE_FORWARD_ONLY</code>,
   *                 <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
   *                 <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
   * @param resultSetConcurrency one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.CONCUR_READ_ONLY</code> or
   *                 <code>ResultSet.CONCUR_UPDATABLE</code>
   * @param resultSetHoldability one of the following <code>ResultSet</code>
   *                 constants: <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
   *                 <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
   * @return a new <code>CallableStatement</code> object, containing the
   *               pre-compiled SQL statement, that will generate
   *               <code>ResultSet</code> objects with the given type, concurrency,
   *               and holdability
   * @exception SQLException if a database access error occurs or the given
   *                      parameters are not <code>ResultSet</code> constants
   *                      indicating type, concurrency, and holdability
   * @see ResultSet
   * @since JDK 1.4
   */
  public java.sql.CallableStatement prepareCall(String sql, int resultSetType,
      int resultSetConcurrency, int resultSetHoldability) throws SQLException
  {
    throw new NotImplementedException("prepareCall");
  }

  /**
   * Creates a default <code>PreparedStatement</code> object that has the
   * capability to retrieve auto-generated keys. The given constant tells the
   * driver whether it should make auto-generated keys available for retrieval.
   * This parameter is ignored if the SQL statement is not an
   * <code>INSERT</code> statement.
   * <p>
   * <b>Note: </b> This method is optimized for handling parametric SQL
   * statements that benefit from precompilation. If the driver supports
   * precompilation, the method <code>prepareStatement</code> will send the
   * statement to the database for precompilation. Some drivers may not support
   * precompilation. In this case, the statement may not be sent to the database
   * until the <code>PreparedStatement</code> object is executed. This has no
   * direct effect on users; however, it does affect which methods throw certain
   * SQLExceptions.
   * <p>
   * Result sets created using the returned <code>PreparedStatement</code>
   * object will by default be type <code>TYPE_FORWARD_ONLY</code> and have a
   * concurrency level of <code>CONCUR_READ_ONLY</code>.
   * 
   * @param sql an SQL statement that may contain one or more '?' IN parameter
   *                 placeholders
   * @param autoGeneratedKeys a flag indicating whether auto-generated keys
   *                 should be returned; one of
   *                 <code>Statement.RETURN_GENERATED_KEYS</code> or
   *                 <code>Statement.NO_GENERATED_KEYS</code>
   * @return a new <code>PreparedStatement</code> object, containing the
   *               pre-compiled SQL statement, that will have the capability of
   *               returning auto-generated keys
   * @exception SQLException if a database access error occurs or the given
   *                      parameter is not a <code>Statement</code> constant
   *                      indicating whether auto-generated keys should be returned
   * @since JDK 1.4
   */
  public java.sql.PreparedStatement prepareStatement(String sql,
      int autoGeneratedKeys) throws SQLException
  {
    PreparedStatement ps = new PreparedStatement(this, sql);
    ps.setGeneratedKeysFlag(autoGeneratedKeys);
    return ps;
  }

  /**
   * Creates a default <code>PreparedStatement</code> object capable of
   * returning the auto-generated keys designated by the given array. This array
   * contains the indexes of the columns in the target table that contain the
   * auto-generated keys that should be made available. This array is ignored if
   * the SQL statement is not an <code>INSERT</code> statement.
   * <p>
   * An SQL statement with or without IN parameters can be pre-compiled and
   * stored in a <code>PreparedStatement</code> object. This object can then
   * be used to efficiently execute this statement multiple times.
   * <p>
   * <b>Note: </b> This method is optimized for handling parametric SQL
   * statements that benefit from precompilation. If the driver supports
   * precompilation, the method <code>prepareStatement</code> will send the
   * statement to the database for precompilation. Some drivers may not support
   * precompilation. In this case, the statement may not be sent to the database
   * until the <code>PreparedStatement</code> object is executed. This has no
   * direct effect on users; however, it does affect which methods throw certain
   * SQLExceptions.
   * <p>
   * Result sets created using the returned <code>PreparedStatement</code>
   * object will by default be type <code>TYPE_FORWARD_ONLY</code> and have a
   * concurrency level of <code>CONCUR_READ_ONLY</code>.
   * 
   * @param sql an SQL statement that may contain one or more '?' IN parameter
   *                 placeholders
   * @param columnIndexes an array of column indexes indicating the columns that
   *                 should be returned from the inserted row or rows
   * @return a new <code>PreparedStatement</code> object, containing the
   *               pre-compiled statement, that is capable of returning the
   *               auto-generated keys designated by the given array of column indexes
   * @exception SQLException if a database access error occurs
   * @since JDK 1.4
   */
  public java.sql.PreparedStatement prepareStatement(String sql,
      int columnIndexes[]) throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  /**
   * Creates a default <code>PreparedStatement</code> object capable of
   * returning the auto-generated keys designated by the given array. This array
   * contains the names of the columns in the target table that contain the
   * auto-generated keys that should be returned. This array is ignored if the
   * SQL statement is not an <code>INSERT</code> statement.
   * <p>
   * An SQL statement with or without IN parameters can be pre-compiled and
   * stored in a <code>PreparedStatement</code> object. This object can then
   * be used to efficiently execute this statement multiple times.
   * <p>
   * <b>Note: </b> This method is optimized for handling parametric SQL
   * statements that benefit from precompilation. If the driver supports
   * precompilation, the method <code>prepareStatement</code> will send the
   * statement to the database for precompilation. Some drivers may not support
   * precompilation. In this case, the statement may not be sent to the database
   * until the <code>PreparedStatement</code> object is executed. This has no
   * direct effect on users; however, it does affect which methods throw certain
   * <code>SQLExceptions</code>.
   * <p>
   * Result sets created using the returned <code>PreparedStatement</code>
   * object will by default be type <code>TYPE_FORWARD_ONLY</code> and have a
   * concurrency level of <code>CONCUR_READ_ONLY</code>.
   * 
   * @param sql an SQL statement that may contain one or more '?' IN parameter
   *                 placeholders
   * @param columnNames an array of column names indicating the columns that
   *                 should be returned from the inserted row or rows
   * @return a new <code>PreparedStatement</code> object, containing the
   *               pre-compiled statement, that is capable of returning the
   *               auto-generated keys designated by the given array of column names
   * @exception SQLException if a database access error occurs
   * @since JDK 1.4
   */
  public java.sql.PreparedStatement prepareStatement(String sql,
      String columnNames[]) throws SQLException
  {
    throw new NotImplementedException("prepareStatement");
  }

  /**
   * Returns the blobFilter value.
   * 
   * @return Returns the blobFilter.
   */
  public AbstractBlobFilter getBlobFilter()
  {
    if (blobFilter == null)
      blobFilter = new HexaBlobFilter();
    return blobFilter;
  }

  /**
   * Gets the table types available in this database. The results are ordered by
   * table type.
   * 
   * @return <code>ResultSet</code> each row has a single String column that
   *               is a catalog name
   * @throws SQLException if a database error occurs
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * Gets a description of the access rights for each table available in a
   * catalog. Note that a table privilege applies to one or more columns in the
   * table. It would be wrong to assume that this priviledge applies to all
   * columns (this may be true for some systems but is not true for all.) Only
   * privileges matching the schema and table name criteria are returned. They
   * are ordered by TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
   * 
   * @param catalog a catalog name; "" retrieves those without a catalog; null
   *                 means drop catalog name from the selection criteria
   * @param schemaPattern a schema name pattern; "" retrieves those without a
   *                 schema
   * @param tableNamePattern a table name pattern
   * @return <code>ResultSet</code> each row is a table privilege description
   * @throws SQLException if a database access error occurs
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * @see java.sql.DatabaseMetaData#getSchemas()
   */
  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 == null)
        return null;
      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 + ")");
    }
  }

  /**
   * @see DatabaseMetaData#getDatabaseProductName()
   */
  public String getDatabaseProductName() throws SQLException
  {
    try
    {
      socketOutput.writeInt(Commands.DatabaseMetaDataGetDatabaseProductName);
      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 + ")");
    }
  }

  /**
   * Fetch next fetchSize rows of data and update the given ResultSet.
   * 
   * @param cursorName name of the ResultSet cursor
   * @param fetchSize number of rows to fetch
   * @param drsToUpdate DriverResultSet to update
   * @throws SQLException if an error occurs
   */
  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 + ")");
    }
  }

  /**
   * Closes the remote ResultSet given its cursor name.
   * 
   * @param cursorName cursor name of the ResultSet to close.
   * @throws SQLException if an error occurs
   */
  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 + ")");
    }
  }

  /**
   * Returns the booleanFalse value.
   * 
   * @return Returns the booleanFalse.
   */
  public String getPreparedStatementBooleanFalse()
  {
    return preparedStatementBooleanFalse;
  }

  /**
   * Sets the booleanFalse value.
   * 
   * @param booleanFalse The booleanFalse to set.
   */
  public void setPreparedStatementBooleanFalse(String booleanFalse)
  {
    this.preparedStatementBooleanFalse = booleanFalse;
  }

  /**
   * Returns the booleanTrue value.
   * 
   * @return Returns the booleanTrue.
   */
  public String getPreparedStatementBooleanTrue()
  {
    return preparedStatementBooleanTrue;
  }

  /**
   * Sets the booleanTrue value.
   * 
   * @param booleanTrue The booleanTrue to set.
   */
  public void setPreparedStatementBooleanTrue(String booleanTrue)
  {
    this.preparedStatementBooleanTrue = booleanTrue;
  }

  /**
   * Returns the escapeBackslash value.
   * 
   * @return Returns the escapeBackslash.
   */
  public boolean isEscapeBackslash()
  {
    return escapeBackslash;
  }

  /**
   * Sets the escapeBackslash value.
   * 
   * @param escapeBackslash The escapeBackslash to set.
   */
  public void setEscapeBackslash(boolean escapeBackslash)
  {
    this.escapeBackslash = escapeBackslash;
  }

  /**
   * Returns the escapeSingleQuote value.
   * 
   * @return Returns the escapeSingleQuote.
   */
  public boolean isEscapeSingleQuote()
  {
    return escapeSingleQuote;
  }

  /**
   * Sets the escapeSingleQuote value.
   * 
   * @param escapeSingleQuote The escapeSingleQuote to set.
   */
  public void setEscapeSingleQuote(boolean escapeSingleQuote)
  {
    this.escapeSingleQuote = escapeSingleQuote;
  }

  /**
   * Sets the driverProcessed value
   * 
   * @param processedByDriver true if the PreparedStatement are processed by the
   *                 C-JDBC driver.
   */
  public void setDriverProcessed(boolean processedByDriver)
  {
    this.driverProcessed = processedByDriver;
  }

  /**
   * Returns the driverProcessed value.
   * 
   * @return Returns the driverProcessed.
   */
  public boolean isDriverProcessed()
  {
    return driverProcessed;
  }

  /**
   * Sets the escapeCharacter value
   * 
   * @param escapeChar the escapeChar value to set
   */
  public void setEscapeChar(String escapeChar)
  {
    this.escapeChar = escapeChar;
  }

  /**
   * @return Returns the escapeChar.
   */
  public String getEscapeChar()
  {
    return escapeChar;
  }
}

---