HikariCP Changes

Changes in 2.4.2

 * Improve accuracy of timeouts for getConnection() calls by accounting for possibly
   long delay aliveness tests.

 * Improve adherence to minimumIdle goal by closing idle connections starting from
   longest idle time to shortest.  Additionally, stop when minimumIdle is reached even
   if connections exceeding idleTimeout remain (but are still within maxLifetime).

 * Introduce larger variance into maxLifetime to avoid mass connection closing and
   subsequent new connection creation load on the database.  Connections now have a
   maximum lifetime between 97.5-100% of configured maxLifetime.  In the case of the
   default 30 minute lifetime, this generates actual lifetimes with a maximum deviation
   of 45 seconds.  Currently, no attempt is made to futher avoid clustering that may
   occur due to randomness.

 * Ongoing com.zaxxer.hikari.metrics refactors. This is not considered public API until
   such time as we announce it. Caveat lector.

 * Performance improvements in the getConnection()/close() hot path.

 * issue 452: fixed race condition when creating an rapidly ramping connections in the
   pool.

 * issue 415: removed use of java.beans classes to allow use of HikariCP with the
   Zulu JRE compact3 profile.

 * issue 406: execute validation query during connection setup to make sure it is
   valid SQL.

Changes in 2.3.12

 * Fixed issue with proxy generation whereby the generated classes contain the
   major version number for Java 8, which makes them incompatible with the Java 7
   runtime.

Changes in 2.4.1

 * issue 380: housekeeper was not being scheduled in the case of a user specified
   ScheduledExecutorService instance.

 * issue 340: rollback change that elides setting the readonly property if the user
   never explicitly configured it.  See discussion in the Github issue tracker.  Also
   fixes binary ABI breakage between 2.3.9 and 2.4.0.

 * issue 379: stop closing idle connections, to keep minimumIdle connections in pool

 * issue 375: fixed InvalidPathException in HikariConfig

 * issue 362: fixed NullPointerException in closing connection (closing statements)

 * issue 357: allow altering the username & password through JMX at runtime

 * issue 349: handle integer Transaction isolation level

 * Throw SQLTransientConnectionException instead of SQLTimeoutException

 * for validating connection, if network time out is set, do not set query timeout too

 * ResultSet.getStatement() should return StatementProxy

Changes in 2.4.0

 * Consolidated distribution into single JVM target (Java 7/8).  Java 6 support has
   entered maintenance mode, bug fixes will continue on the 2.3.x branch.

 * Removed runtime dependency on Javassist by pre-generating proxy classes at build-time.

 * Significantly reduced overhead, and increased reliability, of ConcurrentBag.

 * Reduced garbage generation by 2-3x.

 * Add connection soft-eviction and replacement if backward system clock motion or
   significant forward jumps (greater than 1 minute) are detected.

 * Pool configuration properties and DataSource methods previously marked as
   @Deprecated have been removed.

 * Deprecated HikariDataSource.shutdown() in favor of close().

 * Improve shutdown performance.

 * Allow user specified ScheduledThreadPoolExecutor for housekeeping timer.  Useful
   in applications with dozens or hundreds of pools in the same JVM.

 * Reduce overhead and accuracy of Dropwizard gauges.

Changes in 2.3.7

 * Try harder at resolving the driver by various means when both driverClassName and jdbcUrl
   have been specified.

 * Allow a specifically set DataSource instance to override other settings such as jdbcUrl,
   dataSourceClassName, or driverClassName.

 * Fixed issue where, in the case of a driver-based configuration (jdbcUrl), we were not
   initialising the network timeout Executor.

 * Fixed race condition uncovered during load-testing in which the connections in the pool
   can spike to the maximum pool size when many connections reach their maxLifetime at the
   same time.

Changes in 2.3.6

 * Allow explicit definition of driverClassName to override DriverManager.getDriver(url)
   located driver.

 * Fixed a rare issue where a Connection that is held out of the pool, and never used by
   the holding thread, upon returning to the pool might be given to another thread without
   an aliveness test.

Changes in 2.3.5

 * Fixed regression caused by enhancement #279 that imposed a runtime dependency on
   Dropwizard metrics.

Changes in 2.3.4

 * Fixed class cast exception when setting the HealthCheckRegistry via JNDI lookup.

 * Allow Dropwizard MetricRegistry/HealthCheckRegistry to be set after pool startup --
   one time only.

 * Make logger in BaseHikariPool non-static and use getClass() to log messages as the
   implementation class rather than as BaseHikariPool.

 * Removed deprecation from connectionInitSql, it will be allowed.

 * Made suspect/resume lock non-static (should be be shared across pools).

 * Improved unwrap() behavior in the Hibernate HikariConnectionProvider.

 * Improved leak detection log

Changes in 2.3.3

 * Fixed bad interaction with PostgeSQL JDBC driver whereby a SQLException thrown by
   PostgreSQL where the getNextException() call returns the original exception and causes
   an infinite loop in HikariCP (and eventual stack overflow).

 * Throw a typed Exception rather than a simple RuntimeException when pool initialization
   fails.

 * Allow Dropwizard Metrics and HealthChecks to be configured by a JNDI lookup.

Changes in 2.3.2

 * Add support for Dropwizard HealthChecks through the introduction of two initial health
   checks: ConnectivityCheck and Connection99Percent.  See the Github project wiki for
   documentation.

 * Allow a lower maxLifetime setting of 30 seconds (compared to previous 120 second limit)

 * Improve the message displayed when a connection leak is detected.

 * Fixed a bug where Connection.setNetworkTimeout() was called on an already closed connection
   resulting in a warning log from the AS400 JDBC driver.

Changes in 2.3.1

 * Work around a bug in the MySQL Connector/J implementation of Connection.setNetworkTimeout()
   that results in non-deterministic asynchronous application of the timeout, resulting in an
   NPE from the MySQL driver when setNetworkTimeout() is followed immediately by close().

 * Introduced a separate validationTimeout property, distict from connectionTimeout, to allow
   greater control for some deployments that desire a long (or infinite) connectionTimeout
   but expect the aliveness check to succeed for fail within a different (shorter) amount of
   time.

Changes in 2.3.0

 * Support pool suspend/resume to support certain failover scenarios.

 * Fix theoretical race in JDBC 4.0 detection support.

 * Improve shutdown() semantics to avoid exceptions as connections are forcefully
   aborted.

 * Unregister Codahale metrics at shutdown, if metrics are enabled.

 * Major internal project layout restructuring to allow shared use of common code
   between the Java 6/7 and Java 8 versions.

 * Fixed bug where two pools in the same VM (and ClassLoading domain), using drivers
   with differing JDBC support levels, would fail unless both pools were using
   connectionTestQuery.

 * Improved timeliness of maxLifetime evictions, while increasing performance of
   getConnection() slightly as a side-effect.

 * Fixed bug in HikariDataSource unwrap() semantics.

 * Allow a lower leakDetectionThreshold of 2 seconds.

 * Fixed bug when using the HikariJNDIFactory that required the presence of
   Codahale metrics.

 * Support initializationFailFast even when minimumIdle = 0

 * Log internal pool inconsistencies rather than throwing exceptions that might
   disrupt internal executors.

 * Guard against poor or unreliable System.nanoTime() implementations.

Changes in 2.2.5

 * Fixes for Java 6 compatibility.

 * Implement full transaction state tracking.  This allows HikariCP to bypass
   the automatic rollback when connections are returned to the pool if the
   transaction state is "clean".

 * Rename MBean closeIdleConnections() to softEvictConnections() and implement
   "evict on return" semantics.

 * Fixed bug in code that sets HikariConfig values from a Properties instance
   that prevented defaults from being read properly.

 * Fixed an obscure bug in connection creation with a driver that throws an
   exception when setTransactionIsolation() is called with the value returned
   by getTransactionIsolation().  We now bypass setTransactionIsolation() if
   the user has not configured an isolation level (using the default).

 * Fix a bug where DataSource.loginTimeout() was always being set to 1 second.

 * Fix bug where some drivers return 0 from Connection.getNetworkTimeout(),
   and yet throw SQLFeatureNotSupportedException when setNetworkTimeout() is
   called. This broke they way that HikariCP had implemented JDBC 4.1 support
   detection.

Changes in 2.2.4

 * Generate proxy classes into the same protection domain as the HikariCP
   loaded classes.  This solves issues with signed jars.

 * Improve accuracy of pool statistics available to JMX and logged at debug
   level (at a slight performance cost).

 * Fixed issue where after a database down condition, and when minimumIdle is
   set to 0, when the database connectivity is restored the connections could
   ramp up to the maximum pool size.  Eventually, idleTimeout and maxLifetime
   would restore normal pool conditions, but it was still undesirable behavior.

 * Improved connection timeout handling by using Connection.setNetworkTimeout()
   if available (JDBC 4.1).

 * driverClassName is no longer a required property when jdbcUrl is specified.
   Omitting this property only works for compliant drivers.

 * Add auto-detection of support for Statement.setQueryTimeout() used in the
   alive check.  Fixes failures with test queries on the PostgreSQL driver
   when not using JDBC4 isValid() alive checks.

 * The pool now defaults to fail-fast initialization.  If you need to start
   your application without/before the database, you will need to explicitly
   set initializationFailFast to false.

 * Dropwizard/Codahale metrics are now supported via the setMetricRegistry()
   method in HikariConfig and in HikariDataSource.

 * Fixed issue with pool initialization of MySQL after default value of
   initializationFailFast property was changed to false.

 * Further shadow runtime dependency on Codahale metrics from reflection
   performed by Spring and other IoC containers.

 * Fix issue where network timeout was not properly restored to its default
   value after modifying it for the duration of the addConnection() method.

Changes in 2.1.0

 * Significant internal refactor supporting creation of new proxy instances
   (throwaway) around Connections for each call to getConnection().  This
   can avoid issues where a thread continues to try to use a connection
   after it is closed [returned to the pool].

 * Allow HikariConfig(String propertyFileName) to load properties file from
   classloader as a stream, with fall-back to the file-system.

 * Allow loading of properties file specified by -Dhikaricp.configurationFile
   system property when using the default HikariConfig() or HikariDataSource()
   constructors.

 * Fixed accounting issue with totalConnections when aborting connections
   during shutdown, causing a warning message to be logged.

 * Fixed regression in Java 8 codeline that would prevent minimumIdle from
   being set before maxPoolSize.

 * Fixed regression with Tomcat carping about ThreadLocal variables held after
   web application restart

 * Change to make HikariConfig.getTransactionIsolation()/setTransactionIsolation()
   follow proper bean semantics.

 * Fixed issue where connections created in the pool would skip the alive check
   the first time they were used.

Changes in 2.0.1

 * Split project into Java 6/7 and Java 8 components.

 * Fixed issue in JNDI object factory which would not allow JNDI-defined
   DataSource properties to pass-thru to the pool.

 * Fixed issue where under certain conditions getConnection() could
   timeout prematurely.

 * Fixed issue where user-defined pool name would be overridden by the
   automatically generated name.

 * Fixed NPE when one of either username and password is defined, and the
   other is null.

 * Fixed issue tracking the statements when there are mixed statement
   types (Statement, PreparedStatement, etc.) open on the connection and
   the number of unclosed statements exceeds 32.

 * Fixed issue where housekeeping threads would add idle connections
   even when minimumIdle was 0.

 * Fixed issue where Wrapper.isWrapperFor() and Wrapper.unwrap() calls
   did not recurse as per specification.

 * HikariDataSource now implements the Closable interface.

 * Integrated change to allow specifying a ThreadGroup for thread
   creation is certain restricted environments.

Changes in 1.4.0

 *) Fix bug that did not allow minIdle property to be set.

Changes in 1.3.9

 *) Added pool name to housekeeping thread name to make thread dumps
    more meaningful in containers with multiple pools.

 *) Improved shutdown semantics; make a concerted effort to close
    idle connections and abort or close active connections.

 *) Performance enhancements.

Changes in 1.3.8

 *) Fixed incorrect logic when using JDBC4 isValid() test for alive
    status of connection.

Changes in 1.3.7

 *) Added JNDI object factory (com.zaxxer.hikari.HikariJNDIFactory)
    for Tomcat and other containers that prefer JNDI-registered DataSource
    factories.

 *) Fix NPE that can occur when connections cannot be created and
    callers to getConnection() timeout.

 *) Various bug fixes and minor enhancements.

Changes in 1.3.6

 *) Include connection failure cause in calls to getConnection() that
    timeout (due to connection failure).  Removed chatty logging.

 *) Java8 Compatibility fixes.

 *) Include pool name in logging messages.  Thanks for the contribution
    @jaredstehler.

Changes in 1.3.5

 *) Fixed a regression in the Javassist code generation.

 *) Various bug fixes and minor enhancements.

Changes in 1.3.4

 *) Added new property isolateInternalQueries used to control whether
    internal pool queries such as connection alive tests are isolated
    in their own transaction.

 *) Added properties for DriverManager (driverClassName) and JDBC URL-based
    (jdbcUrl) configuration.  1999 called and wants its JDBC driver back.

 *) Added new username and password properties to allow default authentication
    for connections.

 *) Added support for the getConnection(username, password) method signature
    to HikariDataSource.

 *) Added new property readOnly to control the default read-only status
    of connections in the pool.

 *) Deprecated acquireIncrement property.

 *) Deprecated acquireRetries property.

 *) Deprecated acquireRetryDelay property.

 *) Deprecated minimumPoolSize property.

 *) Added new property minimumIdle used to control the minimum number of
    idle connections the pool should try to maintain on a running basis.

 *) Added evictConnection(Connection) method to HikariDataSource to allow
    special cases where users wish to forcibly eject a connection from
    the pool.  To use used cautiously, read the JavaDoc before using.

 *) Various bug fixes and minor enhancements.

Changes in 1.3.3

 *) Removed shared state contention that was causing excessive CPU cache-line
    flushing.  Nearly 4x improvement in Connection acquisition/release
    performance.

 *) Fixed issue with Tomcat carping about ThreadLocal variables held after
    web application restart.

 *) Fixed issue where the maximum configured connections could be overrun
    during large burst requests for connections.

Changes in 1.3.2

 *) Java 6 compatibility.

 *) HikariDataSource now extends HikariConfig, so pool properties can be
    set directly on a HikariDataSource without need to create a  HikariConfig.
    The cost of doing so is a small runtime cost due to the fact that an
    "is initialized" check must be performed on every invocation of
    getConnection() due to lazy initialization of the pool.

 *) Added Sybase-specific disconnect error codes to SQLException snooping.

 *) Added HikariConfig.setCatalog() method to set DataSource catalog.

 *) Add DataSource.close() method that is synonymous  with shutdown().

 *) More performance improvements (never ending).

 *) Moved benchmarks to https://github.com/brettwooldridge/HikariCP-benchmark

Changes in 1.3.0

 *) Pool is now backed by a custom lock-less ConcurrentBag that
    provides superior performance to LinkedBlockingQueue and
    LinkedTransferQueue for usage patterns of connection pools.

 *) Fixed bugs reported against the 1.2.9 release.

 *) Added more detailed logging for broken connections and failures
    during new connection creation.

Changes in 1.2.9

 *) Added a fail-fast option for pool initialization.  If enabled, a
    RuntimeException will be thrown if there are errors during pool
    initialization.

 *) Made the registration of the HikariCP MBeans optional.  They now
    default to not being registered.  Registering them causes a minor
    performance hit due to additional pool data collection in
    HikariDataSource.getConnection().

 *) Added the SQLException message to the log entry when an exception
    occurs during physical connection acquisition.

 *) Implemented an orderly shutdown of the pool via the shutdown() method
    on HikariDataSource.

 *) Listened to "Adele - Live At The Royal Albert Hall" on endless loop.

Changes in 1.2.8

 *) Fixed a critical bug introduced in 1.2.7 occurring when the number of
    concurrently open statements exceeds sixteen.

Changes in 1.2.7

 *) Finally achieved performance parity between the generated delegates
    and the former method of instrumenting driver classes directly.

 *) Improved generated delegate code. Removed unnecessary casts, moved
    to a static proxy factory rather than a singleton (performance win).

 *) Improved performance of FastStatementList (primary source of speed-up
    to reach parity with former instrumentation code).

 *) Removed aliveness check on connection creation.

 *) Track connection isolation level and only reset if the state has
    become "dirty".  Avoids unnecessary round trip to the DB during the
    aliveness check.

 *) Added interface IConnectionCustomizer and related HikariConfig
    property 'connectionCustomizerClassName' to allow users to specify
    a connection customization implementation.

Changes in 1.2.6

 *) Fixed regression that caused IndexOutOfBounds when multiple unclosed
    Statements existed at the time of Connection.close().

 *) Fixed incorrect pom.xml dependency on Hibernate.

Changes in 1.2.5

 *) Instrumentation mode (agent) removed due to narrowing gap between
    delegation mode and instrumentation (and to simplify the code base).

 *) Added setDataSource() to HikariConfig to allow a DataSource instance
    to be explicitly wrapped by the pool.  Only available when creating
    HikariConfig programmatically or constructing HikariConfig from a
    java.util.Properties instance.

 *) Fixed Hibernate threading issue (certain usage patterns) introduced
    in 1.2.2.

 *) Fixed issue observed with PostgreSQL whereby the query that tests the
    connection for "aliveness" also starts a transaction (when auto-commit
    is false), thereby causing a later failure when we tried to set the
    transaction isolation level.

 *) Fixed issue where idleTimeout could not be set to 0, thereby disabling
    it. Incorrect value validation caused 0 to be rejected as a valid value.

Changes in 1.2.4

 *) Fix another Hibernate-related issue whereby an NPE is encountered when
    a thread that was not the thread that obtained a Connection tries to
    interact with that Connection.

Changes in 1.2.3

 *) Fix internal (but suppressed) exception during rollback of connections
    returned to the pool with auto-commit turned off.

 *) Fix a reflection issue that causes Hibernate failures due to the
    CallableStatement interface being incorrectly injected into statement
    proxies that are PreparedStatement or Statement instances.

Changes in 1.2.2

 *) Perform a rollback() on connections returned to the pool with
    auto commit disabled.

 *) Add a constructor for HikariConfig that accepts a Properties
    object.

 *) Speed improvements for delegate mode.

 *) Fix a bug where connection timeouts could not be disabled.

 *) Permit setting the DataSource logWriter either on the HikariDataSource
    or via addDataSourceProperty() on the HikariConfig.

 *) Add transactionIsolation property to allow setting the default
    transaction isolation level for connections.

Changes in 1.2.1

 *) Clear SQL warnings before returning a connection to the user.

 *) Added asynchronous connection backfill strategy that triggers
    when the pool becomes empty as a result of dispatching a
    connection.

 *) Changed default acquireIncrement to 1, set minimum timeout of
    100ms for acquiring a connection.

Changes in 1.1.9

 *) Added connectionInitSql property to allow setting connection
    properties when a new connection is created.

 *) Added setDataSourceProperties() setter to HikariConfig to
    allow easier configuration though Spring.