public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit) 
{
        _connFactory = connFactory;
        _pool = pool;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
        _defaultAutoCommit = defaultAutoCommit;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

 public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit,
    int defaultTransactionIsolation) 
{
        _connFactory = connFactory;
        _pool = pool;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
        _defaultAutoCommit = defaultAutoCommit;
        _defaultTransactionIsolation = defaultTransactionIsolation;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

defaultTransactionIsolation - the default "Transaction Isolation" setting for returned Connection s

 public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit,
    AbandonedConfig config) 
{
        _connFactory = connFactory;
        _pool = pool;
        _config = config;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
        _defaultAutoCommit = defaultAutoCommit;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

config - the AbandonedConfig if tracing SQL objects

 public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit,
    int defaultTransactionIsolation,
    AbandonedConfig config) 
{
        _connFactory = connFactory;
        _pool = pool;
        _config = config;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
        _defaultAutoCommit = defaultAutoCommit;
        _defaultTransactionIsolation = defaultTransactionIsolation;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

defaultTransactionIsolation - the default "Transaction Isolation" setting for returned Connection s

config - the AbandonedConfig if tracing SQL objects

 public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit,
    int defaultTransactionIsolation,
    String defaultCatalog,
    AbandonedConfig config) 
{
        _connFactory = connFactory;
        _pool = pool;
        _config = config;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
        _defaultAutoCommit = defaultAutoCommit;
        _defaultTransactionIsolation = defaultTransactionIsolation;
        _defaultCatalog = defaultCatalog;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

defaultTransactionIsolation - the default "Transaction Isolation" setting for returned Connection s

defaultCatalog - the default "catalog" setting for returned Connection s

config - the AbandonedConfig if tracing SQL objects

 public PoolableConnectionFactory(ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    Boolean defaultReadOnly,
    boolean defaultAutoCommit,
    int defaultTransactionIsolation,
    String defaultCatalog,
    AbandonedConfig config) 
{
        _connFactory = connFactory;
        _pool = pool;
        _config = config;
        _pool.setFactory(this);
        _stmtPoolFactory = stmtPoolFactory;
        _validationQuery = validationQuery;
        _defaultReadOnly = defaultReadOnly;
        _defaultAutoCommit = defaultAutoCommit;
        _defaultTransactionIsolation = defaultTransactionIsolation;
        _defaultCatalog = defaultCatalog;
}

Create a new PoolableConnectionFactory.

Parameters:

connFactory - the ConnectionFactory from which to obtain base Connection s

pool - the ObjectPool in which to pool those Connection s

stmtPoolFactory - the KeyedObjectPoolFactory to use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s, or null to disable java.sql.PreparedStatement pooling

validationQuery - a query to use to validate Connection s. Should return at least one row. Using null turns off validation.

defaultReadOnly - the default "read only" setting for borrowed Connection s

defaultAutoCommit - the default "auto commit" setting for returned Connection s

defaultTransactionIsolation - the default "Transaction Isolation" setting for returned Connection s

defaultCatalog - the default "catalog" setting for returned Connection s

config - the AbandonedConfig if tracing SQL objects

 public  void activateObject(Object obj) throws Exception 
{
        if(obj instanceof DelegatingConnection) {
            ((DelegatingConnection)obj).activate();
        }
        if(obj instanceof Connection) {
            Connection conn = (Connection)obj;
            if (conn.getAutoCommit() != _defaultAutoCommit) {
                conn.setAutoCommit(_defaultAutoCommit);
            }
            if ((_defaultTransactionIsolation != UNKNOWN_TRANSACTIONISOLATION) 
                    && (conn.getTransactionIsolation() != 
                    _defaultTransactionIsolation)) {
                conn.setTransactionIsolation(_defaultTransactionIsolation);
            }
            if ((_defaultReadOnly != null) && 
                    (conn.isReadOnly() != _defaultReadOnly.booleanValue())) {
                conn.setReadOnly(_defaultReadOnly.booleanValue());
            }
            if ((_defaultCatalog != null) &&
                    (!_defaultCatalog.equals(conn.getCatalog()))) {
                conn.setCatalog(_defaultCatalog);
            }
        }
}

 public  void destroyObject(Object obj) throws Exception 
{
        if(obj instanceof PoolableConnection) {
            ((PoolableConnection)obj).reallyClose();
        }
}

 public ObjectPool getPool() 
{
        return _pool;
}

 public synchronized Object makeObject() throws Exception 
{
        Connection conn = _connFactory.createConnection();
        if(null != _stmtPoolFactory) {
            KeyedObjectPool stmtpool = _stmtPoolFactory.createPool();
            conn = new PoolingConnection(conn,stmtpool);
            stmtpool.setFactory((PoolingConnection)conn);
        }
        return new PoolableConnection(conn,_pool,_config);
}

 public  void passivateObject(Object obj) throws Exception 
{
        if(obj instanceof Connection) {
            Connection conn = (Connection)obj;
            if(!conn.getAutoCommit() && !conn.isReadOnly()) {
                conn.rollback();
            }
            conn.clearWarnings();
            if(!conn.getAutoCommit()) {
                conn.setAutoCommit(true);
            }
        }
        if(obj instanceof DelegatingConnection) {
            ((DelegatingConnection)obj).passivate();
        }
}

 public synchronized  void setConnectionFactory(ConnectionFactory connFactory) 
{
        _connFactory = connFactory;
}

Sets the ConnectionFactory from which to obtain base Connection s.

 public  void setDefaultAutoCommit(boolean defaultAutoCommit) 
{
        _defaultAutoCommit = defaultAutoCommit;
}

Sets the default "auto commit" setting for borrowed Connection s

 public  void setDefaultCatalog(String defaultCatalog) 
{
        _defaultCatalog = defaultCatalog;
}

Sets the default "catalog" setting for borrowed Connection s

 public  void setDefaultReadOnly(boolean defaultReadOnly) 
{
        _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
}

Sets the default "read only" setting for borrowed Connection s

 public  void setDefaultTransactionIsolation(int defaultTransactionIsolation) 
{
        _defaultTransactionIsolation = defaultTransactionIsolation;
}

Sets the default "Transaction Isolation" setting for borrowed Connection s

 public synchronized  void setPool(ObjectPool pool) 
{
        if(null != _pool && pool != _pool) {
            try {
                _pool.close();
            } catch(Exception e) {
                // ignored !?!
            }
        }
        _pool = pool;
}

Sets the ObjectPool in which to pool Connection s.

 public synchronized  void setStatementPoolFactory(KeyedObjectPoolFactory stmtPoolFactory) 
{
        _stmtPoolFactory = stmtPoolFactory;
}

Sets the KeyedObjectPoolFactory I use to create KeyedObjectPool s for pooling java.sql.PreparedStatement s. Set to null to disable java.sql.PreparedStatement pooling.

 public synchronized  void setValidationQuery(String validationQuery) 
{
        _validationQuery = validationQuery;
}

Sets the query I use to validate Connection s. Should return at least one row. Using null turns off validation.

 public  void validateConnection(Connection conn) throws SQLException 
{
        String query = _validationQuery;
        if(conn.isClosed()) {
            throw new SQLException("validateConnection: connection closed");
        }
        if(null != query) {
            Statement stmt = null;
            ResultSet rset = null;
            try {
                stmt = conn.createStatement();
                rset = stmt.executeQuery(query);
                if(!rset.next()) {
                    throw new SQLException("validationQuery didn't return a row");
                }
            } finally {
                if (rset != null) {
                    try {
                        rset.close();
                    } catch(Exception t) {
                        // ignored
                    }
                }
                if (stmt != null) {
                    try {
                        stmt.close();
                    } catch(Exception t) {
                        // ignored
                    }
                }
            }
        }
}

 public boolean validateObject(Object obj) 
{
        if(obj instanceof Connection) {
            try {
                validateConnection((Connection) obj);
                return true;
            } catch(Exception e) {
                return false;
            }
        } else {
            return false;
        }
}