/*

    * JBoss, Home of Professional Open Source

    * Copyright 2006, Red Hat Middleware LLC, and individual contributors

    * as indicated by the @author tags.

    * See the copyright.txt in the distribution for a

    * full listing of individual contributors.

    * This copyrighted material is made available to anyone wishing to use,

    * modify, copy, or redistribute it subject to the terms and conditions

    * of the GNU Lesser General Public License, v. 2.1.

   * This program is distributed in the hope that it will be useful, but WITHOUT A

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

   * v.2.1 along with this distribution; if not, write to the Free Software

   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

   * MA  02110-1301, USA.

   *

   * (C) 2005-2009,

   * @author JBoss Inc.

   */

  /*

   * Copyright (C) 1998, 1999, 2000, 2001,

   *

   * Arjuna Solutions Limited,

   * Newcastle upon Tyne,

   * Tyne and Wear,

   * UK.

   *

   * $Id: ConnectionImple.java 2342 2006-03-30 13:06:17Z  $

   */

  package com.arjuna.ats.internal.jdbc;

  import java.sql.Array;

  import java.sql.Blob;

  import java.sql.CallableStatement;

  import java.sql.Clob;

  import java.sql.Connection;

  import java.sql.DatabaseMetaData;

  import java.sql.NClob;

  import java.sql.PreparedStatement;

  import java.sql.SQLClientInfoException;

  import java.sql.SQLException;

  import java.sql.SQLWarning;

  import java.sql.SQLXML;

  import java.sql.Savepoint;

  import java.sql.Statement;

  import java.sql.Struct;

  import java.util.Map;

  import java.util.Properties;

  import java.util.concurrent.Executor;

  import javax.sql.XAConnection;

  import  javax.transaction.RollbackException;

  import  javax.transaction.Status;

  import  javax.transaction.SystemException;

  import javax.transaction.xa.XAResource;

  import com.arjuna.ats.internal.jdbc.drivers.modifiers.ConnectionModifier;

  import com.arjuna.ats.internal.jdbc.drivers.modifiers.ModifierFactory;

  import com.arjuna.ats.jdbc.TransactionalDriver;

  import com.arjuna.ats.jdbc.common.jdbcPropertyManager;

  import com.arjuna.ats.jdbc.logging.jdbcLogger;

  import com.arjuna.ats.jta.xa.RecoverableXAConnection;

  import com.arjuna.ats.jta.xa.XAModifier;

  public class ConnectionImple implements Connection

  {

  	public ConnectionImple(String dbName, Properties info) throws SQLException

  	{

  		if (jdbcLogger.logger.isTraceEnabled()) {

              jdbcLogger.logger.trace("ConnectionImple.ConnectionImple ( " + dbName + " )");

          }

  		String user = null;

  		String passwd = null;

  		String dynamic = null;

  		if (info != null)

  		{

 			user = info.getProperty(TransactionalDriver.userName);

 			passwd = info.getProperty(TransactionalDriver.password);

 			dynamic = info.getProperty(TransactionalDriver.dynamicClass);

 		}

 		if ((dynamic == null) || (dynamic.equals("")))

 		{

 			_recoveryConnection = new IndirectRecoverableConnection(dbName,

 					user, passwd, this);

 		}

 		else

 		{

 			_recoveryConnection = new DirectRecoverableConnection(dbName, user,

 					passwd, dynamic, this);

 		}

 		/*

 		 * Is there any "modifier" we are required to work with?

 		 */

 		_theModifier = null;

 		_theConnection = null;

 	}

 	public ConnectionImple(String dbName, String user, String passwd)

 			throws SQLException

 	{

 		this(dbName, user, passwd, null);

 	}

 	public ConnectionImple(String dbName, String user, String passwd,

 			String dynamic) throws SQLException

 	{

 		if (jdbcLogger.logger.isTraceEnabled()) {

             jdbcLogger.logger.trace("ConnectionImple.ConnectionImple ( " + dbName + ", " + user

                     + ", " + passwd + ", " + dynamic + " )");

         }

 		if ((dynamic == null) || (dynamic.equals("")))

 		{

 			_recoveryConnection = new IndirectRecoverableConnection(dbName,

 					user, passwd, this);

 		}

 		else

 		{

 			_recoveryConnection = new DirectRecoverableConnection(dbName, user,

 					passwd, dynamic, this);

 		}

 		/*

 		 * Any "modifier" required to work with?

 		 */

 		_theModifier = null;

 		_theConnection = null;

 	}

 	public Statement createStatement() throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().createStatement();

 	}

 	public Statement createStatement(int rs, int rc) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().createStatement(rs, rc);

 	}

 	public PreparedStatement prepareStatement(String sql) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql);

 	}

 	public PreparedStatement prepareStatement(String sql, int rs, int rc)

 			throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql, rs, rc);

 	}

 	public CallableStatement prepareCall(String sql) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareCall(sql);

 	}

 	public CallableStatement prepareCall(String sql, int rs, int rc)

 			throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareCall(sql, rs, rc);

 	}

 	public String nativeSQL(String sql) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().nativeSQL(sql);

 	}

 	public Map getTypeMap() throws SQLException

 	{

 		return getConnection().getTypeMap();

 	}

 /*

     public void setTypeMap(Map map) throws SQLException

 	{

 		getConnection().setTypeMap(map);

 	}

 */
	

 	public void setAutoCommit(boolean autoCommit) throws SQLException

 	{

 		if (transactionRunning())

 		{

 			if (autoCommit)

 				throw new SQLException(jdbcLogger.i18NLogger.get_autocommit());

 		}

 		else

 		{

 			getConnection().setAutoCommit(autoCommit);

 		}

 	}

 	public boolean getAutoCommit() throws SQLException

 	{

 		return getConnection().getAutoCommit();

 	}

 	public void commit() throws SQLException

 	{

 		/*

 		 * If there is a transaction running, then it cannot be terminated via

 		 * the driver - the user must go through current.

 		 */

 		if (transactionRunning())

 		{

 			throw new SQLException(jdbcLogger.i18NLogger.get_commiterror());

 		}

 		else

 			getConnection().commit();

 	}

 	public void rollback() throws SQLException

 	{

 		if (transactionRunning())

 		{

 			throw new SQLException(jdbcLogger.i18NLogger.get_aborterror());

 		}

 		else

 			getConnection().rollback();

 	}

 	/*

 	 * This needs to be reworked in light of experience and requirements.

 	 */

 	public void close() throws SQLException

 	{

 	    try

 	    {

 	        /*

 	         * Need to know whether this particular connection has outstanding

 	         * resources waiting for it. If not then we can close, otherwise we

 	         * can't.

 	         */

 	        if (!_recoveryConnection.inuse())

 	        {

 	            ConnectionManager.remove(this); // finalize?

 	        }

 	        /*

 	         * Delist resource if within a transaction.

 	         */

 	        javax.transaction.TransactionManager tm = com.arjuna.ats.jta.TransactionManager

 	        .transactionManager();

 	        javax.transaction.Transaction tx = tm.getTransaction();

 	        /*

 	         * Don't delist if transaction not running. Rely on exception for

 	         * this. Also only delist if the transaction is the one the

 	         * connection is enlisted with!

 	         */

 	        boolean delayClose = false;

 	        if (tx != null)

 	        {

 	            if (_recoveryConnection.validTransaction(tx))

 	            {

 	                XAResource xares = _recoveryConnection.getResource();

 	                if (!tx.delistResource(xares, XAResource.TMSUCCESS))

 	                    throw new SQLException(

 	                            jdbcLogger.i18NLogger.get_delisterror());

 	                getModifier();

 	                if (_theModifier == null)

 	                {

                         jdbcLogger.i18NLogger.info_closingconnectionnull(_theConnection.toString());

 	                    // no indication about connections, so assume close immediately

 	                    if (_theConnection != null && !_theConnection.isClosed())

 	                        _theConnection.close();

 	                    _theConnection = null;

 	                    return;

 	                }

 	                else

 	                {

 	                    if (((ConnectionModifier) _theModifier).supportsMultipleConnections())

 	                    {

 	                        /*

 	                         * We can't close the connection until the transaction has

 	                         * terminated, so register a Synchronization here.

 	                         */

                             jdbcLogger.i18NLogger.warn_closingconnection(_theConnection.toString());

 	                        delayClose = true;

 	                    }

 	                }

 	                if (delayClose)

 	                {

         	                tx.registerSynchronization(new ConnectionSynchronization(_theConnection, _recoveryConnection));

                                 _theConnection = null;

 	                }

 	            }

 	            else

 	                throw new SQLException(jdbcLogger.i18NLogger.get_closeerrorinvalidtx(tx.toString()));

 	        }

 	        if (!delayClose)  // close now

 	        {

 	            _recoveryConnection.closeCloseCurrentConnection();

 	            if (_theConnection != null && !_theConnection.isClosed())

 	                _theConnection.close();

 	            _theConnection = null;

 	        }

 	        // what about connections without xaCon?

 	    }

 	    catch (IllegalStateException ex)

 	    {

 	        // transaction not running, so ignore.

 	    }

 	    catch (SQLException sqle)

 	    {

 	        throw sqle;

 	    }

 	    catch (Exception e1)

 	    {

 	        SQLException sqlException = new SQLException(jdbcLogger.i18NLogger.get_closeerror());

 	        sqlException.initCause(e1);

 	        throw sqlException;

 	    }

 	}

 	public boolean isClosed() throws SQLException

 	{

 		/*

 		 * A connection may appear closed to a thread if another thread has

 		 * bound it to a different transaction.

 		 */

 		checkTransaction();

 		if (_theConnection == null)

 			return false; // not opened yet.

 		else

 			return _theConnection.isClosed();

 	}

 	public DatabaseMetaData getMetaData() throws SQLException

 	{

 		return getConnection().getMetaData();

 	}

	

 	public void setReadOnly(boolean ro) throws SQLException

 	{

 		if (!_recoveryConnection.inuse())

 		{

 			getConnection().setReadOnly(ro);

 		}

 		else

 			throw new SQLException(jdbcLogger.i18NLogger.get_setreadonly());

 	}

 	public boolean isReadOnly() throws SQLException

 	{

 		return getConnection().isReadOnly();

 	}

 	public void setCatalog(String cat) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		getConnection().setCatalog(cat);

 	}

 	public String getCatalog() throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().getCatalog();

 	}

 	public void setTransactionIsolation(int iso) throws SQLException

 	{

 		checkTransaction();

 		/*

 		 * if (iso != Connection.TRANSACTION_SERIALIZABLE) throw new

 		 * SQLException(jdbcLogger.loggerI18N.getString.getString("com.arjuna.ats.internal.jdbc.stateerror")+"Connection.TRANSACTION_SERIALIZABLE");

 		 */

 		getConnection().setTransactionIsolation(iso);

 	}

 	public int getTransactionIsolation() throws SQLException

 	{

 		return getConnection().getTransactionIsolation();

 	}

 	public SQLWarning getWarnings() throws SQLException

 	{

 		return getConnection().getWarnings();

 	}

 	public void clearWarnings() throws SQLException

 	{

 		getConnection().clearWarnings();

 	}

	

 	public final RecoverableXAConnection recoveryConnection()

 	{

 		return _recoveryConnection;

 	}

 	/*

 	 * ******************************************************************* *

 	 * JDBC 3.0 section

 	 */

     public void setTypeMap(Map<String, Class<?>> map) throws SQLException

     {

         getConnection().setTypeMap(map);

     }

     public void setHoldability(int holdability) throws SQLException

     {

         checkTransaction();

         registerDatabase();

         getConnection().setHoldability(holdability);

     }

     public int getHoldability() throws SQLException

     {

         return getConnection().getHoldability();

     }

     public Savepoint setSavepoint() throws SQLException

     {

         if (transactionRunning())

         {

             throw new SQLException(jdbcLogger.i18NLogger.get_setsavepointerror());

         }

         else

         {

             return getConnection().setSavepoint();

         }

     }

     public Savepoint setSavepoint(String name) throws SQLException

     {

         if (transactionRunning())

         {

             throw new SQLException(jdbcLogger.i18NLogger.get_setsavepointerror());

         }

         else

         {

             return getConnection().setSavepoint(name);

         }

     }

     // The JDBC 3.0 spec (section 12.4) prohibits calling setSavepoint indide an XA tx.

     // It does not explicitly disallow calling rollback(savepoint) or releaseSavepoint(savepoint)

     // but allowing them does not make a whole lot of sense, so we don't:

 	public void rollback(Savepoint savepoint) throws SQLException

 	{

 		if (transactionRunning())

 		{

 			throw new SQLException(jdbcLogger.i18NLogger.get_rollbacksavepointerror());

 		}

 		else

 		{

 			getConnection().rollback(savepoint);

 		}

 	}

 	public void releaseSavepoint(Savepoint savepoint) throws SQLException

 	{

 		if (transactionRunning())

 		{

 			throw new SQLException(jdbcLogger.i18NLogger.get_releasesavepointerror());

 		}

 		else

 		{

 			getConnection().releaseSavepoint(savepoint);

 		}

 	}

 	public Statement createStatement(int resultSetType, int resultSetConcurrency,

 									 int resultSetHoldability) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);

 	}

 	public PreparedStatement prepareStatement(String sql, int resultSetType,

 											  int resultSetConcurrency, int resultSetHoldability) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

 	}

 	public CallableStatement prepareCall(String sql, int resultSetType,

 										 int resultSetConcurrency, int resultSetHoldability) throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

 	}

 	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)

 			throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql, autoGeneratedKeys);

 	}

 	public PreparedStatement prepareStatement(String sql, int columnIndexes[])

 			throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql, columnIndexes);

 	}

 	public PreparedStatement prepareStatement(String sql, String columnNames[])

 			throws SQLException

 	{

 		checkTransaction();

 		registerDatabase();

 		return getConnection().prepareStatement(sql, columnNames);

 	}

 	/*

 	 * end of the JDBC 3.0 section

 	 * *******************************************************************

 	 */

     /*

      * ******************************************************************* *

      * JDBC 4.0 method section.

      */

     public Clob createClob() throws SQLException

     {

         checkTransaction();

         registerDatabase();

         return getConnection().createClob();

     }

     public Blob createBlob() throws SQLException

     {

         checkTransaction();

         registerDatabase();

         return getConnection().createBlob();

     }

     public NClob createNClob() throws SQLException

     {

         checkTransaction();

 		registerDatabase();

 		return getConnection().createNClob();

     }

     public SQLXML createSQLXML() throws SQLException

     {

         checkTransaction();

 		registerDatabase();

 		return getConnection().createSQLXML();

     }

     public boolean isValid(int timeout) throws SQLException

     {

         checkTransaction();

         registerDatabase();

         return getConnection().isValid(timeout);

     }

     public String getClientInfo(String name) throws SQLException

     {

         return getConnection().getClientInfo(name);

     }

     public Properties getClientInfo() throws SQLException

     {