/*
    * Copyright 2004-2022 the original author or authors.
    *
    * Licensed 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
    *
    *    https://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 com.ibatis.common.jdbc;
  
  import com.ibatis.common.beans.ClassInfo;
  import com.ibatis.common.logging.Log;
  import com.ibatis.common.logging.LogFactory;
  import com.ibatis.common.resources.Resources;
  
  import java.io.PrintWriter;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.sql.*;
  import java.util.*;
  import java.util.logging.Logger;
  
  import javax.sql.DataSource;
  
  /**
   * This is a simple, synchronous, thread-safe database connection pool.
   * <p>
   * REQUIRED PROPERTIES ------------------- JDBC.Driver JDBC.ConnectionURL JDBC.Username JDBC.Password
   * <p>
   * Pool.MaximumActiveConnections Pool.MaximumIdleConnections Pool.MaximumCheckoutTime Pool.TimeToWait Pool.PingQuery
   * Pool.PingEnabled Pool.PingConnectionsOlderThan Pool.PingConnectionsNotUsedFor Pool.QuietMode
   */
  public class SimpleDataSource implements DataSource {
  
    /** The Constant log. */
    private static final Log log = LogFactory.getLog(SimpleDataSource.class);
  
    /** The Constant PROP_JDBC_DRIVER. */
    // Required Properties
    private static final String PROP_JDBC_DRIVER = "JDBC.Driver";
  
    /** The Constant PROP_JDBC_URL. */
    private static final String PROP_JDBC_URL = "JDBC.ConnectionURL";
  
    /** The Constant PROP_JDBC_USERNAME. */
    private static final String PROP_JDBC_USERNAME = "JDBC.Username";
  
    /** The Constant PROP_JDBC_PASSWORD. */
    private static final String PROP_JDBC_PASSWORD = "JDBC.Password";
  
    /** The Constant PROP_JDBC_DEFAULT_AUTOCOMMIT. */
    private static final String PROP_JDBC_DEFAULT_AUTOCOMMIT = "JDBC.DefaultAutoCommit";
  
    /** The Constant PROP_POOL_MAX_ACTIVE_CONN. */
    // Optional Properties
    private static final String PROP_POOL_MAX_ACTIVE_CONN = "Pool.MaximumActiveConnections";
  
    /** The Constant PROP_POOL_MAX_IDLE_CONN. */
    private static final String PROP_POOL_MAX_IDLE_CONN = "Pool.MaximumIdleConnections";
  
    /** The Constant PROP_POOL_MAX_CHECKOUT_TIME. */
    private static final String PROP_POOL_MAX_CHECKOUT_TIME = "Pool.MaximumCheckoutTime";
  
    /** The Constant PROP_POOL_TIME_TO_WAIT. */
    private static final String PROP_POOL_TIME_TO_WAIT = "Pool.TimeToWait";
  
    /** The Constant PROP_POOL_PING_QUERY. */
    private static final String PROP_POOL_PING_QUERY = "Pool.PingQuery";
  
    /** The Constant PROP_POOL_PING_CONN_OLDER_THAN. */
    private static final String PROP_POOL_PING_CONN_OLDER_THAN = "Pool.PingConnectionsOlderThan";
  
    /** The Constant PROP_POOL_PING_ENABLED. */
    private static final String PROP_POOL_PING_ENABLED = "Pool.PingEnabled";
  
    /** The Constant PROP_POOL_PING_CONN_NOT_USED_FOR. */
    private static final String PROP_POOL_PING_CONN_NOT_USED_FOR = "Pool.PingConnectionsNotUsedFor";
  
    /** The expected connection type code. */
    private int expectedConnectionTypeCode;
  
    /** The Constant ADD_DRIVER_PROPS_PREFIX. */
    // Additional Driver Properties prefix
    private static final String ADD_DRIVER_PROPS_PREFIX = "Driver.";
  
    /** The Constant ADD_DRIVER_PROPS_PREFIX_LENGTH. */
    private static final int ADD_DRIVER_PROPS_PREFIX_LENGTH = ADD_DRIVER_PROPS_PREFIX.length();
  
    /** The pool lock. */
    // ----- BEGIN: FIELDS LOCKED BY POOL_LOCK -----
    private final Object POOL_LOCK = new Object();
 
   /** The idle connections. */
   private List idleConnections = new ArrayList();
 
   /** The active connections. */
   private List activeConnections = new ArrayList();
 
   /** The request count. */
   private long requestCount = 0;
 
   /** The accumulated request time. */
   private long accumulatedRequestTime = 0;
 
   /** The accumulated checkout time. */
   private long accumulatedCheckoutTime = 0;
 
   /** The claimed overdue connection count. */
   private long claimedOverdueConnectionCount = 0;
 
   /** The accumulated checkout time of overdue connections. */
   private long accumulatedCheckoutTimeOfOverdueConnections = 0;
 
   /** The accumulated wait time. */
   private long accumulatedWaitTime = 0;
 
   /** The had to wait count. */
   private long hadToWaitCount = 0;
 
   /** The bad connection count. */
   private long badConnectionCount = 0;
   // ----- END: FIELDS LOCKED BY POOL_LOCK -----
 
   /** The jdbc driver. */
   // ----- BEGIN: PROPERTY FIELDS FOR CONFIGURATION -----
   private String jdbcDriver;
 
   /** The jdbc url. */
   private String jdbcUrl;
 
   /** The jdbc username. */
   private String jdbcUsername;
 
   /** The jdbc password. */
   private String jdbcPassword;
 
   /** The jdbc default auto commit. */
   private boolean jdbcDefaultAutoCommit;
 
   /** The driver props. */
   private Properties driverProps;
 
   /** The use driver props. */
   private boolean useDriverProps;
 
   /** The pool maximum active connections. */
   private int poolMaximumActiveConnections;
 
   /** The pool maximum idle connections. */
   private int poolMaximumIdleConnections;
 
   /** The pool maximum checkout time. */
   private int poolMaximumCheckoutTime;
 
   /** The pool time to wait. */
   private int poolTimeToWait;
 
   /** The pool ping query. */
   private String poolPingQuery;
 
   /** The pool ping enabled. */
   private boolean poolPingEnabled;
 
   /** The pool ping connections older than. */
   private int poolPingConnectionsOlderThan;
 
   /** The pool ping connections not used for. */
   private int poolPingConnectionsNotUsedFor;
 
   // ----- END: PROPERTY FIELDS FOR CONFIGURATION -----
 
   /**
    * Constructor to allow passing in a map of properties for configuration.
    *
    * @param props
    *          - the configuration parameters
    */
   public SimpleDataSource(Map props) {
     initialize(props);
   }
 
   /**
    * Initialize.
    *
    * @param props
    *          the props
    */
   private void initialize(Map props) {
     try {
       String prop_pool_ping_query = null;
 
       if (props == null) {
         throw new RuntimeException("SimpleDataSource: The properties map passed to the initializer was null.");
       }
 
       if (!(props.containsKey(PROP_JDBC_DRIVER) && props.containsKey(PROP_JDBC_URL)
           && props.containsKey(PROP_JDBC_USERNAME) && props.containsKey(PROP_JDBC_PASSWORD))) {
         throw new RuntimeException("SimpleDataSource: Some properties were not set.");
       } else {
 
         jdbcDriver = (String) props.get(PROP_JDBC_DRIVER);
         jdbcUrl = (String) props.get(PROP_JDBC_URL);
         jdbcUsername = (String) props.get(PROP_JDBC_USERNAME);
         jdbcPassword = (String) props.get(PROP_JDBC_PASSWORD);
 
         poolMaximumActiveConnections = props.containsKey(PROP_POOL_MAX_ACTIVE_CONN)
             ? Integer.parseInt((String) props.get(PROP_POOL_MAX_ACTIVE_CONN)) : 10;
 
         poolMaximumIdleConnections = props.containsKey(PROP_POOL_MAX_IDLE_CONN)
             ? Integer.parseInt((String) props.get(PROP_POOL_MAX_IDLE_CONN)) : 5;
 
         poolMaximumCheckoutTime = props.containsKey(PROP_POOL_MAX_CHECKOUT_TIME)
             ? Integer.parseInt((String) props.get(PROP_POOL_MAX_CHECKOUT_TIME)) : 20000;
 
         poolTimeToWait = props.containsKey(PROP_POOL_TIME_TO_WAIT)
             ? Integer.parseInt((String) props.get(PROP_POOL_TIME_TO_WAIT)) : 20000;
 
         poolPingEnabled = props.containsKey(PROP_POOL_PING_ENABLED)
             && Boolean.valueOf((String) props.get(PROP_POOL_PING_ENABLED)).booleanValue();
 
         prop_pool_ping_query = (String) props.get(PROP_POOL_PING_QUERY);
         poolPingQuery = props.containsKey(PROP_POOL_PING_QUERY) ? prop_pool_ping_query : "NO PING QUERY SET";
 
         poolPingConnectionsOlderThan = props.containsKey(PROP_POOL_PING_CONN_OLDER_THAN)
             ? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_OLDER_THAN)) : 0;
 
         poolPingConnectionsNotUsedFor = props.containsKey(PROP_POOL_PING_CONN_NOT_USED_FOR)
             ? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_NOT_USED_FOR)) : 0;
 
         jdbcDefaultAutoCommit = props.containsKey(PROP_JDBC_DEFAULT_AUTOCOMMIT)
             && Boolean.valueOf((String) props.get(PROP_JDBC_DEFAULT_AUTOCOMMIT)).booleanValue();
 
         useDriverProps = false;
         Iterator propIter = props.keySet().iterator();
         driverProps = new Properties();
         driverProps.put("user", jdbcUsername);
         driverProps.put("password", jdbcPassword);
         while (propIter.hasNext()) {
           String name = (String) propIter.next();
           String value = (String) props.get(name);
           if (name.startsWith(ADD_DRIVER_PROPS_PREFIX)) {
             driverProps.put(name.substring(ADD_DRIVER_PROPS_PREFIX_LENGTH), value);
             useDriverProps = true;
           }
         }
 
         expectedConnectionTypeCode = assembleConnectionTypeCode(jdbcUrl, jdbcUsername, jdbcPassword);
 
         Resources.instantiate(jdbcDriver);
 
         if (poolPingEnabled
             && (!props.containsKey(PROP_POOL_PING_QUERY) || prop_pool_ping_query.trim().length() == 0)) {
           throw new RuntimeException("SimpleDataSource: property '" + PROP_POOL_PING_ENABLED
               + "' is true, but property '" + PROP_POOL_PING_QUERY + "' is not set correctly.");
         }
       }
 
     } catch (Exception e) {
       log.error("SimpleDataSource: Error while loading properties. Cause: " + e.toString(), e);
       throw new RuntimeException("SimpleDataSource: Error while loading properties. Cause: " + e, e);
     }
   }
 
   /**
    * Assemble connection type code.
    *
    * @param url
    *          the url
    * @param username
    *          the username
    * @param password
    *          the password
    *
    * @return the int
    */
   private int assembleConnectionTypeCode(String url, String username, String password) {
     return ("" + url + username + password).hashCode();
   }
 
   /**
    * @see javax.sql.DataSource#getConnection()
    */
   public Connection getConnection() throws SQLException {
     return popConnection(jdbcUsername, jdbcPassword).getProxyConnection();
   }
 
   /**
    * @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)
    */
   public Connection getConnection(String username, String password) throws SQLException {
     return popConnection(username, password).getProxyConnection();
   }
 
   /**
    * @see javax.sql.DataSource#setLoginTimeout(int)
    */
   public void setLoginTimeout(int loginTimeout) throws SQLException {
     DriverManager.setLoginTimeout(loginTimeout);
   }
 
   /**
    * @see javax.sql.DataSource#getLoginTimeout()
    */
   public int getLoginTimeout() throws SQLException {
     return DriverManager.getLoginTimeout();
   }
 
   /**
    * @see javax.sql.DataSource#setLogWriter(java.io.PrintWriter)
    */
   public void setLogWriter(PrintWriter logWriter) throws SQLException {
     DriverManager.setLogWriter(logWriter);
   }
 
   /**
    * @see javax.sql.DataSource#getLogWriter()
    */
   public PrintWriter getLogWriter() throws SQLException {
     return DriverManager.getLogWriter();
   }
 
   /**
    * If a connection has not been used in this many milliseconds, ping the database to make sure the connection is still
    * good.
    *
    * @return the number of milliseconds of inactivity that will trigger a ping
    */
   public int getPoolPingConnectionsNotUsedFor() {
     return poolPingConnectionsNotUsedFor;
   }
 
   /**
    * Getter for the name of the JDBC driver class used.
    *
    * @return The name of the class
    */
   public String getJdbcDriver() {
     return jdbcDriver;
   }
 
   /**
    * Getter of the JDBC URL used.
    *
    * @return The JDBC URL
    */
   public String getJdbcUrl() {
     return jdbcUrl;
   }
 
   /**
    * Getter for the JDBC user name used.
    *
    * @return The user name
    */
   public String getJdbcUsername() {
     return jdbcUsername;
   }
 
   /**
    * Getter for the JDBC password used.
    *
    * @return The password
    */
   public String getJdbcPassword() {
     return jdbcPassword;
   }
 
   /**
    * Getter for the maximum number of active connections.
    *
    * @return The maximum number of active connections
    */
   public int getPoolMaximumActiveConnections() {
     return poolMaximumActiveConnections;
   }
 
   /**
    * Getter for the maximum number of idle connections.
    *
    * @return The maximum number of idle connections
    */
   public int getPoolMaximumIdleConnections() {
     return poolMaximumIdleConnections;
   }
 
   /**
    * Getter for the maximum time a connection can be used before it *may* be given away again.
    *
    * @return The maximum time
    */
   public int getPoolMaximumCheckoutTime() {
     return poolMaximumCheckoutTime;
   }
 
   /**
    * Getter for the time to wait before retrying to get a connection.
    *
    * @return The time to wait
    */
   public int getPoolTimeToWait() {
     return poolTimeToWait;
   }
 
   /**
    * Getter for the query to be used to check a connection.
    *
    * @return The query
    */
   public String getPoolPingQuery() {
     return poolPingQuery;
   }
 
   /**
    * Getter to tell if we should use the ping query.
    *
    * @return True if we need to check a connection before using it
    */
   public boolean isPoolPingEnabled() {
     return poolPingEnabled;
   }
 
   /**
    * Getter for the age of connections that should be pinged before using.
    *
    * @return The age
    */
   public int getPoolPingConnectionsOlderThan() {
     return poolPingConnectionsOlderThan;
   }
 
   /**
    * Gets the expected connection type code.
    *
    * @return the expected connection type code
    */
   private int getExpectedConnectionTypeCode() {
     return expectedConnectionTypeCode;
   }
 
   /**
    * Getter for the number of connection requests made.
    *
    * @return The number of connection requests made
    */
   public long getRequestCount() {
     synchronized (POOL_LOCK) {
       return requestCount;
     }
   }
 
   /**
    * Getter for the average time required to get a connection to the database.
    *
    * @return The average time
    */
   public long getAverageRequestTime() {
     synchronized (POOL_LOCK) {
       return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
     }
   }
 
   /**
    * Getter for the average time spent waiting for connections that were in use.
    *
    * @return The average time
    */
   public long getAverageWaitTime() {
     synchronized (POOL_LOCK) {
       return hadToWaitCount == 0 ? 0 : accumulatedWaitTime / hadToWaitCount;
     }
   }
 
   /**
    * Getter for the number of requests that had to wait for connections that were in use.
    *
    * @return The number of requests that had to wait
    */
   public long getHadToWaitCount() {
     synchronized (POOL_LOCK) {
       return hadToWaitCount;
     }
   }
 
   /**
    * Getter for the number of invalid connections that were found in the pool.
    *
    * @return The number of invalid connections
    */
   public long getBadConnectionCount() {
     synchronized (POOL_LOCK) {
       return badConnectionCount;
     }
   }
 
   /**
    * Getter for the number of connections that were claimed before they were returned.
    *
    * @return The number of connections
    */
   public long getClaimedOverdueConnectionCount() {
     synchronized (POOL_LOCK) {
       return claimedOverdueConnectionCount;
     }
   }
 
   /**
    * Getter for the average age of overdue connections.
    *
    * @return The average age
    */
   public long getAverageOverdueCheckoutTime() {
     synchronized (POOL_LOCK) {
       return claimedOverdueConnectionCount == 0 ? 0
           : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
     }
   }
 
   /**
    * Getter for the average age of a connection checkout.
    *
    * @return The average age
    */
   public long getAverageCheckoutTime() {
     synchronized (POOL_LOCK) {
       return requestCount == 0 ? 0 : accumulatedCheckoutTime / requestCount;
     }
   }
 
   /**
    * Returns the status of the connection pool.
    *
    * @return The status
    */
   public String getStatus() {
     StringBuilder builder = new StringBuilder();
 
     builder.append("\n===============================================================");
     builder.append("\n jdbcDriver                     ").append(jdbcDriver);
     builder.append("\n jdbcUrl                        ").append(jdbcUrl);
     builder.append("\n jdbcUsername                   ").append(jdbcUsername);
     builder.append("\n jdbcPassword                   ").append((jdbcPassword == null ? "NULL" : "************"));
     builder.append("\n poolMaxActiveConnections       ").append(poolMaximumActiveConnections);
     builder.append("\n poolMaxIdleConnections         ").append(poolMaximumIdleConnections);
     builder.append("\n poolMaxCheckoutTime            " + poolMaximumCheckoutTime);
     builder.append("\n poolTimeToWait                 " + poolTimeToWait);
     builder.append("\n poolPingEnabled                " + poolPingEnabled);
     builder.append("\n poolPingQuery                  " + poolPingQuery);
     builder.append("\n poolPingConnectionsOlderThan   " + poolPingConnectionsOlderThan);
     builder.append("\n poolPingConnectionsNotUsedFor  " + poolPingConnectionsNotUsedFor);
     builder.append("\n --------------------------------------------------------------");
     builder.append("\n activeConnections              " + activeConnections.size());
     builder.append("\n idleConnections                " + idleConnections.size());
     builder.append("\n requestCount                   " + getRequestCount());
     builder.append("\n averageRequestTime             " + getAverageRequestTime());
     builder.append("\n averageCheckoutTime            " + getAverageCheckoutTime());
     builder.append("\n claimedOverdue                 " + getClaimedOverdueConnectionCount());
     builder.append("\n averageOverdueCheckoutTime     " + getAverageOverdueCheckoutTime());
     builder.append("\n hadToWait                      " + getHadToWaitCount());
     builder.append("\n averageWaitTime                " + getAverageWaitTime());
     builder.append("\n badConnectionCount             " + getBadConnectionCount());
     builder.append("\n===============================================================");
     return builder.toString();
   }
 
   /**
    * Closes all of the connections in the pool.
    */
   public void forceCloseAll() {
     synchronized (POOL_LOCK) {
       for (int i = activeConnections.size(); i > 0; i--) {
         try {
           SimplePooledConnection conn = (SimplePooledConnection) activeConnections.remove(i - 1);
           conn.invalidate();
 
           Connection realConn = conn.getRealConnection();
           if (!realConn.getAutoCommit()) {
             realConn.rollback();
           }
           realConn.close();
         } catch (Exception e) {
           // ignore
         }
       }
       for (int i = idleConnections.size(); i > 0; i--) {
         try {
           SimplePooledConnection conn = (SimplePooledConnection) idleConnections.remove(i - 1);
           conn.invalidate();
 
           Connection realConn = conn.getRealConnection();
           if (!realConn.getAutoCommit()) {
             realConn.rollback();
           }
           realConn.close();
         } catch (Exception e) {
           // ignore
         }
       }
     }
     if (log.isDebugEnabled()) {
       log.debug("SimpleDataSource forcefully closed/removed all connections.");
     }
   }
 
   /**
    * Push connection.
    *
    * @param conn
    *          the conn
    *
    * @throws SQLException
    *           the SQL exception
    */
   private void pushConnection(SimplePooledConnection conn) throws SQLException {
 
     synchronized (POOL_LOCK) {
       activeConnections.remove(conn);
       if (conn.isValid()) {
         if (idleConnections.size() < poolMaximumIdleConnections
             && conn.getConnectionTypeCode() == getExpectedConnectionTypeCode()) {
           accumulatedCheckoutTime += conn.getCheckoutTime();
           if (!conn.getRealConnection().getAutoCommit()) {
             conn.getRealConnection().rollback();
           }
           SimplePooledConnection newConn = new SimplePooledConnection(conn.getRealConnection(), this);
           idleConnections.add(newConn);
           newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
           newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
           conn.invalidate();
           if (log.isDebugEnabled()) {
             log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
           }
           POOL_LOCK.notifyAll();
         } else {
           accumulatedCheckoutTime += conn.getCheckoutTime();
           if (!conn.getRealConnection().getAutoCommit()) {
             conn.getRealConnection().rollback();
           }
           conn.getRealConnection().close();
           if (log.isDebugEnabled()) {
             log.debug("Closed connection " + conn.getRealHashCode() + ".");
           }
           conn.invalidate();
         }
       } else {
         if (log.isDebugEnabled()) {
           log.debug("A bad connection (" + conn.getRealHashCode()
               + ") attempted to return to the pool, discarding connection.");
         }
         badConnectionCount++;
       }
     }
   }
 
   /**
    * Pop connection.
    *
    * @param username
    *          the username
    * @param password
    *          the password
    *
    * @return the simple pooled connection
    *
    * @throws SQLException
    *           the SQL exception
    */
   private SimplePooledConnection popConnection(String username, String password) throws SQLException {
     boolean countedWait = false;
     SimplePooledConnection conn = null;
     long t = System.currentTimeMillis();
     int localBadConnectionCount = 0;
 
     while (conn == null) {
       synchronized (POOL_LOCK) {
         if (idleConnections.size() > 0) {
           // Pool has available connection
           conn = (SimplePooledConnection) idleConnections.remove(0);
           if (log.isDebugEnabled()) {
             log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
           }
         } else {
           // Pool does not have available connection
           if (activeConnections.size() < poolMaximumActiveConnections) {
             // Can create new connection
             if (useDriverProps) {
               conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, driverProps), this);
             } else {
               conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword), this);
             }
             Connection realConn = conn.getRealConnection();
             if (realConn.getAutoCommit() != jdbcDefaultAutoCommit) {
               realConn.setAutoCommit(jdbcDefaultAutoCommit);
             }
             if (log.isDebugEnabled()) {
               log.debug("Created connection " + conn.getRealHashCode() + ".");
             }
           } else {
             // Cannot create new connection
             SimplePooledConnection oldestActiveConnection = (SimplePooledConnection) activeConnections.get(0);
             long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
             if (longestCheckoutTime > poolMaximumCheckoutTime) {
               // Can claim overdue connection
               claimedOverdueConnectionCount++;
               accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
               accumulatedCheckoutTime += longestCheckoutTime;
               activeConnections.remove(oldestActiveConnection);
               if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                 oldestActiveConnection.getRealConnection().rollback();
               }
               conn = new SimplePooledConnection(oldestActiveConnection.getRealConnection(), this);
               oldestActiveConnection.invalidate();
               if (log.isDebugEnabled()) {
                 log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
               }
             } else {
               // Must wait
               try {
                 if (!countedWait) {
                   hadToWaitCount++;
                   countedWait = true;
                 }
                 if (log.isDebugEnabled()) {
                   log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                 }
                 long wt = System.currentTimeMillis();
                 POOL_LOCK.wait(poolTimeToWait);
                 accumulatedWaitTime += System.currentTimeMillis() - wt;
               } catch (InterruptedException e) {
                 break;
               }
             }
           }
         }
         if (conn != null) {
           if (conn.isValid()) {
             if (!conn.getRealConnection().getAutoCommit()) {
               conn.getRealConnection().rollback();
             }
             conn.setConnectionTypeCode(assembleConnectionTypeCode(jdbcUrl, username, password));
             conn.setCheckoutTimestamp(System.currentTimeMillis());
             conn.setLastUsedTimestamp(System.currentTimeMillis());
             activeConnections.add(conn);
             requestCount++;
             accumulatedRequestTime += System.currentTimeMillis() - t;
           } else {
             if (log.isDebugEnabled()) {
               log.debug("A bad connection (" + conn.getRealHashCode()
                   + ") was returned from the pool, getting another connection.");
             }
             badConnectionCount++;
             localBadConnectionCount++;
             conn = null;
             if (localBadConnectionCount > (poolMaximumIdleConnections + 3)) {
               if (log.isDebugEnabled()) {
                 log.debug("SimpleDataSource: Could not get a good connection to the database.");
               }
               throw new SQLException("SimpleDataSource: Could not get a good connection to the database.");
             }
           }
         }
       }
 
     }
 
     if (conn == null) {
       if (log.isDebugEnabled()) {
         log.debug("SimpleDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
       }
       throw new SQLException(
           "SimpleDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
     }
 
     return conn;
   }
 
   /**
    * Method to check to see if a connection is still usable.
    *
    * @param conn
    *          - the connection to check
    *
    * @return True if the connection is still usable
    */
   private boolean pingConnection(SimplePooledConnection conn) {
     boolean result = true;
 
     try {
       result = !conn.getRealConnection().isClosed();
     } catch (SQLException e) {
       if (log.isDebugEnabled()) {
         log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
       }
       result = false;
     }
 
     if (result) {
       if (poolPingEnabled) {
         if ((poolPingConnectionsOlderThan > 0 && conn.getAge() > poolPingConnectionsOlderThan)
             || (poolPingConnectionsNotUsedFor > 0
                 && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor)) {
 
           try {
             if (log.isDebugEnabled()) {
               log.debug("Testing connection " + conn.getRealHashCode() + " ...");
             }
             Connection realConn = conn.getRealConnection();
             Statement statement = realConn.createStatement();
             ResultSet rs = statement.executeQuery(poolPingQuery);
             rs.close();
             statement.close();
             if (!realConn.getAutoCommit()) {
               realConn.rollback();
             }
             result = true;
             if (log.isDebugEnabled()) {
               log.debug("Connection " + conn.getRealHashCode() + " is GOOD!");
             }
           } catch (Exception e) {
             log.warn("Execution of ping query '" + poolPingQuery + "' failed: " + e.getMessage());
             try {
               conn.getRealConnection().close();
             } catch (Exception e2) {
               // ignore
             }
             result = false;
             if (log.isDebugEnabled()) {
               log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
             }
           }
         }
       }
     }
     return result;
   }
 
   /**
    * Unwraps a pooled connection to get to the 'real' connection.
    *
    * @param conn
    *          - the pooled connection to unwrap
    *
    * @return The 'real' connection
    */
   public static Connection unwrapConnection(Connection conn) {
     if (conn instanceof SimplePooledConnection) {
       return ((SimplePooledConnection) conn).getRealConnection();
     } else {
       return conn;
     }
   }
 
   protected void finalize() throws Throwable {
     forceCloseAll();
   }
 
   /**
    * --------------------------------------------------------------------------------------- SimplePooledConnection
    * ---------------------------------------------------------------------------------------.
    */
   public static class SimplePooledConnection implements InvocationHandler {
 
     /** The Constant CLOSE. */
     private static final String CLOSE = "close";
 
     /** The Constant IFACES. */
     private static final Class[] IFACES = new Class[] { Connection.class };
 
     /** The hash code. */
     private int hashCode = 0;
 
     /** The data source. */
     private SimpleDataSource dataSource;
 
     /** The real connection. */
     private Connection realConnection;
 
     /** The proxy connection. */
     private Connection proxyConnection;
 
     /** The checkout timestamp. */
     private long checkoutTimestamp;
 
     /** The created timestamp. */
     private long createdTimestamp;
 
     /** The last used timestamp. */
     private long lastUsedTimestamp;
 
     /** The connection type code. */
     private int connectionTypeCode;
 
     /** The valid. */
     private boolean valid;
 
     /**
      * Constructor for SimplePooledConnection that uses the Connection and SimpleDataSource passed in.
      *
      * @param connection
      *          - the connection that is to be presented as a pooled connection
      * @param dataSource
      *          - the dataSource that the connection is from
      */
     public SimplePooledConnection(Connection connection, SimpleDataSource dataSource) {
       this.hashCode = connection.hashCode();
       this.realConnection = connection;
       this.dataSource = dataSource;
       this.createdTimestamp = System.currentTimeMillis();
       this.lastUsedTimestamp = System.currentTimeMillis();
       this.valid = true;
 
       proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
     }
 
     /**
      * Invalidates the connection.
      */
     public void invalidate() {
       valid = false;
     }
 
     /**
      * Method to see if the connection is usable.
      *
      * @return True if the connection is usable
      */
     public boolean isValid() {
       return valid && realConnection != null && dataSource.pingConnection(this);
     }
 
     /**
      * Getter for the *real* connection that this wraps.
      *
      * @return The connection
      */
     public Connection getRealConnection() {
       return realConnection;
     }
 
     /**
      * Getter for the proxy for the connection.
      *
      * @return The proxy
      */
     public Connection getProxyConnection() {
       return proxyConnection;
     }
 
     /**
      * Gets the hashcode of the real connection (or 0 if it is null).
      *
      * @return The hashcode of the real connection (or 0 if it is null)
      */
     public int getRealHashCode() {
       if (realConnection == null) {
         return 0;
       } else {
         return realConnection.hashCode();
       }
     }
 
     /**
      * Getter for the connection type (based on url + user + password).
      *
      * @return The connection type
      */
     public int getConnectionTypeCode() {
       return connectionTypeCode;
     }
 
     /**
      * Setter for the connection type.
      *
      * @param connectionTypeCode
      *          - the connection type
      */
     public void setConnectionTypeCode(int connectionTypeCode) {
       this.connectionTypeCode = connectionTypeCode;
     }
 
     /**
      * Getter for the time that the connection was created.
      *
      * @return The creation timestamp
      */
     public long getCreatedTimestamp() {
       return createdTimestamp;
     }
 
     /**
      * Setter for the time that the connection was created.
      *
      * @param createdTimestamp
      *          - the timestamp
      */
     public void setCreatedTimestamp(long createdTimestamp) {
       this.createdTimestamp = createdTimestamp;
     }
 
     /**
      * Getter for the time that the connection was last used.
      *
      * @return - the timestamp
      */
     public long getLastUsedTimestamp() {
       return lastUsedTimestamp;
     }
 
     /**
      * Setter for the time that the connection was last used.
      *
      * @param lastUsedTimestamp
      *          - the timestamp
      */
     public void setLastUsedTimestamp(long lastUsedTimestamp) {
       this.lastUsedTimestamp = lastUsedTimestamp;
     }
 
     /**
      * Getter for the time since this connection was last used.
      *
      * @return - the time since the last use
      */
     public long getTimeElapsedSinceLastUse() {
       return System.currentTimeMillis() - lastUsedTimestamp;
     }
 
     /**
      * Getter for the age of the connection.
      *
      * @return the age
      */
     public long getAge() {
       return System.currentTimeMillis() - createdTimestamp;
     }
 
     /**
      * Getter for the timestamp that this connection was checked out.
      *
      * @return the timestamp
      */
     public long getCheckoutTimestamp() {
       return checkoutTimestamp;
     }
 
     /**
      * Setter for the timestamp that this connection was checked out.
      *
      * @param timestamp
      *          the timestamp
      */
     public void setCheckoutTimestamp(long timestamp) {
       this.checkoutTimestamp = timestamp;
     }
 
     /**
      * Getter for the time that this connection has been checked out.
      *
      * @return the time
      */
     public long getCheckoutTime() {
       return System.currentTimeMillis() - checkoutTimestamp;
     }
 
     /**
      * Gets the valid connection.
      *
      * @return the valid connection
      */
     private Connection getValidConnection() {
       if (!valid) {
         throw new RuntimeException("Error accessing SimplePooledConnection. Connection is invalid.");
       }
       return realConnection;
     }
 
     public int hashCode() {
       return hashCode;
     }
 
     /**
      * Allows comparing this connection to another
      *
      * @param obj
      *          - the other connection to test for equality
      *
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals(Object obj) {
       if (obj instanceof SimplePooledConnection) {
         return realConnection.hashCode() == (((SimplePooledConnection) obj).realConnection.hashCode());
       } else if (obj instanceof Connection) {
         return hashCode == obj.hashCode();
       } else {
         return false;
       }
     }
 
     // **********************************
     // Implemented Connection Methods -- Now handled by proxy
     // **********************************
 
     /**
      * Required for InvocationHandler implementation.
      *
      * @param proxy
      *          - not used
      * @param method
      *          - the method to be executed
      * @param args
      *          - the parameters to be passed to the method
      *
      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
      */
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       String methodName = method.getName();
       if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
         dataSource.pushConnection(this);
         return null;
       } else {
         try {
           return method.invoke(getValidConnection(), args);
         } catch (Throwable t) {
           throw ClassInfo.unwrapThrowable(t);
         }
       }
     }
 
     /**
      * Creates the statement.
      *
      * @return the statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Statement createStatement() throws SQLException {
       return getValidConnection().createStatement();
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql) throws SQLException {
       return getValidConnection().prepareStatement(sql);
     }
 
     /**
      * Prepare call.
      *
      * @param sql
      *          the sql
      *
      * @return the callable statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public CallableStatement prepareCall(String sql) throws SQLException {
       return getValidConnection().prepareCall(sql);
     }
 
     /**
      * Native SQL.
      *
      * @param sql
      *          the sql
      *
      * @return the string
      *
      * @throws SQLException
      *           the SQL exception
      */
     public String nativeSQL(String sql) throws SQLException {
       return getValidConnection().nativeSQL(sql);
     }
 
     /**
      * Sets the auto commit.
      *
      * @param autoCommit
      *          the new auto commit
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setAutoCommit(boolean autoCommit) throws SQLException {
       getValidConnection().setAutoCommit(autoCommit);
     }
 
     /**
      * Gets the auto commit.
      *
      * @return the auto commit
      *
      * @throws SQLException
      *           the SQL exception
      */
     public boolean getAutoCommit() throws SQLException {
       return getValidConnection().getAutoCommit();
     }
 
     /**
      * Commit.
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void commit() throws SQLException {
       getValidConnection().commit();
     }
 
     /**
      * Rollback.
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void rollback() throws SQLException {
       getValidConnection().rollback();
     }
 
     /**
      * Close.
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void close() throws SQLException {
       dataSource.pushConnection(this);
     }
 
     /**
      * Checks if is closed.
      *
      * @return true, if is closed
      *
      * @throws SQLException
      *           the SQL exception
      */
     public boolean isClosed() throws SQLException {
       return getValidConnection().isClosed();
     }
 
     /**
      * Gets the meta data.
      *
      * @return the meta data
      *
      * @throws SQLException
      *           the SQL exception
      */
     public DatabaseMetaData getMetaData() throws SQLException {
       return getValidConnection().getMetaData();
     }
 
     /**
      * Sets the read only.
      *
      * @param readOnly
      *          the new read only
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setReadOnly(boolean readOnly) throws SQLException {
       getValidConnection().setReadOnly(readOnly);
     }
 
     /**
      * Checks if is read only.
      *
      * @return true, if is read only
      *
      * @throws SQLException
      *           the SQL exception
      */
     public boolean isReadOnly() throws SQLException {
       return getValidConnection().isReadOnly();
     }
 
     /**
      * Sets the catalog.
      *
      * @param catalog
      *          the new catalog
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setCatalog(String catalog) throws SQLException {
       getValidConnection().setCatalog(catalog);
     }
 
     /**
      * Gets the catalog.
      *
      * @return the catalog
      *
      * @throws SQLException
      *           the SQL exception
      */
     public String getCatalog() throws SQLException {
       return getValidConnection().getCatalog();
     }
 
     /**
      * Sets the transaction isolation.
      *
      * @param level
      *          the new transaction isolation
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setTransactionIsolation(int level) throws SQLException {
       getValidConnection().setTransactionIsolation(level);
     }
 
     /**
      * Gets the transaction isolation.
      *
      * @return the transaction isolation
      *
      * @throws SQLException
      *           the SQL exception
      */
     public int getTransactionIsolation() throws SQLException {
       return getValidConnection().getTransactionIsolation();
     }
 
     /**
      * Gets the warnings.
      *
      * @return the warnings
      *
      * @throws SQLException
      *           the SQL exception
      */
     public SQLWarning getWarnings() throws SQLException {
       return getValidConnection().getWarnings();
     }
 
     /**
      * Clear warnings.
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void clearWarnings() throws SQLException {
       getValidConnection().clearWarnings();
     }
 
     /**
      * Creates the statement.
      *
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      *
      * @return the statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
       return getValidConnection().createStatement(resultSetType, resultSetConcurrency);
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
         throws SQLException {
       return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
     }
 
     /**
      * Prepare call.
      *
      * @param sql
      *          the sql
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      *
      * @return the callable statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
       return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
     }
 
     /**
      * Gets the type map.
      *
      * @return the type map
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Map getTypeMap() throws SQLException {
       return getValidConnection().getTypeMap();
     }
 
     /**
      * Sets the type map.
      *
      * @param map
      *          the new type map
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setTypeMap(Map map) throws SQLException {
       getValidConnection().setTypeMap(map);
     }
 
     // **********************************
     // JDK 1.4 JDBC 3.0 Methods below
     // **********************************
 
     /**
      * Sets the holdability.
      *
      * @param holdability
      *          the new holdability
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void setHoldability(int holdability) throws SQLException {
       getValidConnection().setHoldability(holdability);
     }
 
     /**
      * Gets the holdability.
      *
      * @return the holdability
      *
      * @throws SQLException
      *           the SQL exception
      */
     public int getHoldability() throws SQLException {
       return getValidConnection().getHoldability();
     }
 
     /**
      * Sets the savepoint.
      *
      * @return the savepoint
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Savepoint setSavepoint() throws SQLException {
       return getValidConnection().setSavepoint();
     }
 
     /**
      * Sets the savepoint.
      *
      * @param name
      *          the name
      *
      * @return the savepoint
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Savepoint setSavepoint(String name) throws SQLException {
       return getValidConnection().setSavepoint(name);
     }
 
     /**
      * Rollback.
      *
      * @param savepoint
      *          the savepoint
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void rollback(Savepoint savepoint) throws SQLException {
       getValidConnection().rollback(savepoint);
     }
 
     /**
      * Release savepoint.
      *
      * @param savepoint
      *          the savepoint
      *
      * @throws SQLException
      *           the SQL exception
      */
     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
       getValidConnection().releaseSavepoint(savepoint);
     }
 
     /**
      * Creates the statement.
      *
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      * @param resultSetHoldability
      *          the result set holdability
      *
      * @return the statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
         throws SQLException {
       return getValidConnection().createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      * @param resultSetHoldability
      *          the result set holdability
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
         int resultSetHoldability) throws SQLException {
       return getValidConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
     }
 
     /**
      * Prepare call.
      *
      * @param sql
      *          the sql
      * @param resultSetType
      *          the result set type
      * @param resultSetConcurrency
      *          the result set concurrency
      * @param resultSetHoldability
      *          the result set holdability
      *
      * @return the callable statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
         int resultSetHoldability) throws SQLException {
       return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      * @param autoGeneratedKeys
      *          the auto generated keys
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
       return getValidConnection().prepareStatement(sql, autoGeneratedKeys);
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      * @param columnIndexes
      *          the column indexes
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql, int columnIndexes[]) throws SQLException {
       return getValidConnection().prepareStatement(sql, columnIndexes);
     }
 
     /**
      * Prepare statement.
      *
      * @param sql
      *          the sql
      * @param columnNames
      *          the column names
      *
      * @return the prepared statement
      *
      * @throws SQLException
      *           the SQL exception
      */
     public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {
       return getValidConnection().prepareStatement(sql, columnNames);
     }
 
   }
 
   public Logger getParentLogger() throws SQLFeatureNotSupportedException {
     // TODO Auto-generated method stub
     return null;
   }
 
   public <T> T unwrap(Class<T> iface) throws SQLException {
     // TODO Auto-generated method stub
     return null;
   }
 
   public boolean isWrapperFor(Class<?> iface) throws SQLException {
     // TODO Auto-generated method stub
     return false;
   }
 }