/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.dbcp;

 import java.sql.CallableStatement;

 import java.sql.Connection;

 import java.sql.DatabaseMetaData;

 import java.sql.PreparedStatement;

 import java.sql.SQLException;

 import java.sql.SQLWarning;

 import java.sql.Statement;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.sql.ResultSet;

 /* JDBC_4_ANT_KEY_BEGIN */

 import java.sql.Array;

 import java.sql.Blob;

 import java.sql.ClientInfoStatus;

 import java.sql.Clob;

 import java.sql.NClob;

 import java.sql.SQLClientInfoException;

 import java.sql.SQLXML;

 import java.sql.Struct;

 import java.util.Collections;

 import java.util.Properties;

 /* JDBC_4_ANT_KEY_END */

 /**

  * A base delegating implementation of {@link Connection}.

  * <p>

  * All of the methods from the {@link Connection} interface

  * simply check to see that the {@link Connection} is active,

  * and call the corresponding method on the "delegate"

  * provided in my constructor.

  * <p>

  * Extends AbandonedTrace to implement Connection tracking and

  * logging of code which created the Connection. Tracking the

  * Connection ensures that the AbandonedObjectPool can close

  * this connection and recycle it if its pool of connections

  * is nearing exhaustion and this connection's last usage is

  * older than the removeAbandonedTimeout.

  *

  * @author Rodney Waldhoff

  * @author Glenn L. Nielsen

  * @author James House

  * @author Dirk Verbeeck

  * @version $Revision: 1023401 $ $Date: 2010-10-16 21:54:24 -0400 (Sat, 16 Oct 2010) $

  */

 public class DelegatingConnection extends AbandonedTrace

         implements Connection {

 /* JDBC_4_ANT_KEY_BEGIN */

     private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =

         Collections.<String, ClientInfoStatus>emptyMap();

 /* JDBC_4_ANT_KEY_END */

     /** My delegate {@link Connection}. */

     protected Connection _conn = null;

     protected boolean _closed = false;

     /**

      * Create a wrapper for the Connection which traces this

      * Connection in the AbandonedObjectPool.

      *

      * @param c the {@link Connection} to delegate all calls to.

      */

     public DelegatingConnection(Connection c) {

         super();

         _conn = c;

     }

     /**

      * Create a wrapper for the Connection which traces

      * the Statements created so that any unclosed Statements

      * can be closed when this Connection is closed.

      *

      * @param c the {@link Connection} to delegate all calls to.

      * @param config the configuration for tracing abandoned objects

      */

     public DelegatingConnection(Connection c, AbandonedConfig config) {

         super(config);

         _conn = c;

     }

     /**

      * Returns a string representation of the metadata associated with

      * the innnermost delegate connection.

      * 

      * @since 1.2.2

      */

     public String toString() {

         String s = null;

         Connection c = this.getInnermostDelegateInternal();

         if (c != null) {

             try {

                 if (c.isClosed()) {

                     s = "connection is closed";

                 }

                 else {

                     DatabaseMetaData meta = c.getMetaData();

                     if (meta != null) {

                         StringBuffer sb = new StringBuffer();

                         sb.append(meta.getURL());

                         sb.append(", UserName=");

                         sb.append(meta.getUserName());

                         sb.append(", ");

                         sb.append(meta.getDriverName());

                         s = sb.toString();

                     }

                 }

             }

             catch (SQLException ex) {

                 // Ignore

             }

         }

         if (s == null) {

             s = super.toString();

         }

         return s;

     }

     /**

      * Returns my underlying {@link Connection}.

      * @return my underlying {@link Connection}.

      */

     public Connection getDelegate() {

         return getDelegateInternal();

     }

     /**

      * Should be final but can't be for compatibility with previous releases.

      */

     protected Connection getDelegateInternal() {

         return _conn;

     }

     /**

      * Compares innermost delegate to the given connection.

      * 

      * @param c connection to compare innermost delegate with

      * @return true if innermost delegate equals <code>c</code>

      * @since 1.2.2

      */

     public boolean innermostDelegateEquals(Connection c) {

         Connection innerCon = getInnermostDelegateInternal();

         if (innerCon == null) {

             return c == null;

         } else {

             return innerCon.equals(c);

         }

     }

     /**

      * This method considers two objects to be equal 

      * if the underlying jdbc objects are equal.

      */

     public boolean equals(Object obj) {

         if (obj == null) {

             return false;

         }

         if (obj == this) {

             return true;

         }

         Connection delegate = getInnermostDelegateInternal();

         if (delegate == null) {

             return false;

         }

         if (obj instanceof DelegatingConnection) {    

             DelegatingConnection c = (DelegatingConnection) obj;

             return c.innermostDelegateEquals(delegate);

         }

         else {

             return delegate.equals(obj);

         }

     }

     public int hashCode() {

         Object obj = getInnermostDelegateInternal();

         if (obj == null) {

             return 0;

         }

         return obj.hashCode();

     }

     /**

      * If my underlying {@link Connection} is not a

      * <tt>DelegatingConnection</tt>, returns it,

      * otherwise recursively invokes this method on

      * my delegate.

      * <p>

      * Hence this method will return the first

      * delegate that is not a <tt>DelegatingConnection</tt>,

      * or <tt>null</tt> when no non-<tt>DelegatingConnection</tt>

      * delegate can be found by traversing this chain.

      * <p>

      * This method is useful when you may have nested

      * <tt>DelegatingConnection</tt>s, and you want to make

      * sure to obtain a "genuine" {@link Connection}.

      */

     public Connection getInnermostDelegate() {

         return getInnermostDelegateInternal();

     }

     protected final Connection getInnermostDelegateInternal() {

         Connection c = _conn;

         while(c != null && c instanceof DelegatingConnection) {

             c = ((DelegatingConnection)c).getDelegateInternal();

             if(this == c) {

                 return null;

             }

         }

         return c;

     }

     /** Sets my delegate. */

     public void setDelegate(Connection c) {

         _conn = c;

     }

     /**

      * Closes the underlying connection, and close

      * any Statements that were not explicitly closed.

      */

     public void close() throws SQLException {

         passivate();

         _conn.close();

     }

     protected void handleException(SQLException e) throws SQLException {

         throw e;

     }

     public Statement createStatement() throws SQLException {

         checkOpen();

         try {

             return new DelegatingStatement(this, _conn.createStatement());

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public Statement createStatement(int resultSetType,

                                      int resultSetConcurrency) throws SQLException {

         checkOpen();

         try {

             return new DelegatingStatement

                 (this, _conn.createStatement(resultSetType,resultSetConcurrency));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public PreparedStatement prepareStatement(String sql) throws SQLException {

         checkOpen();

         try {

             return new DelegatingPreparedStatement

                 (this, _conn.prepareStatement(sql));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public PreparedStatement prepareStatement(String sql,

                                               int resultSetType,

                                               int resultSetConcurrency) throws SQLException {

         checkOpen();

         try {

             return new DelegatingPreparedStatement

                 (this, _conn.prepareStatement

                     (sql,resultSetType,resultSetConcurrency));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public CallableStatement prepareCall(String sql) throws SQLException {

         checkOpen();

         try {

             return new DelegatingCallableStatement(this, _conn.prepareCall(sql));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public CallableStatement prepareCall(String sql,

                                          int resultSetType,

                                          int resultSetConcurrency) throws SQLException {

         checkOpen();

         try {

             return new DelegatingCallableStatement

                 (this, _conn.prepareCall(sql, resultSetType,resultSetConcurrency));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public void clearWarnings() throws SQLException

     { checkOpen(); try { _conn.clearWarnings(); } catch (SQLException e) { handleException(e); } }

     public void commit() throws SQLException

     { checkOpen(); try { _conn.commit(); } catch (SQLException e) { handleException(e); } }

     public boolean getAutoCommit() throws SQLException

     { checkOpen(); try { return _conn.getAutoCommit(); } catch (SQLException e) { handleException(e); return false; } 

     }

     public String getCatalog() throws SQLException

     { checkOpen(); try { return _conn.getCatalog(); } catch (SQLException e) { handleException(e); return null; } }

     public DatabaseMetaData getMetaData() throws SQLException {

         checkOpen();

         try {

             return new DelegatingDatabaseMetaData(this, _conn.getMetaData());

         } catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public int getTransactionIsolation() throws SQLException

     { checkOpen(); try { return _conn.getTransactionIsolation(); } catch (SQLException e) { handleException(e); return -1; } }

     public Map getTypeMap() throws SQLException

     { checkOpen(); try { return _conn.getTypeMap(); } catch (SQLException e) { handleException(e); return null; } }

     public SQLWarning getWarnings() throws SQLException

     { checkOpen(); try { return _conn.getWarnings(); } catch (SQLException e) { handleException(e); return null; } }

     public boolean isReadOnly() throws SQLException

     { checkOpen(); try { return _conn.isReadOnly(); } catch (SQLException e) { handleException(e); return false; } }

     public String nativeSQL(String sql) throws SQLException

     { checkOpen(); try { return _conn.nativeSQL(sql); } catch (SQLException e) { handleException(e); return null; } }

     public void rollback() throws SQLException

     { checkOpen(); try {  _conn.rollback(); } catch (SQLException e) { handleException(e); } }

     public void setAutoCommit(boolean autoCommit) throws SQLException

     { checkOpen(); try { _conn.setAutoCommit(autoCommit); } catch (SQLException e) { handleException(e); } }

     public void setCatalog(String catalog) throws SQLException

     { checkOpen(); try { _conn.setCatalog(catalog); } catch (SQLException e) { handleException(e); } }

     public void setReadOnly(boolean readOnly) throws SQLException

     { checkOpen(); try { _conn.setReadOnly(readOnly); } catch (SQLException e) { handleException(e); } }

     public void setTransactionIsolation(int level) throws SQLException

     { checkOpen(); try { _conn.setTransactionIsolation(level); } catch (SQLException e) { handleException(e); } }

     public void setTypeMap(Map map) throws SQLException

     { checkOpen(); try { _conn.setTypeMap(map); } catch (SQLException e) { handleException(e); } }

     public boolean isClosed() throws SQLException {

         return _closed || _conn.isClosed();

     }

     protected void checkOpen() throws SQLException {

         if(_closed) {

             if (null != _conn) {

                 String label = "";

                 try {

                     label = _conn.toString();

                 } catch (Exception ex) {

                     // ignore, leave label empty

                 }

                 throw new SQLException

                     ("Connection " + label + " is closed.");

             } else {

                 throw new SQLException

                     ("Connection is null.");

             }      

         }

     }

     protected void activate() {

         _closed = false;

         setLastUsed();

         if(_conn instanceof DelegatingConnection) {

             ((DelegatingConnection)_conn).activate();

         }

     }

     protected void passivate() throws SQLException {

         try {

             // The JDBC spec requires that a Connection close any open

             // Statement's when it is closed.

             // DBCP-288. Not all the traced objects will be statements

             List traces = getTrace();

             if(traces != null) {

                 Iterator traceIter = traces.iterator();

                 while (traceIter.hasNext()) {

                     Object trace = traceIter.next();

                     if (trace instanceof Statement) {

                         ((Statement) trace).close();

                     } else if (trace instanceof ResultSet) {

                         // DBCP-265: Need to close the result sets that are

                         // generated via DatabaseMetaData

                         ((ResultSet) trace).close();

                     }

                 }

                 clearTrace();

             }

             setLastUsed(0);

             if(_conn instanceof DelegatingConnection) {

                 ((DelegatingConnection)_conn).passivate();

             }

         }

         finally {

             _closed = true;

         }

     }

     public int getHoldability() throws SQLException

     { checkOpen(); try { return _conn.getHoldability(); } catch (SQLException e) { handleException(e); return 0; } }

     public void setHoldability(int holdability) throws SQLException

     { checkOpen(); try { _conn.setHoldability(holdability); } catch (SQLException e) { handleException(e); } }

     public java.sql.Savepoint setSavepoint() throws SQLException

     { checkOpen(); try { return _conn.setSavepoint(); } catch (SQLException e) { handleException(e); return null; } }

     public java.sql.Savepoint setSavepoint(String name) throws SQLException

     { checkOpen(); try { return _conn.setSavepoint(name); } catch (SQLException e) { handleException(e); return null; } }

     public void rollback(java.sql.Savepoint savepoint) throws SQLException

     { checkOpen(); try { _conn.rollback(savepoint); } catch (SQLException e) { handleException(e); } }

     public void releaseSavepoint(java.sql.Savepoint savepoint) throws SQLException

     { checkOpen(); try { _conn.releaseSavepoint(savepoint); } catch (SQLException e) { handleException(e); } }

     public Statement createStatement(int resultSetType,

                                      int resultSetConcurrency,

                                      int resultSetHoldability) throws SQLException {

         checkOpen();

         try {

             return new DelegatingStatement(this, _conn.createStatement(

                 resultSetType, resultSetConcurrency, resultSetHoldability));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public PreparedStatement prepareStatement(String sql, int resultSetType,

                                               int resultSetConcurrency,

                                               int resultSetHoldability) throws SQLException {

         checkOpen();

         try {

             return new DelegatingPreparedStatement(this, _conn.prepareStatement(

                 sql, resultSetType, resultSetConcurrency, resultSetHoldability));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public CallableStatement prepareCall(String sql, int resultSetType,

                                          int resultSetConcurrency,

                                          int resultSetHoldability) throws SQLException {

         checkOpen();

         try {

             return new DelegatingCallableStatement(this, _conn.prepareCall(

                 sql, resultSetType, resultSetConcurrency, resultSetHoldability));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {

         checkOpen();

         try {

             return new DelegatingPreparedStatement(this, _conn.prepareStatement(

                 sql, autoGeneratedKeys));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

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

         checkOpen();

         try {

             return new DelegatingPreparedStatement(this, _conn.prepareStatement(

                 sql, columnIndexes));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {

         checkOpen();

         try {

             return new DelegatingPreparedStatement(this, _conn.prepareStatement(

                 sql, columnNames));

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

 /* JDBC_4_ANT_KEY_BEGIN */

     public boolean isWrapperFor(Class<?> iface) throws SQLException {

         return iface.isAssignableFrom(getClass()) || _conn.isWrapperFor(iface);

     }

     public <T> T unwrap(Class<T> iface) throws SQLException {

         if (iface.isAssignableFrom(getClass())) {

             return iface.cast(this);

         } else if (iface.isAssignableFrom(_conn.getClass())) {

             return iface.cast(_conn);

         } else {

             return _conn.unwrap(iface);

         }

     }

     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {

         checkOpen();

         try {

             return _conn.createArrayOf(typeName, elements);

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public Blob createBlob() throws SQLException {

         checkOpen();

         try {

             return _conn.createBlob();

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public Clob createClob() throws SQLException {

         checkOpen();

         try {

             return _conn.createClob();

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public NClob createNClob() throws SQLException {

         checkOpen();

         try {

             return _conn.createNClob();

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public SQLXML createSQLXML() throws SQLException {

         checkOpen();

         try {

             return _conn.createSQLXML();

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {

         checkOpen();

         try {

             return _conn.createStruct(typeName, attributes);

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public boolean isValid(int timeout) throws SQLException {

         checkOpen();

         try {

             return _conn.isValid(timeout);

         }

         catch (SQLException e) {

             handleException(e);

             return false;

         }

     }

     public void setClientInfo(String name, String value) throws SQLClientInfoException {

         try {

             checkOpen();

             _conn.setClientInfo(name, value);

         }

         catch (SQLClientInfoException e) {

             throw e;

         }

         catch (SQLException e) {

             throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);

         }

     }

     public void setClientInfo(Properties properties) throws SQLClientInfoException {

         try {

             checkOpen();

             _conn.setClientInfo(properties);

         }

         catch (SQLClientInfoException e) {

             throw e;

         }

         catch (SQLException e) {

             throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);

         }

     }

     public Properties getClientInfo() throws SQLException {

         checkOpen();

         try {

             return _conn.getClientInfo();

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

     public String getClientInfo(String name) throws SQLException {

         checkOpen();

         try {

             return _conn.getClientInfo(name);

         }

         catch (SQLException e) {

             handleException(e);

             return null;

         }

     }

 /* JDBC_4_ANT_KEY_END */

 }