<<<<<<< HEAD
/*

Copyright 2009 Wallace Wadge

This file is part of BoneCP.

	}
import java.sql.PreparedStatement;
BoneCP 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 3 of the License, or
(at your option) any later version.

BoneCP 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with BoneCP.  If not, see .
*/

package com.jolbox.bonecp;

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.DriverManager;
import java.sql.NClob;
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.ConcurrentLinkedQueue;

import org.apache.log4j.Logger;

import com.google.common.collect.ImmutableSet;

/**
 * Connection handle "wrapper". Proxies are nice and cool... but around twice as
 * slow as doing it the boring old way. No proxy stuff here, we're aiming for
 * the best speed possible at the expense of code readability...
 * 
 * @author wwadge
 * 
 */
public class ConnectionHandle implements Connection {

	/** Connection handle. */
	private Connection connection = null;
	/** Last time this connection was used by an application. */
	private long connectionLastUsed = System.currentTimeMillis();
	/** Last time we sent a reset to this connection. */
	private long connectionLastReset = System.currentTimeMillis();
	/** Pool handle. */
	private BoneCP pool;
	/**
	 * If true, this connection might have failed communicating with the
	 * database. We assume that exceptions should be rare here i.e. the normal
	 * case is assumed to succeed.
	 */
	private boolean possiblyBroken;
	/** If true, we've called internalClose() on this connection. */
	private boolean connectionClosed = false;
	/** Original partition. */
	private ConnectionPartition originatingPartition = null;
	/** Prepared Statement Cache. */
	private IStatementCache preparedStatementCache = null;
	/** Prepared Statement Cache. */
	private IStatementCache callableStatementCache = null;
	/** Logger handle. */
	private static Logger logger = Logger.getLogger(ConnectionHandle.class);
	/** An opaque handle for an application to use in any way it deems fit. */
	private Object debugHandle;

	/**
	 * List of statements that will be closed when this preparedStatement is
	 * logically closed.
	 */
	private ConcurrentLinkedQueue statementHandles = new ConcurrentLinkedQueue();
	/**
	 * From: http://publib.boulder.ibm.com/infocenter/db2luw/v8/index.jsp?topic=/com.ibm.db2.udb.doc/core/r0sttmsg.htm
	 * Table 7. Class Code 08: Connection Exception
		SQLSTATE Value	  
		Value	Meaning
		08001	The application requester is unable to establish the connection.
		08002	The connection already exists.
		08003	The connection does not exist.
		08004	The application server rejected establishment of the connection.
		08007	Transaction resolution unknown.
		08502	The CONNECT statement issued by an application process running with a SYNCPOINT of TWOPHASE has failed, because no transaction manager is available.
		08504	An error was encountered while processing the specified path rename configuration file.
	 SQL Failure codes indicating the database is broken/died (and thus kill off remaining connections). 
	  Anything else will be taken as the *connection* (not the db) being broken. 

	  08S01 is a mysql-specific code to indicate a connection failure (though in my tests it was triggered even when the entire
	  database was down so I treat that as a DB failure)
	 */
	private static final ImmutableSet sqlStateDBFailureCodes = ImmutableSet.of("08001", "08007", "08S01"); 
	/**
	 * Connection wrapper constructor
	 * 
	 * @param url
	 *            JDBC connection string
	 * @param username
	 *            user to use
	 * @param password
	 *            password for db
	 * @param pool
	 *            pool handle.
	 * @throws SQLException
	 *             on error
	 */
	public ConnectionHandle(String url, String username, String password,
			BoneCP pool) throws SQLException {
		try {
			this.connection = DriverManager.getConnection(url, username,
					password);

			int cacheSize = pool.getConfig().getPreparedStatementsCacheSize();
			if (cacheSize > 0) {
				this.preparedStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());
				this.callableStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());

			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		this.pool = pool;
	}

	/** Private constructor used solely for unit testing. 
	 * @param connection 
	 * @param preparedStatementCache 
	 * @param callableStatementCache 
	 * @param pool */
	public ConnectionHandle(Connection connection, IStatementCache preparedStatementCache, IStatementCache callableStatementCache, BoneCP pool){
		this.connection = connection;
		this.preparedStatementCache = preparedStatementCache;
		this.callableStatementCache = callableStatementCache;
		this.pool = pool;
	}


	/**
	 * Adds the given statement to a list.
	 * 
	 * @param statement
	 *            Statement to keep track of
	 * @return statement
	 */
	private Statement trackStatement(Statement statement) {
		if (statement != null){
			this.statementHandles.add(statement);
		}
		return statement;
	}

	/** 
	 * Given an exception, flag the connection (or database) as being potentially broken. If the exception is a data-specific exception,
	 * do nothing except throw it back to the application. 
	 * 
	 * @param t throwable exception to process
	 * @return SQLException for further processing
	 */
	protected SQLException markPossiblyBroken(Throwable t) {
		SQLException e;
		if (t instanceof SQLException){
			e=(SQLException) t;
		} else {
			e = new SQLException(t == null ? "Unknown error" : t.getMessage(), "08999");
			e.initCause( t );
		}

		String state = e.getSQLState();
		if (state == null){ // safety;
			state = "Z";
		}
		if (sqlStateDBFailureCodes.contains(state) && this.pool != null){
			logger.error("Database access problem. Killing off all remaining connections in the connection pool. SQL State = " + state);
			this.pool.terminateAllConnections();
		}

		// SQL-92 says:
		//		 Class values that begin with one of the s '5', '6', '7',
		//         '8', or '9' or one of the s 'I',
		//         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
		//         'W', 'X', 'Y', or 'Z' are reserved for implementation-specified
		//         conditions.


		return result;
		char firstChar = state.charAt(0);
		// if it's a communication exception or an implementation-specific error code, flag this connection as being potentially broken.
		if (state.startsWith("08") ||  (firstChar >= '5' && firstChar <='9') || (firstChar >='I' && firstChar <= 'Z')){
			this.possiblyBroken = true;
		}

		return e;
	}


	public void clearWarnings() throws SQLException {
		checkClosed();
		try {
			this.connection.clearWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Checks if the connection is (logically) closed and throws an exception if it is.
	 * 
	 * @throws SQLException
	 *             on error
	 * 
	 * 
	 */
	private void checkClosed() throws SQLException {
		if (this.connectionClosed) {
			throw new SQLException("Connection is closed.");
		}
	}

	/**
	 * Release the connection if called. never really thrown
	 * 
	 * @throws SQLException
	 */
	public void close() throws SQLException {
		try {
			if (!this.connectionClosed) {
				this.connectionClosed = true;
				this.pool.releaseConnection(this);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Close off the connection.
	 * 
	 * @throws SQLException
	 */
	protected void internalClose() throws SQLException {
		try {
			clearStatementHandles(true);
			this.connection.close();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void commit() throws SQLException {
		checkClosed();
		try {
			this.connection.commit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Array createArrayOf(String typeName, Object[] elements)
	throws SQLException {
		Array result = null;
		checkClosed();
		try {
			result = this.connection.createArrayOf(typeName, elements);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Blob createBlob() throws SQLException {
		Blob result = null;
		checkClosed();
		try {
			result = this.connection.createBlob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Clob createClob() throws SQLException {
		Clob result = null;
		checkClosed();
		try {
			result = this.connection.createClob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;

	}

	public NClob createNClob() throws SQLException {
		NClob result = null;
		checkClosed();
		try {
			result = this.connection.createNClob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

	public SQLXML createSQLXML() throws SQLException {
		SQLXML result = null;
		checkClosed();
		try {
			result = this.connection.createSQLXML();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement() throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType, int resultSetConcurrency)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Struct createStruct(String typeName, Object[] attributes)
	throws SQLException {
		Struct result = null;
		checkClosed();
		try {
			result = this.connection.createStruct(typeName, attributes);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean getAutoCommit() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.getAutoCommit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getCatalog() throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.getCatalog();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Properties getClientInfo() throws SQLException {
		Properties result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getClientInfo(String name) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getHoldability() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getHoldability();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
		return result;
	}

		return result;
	}

	public DatabaseMetaData getMetaData() throws SQLException {
		DatabaseMetaData result = null;
		checkClosed();
		try {
			result = this.connection.getMetaData();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getTransactionIsolation() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getTransactionIsolation();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Map> getTypeMap() throws SQLException {
		Map> result = null;
		checkClosed();
		try {
			result = this.connection.getTypeMap();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public SQLWarning getWarnings() throws SQLException {
		SQLWarning result = null;
		checkClosed();
		try {
			result = this.connection.getWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isClosed() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isClosed();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isReadOnly() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isReadOnly();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isValid(int timeout) throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isValid(timeout);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String nativeSQL(String sql) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.nativeSQL(sql);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {

			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql);
				if (result == null) {
					String cacheKey = sql;
					result = (CallableStatement) trackStatement(new CallableStatementHandle(this.connection.prepareCall(sql),
							sql, this.callableStatementCache, this, cacheKey));

				} 

				((CallableStatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.callableStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency), sql, this.callableStatementCache, this, cacheKey));

				} 

				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType, resultSetConcurrency);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {

				result = (CallableStatement) this.callableStatementCache.get(sql);

				if (result == null) {
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability), sql,
							this.callableStatementCache, this, sql));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql) throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = this.preparedStatementCache.get(sql);

				if (result == null) {

					String cacheKey = sql;

					result =  trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql), sql,
							this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return (PreparedStatement) result;
	}

	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, autoGeneratedKeys);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, autoGeneratedKeys);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									autoGeneratedKeys), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql,
						autoGeneratedKeys);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnIndexes);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnIndexes);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection
							.prepareStatement(sql, columnIndexes), sql,
							this.preparedStatementCache, this, cacheKey));
				}
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnIndexes);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, String[] columnNames)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnNames);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnNames);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql, columnNames),
							sql, this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnNames);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency,
									resultSetHoldability), sql,
									this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.releaseSavepoint(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);

		}
	}

	public void rollback() throws SQLException {
		checkClosed();
		try {
			this.connection.rollback();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void rollback(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.rollback(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setAutoCommit(boolean autoCommit) throws SQLException {
		checkClosed();
		try {
			this.connection.setAutoCommit(autoCommit);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setCatalog(String catalog) throws SQLException {
		checkClosed();
		try {
			this.connection.setCatalog(catalog);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setClientInfo(Properties properties)
	throws SQLClientInfoException {
		this.connection.setClientInfo(properties);
	}

	public void setClientInfo(String name, String value)
	throws SQLClientInfoException {
		this.connection.setClientInfo(name, value);
	}

	public void setHoldability(int holdability) throws SQLException {
		checkClosed();
		try {
			this.connection.setHoldability(holdability);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setReadOnly(boolean readOnly) throws SQLException {
		checkClosed();
		try {
			this.connection.setReadOnly(readOnly);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Savepoint setSavepoint() throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Savepoint setSavepoint(String name) throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void setTransactionIsolation(int level) throws SQLException {
		checkClosed();
		try {
			this.connection.setTransactionIsolation(level);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setTypeMap(Map> map) throws SQLException {
		checkClosed();
		try {
			this.connection.setTypeMap(map);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public boolean isWrapperFor(Class iface) throws SQLException {
		return this.connection.isWrapperFor(iface);
	}

	public  T unwrap(Class iface) throws SQLException {
		return this.connection.unwrap(iface);
	}

	/**
	 * @return the connectionLastUsed
	 */
	public long getConnectionLastUsed() {
		return this.connectionLastUsed;
	}

	/**
	 * @param connectionLastUsed
	 *            the connectionLastUsed to set
	 */
	public void setConnectionLastUsed(long connectionLastUsed) {
		this.connectionLastUsed = connectionLastUsed;
	}

	/**
	 * @return the connectionLastReset
	 */
	public long getConnectionLastReset() {
		return this.connectionLastReset;
	}

	/**
	 * @param connectionLastReset
	 *            the connectionLastReset to set
	 */
	public void setConnectionLastReset(long connectionLastReset) {
		this.connectionLastReset = connectionLastReset;
	}

	/**
	 * Gets true if connection has triggered an exception at some point.
	 * 
	 * @return true if the connection has triggered an error
	 */
	public boolean isPossiblyBroken() {
		return this.possiblyBroken;
	}


	/**
	 * Gets the partition this came from.
	 * 
	 * @return the partition this came from
	 */
	public ConnectionPartition getOriginatingPartition() {
		return this.originatingPartition;
	}

	/**
	 * Sets Originating partition
	 * 
	 * @param originatingPartition
	 *            to set
	 */
	public void setOriginatingPartition(ConnectionPartition originatingPartition) {
		this.originatingPartition = originatingPartition;
	}

	/**
	 * Renews this connection, i.e. Sets this connection to be logically open
	 * (although it was never really closed)
	 */
	public void renewConnection() {
		this.connectionClosed = false;
	}


	/** Clears out the statement handles.
	 * @param internalClose if true, close the inner statement handle too. 
	 * @throws SQLException
	 */
	protected void clearStatementHandles(boolean internalClose) throws SQLException {
		if (!internalClose){
			this.statementHandles.clear();
		} else{
			Statement statement = null;
			while ((statement = this.statementHandles.poll()) != null) {
				((StatementHandle) statement).internalClose();
			}
		}
	}

	/** Returns a debug handle as previously set by an application
	 * @return DebugHandle
	 */
	public Object getDebugHandle() {
		return this.debugHandle;
	}

	/** Sets a debugHandle, an object that is not used by the connection pool at all but may be set by an application to track
	 * this particular connection handle for any purpose it deems fit.
	 * @param debugHandle any object.
	 */
	public void setDebugHandle(Object debugHandle) {
		this.debugHandle = debugHandle;
	}
}
=======
/*

Copyright 2009 Wallace Wadge

This file is part of BoneCP.

BoneCP 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 3 of the License, or
(at your option) any later version.

BoneCP 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with BoneCP.  If not, see .
*/

package com.jolbox.bonecp;

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.DriverManager;
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.ConcurrentLinkedQueue;

import org.apache.log4j.Logger;

import com.google.common.collect.ImmutableSet;
import com.jolbox.bonecp.hooks.ConnectionHook;

/**
 * Connection handle "wrapper". Proxies are nice and cool... but around twice as
 * slow as doing it the boring old way. No proxy stuff here, we're aiming for
 * the best speed possible at the expense of code readability...
 * 
 * @author wwadge
 * 
 */
public class ConnectionHandle implements Connection {

	/** Connection handle. */
	private Connection connection = null;
	/** Last time this connection was used by an application. */
	private long connectionLastUsed = System.currentTimeMillis();
	/** Last time we sent a reset to this connection. */
	private long connectionLastReset = System.currentTimeMillis();
	/** Pool handle. */
	private BoneCP pool;
	/**
	 * If true, this connection might have failed communicating with the
	 * database. We assume that exceptions should be rare here i.e. the normal
	 * case is assumed to succeed.
	 */
	private boolean possiblyBroken;
	/** If true, we've called internalClose() on this connection. */
	private boolean connectionClosed = false;
	/** Original partition. */
	private ConnectionPartition originatingPartition = null;
	/** Prepared Statement Cache. */
	private IStatementCache preparedStatementCache = null;
	/** Prepared Statement Cache. */
	private IStatementCache callableStatementCache = null;
	/** Logger handle. */
	private static Logger logger = Logger.getLogger(ConnectionHandle.class);
	/** An opaque handle for an application to use in any way it deems fit. */
	private Object debugHandle;

	/**
	 * List of statements that will be closed when this preparedStatement is
	 * logically closed.
	 */
	private ConcurrentLinkedQueue statementHandles = new ConcurrentLinkedQueue();
	/** Handle to the connection hook as defined in the config. */
	private ConnectionHook connectionHook;
	
	/**
	 * From: http://publib.boulder.ibm.com/infocenter/db2luw/v8/index.jsp?topic=/com.ibm.db2.udb.doc/core/r0sttmsg.htm
	 * Table 7. Class Code 08: Connection Exception
		SQLSTATE Value	  
		Value	Meaning
		08001	The application requester is unable to establish the connection.
		08002	The connection already exists.
		08003	The connection does not exist.
		08004	The application server rejected establishment of the connection.
		08007	Transaction resolution unknown.
		08502	The CONNECT statement issued by an application process running with a SYNCPOINT of TWOPHASE has failed, because no transaction manager is available.
		08504	An error was encountered while processing the specified path rename configuration file.
		checkClosed();
	 SQL Failure codes indicating the database is broken/died (and thus kill off remaining connections). 
	  Anything else will be taken as the *connection* (not the db) being broken. 

	  08S01 is a mysql-specific code to indicate a connection failure (though in my tests it was triggered even when the entire
	  database was down so I treat that as a DB failure)
	 */
	private static final ImmutableSet sqlStateDBFailureCodes = ImmutableSet.of("08001", "08007", "08S01"); 
	/**
	 * Connection wrapper constructor
	 * 
	 * @param url
	 *            JDBC connection string
	 * @param username
	 *            user to use
	 * @param password
	 *            password for db
	 * @param pool
	 *            pool handle.
	 * @throws SQLException
	 *             on error
	 */
	public ConnectionHandle(String url, String username, String password,
			BoneCP pool) throws SQLException {
		
		this.pool = pool;

		try {
			this.connection = DriverManager.getConnection(url, username,
					password);

			int cacheSize = pool.getConfig().getPreparedStatementsCacheSize();
			if (cacheSize > 0) {
				this.preparedStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());
				this.callableStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());

			}
			// keep track of this hook.
			this.connectionHook = this.pool.getConfig().getConnectionHook();
			// call the hook, if available.
			if (this.connectionHook != null){
				this.connectionHook.onAcquire(this);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/** Private constructor used solely for unit testing. 
	 * @param connection 
	 * @param preparedStatementCache 
	 * @param callableStatementCache 
	 * @param pool */
	public ConnectionHandle(Connection connection, IStatementCache preparedStatementCache, IStatementCache callableStatementCache, BoneCP pool){
		this.connection = connection;
		this.preparedStatementCache = preparedStatementCache;
		this.callableStatementCache = callableStatementCache;
		this.pool = pool;
	}


	/**
	 * Adds the given statement to a list.
	 * 
	 * @param statement
	 *            Statement to keep track of
	 * @return statement
	 */
	private Statement trackStatement(Statement statement) {
		if (statement != null){
			this.statementHandles.add(statement);
		}
		return statement;
	}

	/** 
	 * Given an exception, flag the connection (or database) as being potentially broken. If the exception is a data-specific exception,
	 * do nothing except throw it back to the application. 
	 * 
	 * @param t throwable exception to process
	 * @return SQLException for further processing
	 */
	protected SQLException markPossiblyBroken(Throwable t) {
		SQLException e;
		if (t instanceof SQLException){
			e=(SQLException) t;
		} else {
			e = new SQLException(t == null ? "Unknown error" : t.getMessage(), "08999");
			e.initCause( t );
		}

		String state = e.getSQLState();
		if (state == null){ // safety;
			state = "Z";
		}
		if (sqlStateDBFailureCodes.contains(state) && this.pool != null){
			logger.error("Database access problem. Killing off all remaining connections in the connection pool. SQL State = " + state);
			this.pool.terminateAllConnections();
		}

		// SQL-92 says:
		NClob result = null;
		//		 Class values that begin with one of the s '5', '6', '7',
		//         '8', or '9' or one of the s 'I',
		//         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
		//         'W', 'X', 'Y', or 'Z' are reserved for implementation-specified
		//         conditions.


		char firstChar = state.charAt(0);
		// if it's a communication exception or an implementation-specific error code, flag this connection as being potentially broken.
		if (state.startsWith("08") ||  (firstChar >= '5' && firstChar <='9') || (firstChar >='I' && firstChar <= 'Z')){
			this.possiblyBroken = true;
		}

		return e;
	}


	public void clearWarnings() throws SQLException {
		checkClosed();
		try {
			this.connection.clearWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Checks if the connection is (logically) closed and throws an exception if it is.
	 * 
	 * @throws SQLException
	 *             on error
	 * 
	 * 
	 */
	private void checkClosed() throws SQLException {
		if (this.connectionClosed) {
			throw new SQLException("Connection is closed.");
		}
	}

	/**
	 * Release the connection if called. 
	 * 
	 * @throws SQLException Never really thrown
	 */
	public void close() throws SQLException {
		try {
			if (!this.connectionClosed) {
				this.connectionClosed = true;
				this.pool.releaseConnection(this);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Close off the connection.
	 * 
	 * @throws SQLException
	 */
	protected void internalClose() throws SQLException {
		try {
			clearStatementHandles(true);
			this.connection.close();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void commit() throws SQLException {
		checkClosed();
		try {
			this.connection.commit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Array createArrayOf(String typeName, Object[] elements)
	throws SQLException {
		Array result = null;
		checkClosed();
		try {
			result = this.connection.createArrayOf(typeName, elements);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Blob createBlob() throws SQLException {
		Blob result = null;
		checkClosed();
		try {
			result = this.connection.createBlob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Clob createClob() throws SQLException {
		Clob result = null;
		checkClosed();
		try {
			result = this.connection.createClob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;

	}

	public NClob createNClob() throws SQLException {
		try {
			result = this.connection.createNClob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public SQLXML createSQLXML() throws SQLException {
		SQLXML result = null;
		checkClosed();
		try {
			result = this.connection.createSQLXML();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement() throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType, int resultSetConcurrency)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Struct createStruct(String typeName, Object[] attributes)
	throws SQLException {
		Struct result = null;
		checkClosed();
		try {
			result = this.connection.createStruct(typeName, attributes);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean getAutoCommit() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.getAutoCommit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getCatalog() throws SQLException {
		String result = null;
		checkClosed();
	}
		try {
			result = this.connection.getCatalog();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Properties getClientInfo() throws SQLException {
		Properties result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getClientInfo(String name) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getHoldability() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getHoldability();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public DatabaseMetaData getMetaData() throws SQLException {
		DatabaseMetaData result = null;
		checkClosed();
		try {
			result = this.connection.getMetaData();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getTransactionIsolation() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getTransactionIsolation();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Map> getTypeMap() throws SQLException {
		Map> result = null;
		checkClosed();
		try {
			result = this.connection.getTypeMap();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public SQLWarning getWarnings() throws SQLException {
		SQLWarning result = null;
		checkClosed();
		try {
			result = this.connection.getWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isClosed() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isClosed();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isReadOnly() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isReadOnly();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isValid(int timeout) throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isValid(timeout);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;

	public String nativeSQL(String sql) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.nativeSQL(sql);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {

			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql);
				if (result == null) {
					String cacheKey = sql;
					result = (CallableStatement) trackStatement(new CallableStatementHandle(this.connection.prepareCall(sql),
							sql, this.callableStatementCache, this, cacheKey));

				} 

				((CallableStatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.callableStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency), sql, this.callableStatementCache, this, cacheKey));

				} 

				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType, resultSetConcurrency);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {

				result = (CallableStatement) this.callableStatementCache.get(sql);

				if (result == null) {
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability), sql,
							this.callableStatementCache, this, sql));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql) throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = this.preparedStatementCache.get(sql);

				if (result == null) {

					String cacheKey = sql;

					result =  trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql), sql,
							this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return (PreparedStatement) result;
	}

	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, autoGeneratedKeys);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, autoGeneratedKeys);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									autoGeneratedKeys), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql,
						autoGeneratedKeys);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnIndexes);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnIndexes);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection
							.prepareStatement(sql, columnIndexes), sql,
							this.preparedStatementCache, this, cacheKey));
				}
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnIndexes);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, String[] columnNames)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnNames);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnNames);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql, columnNames),
							sql, this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnNames);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency,
									resultSetHoldability), sql,
									this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.releaseSavepoint(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);

		}
	}

	public void rollback() throws SQLException {
		checkClosed();
		try {
			this.connection.rollback();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void rollback(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.rollback(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setAutoCommit(boolean autoCommit) throws SQLException {
		checkClosed();
		try {
			this.connection.setAutoCommit(autoCommit);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setCatalog(String catalog) throws SQLException {
		checkClosed();
		try {
			this.connection.setCatalog(catalog);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setClientInfo(Properties properties)
	throws SQLClientInfoException {
		this.connection.setClientInfo(properties);
	}

	public void setClientInfo(String name, String value)
		} catch (Throwable t) {
	throws SQLClientInfoException {
		this.connection.setClientInfo(name, value);
	}

	public void setHoldability(int holdability) throws SQLException {
		checkClosed();
		try {
			this.connection.setHoldability(holdability);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setReadOnly(boolean readOnly) throws SQLException {
		checkClosed();
		try {
			this.connection.setReadOnly(readOnly);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Savepoint setSavepoint() throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint();
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Savepoint setSavepoint(String name) throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void setTransactionIsolation(int level) throws SQLException {
		checkClosed();
		try {
			this.connection.setTransactionIsolation(level);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setTypeMap(Map> map) throws SQLException {
		checkClosed();
		try {
			this.connection.setTypeMap(map);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public boolean isWrapperFor(Class iface) throws SQLException {
		return this.connection.isWrapperFor(iface);
	}

	public  T unwrap(Class iface) throws SQLException {
		return this.connection.unwrap(iface);
	}

	/**
	 * @return the connectionLastUsed
	 */
	public long getConnectionLastUsed() {
		return this.connectionLastUsed;
	}

	/**
	 * @param connectionLastUsed
	 *            the connectionLastUsed to set
	 */
	protected void setConnectionLastUsed(long connectionLastUsed) {
		this.connectionLastUsed = connectionLastUsed;
	}

	/**
	 * @return the connectionLastReset
	 */
	public long getConnectionLastReset() {
		return this.connectionLastReset;
	}

	/**
	 * @param connectionLastReset
	 *            the connectionLastReset to set
	 */
	protected void setConnectionLastReset(long connectionLastReset) {
		this.connectionLastReset = connectionLastReset;
	}

	/**
	 * Gets true if connection has triggered an exception at some point.
	 * 
	 * @return true if the connection has triggered an error
	 */
	public boolean isPossiblyBroken() {
		return this.possiblyBroken;
	}


	/**
	 * Gets the partition this came from.
	 * 
	 * @return the partition this came from
	 */
	public ConnectionPartition getOriginatingPartition() {
		return this.originatingPartition;
	}

	/**
	 * Sets Originating partition
	 * 
	 * @param originatingPartition
	 *            to set
	 */
	protected void setOriginatingPartition(ConnectionPartition originatingPartition) {
		this.originatingPartition = originatingPartition;
	}

	/**
	 * Renews this connection, i.e. Sets this connection to be logically open
	 * (although it was never really closed)
	 */
	protected void renewConnection() {
		this.connectionClosed = false;
	}


	/** Clears out the statement handles.
	 * @param internalClose if true, close the inner statement handle too. 
	 * @throws SQLException
	 */
	protected void clearStatementHandles(boolean internalClose) throws SQLException {
		if (!internalClose){
			this.statementHandles.clear();
		} else{
			Statement statement = null;
			while ((statement = this.statementHandles.poll()) != null) {
				((StatementHandle) statement).internalClose();
			}
		}
	}

	/** Returns a debug handle as previously set by an application
	 * @return DebugHandle
	 */
	public Object getDebugHandle() {
		return this.debugHandle;
	}

	/** Sets a debugHandle, an object that is not used by the connection pool at all but may be set by an application to track
	 * this particular connection handle for any purpose it deems fit.
	 * @param debugHandle any object.
	 */
	public void setDebugHandle(Object debugHandle) {
		this.debugHandle = debugHandle;
	}

	/** Returns the internal connection as obtained via the JDBC driver.
	 * @return the raw connection
	 */
	public Connection getRawConnection() {
		return this.connection;
	}

	/** Returns the configured connection hook object.
	 * @return the connectionHook that was set in the config
	 */
	public ConnectionHook getConnectionHook() {
		return this.connectionHook;
	}
}
>>>>>>> d7a6bd4eb2ee52d1e4106dadf6c5f63704d5d659

/*

Copyright 2009 Wallace Wadge

This file is part of BoneCP.

BoneCP 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 3 of the License, or
(at your option) any later version.

BoneCP 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with BoneCP.  If not, see .
*/

package com.jolbox.bonecp;

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.DriverManager;
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.ConcurrentLinkedQueue;

import org.apache.log4j.Logger;

import com.google.common.collect.ImmutableSet;
import com.jolbox.bonecp.hooks.ConnectionHook;

/**
 * Connection handle "wrapper". Proxies are nice and cool... but around twice as
 * slow as doing it the boring old way. No proxy stuff here, we're aiming for
 * the best speed possible at the expense of code readability...
 * 
 * @author wwadge
 * 
 */
public class ConnectionHandle implements Connection {

	/** Connection handle. */
	private Connection connection = null;
	/** Last time this connection was used by an application. */
	private long connectionLastUsed = System.currentTimeMillis();
	/** Last time we sent a reset to this connection. */
	private long connectionLastReset = System.currentTimeMillis();
	/** Pool handle. */
	private BoneCP pool;
	/**
	 * If true, this connection might have failed communicating with the
	 * database. We assume that exceptions should be rare here i.e. the normal
	 * case is assumed to succeed.
	 */
	private boolean possiblyBroken;
	/** If true, we've called internalClose() on this connection. */
	private boolean connectionClosed = false;
	/** Original partition. */
	 * 
	private ConnectionPartition originatingPartition = null;
	/** Prepared Statement Cache. */
	private IStatementCache preparedStatementCache = null;
	/** Prepared Statement Cache. */
	private IStatementCache callableStatementCache = null;
	/** Logger handle. */
	private static Logger logger = Logger.getLogger(ConnectionHandle.class);
	/** An opaque handle for an application to use in any way it deems fit. */
	private Object debugHandle;

	/**
	 * List of statements that will be closed when this preparedStatement is
	 * logically closed.
	 */
	private ConcurrentLinkedQueue statementHandles = new ConcurrentLinkedQueue();
	/** Handle to the connection hook as defined in the config. */
	private ConnectionHook connectionHook;
	
	/**
	 * From: http://publib.boulder.ibm.com/infocenter/db2luw/v8/index.jsp?topic=/com.ibm.db2.udb.doc/core/r0sttmsg.htm
	 * Table 7. Class Code 08: Connection Exception
		SQLSTATE Value	  
		Value	Meaning
		08001	The application requester is unable to establish the connection.
		08002	The connection already exists.
		08003	The connection does not exist.
		08004	The application server rejected establishment of the connection.
		08007	Transaction resolution unknown.
		}
		08502	The CONNECT statement issued by an application process running with a SYNCPOINT of TWOPHASE has failed, because no transaction manager is available.
		08504	An error was encountered while processing the specified path rename configuration file.
	 SQL Failure codes indicating the database is broken/died (and thus kill off remaining connections). 
	  Anything else will be taken as the *connection* (not the db) being broken. 

	  08S01 is a mysql-specific code to indicate a connection failure (though in my tests it was triggered even when the entire
	  database was down so I treat that as a DB failure)
	 */
	private static final ImmutableSet sqlStateDBFailureCodes = ImmutableSet.of("08001", "08007", "08S01"); 
	/**
	 * Connection wrapper constructor
	 * 
	 * @param url
	 *            JDBC connection string
	 * @param username
	 *            user to use
	 * @param password
	 *            password for db
	 * @param pool
	 *            pool handle.
	 * @throws SQLException
	 *             on error
	 */
	public ConnectionHandle(String url, String username, String password,
			BoneCP pool) throws SQLException {
		
		this.pool = pool;

		try {
			this.connection = DriverManager.getConnection(url, username,
					password);

			int cacheSize = pool.getConfig().getPreparedStatementsCacheSize();
			if (cacheSize > 0) {
				this.preparedStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());
				this.callableStatementCache = new StatementCache(cacheSize,  pool.getConfig().getStatementsCachedPerConnection());

			}
			// keep track of this hook.
			this.connectionHook = this.pool.getConfig().getConnectionHook();
			// call the hook, if available.
			if (this.connectionHook != null){
				this.connectionHook.onAcquire(this);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/** Private constructor used solely for unit testing. 
	 * @param connection 
	 * @param preparedStatementCache 
	 * @param callableStatementCache 
	 * @param pool */
	public ConnectionHandle(Connection connection, IStatementCache preparedStatementCache, IStatementCache callableStatementCache, BoneCP pool){
		this.connection = connection;
		this.preparedStatementCache = preparedStatementCache;
		this.callableStatementCache = callableStatementCache;
		this.pool = pool;
	}


	/**
	 * Adds the given statement to a list.
	 * 
	 * @param statement
	 *            Statement to keep track of
	 * @return statement
	 */
	private Statement trackStatement(Statement statement) {
		if (statement != null){
			this.statementHandles.add(statement);
		}
		return statement;
	}

	/** 
	 * Given an exception, flag the connection (or database) as being potentially broken. If the exception is a data-specific exception,
	 * do nothing except throw it back to the application. 
	 * 
	 * @param t throwable exception to process
	 * @return SQLException for further processing
	 */
	protected SQLException markPossiblyBroken(Throwable t) {
		SQLException e;
		if (t instanceof SQLException){
			e=(SQLException) t;
		} else {
			e = new SQLException(t == null ? "Unknown error" : t.getMessage(), "08999");
			e.initCause( t );
		}

		String state = e.getSQLState();
		if (state == null){ // safety;
			state = "Z";
		}
		if (sqlStateDBFailureCodes.contains(state) && this.pool != null){
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
			logger.error("Database access problem. Killing off all remaining connections in the connection pool. SQL State = " + state);
			this.pool.terminateAllConnections();
		}

		// SQL-92 says:
		//		 Class values that begin with one of the s '5', '6', '7',
		//         '8', or '9' or one of the s 'I',
		//         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
		//         'W', 'X', 'Y', or 'Z' are reserved for implementation-specified
		//         conditions.


		char firstChar = state.charAt(0);
		// if it's a communication exception or an implementation-specific error code, flag this connection as being potentially broken.
		if (state.startsWith("08") ||  (firstChar >= '5' && firstChar <='9') || (firstChar >='I' && firstChar <= 'Z')){
			this.possiblyBroken = true;
		}

		return e;
	}


	public void clearWarnings() throws SQLException {
		checkClosed();
		try {
			this.connection.clearWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Checks if the connection is (logically) closed and throws an exception if it is.
	 * 
	 * @throws SQLException
	 *             on error
	 * 
	 * 
	 */
	private void checkClosed() throws SQLException {
		if (this.connectionClosed) {
			throw new SQLException("Connection is closed.");
		}
	}

	/**
	 * Release the connection if called. 
	 * 
	 * @throws SQLException Never really thrown
	 */
	public void close() throws SQLException {
		try {
			if (!this.connectionClosed) {
				this.connectionClosed = true;
				this.pool.releaseConnection(this);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	/**
	 * Close off the connection.
	 * 
	 * @throws SQLException
	 */
	protected void internalClose() throws SQLException {
		try {
			clearStatementHandles(true);
			this.connection.close();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void commit() throws SQLException {
		checkClosed();
		try {
			this.connection.commit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Array createArrayOf(String typeName, Object[] elements)
	throws SQLException {
		Array result = null;
		checkClosed();
		try {
			result = this.connection.createArrayOf(typeName, elements);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Blob createBlob() throws SQLException {
		Blob result = null;
		checkClosed();
		try {
			result = this.connection.createBlob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Clob createClob() throws SQLException {
		Clob result = null;
		checkClosed();
		try {
			result = this.connection.createClob();

		return result;

	}

	public NClob createNClob() throws SQLException {
		NClob result = null;
		checkClosed();
		try {
			result = this.connection.createNClob();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public SQLXML createSQLXML() throws SQLException {
		SQLXML result = null;
		checkClosed();
		try {
			result = this.connection.createSQLXML();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement() throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType, int resultSetConcurrency)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Statement createStatement(int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			result = trackStatement(new StatementHandle(this.connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability), this));
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public Struct createStruct(String typeName, Object[] attributes)
	throws SQLException {
		Struct result = null;
		checkClosed();
		try {
			result = this.connection.createStruct(typeName, attributes);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean getAutoCommit() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.getAutoCommit();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getCatalog() throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.getCatalog();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Properties getClientInfo() throws SQLException {
		Properties result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String getClientInfo(String name) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.getClientInfo(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getHoldability() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getHoldability();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}

		return result;
	}

	public DatabaseMetaData getMetaData() throws SQLException {
		DatabaseMetaData result = null;
		checkClosed();
		try {
			result = this.connection.getMetaData();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public int getTransactionIsolation() throws SQLException {
		int result = 0;
		checkClosed();
		try {
			result = this.connection.getTransactionIsolation();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Map> getTypeMap() throws SQLException {
		Map> result = null;
		checkClosed();
		try {
			result = this.connection.getTypeMap();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public SQLWarning getWarnings() throws SQLException {
		SQLWarning result = null;
		checkClosed();
		try {
			result = this.connection.getWarnings();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isClosed() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isClosed();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isReadOnly() throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isReadOnly();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public boolean isValid(int timeout) throws SQLException {
		boolean result = false;
		checkClosed();
		try {
			result = this.connection.isValid(timeout);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public String nativeSQL(String sql) throws SQLException {
		String result = null;
		checkClosed();
		try {
			result = this.connection.nativeSQL(sql);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {

			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql);
				if (result == null) {
		}
					String cacheKey = sql;
					result = (CallableStatement) trackStatement(new CallableStatementHandle(this.connection.prepareCall(sql),
							sql, this.callableStatementCache, this, cacheKey));

				} 

				((CallableStatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {
				result = (CallableStatement) this.callableStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.callableStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency), sql, this.callableStatementCache, this, cacheKey));

				} 

				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType, resultSetConcurrency);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public CallableStatement prepareCall(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		CallableStatement result = null;
		checkClosed();
		try {
			if (this.callableStatementCache != null) {

				result = (CallableStatement) this.callableStatementCache.get(sql);

				if (result == null) {
					result = (CallableStatement) trackStatement(new CallableStatementHandle(
							this.connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability), sql,
							this.callableStatementCache, this, sql));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareCall(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql) throws SQLException {
		Statement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = this.preparedStatementCache.get(sql);

				if (result == null) {

					String cacheKey = sql;

					result =  trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql), sql,
							this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return (PreparedStatement) result;
	}

	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

			throw markPossiblyBroken(t);
				result = (PreparedStatement) this.preparedStatementCache.get(sql, autoGeneratedKeys);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, autoGeneratedKeys);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									autoGeneratedKeys), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql,
						autoGeneratedKeys);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnIndexes);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnIndexes);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection
							.prepareStatement(sql, columnIndexes), sql,
							this.preparedStatementCache, this, cacheKey));
				}
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnIndexes);
			}
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, String[] columnNames)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, columnNames);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, columnNames);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql, columnNames),
							sql, this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, columnNames);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency) throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency), sql,
									this.preparedStatementCache, this, cacheKey));
				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency);
			}

		} catch (Throwable t) {
		return result;
	}

	public PreparedStatement prepareStatement(String sql, int resultSetType,
			int resultSetConcurrency, int resultSetHoldability)
	throws SQLException {
		PreparedStatement result = null;
		checkClosed();
		try {
			if (this.preparedStatementCache != null) {

				result = (PreparedStatement) this.preparedStatementCache.get(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

				if (result == null) {
					String cacheKey = this.preparedStatementCache.calculateCacheKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability);

					result = (PreparedStatement) trackStatement(new PreparedStatementHandle(
							this.connection.prepareStatement(sql,
									resultSetType, resultSetConcurrency,
									resultSetHoldability), sql,
									this.preparedStatementCache, this, cacheKey));

				} 
				((StatementHandle)result).setLogicallyOpen();
			} else {
				result = this.connection.prepareStatement(sql, resultSetType,
						resultSetConcurrency, resultSetHoldability);
			}

		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.releaseSavepoint(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);

		}
	}

	public void rollback() throws SQLException {
		checkClosed();
		try {
			this.connection.rollback();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void rollback(Savepoint savepoint) throws SQLException {
		checkClosed();
		try {
			this.connection.rollback(savepoint);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setAutoCommit(boolean autoCommit) throws SQLException {
		checkClosed();
		try {
			this.connection.setAutoCommit(autoCommit);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setCatalog(String catalog) throws SQLException {
		checkClosed();
		try {
			this.connection.setCatalog(catalog);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setClientInfo(Properties properties)
	throws SQLClientInfoException {
		this.connection.setClientInfo(properties);
	}

	public void setClientInfo(String name, String value)
	throws SQLClientInfoException {
		this.connection.setClientInfo(name, value);
	}

	public void setHoldability(int holdability) throws SQLException {
		checkClosed();
		try {
			this.connection.setHoldability(holdability);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setReadOnly(boolean readOnly) throws SQLException {
		checkClosed();
		try {
			this.connection.setReadOnly(readOnly);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public Savepoint setSavepoint() throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint();
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public Savepoint setSavepoint(String name) throws SQLException {
		checkClosed();
		Savepoint result = null;
		try {
			result = this.connection.setSavepoint(name);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
		return result;
	}

	public void setTransactionIsolation(int level) throws SQLException {
		checkClosed();
		try {
			this.connection.setTransactionIsolation(level);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public void setTypeMap(Map> map) throws SQLException {
		checkClosed();
		try {
			this.connection.setTypeMap(map);
		} catch (Throwable t) {
			throw markPossiblyBroken(t);
		}
	}

	public boolean isWrapperFor(Class iface) throws SQLException {
		return this.connection.isWrapperFor(iface);
	}

	public  T unwrap(Class iface) throws SQLException {
		return this.connection.unwrap(iface);
	}

	/**
	 * @return the connectionLastUsed
	 */
	public long getConnectionLastUsed() {
		return this.connectionLastUsed;
	}

	/**
	 * @param connectionLastUsed
	 *            the connectionLastUsed to set
	 */
	protected void setConnectionLastUsed(long connectionLastUsed) {
		this.connectionLastUsed = connectionLastUsed;
	}

	/**
	 * @return the connectionLastReset
	 */
	public long getConnectionLastReset() {
		return this.connectionLastReset;
	}

	/**
	 * @param connectionLastReset
	 *            the connectionLastReset to set
	 */
	protected void setConnectionLastReset(long connectionLastReset) {
		this.connectionLastReset = connectionLastReset;
	}

	/**
	 * Gets true if connection has triggered an exception at some point.
	 * @return true if the connection has triggered an error
	 */
	public boolean isPossiblyBroken() {
		return this.possiblyBroken;
	}


	/**
	 * Gets the partition this came from.
	 * 
	 * @return the partition this came from
	 */
	public ConnectionPartition getOriginatingPartition() {
		return this.originatingPartition;
	}

	/**
	 * Sets Originating partition
	 * 
	 * @param originatingPartition
	 *            to set
	 */
	protected void setOriginatingPartition(ConnectionPartition originatingPartition) {
		this.originatingPartition = originatingPartition;
	}

	/**
	 * Renews this connection, i.e. Sets this connection to be logically open
	 * (although it was never really closed)
	 */
	protected void renewConnection() {
		this.connectionClosed = false;
	}


	/** Clears out the statement handles.
	 * @param internalClose if true, close the inner statement handle too. 
	 * @throws SQLException
	 */
	protected void clearStatementHandles(boolean internalClose) throws SQLException {
		if (!internalClose){
			this.statementHandles.clear();
		} else{
			Statement statement = null;
			while ((statement = this.statementHandles.poll()) != null) {
				((StatementHandle) statement).internalClose();
			}
		}
	}

	/** Returns a debug handle as previously set by an application
	 * @return DebugHandle
	 */
	public Object getDebugHandle() {
		return this.debugHandle;
	}

	/** Sets a debugHandle, an object that is not used by the connection pool at all but may be set by an application to track
	 * this particular connection handle for any purpose it deems fit.
	 * @param debugHandle any object.
	 */
	public void setDebugHandle(Object debugHandle) {
		this.debugHandle = debugHandle;
	}

	/** Returns the internal connection as obtained via the JDBC driver.
	 * @return the raw connection
	 */
	public Connection getRawConnection() {
		return this.connection;
	}

	/** Returns the configured connection hook object.
	 * @return the connectionHook that was set in the config
	 */
	public ConnectionHook getConnectionHook() {
		return this.connectionHook;
	}
}