OSGi declarations contain multiple import headers for javax.transaction. Add jmxName to properties set by BasicDataSourceFactory. This enables container-managed pools created from JNDI Resource definitions to enable JMX by supplying a valid root JMX name. NullPointerException thrown when calling ManagedConnection.isClosed(). InvalidateConnection can result in closed connection returned by getConnection. Complete the fix for DBCP-418, enabling PoolableConnection class to load in environments (such as GAE) where the JMX ManagementFactory is not available. Add constructor DriverManagerConnectionFactory(String). Ensure that the cacheState setting is used when statement pooling is disabled. Ensure that setSoftMinEvictableIdleTimeMillis is used when working with BasicDataSource. Correct the name of the configuration attribute softMinEvictableIdleTimeMillis. Updated pool version to 2.4.2. The fix for POOL-300 may cause DBCP users to see more reports of abandoned connections (if removal and logging are configured). Prior to the fix for POOL-300, the PrintWriter used to log abandoned connection stack traces was not being flushed on each log event. Added BasicDataSource abandonedUsageTracking property missing from BasicDataSourceFactory. SharedPoolDataSource getConnection fails when testOnBorrow is set with a null validation query. Nested connections in a transaction (local) throws null pointer. BasicDataSource does not set disconnectionSql properties on its PoolableConnectionFactory. InstanceKeyDataSource discards native SQLException when given password does not match password used to create the connection. Update Apache Commons Logging to 1.2 from 1.1.3. Correct some Javadoc references to Apache Commons Pool 2 classes that have changed names since Pool 1.x. Do not ignore the configured custom eviction policy when creating a BasicDataSource. Added invalidateConnection method to BasicDataSource. Unsuccessful Connection enlistment in XA Transaction ignored by TransactionContext. Made expired connection logging configurable in BasicDataSource. Setting logExpiredConnections to false suppresses expired connection log messages. Made Datasources implement AutoCloseable. Added fastFailValidation property to PooloableConnection, configurable in BasicDataSource. When set to true, connections that have previously thrown fatal disconnection errors will fail validation immediately (no driver calls). Changed BasicDataSource createDataSource method to ensure that initialization completes before clients get reference to newly created instances. Fixed connection leak when SQLException is thrown while enlisting an XA transaction. Setting jmxName to null should suppress JMX registration of connection and statement pools. Eliminated synchronization in BasicDataSource getNumActive, getNumIdle methods. Added property name verification to BasicDataSourceFactory. References including obsolete or unrecognized properties now generate log messages. Small performance improvements when returning connections to the pool. Fixed DelegatingStatement close to ensure closed statements do not retain references to pooled prepared statements. Due to finalization code added in 2.0, this was causing pooled prepared statements to be closed by GC while in use by clients. Added check in PoolingDataSource constructor to ensure that the connection factory and pool are properly linked. Fixed connection leak when managed connections are closed during transactions. Enable PoolableConnection class to load without JMX. BasicManagedDataSource - unregister from JMX on close(). Log validation failures of poolable connections. DelegatingStatement.close() fails with NPE if statement is null CPDSConnectionFactory.validateObject(Object) ignores Throwable. Provide a new option (cacheState) to cache current values of autoCommit and readOnly so database queries are not required for every call to the associated getters. This option is enabled by default. Removed unnecessary synchronisation in BasicDataSource#createDataSource. The Java package name has been changed from org.apache.commons.dbcp to org.apache.commons.dbcp2. Update to Commons Pool 2 (based on java.util.concurrent) to provide pooling functionality. Updated source code for Java 1.6 (added @Override & @Deprecated annotations). Removed JOCL support. Remove deprecated SQLNestedException. Fix threading issues with accessToUnderlyingConnectionAllowed attribute of PoolingDriver which is used to support unit testing. BasicDataSource instances are now exposed via JMX. All the configuration properties are available as is the connection pool and the statement pools (if statement pooling is enabled). Fix thread safety issues in the SharedPoolDataSource and the PerUserPoolDataSource. Allow accessToUnderlyingConnectionAllowed to be configured when configuration takes place via JNDI in a JavaEE container. Fix threading issue when using multiple instances of the SharedPoolDataSource concurrently. Ensure that the close state of a pooled connection and the underlying connection is consistent when the underlying connection is closed as a result of an error condition. Make all mutable fields private. Return BasicDataSource rather than DataSource from BasicDataSourceFactory so a cast is not required to use BasicDataSource specific methods. The equals() implementations of the DelegatingXxx classes are now symmetric. There are some important API changes underlying this fix. Firstly, two DelegatingXxx instances are no longer considered equal if they have the same innermost delegate. Secondly, a DelegatingXxx instance is not considered equal to its innermost delegate. The getInnermostDelegateInternal() method has been made public (but remains part of the internal API) to allow classes extending this implementation to access the innermost delegate when required. Expose the new Pool 2 property evictionPolicyClassName to enable more sophisticated eviction strategies to be used. Add support for pooling PreparedStatements that use auto-generated keys. Enable JDBC resources that are no longer referenced by client code to be eligible for garbage collection. Enable DBCP to work with a SecurityManager such that only DBCP needs to be granted the necessary permissions to communicate with the database. Correct path to Javadoc overview in build.xml. The default values for readOnly, autoCommit and transactionIsolation are now taken from the JDBC driver. No calls to setReadOnly(), setAutoCommit() or setTransactionIsolation() will be made for a newly borrowed connection unless a default is explicitly configured and the connection is currently using a different setting. Register pooled connections with JMX so that they may be forcibly closed via JMX if required. Modify SharedPoolDataSource and PerUserPoolDataSource to expose all of the configuration properties of the underlying connection pool(s). This represents a significant refactoring of these classes and a number of property names have changed as a result. Provide an option to control if autoCommit is always set to true when a connection is returned to the connection pool. Provide an option to control if rollback is called when a connection is returned to the poll with autoCommit disabled. Provide an option to set the default query timeout. Connection.isValid() should not throw an SQLException if the connection is closed. Use Connection.isValid() to validate connections unless a validation query is explicitly configured. Note that this means it is no longer necessary for a validation query to be specified in order for validation to take place. When testing with Oracle, this resulted in database validation being approximately 7 times faster. Add support for validation testing database connections on creation. Correct the documentation for the maxOpenPreparedStatements parameter and review the use of the phrase non-positive throughout the documentation and javadoc, replacing it with negative where that is the correct definition to use. Avoid multiple calls to Connection.getAutoCommit() in PoolableConnectionFactory.passivateObject() as it could be an expensive call. Use one line per statement for methods with multiple statements rather than using a single line. Expose all of the AbandonedConfig properties through a BasicDataSource. Correct implementation of DelegatingConnection.isWrapperFor() so it works correctly with older JDBC drivers. Correct implementation of DelegatingStatement.isWrapperFor(). Also fix DelegatingDatabaseMetaData.isWrapperFor() and DelegatingResultSet.isWrapperFor() that had the same problem. LocalXAConnectionFactory does not properly check if Xid is equal to currentXid when resuming which may result in an XAException. Ensure that the XAConnection is closed when the associated Connection is closed. Clarify Jaavdoc for isClosed() method of PoolableConnection. Avoid NullPointerException and throw an XAException if an attempt is made to commit the current transaction for a connection when no transaction has been started. Using batchUpdate() should not invalidate the PreparedStatement when it is returned to the pool. Improve documentation for JNDI example using BasicDataSource. Exposed GenericObjectPool's softMinEvictableIdleTimeMillis property for configuration and use by BasicDataSource. Made equals reflexive in DelegatingStatement (and subclasses), DelegatingMetaData, DelegatingResultSet and PoolingDriver#PoolGuardConnectionWrapper. Modified createDataSource method in BasicDataSource to ensure that GenericObjectPool Evictor tasks are not started and orphaned when BasicDataSource encounters errors on initialization. Prior to this fix, when minIdle and timeBetweenEvictionRunsMillis are both positive, Evictors orphaned by failed initialization can continue to generate database connection requests. This issue is duplicated by DBCP-339 and DBCP-93. Changed DelegatingDatabaseMetaData to no longer add itself to the AbandonedTrace of its parent connection. This was causing excessive memory consumption and was not necessary, as resultsets created by DelegatingDatabaseMetaData instances are attached to the parent connection's trace on creation. Also fixes DBCP-352. Modified execute methods of Statement objects to ensure that whenever a statement is used, the lastUsed property of its parent connection is updated. Correctly implemented the option to configure the class loader used to load the JDBC driver. LIFO configuration option has been added to BasicDataSource. When set to true (the default), the pool acts as a LIFO queue; setting to false causes connections to enter and exit to pool in FIFO order. Test transitive dependencies brought in by geronimo-transaction created version conflicts (commons logging and junit). These have been explicitly excluded in the POM. BasicDataSourceFactory incorrectly used "initConnectSqls" in versions 1.3 and 1.4 of DBCP as the property name for connectionInitSqls. Online docs for 1.3/1/4 have been updated to reflect this inconsistency. The BasicDataSourceFactory property name has been changed to "connectInitSqls" to match the online docs and the BasicDataSource property name. Eliminated poolKeys cache from PerUserPoolDataSource. Eliminated userKeys LRUMap cache from SharedPoolDataSource. Made private fields final where possible. PerUserPoolDataSource.getPooledConnectionAndInfo multi-threading bug. Remove throws clause from method that does not throw an exception. Remove code that catches and ignores Exceptions when calling PooledConnection.removeConnectionEventListener(ConnectionEventListener) as the method does not throw any Exceptions. Remove impossible null check. Renamed variables with duplicate names in different scopes. Clarified javadoc for BasicDataSource close() method. Made PoolingConnection pool CallableStatements. When BasicDataSource's poolPreparedStatements property is true, CallableStatements are now pooled along with PreparedStatements. The maxOpenPreparedStatements property limits the combined number of Callable and Prepared statements that can be in use at a given time. Use an API specific exception for logging abandoned objects to make scanning the logs for these exceptions simpler and to provide a better message that includes the creation time of the abandoned object. Ensure Statement.getGeneratedKeys() works correctly with the CPDS adapter. Removed incorrectly advertised ClassNotFoundException from JOCLContentHandler.ConstructorDetails.createObject(). Make the class loader used to load the JDBC driver configurable for the BasicDatasource. Handle user password changes for InstanceKeyDataSources. Made XADataSource configurable in BasicManagedDataSource. Added PoolableManagedConnection and PoolableManagedConnectionFactory so that pooled managed connections can unregister themselves from transaction registries, avoiding resource leaks. Added connectionProperties property to DriverAdapterCPDS. Added a validationQueryTimeout configuration parameter to BasicDataSource allowing the user to specify a timeout value (in seconds) for connection validation queries. Added a connectionInitSqls configuration parameter to BasicDataSource allowing the user to specify a collection of SQL statements to execute one time when a physical database connection is first opened. PoolableConnectionFactory.makeObject() is no longer synchronized. This provides improved response times when load spikes at the cost of a faster rise in database server load. This change was made as a partial fix for DBCP-212. The synchronization changes in Commons Pool 1.5 complete the fix for this issue. Reverted DelegatingConnection close to 1.2.2 version to ensure open statements are closed before the underlying connection is closed. Refactor DelegatingConnection and ManagedConnection enable overridden equals() and hashcode() to work correctly. Add a DelegatingDatabaseMetaData to track ResultSets returned from DatabaseMetaData objects. Modified BasicDataSourceFactory to complete initialization of the pool by creating initialSize connections rather than leaving this to lazy initialization when the pool is used. Eliminated masked _stmt field in descendents of DelegatingStatement. Modified DBCP sources to support compilation under JDK 1.4-1.6 using Ant flags to do conditional compilation. Added a static initializer to BasicDatasource that calls DriverManager.getDrivers() to force initialization before we ever do anything that might use Class.forName() to load (and register) a JDBC driver. Eliminated direct System.out calls in AbandonedTrace. Modified DelegatingStatment close to clear open batches. Eliminated unused private "parent" field in AbandonedTrace. Fixed errors handling boolean-valued Reference properties in InstanceKeyObjectFactory, DriverAdapterCPDS that were causing testOnBorrow and poolPreparedStatements properties to be incorrectly set when creating objects from javax.naming.Reference instances. Made private instance fields of AbandonedTrace volatile (parent, createdBy, lastUsed, createdTime) or final (trace). Narrowed synchronization in AbandonedTrace to resolve an Evictor deadlock. Corrected Javadoc to state that getLoginTimeout and setLoginTimeout are NOT supported by BasicDataSource. Added Maven 2 pom.xml. Removed a block of code from TestJOCLed that set the Xerces parser manually. This was to support early JDKs. The 1.3 version of DBCP requires JDK 1.4+. Added support for pooling managed connections. Added BasicManagedDataSource, extending BasicDataSource. Also improved extensibility of BasicDataSource by encapsulating methods to create object pool, connection factory and datasource instance previously embedded in createDataSource. Changed behavior to allow Connection, Statement, PreparedStatement, CallableStatement and ResultSet to be closed multiple times. The first time close is called the resource is closed and any subsequent calls have no effect. This behavior is required as per the JavaDocs for these classes. Also added tests for closing all types multiple times and updated any tests that incorrectly assert that a resource can not be closed more then once. Fixes DBCP-3, DBCP-5, DBCP-23 and DBCP-134. Modified PoolingDataSource, PoolingDriver and DelegatingStatement to assure that all returned Statements, PreparedStatements, CallableStatements and ResultSets are wrapped with a delegating object, which already properly handle the back pointers for Connection and Statement. Also added tests to to assure that the *same* object used to create the statement or result set is returned from either getConnection() or getStatement(). SQLNestedException has been deprecated and will be replaced in DBCP 2.0 with SQLException and standard Java exception chaining. BasicDataSource.close() now permanently marks the data source as closed, and no new connections can be obtained from the data source. At close all idle connections are destroyed and the method returns. As the remaining active connections are closed, they are destroyed. Eliminated potential sources of NullPointerExceptions in PoolingConnection. Improved error recovery and listener cleanup in KeyedCPDSConnectionFactory. Substituted calls to destroyObject with _pool.invalidateObject on error to ensure pool active count is decremented on error events. Ensured that events from closed or invalid connections are ignored and listeners are cleaned up. Fixed error in SharedPoolDataSource causing incorrect passwords to be stored under certain conditions. Added exception handler to ensure that PooledConnections are not orphaned when an exception occurs in setUpDefaults or clearWarnings in IntanceKeyDataSource.getConnection. Made getPool synchronized in PoolableConnectionFactory. Fixes inconsistent synchronization accessing _pool. Fixed inconsistent synchronization on _rollbackAfterValidation, _validationQuery and _pool in CPDSConnectionFactory and KeyedCPDSConnectionFactory by making the first two volatile and making both getter and setter for _pool synchronized. See <a href="changes-report.html#a1.4">DBCP 1.4 Changes </a> for details. Version 1.3 is identical to 1.4, other than JDBC 4 methods being filtered out of the DBCP 1.3 sources. Changes Since 1.2.2 are the same for 1.3 and 1.4. Add a <i>JNDI How To</i> to the User Guide. DriverManagerConnectionFactory: blank username/password handling. Broken behaviour for BasicDataSource.setMaxActive(0). BasicDataSource does not work with getConnection(String, String). Enhancements to prepared statement in DriverAdapterCPDS. Better messages and docs for LoginTimeout UnsupportedOperationException. Error in JOCL snippet in org.apache.commons.dbcp package javadoc. Added toString() methods to DelegatingPreparedStatement and DelegatingStatement Changes to make DBCP compile on JDK 1.5 by adding source="1.4" to compiler arguments (there are compiler errors in JDK 5.0 without this source switch that cannot be fixed without JDK 5.0-specific syntax). Per-user pooling with Oracle driver and default isolation settings. Error in JOCL document in javadoc. Added toString() method to DelegatingConnection. Add DriverManager.invalidateConnection(). Improved Exception nesting in ConnectionPool. Fix broken website links for examples. Modified PoolableConnection close method to invalidate instance when invoked on an already closed connection. Inserted null checks to avoid NPE in close operations. Changed getReference method in InstanceKeyDataSource to return a concrete factory and added implementations of getReference in concrete subclasses. Inserted null check in close method of SharedPoolDataSource to avoid NPE when invoked on non-initialized pool. Document fact that true values for testOnBorrow, testOnReturn, testWhileIdle only have effect when validationQuery is set to a non-null string. Modified activateObject in PoolableConnection to test connection properties before resetting to defaults. Corrected maxActive documentation in configuration.html. Upgraded dependency to Pool 1.3. Added connection info to SQLException messages when closed connections (resp stmts) are accessed in DelegatingConnection, DelegatingStatement. Fixed errors in pool parameter documentation and made 0 value for _maxPreparedStatements in DriverAdapterCPDS behave like a negative value, to be consistent with documentation and pool behavior. Made userKeys an instance variable (i.e., not static) in SharedPoolDataSource. Changed implementation of equals in PoolingDataSource.PoolGuardConnectionWrapper to ensure it is reflexive, even when wrapped connections are not DelegatingConnections. Added rollbackAfterValidation property and code to issue a rollback on a connection after validation when this property is set to true to eliminate Oracle driver exceptions. Default property value is false. Removed dependency on Commons Collections by adding collections 2.1 sources for LRUMap and SequencedHashMap with package scope to datasources package. Removed synchronization from prepareStatement methods in PoolingConnection. Synchronization in these methods was causing deadlocks. No resources other than the prepared statement pool are accessed by these methods, and the pool methods are synchronized. Also fixes DBCP-202. See <a href="release-notes-1.2.1.html">DBCP 1.2.1 Release Notes</a> for details. See <a href="release-notes-1.2.html">DBCP 1.2 Release Notes</a> for details. See <a href="release-notes-1.1.html">DBCP 1.1 Release Notes</a> for details. Initial Release