c3p0-0.15.1
        -- Fix some embarrasing documentation errors, update README.md.
        -- Make mchange-commons-java transitive dependencies optional in ivy.xml
           as well as under pom.xml, so we don't sometimes see them pulled in,
           sometimes not. (mchange-commons-java)
        -- Eliminate loud warnings with scary stack traces accidentally introduced
           into the logging path when HOCON / typesafe-config libraries can't
           be found. The absences of typesafe-config is a common and supported
           configuration, not a crisis to shout about. (mchange-commons-java)
c3p0-0.15.0
        -- Use the prior two extensibility augmentations to mchange-commons-java
           to support c3p0-xml directly within com.mchange.v2.cfg, but without
           layer inversions that would have required the config and log libraries
           to know anything about their client c3p0.
        -- Make com.mchange.v2.log config extensible by allowing specification
           of extra resource paths for log config in mlog-config-resource-paths.txt,
           which becomes a #-commented, one-per-line list of resource paths
           the current configuration of com.mchange.v2.cfg supports. (mchange-commons-java)
        -- Make com.mchange.v2.cfg extensible, by allowing users to specify
	   ExtraPropertiesConfigSources (by fqcn) in a resoure called
           mcfg-extra-properties-config-sources.txt, which becomes a #-commented,
           one-per-line list if by-name-instantiable sublasses of
           com.mchange.v2.cfg.ExtraPropertiesConfigSources. (mchange-commons-java)
        -- Clarify, fix, and test support for config and user names containing dots,
           as long as they don't contain dot delineated "named-configs", "extensions",
           or "user-overrides" elements.
        -- Port XML config parsing (including the security hardenings) to the new,
           unified config. Support compound properties in <default-config>, not
           just unprefixed c3p0.xxx properties.
        -- Improve, and add much better documentation for, the API permitting
           refreshes, augmentations, and therefore customization of c3p0 config at
           runtime. Make it configurable whether MLog config should also be
           updated on such a refresh. Allow augmenting with "backstops" as well
           as with "overrides" when refreshing config. Backstops only take effect
           if nothing else in config sets the value. Overrides override values
           set within standard c3p0 configuration.
        -- The never-really-documented feature of permitting user-specified
           "C3P0ConfigFinder" implementations is no longer supported and has
           been removed. It opened more doors to mischief than it solved
           likely problems. (In the unlikely case you used and actually
           miss this feature, please do let us know.)
        -- Major reworking of c3p0's internal config library,
           com.mchange.v2.c3p0.cfg. Structurally it used to have two views
           of config data that could under some circumstances slip out of
           sync. Now the code is much simpler, and there is only one, canonical
           representation of the data.
        -- Take greater care that items that might contain passwords or
           credentials are masked before appearing in logs. LOOSEN restriction
           on usernames appearing in logs. They can be helpful for debugging
           (particularly in deployments where the user-overrides feature is used)
           and are not properly secrets.
        -- Documentation of c3p0's properties-based configuration
           precedence ordering has been updated, and we now test to
           verify that the documented preference ordering holds.
        -- We've unified the initial configuration sources of c3p0
           and the mlog library, so c3p0 now sees config from classloader
           resource com/mchange/v2/log/default-mchange-log.properties.
           That's intended for mchange-commons-java internal-use only,
           but we've documented the addition.
        -- Migrate both c3p0 and mchange-commons-java away from
           mchange-commons-java's traditional
           resource-based-source-of-configuration-resources to examine.
           That mechanism served us fine for many years, but it's
           complicated, more difficult to reason about than simply hardcoding
           config sources into code. We offer (and now document) API by which
           users who wish to alter config sources that c3p0 and
           mchange-commons-java's logging library consult may do so. This
           approach seems preferable to adding or modifying classloader
           resources to perform this kind of alteration. We now warn if we
           find old-school resources naming config sources (and we continue to
           support those if we do find them), but users should consider that
           mechanism deprecated. We also log at info level the sources both
           c3p0 and the mlog libraries are consulting for properties-based
           config. The classloader resource mchange-config-resource-paths.txt
           no longer ships with c3p0, and it should not be replaced.
        -- Add to MConfig an AsProvidedIgnoreVetoed facade, which continues
           rather than fails if a vetoable config resource does veto. The
           vetoing resource is ignored with a warning. (Users of this facade
           should remain cognizant that an ignored config source might contain
           config that would tighten security arrangements, in which case
           ignoring rather than failing might reduce security. Ideally,
           applications are designed to be extremely secure by default, with
           relaxations requiring overt config, which mitigates this concern.)
           (mchange-commons-java)
        -- Make security configuration a bit more visible in the logs.
           At library initialization, warn on certain weaker security settings.
           If logger com.mchange.v2.c3p0.C3P0Registry is loggable at FINE/DEBUG,
           dump security-relevant config to the log at that level.
        -- Previously, using MultiPropertiesConfig.fromProperties(Properties props)
           gave a single, constant, notional resource path. Since we've formalized
           a requirement that each notional resource path have a unique precedence
           level in a MultiPropertiesConfig, that invited collisions and config
           with uncertain precedence (if two elements with the same resource path
           are combined at distinct precedence levels). Now we include a unique ID
           in each generated notional resource path to prevent path name
           collisions. (mchange-commons-java)
        -- Stop uselessly making a network call (getLocalHost()) in order
           to establish a VMID. (getLocalHost() is expensive, brittle, and
           what it supplied is far from reliably unique to a VM.) Fix VMID
           computation logic, which worked before, but primarily via a backstop
           to a quietly broken path. (mchange-commons-java)
        -- Gate the potentially unsafe InitialContext environment used by
           JndiRefForwardingDataSource behind our new
           com.mchange.v2.naming.unsafeInitialContextEnvFilterClassName,
           making it possible for deserialized/dereferenced InitialContext
           environments to be supported, but keeping untrusted, potentially
           dangerous environments forbidden by default.
        -- Add some "defense-in-depth" to our cautious XML parse path. For
           parsers that support all of the security config we try, this won't
           have an effect, but if a parser were to lack support for e.g.
           http://apache.org/xml/features/disallow-doctype-decl we've added
           backstop restrictions that help limit the hazard. We also
           now warn if http://apache.org/xml/features/disallow-doctype-decl
           fails to set.
        -- Fix parsing bug re com.mchange.v2.c3p0.impl.DefaultConnectionTester.isValidTimeout,
           previously did not trim so leading or trailing whitespace would fall
           back to the default value (of 0, meaning no limit).
        -- Update DefaultConnectionTester to conform to the expectation that
           by-name instantiated classes be stateless. DefaultConnectionTester now
           tracks changes to its configuration properties "live", rather than
           initializing itself based on a snapshot of configuration, which rendered
           different instances of DefaultConnectionTester potentially meaningfully
           distinct depending on the timing of their instantiation.
        -- Cache by-name instantiated com.mchange.v2.naming.NameGuard instances,
           since we insist they must be stateless. (mchange-commons-java)
        -- Formalize implicit expectation that where implementations are
           configurable by class name alone for by-name instantiation, the expectation
           is that implementations be effectively stateless, such that any
           instantiated object of the class could substitute for any other,
           and so they can safely be cached. (We already often cached them.
           This was an implicit expectation.) (mchange-commons-java)
        -- CsvSecurelyStringifiableBeangenGeneratorExtension is updated to generate
           according to the new SecurelyStringifiable contract. In the very
           unlikely case you have code previously generated by that class outside
           of c3p0, you will want to regenerate that code with the updated extension.
        -- Modify the contract of com.mchange.v2.naming.SecurelyStringifiable so that
           both SecurelyStringifiable.constructSecurelyStringified(...) and the duck-typed
           constructSecurelyStringified(...) method expected on classes that conform to
           the SecurelyStringifiable protocol accept a PropertiesConfig object, so
           that we can apply a new whitelist to reconstructing objects serialized via
           SecurelyStringifiable, under com.mchange.v2.naming.securelyStringifiable.whitelist
           and its subkeys. Absent this, tampering with stringified representations
           might lead applications to instantiate classes specified by an attacker.
           This whitelist is enforced already, unlike the by-name-instantiation
           whitelist which (temporarily!) only warns to give deployments time to
           whitelist custom classes. This is an incompatible change from
           prior versions, but we believe SecurelyStringifiable is not widely used
           outside of mchange-commons-java and c3p0, so few installations should be
           affected. (Although the method signature has only changed for reading
           SecurelyStringifiable classes, neither reads nor writes will work for
           classes that still implement the old read method signature, as
           SecurelyStringifiable methods gate on conformance to a duck-type based
           on both signatures.) (mchange-commons-java)
        -- When resolving properties-format ClassLoader resources into
           MultiPropertiesConfigs, previously if there were multiple resources
           in the CLASSPATH that matched the same resource path, we simply took
           the first item in the CLASSPATH. Now we take all matching paths
           from the CLASSPATH and merge. But if there are conflicts, following
           Java CLASSPATH conventions (in CONTRAST to the usual convention of
           com.mchange.v2.cfg), the value found in the earliest CLASSPATH
           resource to define the key is retained. (mchange-commons-java)
        -- Add config key com.mchange.v2.naming.unsafeInitialContextEnvFilterClassName,
           which should refer to a class implementing UnsafeInitialContextEnvFilter,
           which inspects any Hashtable<?,?> that may have been derived from untrustworthy
           dereferencing or deserialization and can either sanitize or completely reject
           the potentially dangerous environment. Defaults to
           com.mchange.v2.naming.AlwaysForbidUnsafeInitialContextEnvFilter, which simply
           rejects any potentially dangerous environment. NOTE: This means that,
           if you are using ReferenceIndirector / ReferenceSerialized (very rarely used!),
           it is no longer enough to set
           'com.mchange.v2.naming.acceptDeserializedInitialContextEnvironment=true'.
           You must also define and configure a more permissive UnsafeInitialContextEnvFilter
           than AlwaysForbidUnsafeInitialContextEnvFilter. (mchange-commons-java and c3p0)
        -- SealedSystemProperties are now in-line and of higher precedence in c3p0's config
           than "live" mutable System properties. Config specified as -Dkey=value will be
           effectively immutable as far as c3p0 is concerned, as long as it has not been
           messed with prior to initialization of C3P0's configuration (that is, almost any
           use of a c3p0 DataSource).
        -- Modify security sensitive string properties, boolean properties, and whitelists
           to consult sealed system properties rather than current system properties
           for security-sensitive config (mchange-commons-java and c3p0).
        -- Implement SealedSystemProperties, a snapshot of system properties intended
           to be taken early in the life of an application, so that security-sensitive
           properties can be accessed in a state that is unlikely to have been modified
           at runtime by malicious code. The early snapshot can be taken explicitly by
           calling SealedSystemProperties.seal(), or is taken implicitly the first time
           a security-sensitive SealedSystemProperty is consulted. (mchange-commons-java)
        -- In classname whitelists, if BOTH a deprecated whitelist key AND one of the
           current, supported forms of configuring a whitelist are set, the resulting
           whitelist becomes conservatively the INTERSECTION of the two potentially
           conflicting lists, and we emit a lot of warnings.
        -- Standardize classname whitelists, allow specification across multiple subkeys
           of a base whitelist key (so different libraries can whitelist what they need
           without conflicting). Whitelists are the union of the <prefix>.whitelist key and its subkeys,
           though if any one key or subkey is specified in both system properties and other
           configuration, only the intersection of the settings comes through. Each whitelist
           has a <prefix>.overrideWhitelist key that, if set, supersedes the key + subkeys union
           with just the single specified list. A whitelist that contains only the single entry "*"
           means disable enforcement, accept anything. A whitelist entry "[]" anywhere in a
           whitelist, its subkeys, its override key, or a deprecated prior key renders the whitelist
           DENY ALL. Old whitelist keys com.mchange.v2.naming.objectFactoryWhitelist
           and com.mchange.v2.naming.referenceableJavaBeanClassWhitelist still work, but
           are deprecated and warned in favor of new-style com.mchange.v2.naming.objectFactory.whitelist
           and com.mchange.v2.naming.referenceableJavaBeanClass.whitelist, which also support
           subkeys. If deprecated keys and contemporary config are both present, the computed whitelist
           is the union of those two sources (which will probably be broken and hopefully
           encourage moving towards contemporary config). (mchange-commons-java)
        -- Gate behind a whitelist by-name-instantiation of fully-qualified class names
           that may have come from dereferenced or deserialized objects. For now,
           instantiation of non-white-listed class names succeeds, but with a warning.
           Enforcement can be enabled via com.mchange.v2.reflect.byNameInstantiation.enforceWhitelist,
           see "Configuring Security" in the docs. THE CURRENT DEFAULT OF PERMISSIVENESS IS
           TEMPORARY. Future releases will default to enforcement rather than warning. Deployments
           that explicitly enable enforcement of the whitelist will enjoy greater security and avoid
           a potentially disruptive change during future releases. Many thanks to @manus-use on github
           for suggesting this addition. (mchange-commons-java)
        -- In JndiRefForwardingDataSource, refuse to look up JNDI references from
           InitialContext instances with non-default environment, because we can't guarantee
           those environments haven't been constructed by deserialization or dereferencing
           from a maliciously crafted Serialized object or DataSource. Many thanks to
           @abhishekkushwaha4u on github for reporting this vulnerability.
        -- Add miscellaneous security hardenings and discouragements of insecure use
           to mchange-commons-java (SmtpUtils, XMLProps parsers, FileCacheKey),
           thanks to @chennbnbnb on github for reporting. (mchange-commons-java)
        -- Link mchange-java-build-checkers into the build (via StringentJavaModule
           in mill plugin) to insist that overriding methods be marked @Override.
        -- "Modernize" (to circa JDK 1.5 standards) mchange-commons-java library:
           parameterize types to minimize raw-type and unchecked warnings.
        -- "Modernize" (to circa JDK 1.5 standards), both c3p0 and mchange-commons-java:
           add @Override annotations to methods that should override.
        -- Address a rare issue where forceUseNamedDriverClass is not set, but a
           driverClass name is available, and the lookup of the Driver by JDBC URL fails.
           Previously the attempt to load the driver would simply fail. Now,
           DriverManagerDataSource will fall back to trying to load the Driver class by name
           and instantiate the driver before giving up.
        -- Move refreshStatement(...), which performs potentially blocking JDBC operations,
           out of GooGooStatementCache.mainLock, to reduce contention on that lock.
        -- When we are enforcing a prohibition on simultaneous operations against any of a
           Connection's children -- typically, when statementCacheNumDeferredCloseThreads
           is set to a nonzero value -- GooGooStatementCache.closeAll( pcon ) now participates.
           It requires -- and asserts, when assertions are enabled -- that pcon be marked in-use
           before closing that Connection's Statements, and it ensures those Statements are
           closed asynchronously, once the Connection is no longer in-use. (c3p0's internal
           calls adhere to this requirement. Any independent users of GooGooStatementCache
           should verify their compliance before upgrading.)
        -- Fix latent defect in Statement cache where closeAll(conn) might have been called
           while the cache was acquiring Statements from conn. Incorporating those Statements
           would occupy cache space and prevent garbage collection of often permanently close()ed
           Connections. Where a global maxStatements is configured, such Statements
           would eventually be culled under pressure from other Connections; where only
           maxStatementsPerConnection is set, nothing would ever cull them, since culling for
           a Connection is driven by new Statements on that same Connection. In practice, this
           defect was latent within c3p0, because Statement acquisition and closeAll(...) calls
           for a single Connection are serialized under the lock of a NewPooledConnection. But
           that's fragile, and who knows, maybe someone uses the Statement cache implementation
           independently.
        -- Guard against the possibility of "dueling Statement caches", where the Statement
           cache, when it goes to a Connection intending to prepare a new PreparedStatement,
           instead receives a reference to a Statement in a different cache, which our Statement
           cache may have already encountered, and so cached itself! Insidiously, such references
           might be re-cached under different keys than when we first encountered and cached them.
           We key on a variety of characteristics beyond the Statement's SQL text, including
           result_set_type, result_set_concurrency, autogeneratedKeys, and resultSetHoldability.
           These characteristics are immutable to us, but JDBC-driver-based caches may have access
           to PreparedStatement internals, and may simply mutate these properties prior to client
           checkout (or, less charitably, ignore them), and so return a reference we have already
           seen and cached under one key, but would now be cached under a distinct key! We do not
           want to track Statements whose putatively fixed properties may be evolving unbeknownst
           to our cache, and in fact, we presume that we receive fresh Statements whenever we ask
           a Connection to prepare a Statement. Dueling Statement caches constitute a pathological
           condition from our perspective. But it's a condition that does seem to occur in the wild,
           so we need to be resilient to it! When acquiring a new Statement from a Connection, we
           now check whether the Statement we receive is already in the cache. If it is, we do not
           recache the new Statement, and we drop the Statement from the cache. It becomes from our
           perspective an uncached Statement (and per the fix just below, is marked for clean-up
           on checkin of its parent Connection). Thanks to @Devil2-O on github for observing and
           reporting the failures that led us to diagnose this condition.
        -- Fix a potential Statement leak when (1) a Statement cache is full, and so a newly
           requested PreparedStatement is returned as an uncached "overload Statement"; and
           (2) the client omits to call close() on the Statement explicitly. In this case,
           the Statement ended up neither under the management (and subject to eventual closure)
           by the Statement cache, nor marked as an uncachedActiveStatement in NewPooledConnection,
           which would have subjected it to automatic closure on check-in. In short, nothing would
           ever close() such a Statement unless and until the physical Connection behind it was
           eventually retired and culled from the Connection pool. (On Connection.close() the
           JDBC driver would clean up any unclosed Statements against the Connection.) We now
           capture such "overload Statements" as uncachedActiveStatement, so they do get close()ed
           as soon as the Connection is checked in.
        -- Some hardening of com.mchange.v2.log (in mchange-commons-java)
        -- Substantial reorganization of com.mchange.v2.cfg, including adding support for 'file:'-URL
           specified resources, which can (via pseudo-query-string config) be restricted to files
           with user-only access, and which can be required or be skippable. (in mchange-commons-java)
        -- Fix unlikely but possible thread leaks and hangs in the Statement cache, if a misbehaving
           JDBC driver returned null from a Statement producing method (rather than producing a
           Statement or throwing an Exception per the spec), or if a c3p0 pool-backed DataSource
           was close()ed, reset(), or reconfigured (many ComboPooledDataSource setters reset the
           pool) while a thread was still waiting on Statement acquisition. Although this
           issue was never observed in the wild, frozen threads would hold Connection monitors,
           so the freezes would deadlock Connection clients as well as leaking resources.
        -- Let "Claude" build a stress-testing harness (complete with instrumenting mock JDBC
           driver) to help track down rare Statement cache faults and inconsistencies.
        -- Reorganize the build, which previously was basically a direct port of an ancient ant
           build, into a build that is reliable, much simpler, and respects the mill-build philosophy.
           (With a lot of help from claude.ai, this one.)
        -- The Statement cache was clearing parameters and batches, but otherwise not resetting
           Statement state that may have been modified by prior users' activity. We now carefully
           either reset mutated Statement state, or refuse to re-cache on operations that change
           state in ways we can't reverse. Many thanks to Fredrik Jeppsson for calling attention
           to this issue!
c3p0-0.14.1
        -- Modify c3p0 to use new BeanInfoGen functionality, restoring compatability with
           Java [7,11).
        -- Modify BeanInfoGen to (optionally but by default) cache descriptors rather than
           regenerating for each call to an introspection method.
        -- Modify BeanInfoGen to log items skipped from descriptors due to API incompatibility.
        -- Modify BeanInfoGen to generate BeanInfo classes in which properties/events/methods that
           existed in the JVM under which they were generated and built, but do not exist under the
           runtime JVM are tolerate, simply omitted at runtime from BeanInfo descriptors. This fixes
           compatability with Java environments before Java 11, under whose API c3p0 and
           mchange-commons-java are currently built. (Thanks to Vlad Skarzhevskyy, @skarzhevskyy on
           GitHub, for calling attention to this issue.)
c3p0-0.14.0
        -- Update to mill 1.1.6 and fix broken support for reproducible builds via the SOURCE_DATE_EPOCH
           environment variable.
        -- Generate explicit BeanInfo classes for c3p0-defined concrete DataSource and ConnectionPoolDataSource
           implementations, which exclude "connection" and/or "pooledConnection" from introspected bean properties,
           in order to preclude attacks such as those described here: https://mogwailabs.de/en/blog/2023/04/look-mama-no-templatesimpl/
        -- Enforce a deterministic ordering on methods produced by the code generator DelegatorGenerator, in order
           to keep builds including such generated classes reproducible. (mchange-commons-java and c3p0 subclass)
        -- Define BeanInfoGen, a code-generation utility that defines explicit BeanInfo
           classes for what otherwise would have been introspected via JavaBean naming conventions, but that
           permits properties to be excluded from such introspection. (mchange-commons-java)
        -- JavaBeanObjectFactory now enforces a whitelist of classes it is willing to construct from References
           that call upon it. That whitelist is defined by new config parameter
           com.mchange.v2.naming.referenceableJavaBeanClassWhitelist (mchange-commons-java)
        -- Define false-biased config security key com.mchange.v2.naming.allowIndirectSerializationViaReference,
           disabling by default indirect serialization/deserialization of Referenceable but otherwise not
           serializable objects by serializing their references. This is a clever mechanism, but rarely used,
           and a place where attackers might smuggle a malicious reference. (mchange-commons-java)
c3p0-0.13.0
        -- Ensure sessions are marked as endRequest() is called prior to check-in, to eliminate
           race between DBMS cleanup and checkout by a new client. Thanks Krrish (@ota0912 on github).
        -- Take generic JavaBeanObjectFactory out of the whitelist of object factories,
           com.mchange.v2.naming.objectFactoryWhitelist, mchange-commons-java ReferenceableUtils
           is willing to dereference. Only C3P0JavaBeanObjectFactory should be used.
        -- Modify C3P0JavaBeanObjectFactory to use C3P0JavaBeanReferencePropertyOverrider.
        -- Modify the JavaBeanReferenceMaker employed by c3p0 beans to use C3P0JavaBeanReferencePropertyOverrider
        -- Define C3P0JavaBeanReferencePropertyOverrider, supporting the serialization and deserialization
           of user-defined config key value pairs (the 'extensions' property)
        -- Add support for extensions, in the form of JavaBeanReferencePropertyOverrider, that
           allow javax.naming.Referenceable JavaBeans that include non-String, non-coerceable-to-string,
           non-SecurelyStringifiable properties to use some custom serialization to a Reference.
           Add support both the JavaBeanReferenceMaker and JavaBeanObjectFactory for supporting
           such extensions.
        -- Replace with a CSV format internal use of Java serialization by JavaBeanObjectFactory
           and JavaBeanReferenceMaker when tracking reference properties. [in mchange-commons-java]
        -- Eliminate support for decoding BinaryRefAddrs via Java (de)serialization in
           JavaBeanObjectFactory. The capability still exists, but one must explicitly
           extend JavaBeanObjectFactory in order to support it. No existing classes in
           c3p0 or mchange-commons-java now use Java serialization to unpickle objects
           from References.
        -- Add support for SecurelySerializable to c3p0's code-generated bean superclasses,
           and to the concrete derived beans as well.
        -- Define CsvSecurelyStringifiableBeangenGeneratorExtension to enable code-generated Java beans
           that support the new SecurelyStringifiable alternative serialization  [in mchange-commons-java]
        -- When generating references with JavaBeanReferenceMaker, gate use of Java-serialization
           to define properties behind a new false-biased configuration parameter,
           com.mchange.v2.naming.generateSerializedObjectBinaryRefAddr. (This should almost
           never be reset to true.) [in mchange-commons-java]
        -- Define in com.mchange.v2.naming a SecurelyStringifiable mechanism, intended
           to replace the use of dangerous Java serialization in the construction of
           references [in mchange-commons-java]
c3p0-0.12.0
        -- Replace com.mchange.v2.naming.permitNonlocalJndiNames with more configurable
           com.mchange.v2.naming.nameGuardClassName. By default, it is null, and the same
           "apparently local" restriction previously enforced by com.mchange.v2.naming.permitNonlocalJndiNames
           is enforced. But users can supply custom com.mchange.v2.naming.NameGuard instances
           to control what names are permissible, and four implementations of NameGuard are
           provided. (See the main docs.)
        -- Documentation updates.
        -- Disable by default reflective instantiation of javax.naming.spi.ObjectFactory instances
           unless their classname is included on a whitelist. Define properties-style config parameter
           com.mchange.v2.naming.objectFactoryWhitelist where the comma-separated whitelist can be provided.
           By default this parameter contains the two ObjectFactory classes c3p0 includes in references it
           creates.
        -- Change the format of userOverridesAsString, which is just a String representation of
           Map<String,Map<String,String>>. Use a CSV-inspired format, and the mchange-commons-java
           fastcsv utility, rather than dangerous Java Object serialization of the Map of Maps.
        -- Disable by default support for resolving references serialized with their own InitialContext
           custom environment. Define properties-style config parameter
           com.mchange.v2.naming.acceptDeserializedInitialContextEnvironment, defaulting to false,
           to manage this dangerous functionality.
        -- Disable by default JNDI lookups of nonlocal names (conservatively, names that do not seem to be local).
           For now only String names beginning with "java:" or Name objects whose first component starts with
           "java:" are considered to be local.
           Define properties-style config parameter com.mchange.v2.naming.permitNonlocalJndiNames, defaulting
           to false, to manage this dangerous functionality.
        -- Disable by default support for loading of javax.naming.spi.ObjectFactory from remote locations
           via Reference.factoryClassLocation. Define properties-style config parameter
           com.mchange.v2.naming.supportReferenceRemoteFactoryClassLocation, defaulting to
           false, to manage this dangerous functionality.
        -- Fix rare issue in Statement caching (GooGooStatementCache), make sure any Statement
           we remove is checked into the cache in order to ensure we don't see internal inconsistencies
           when Statements we mean to cull fail to be removed by removeStatement(...) because they
           are checked out. Thanks to @vimalesh on GitHub for calling attention to this issue.
c3p0-0.11.2
        -- Expose utilities `overwriteJavaBeanProperties` and `overwriteC3P0PrefixedProperties`
           in the `DataSources` class, and refactor existing functions to use those.
c3p0-0.11.1
        -- in BasicResourcePool, forceKillAcquires() accidentally failed to surrender its lock,
           leading to deadlocks following a full round of acquisition failures. Many thanks
           to @pwielgolaski on github for tracking down the issue, to @driseley on github for
           providing a reproduction of the issue, and to @michalgutkowski on github for providing
           a pull request with the fix.
c3p0-0.11.0
        -- Additional testing.
c3p0-0.11.0-pre2
        -- Define new property cancelAutomaticallyClosedStatements, which, if true, ensures
           that Statement.cancel() will be called prior to Statement.close() when c3p0 automatically
           close()es statements because a client has neglected to, a Connection with open Statements
           has exceeded its unreturnedConnectionTimeout, or the Statement cache is expiring a PreparedStatement.
           Thanks to Andreas Dangel (in 2014!) for pointing out scenarios where this might be
           helpful, and offering a PR demonstrating the basic fix, and Luis Paolini for reminding me
           that I flaked 11 years ago and this is still worth pursuing.
c3p0-0.11.0-pre1
        -- Rewrite BasicResourcePool and GooGooStatementCache in terms of
           ReentrantLock and Condition.{await/signalAll} rather than native
           monitors and wait()/notifyAll(), because wait() pins loom
           virtual threads. Many thanks to alex-kormukhin for calling
           attention to this issue and proposing the fix!
        -- Double check after termination of BasicResourcePool.awaitAvailable(...)
           that following notification/termination a resource (Connection) remains
           available. Many thanks to @C3Stones and @xtb359 on github for calling
           attention to this issue.
        -- Prevent fragility under non-bootstrap / non-system CLASSLOADERs under
           Java 8, where references to java.sql.ShardingKey not available under Java 8
           provoke NoClassDefFoundError. Bifurcate Connection proxies, generate
           version without sharding key methods under JVMs where ShardingKey is unavailable,
           full JDBC 4.3 Connection API proxies where ShardingKey is present.
           Thanks to "Force Rs" on github for finding the issue and suggesting the
           solution!
c3p0-0.10.2
        -- Prevent freeze due to re-waiting if a non-Exception Throwable occurs
           while acquiring a PreparedStatement to cache. Thanks Totyo Totev!
c3p0-0.10.1
        -- Implement more and "louder" (log ugly stack traces) validation of
           config properties.
        -- Modify former InUseLock (now InternalUseLock) and NewProxyConnection
           to use ReentrantLock rather than native monitors, to prevent pinning
           when clients run on loom virtual threads.
           Thanks Alex Kormukhin and Jeffrey Tucker!
        -- Implement config parameter markSessionBoundaries, so that users can
           disable JDBC 4.3 beginRequest / endRequest session boundary marking
           when JDBC drivers so undesirable things with those hints.
           Thanks Bikas Anand!
        -- Implement more careful examination of begin/endRequest methods, to take
           into account the case where those methods exist on the JDBC driver Connection
           implementation, but not in the Connection interface of a pre-Java-9 JVM.
           We still support begin/endRequest in this case, but reflectively.
           Thanks Vlad Skarzhevskyy, khushboo11-dotcom!
c3p0-0.10.0
        -- A bit more testing
c3p0-0.10.0-pre7
        -- Improve performance of begin/endRequest support
        -- Implement c3p0-loom UninstrumentedVirtualThreadPerTaskTaskRunnerFactory
        -- Change mind. Eliminate naggingly prescriptive equals/hashCode pseudorequirements
           from plugin interfaces, because our canonicalization strategy is by key, doesn' actually
           rely upon those implementations.
        -- Guard collection of MBeanAttributeInfo against items that would have no getter
           or setter to prevent ugly IntrospectionExceptions.
           See https://github.com/swaldman/c3p0/issues/128
           Thanks @philippscs!
        -- Let C3P0PooledConnectionPool manager test introspected authentication that appears
           perhaps incomplete, and revert to NULL_AUTH (no-arg DataSource.getConnection()) if
           the test fails.
           See, should address, https://github.com/swaldman/c3p0/issues/159
           Thanks @sbaeumlisberger!
c3p0-0.10.0-pre6
        -- Lots of documentation work.
        -- Implement attemptResurrectOnCheckin config parameter.
           See https://github.com/swaldman/c3p0/issues/47
           Thanks Bartosz Radaczyński and Igor Khromov!
        -- Add guard to automaticTestTable preventing use of weird or potentially malicious table names.
           Thanks to Andy at Privitar
        -- Pick up com.mchange.v2.c3p0.impl.DefaultConnectionTester.isValidTimeout as default
           value of new connectionIsValidTimeout property, so that users upgrading from previous
           version still capture the setting from the old config, even as their ConnectionTester
           now falls back to null.
c3p0-0.10.0-pre5
        -- Lots of documenting, condensing, clean-up, etc.
        -- Define connectionIsValidTimeout as an ordinary bean-style config parameter.
           Previously users had to set a universal property (in c3p0.properties or System
           properties) to set this timeout.
        -- Use simplified isValid(...) based timeout by default, use traditional
           ConnectionTester logic only when users specify or force a ConnectionTester
c3p0-0.10.0-pre4
        -- Define (in a separate, Java 21, project) a loom virtual-threads based
           TaskRunnerFactory, VirtualThreadPerTaskExecutorTaskRunnerFactory.
           See https://github.com/swaldman/c3p0-loom
        -- DefineFixedThreadPoolExecutorTaskRunnerFactory, a simple example that
           replaces c3p0's traditional Thread pool with an unshared ThreadPoolExecutor
           of size numHelperThreads.
        -- Define AbstractExecutorTaskRunnerFactory, which users can extend to use or
           share java.util.concurrent.Executor instances rather than c3p0's traditional
           hand-rolled Thread pool.
           See https://github.com/swaldman/c3p0/issues/76
               https://github.com/swaldman/c3p0/issues/41
           Thanks Michele Rossi, and mysterious GitHub @ghost.
        -- Define TaskRunnerFactory, and config param TaskRunnerFactoryClassName.
           Users can provide implementations of TaskRunnerFactory with a public no-arg
           constructor to take full control of threading, thread-pooling, etc.
        -- Support SOURCE_DATE_EPOCH for deterministic builds.
           (Here and in mchange-commons-java.)
           See https://github.com/swaldman/c3p0/issues/163
               https://reproducible-builds.org/docs/source-date-epoch/
               https://github.com/swaldman/mchange-commons-java/commit/09480482ddde70b98baf8437e66c5e3bba9ae3e2
           Thanks Bernhard M. Wiedemann!
        -- Eliminate support for traditional reflective proxies.
        -- Fix bad anchor in docs, thanks Hakan!
        -- Relicense to allow users to opt for LGPL-2.1 or later, rather than LGPL-2.1-only.
           (Here and in mchange-commons-java.)
           See https://github.com/swaldman/c3p0/issues/133
           Thanks Bernhard E. Reiter!
        -- Update to mchange-commons-java 0.3.0
c3p0-0.10.0-pre3
        -- Have build fail if we try to build with an unexpected JVM version.
           We want to use a consistent JVM version (currently 11) and target version (currently 7)
           when we build c3p0.
        -- Remove vestiges of unsupported BasicResourcePool.AcquireTask
        -- Disable very slow handholding function intended to help with misspellings / misspecifications
           of resource "/c3p0-config.xml"
           See https://github.com/swaldman/c3p0/issues/121
           Thanks chinhodado!
        -- Let PooledDataSource implement AutoCloseable.
           This necessitates targeting Java 7, rather than Java 6, classfiles.
           Thanks koszta5!
        -- Bring documentation of acquireRetryAttempts into sync with c3p0's actual behavior.
           See https://github.com/swaldman/c3p0/issues/132
           Thanks marcatl, MichaelMih, Leona Nezvalova!
        -- Include license files in published source jar.
           (Here and in mchange-commons-java.)
           See https://github.com/swaldman/c3p0/issues/167
c3p0-0.10.0-pre2
        -- Add "Automatic-Module-Name" entry to jar manifest for interoperability with Project Jigsaw / Java 9 modules
           See https://github.com/swaldman/c3p0/issues/171
           Thanks Jörg Hohwiller
        -- Try context ClassLoader if library ClassLoader fails to load a named, necessary driver class.
           See https://github.com/swaldman/c3p0/pull/115
           Thanks Rodrigo Merino!
        -- Let statement cache fail not-quietly if drivers provide PreparedStatements without a proper equals implementation.
           See https://github.com/swaldman/c3p0/pull/59/
           Thanks Thomas Beckmann!
        -- Be slightly less negative in the docs about unreturnedConnectionTimeout.
           See https://github.com/swaldman/c3p0/pull/160
           Thanks Matteo Mazza!
        -- Implement more robustly accurate checkoutTimeout.
           See https://github.com/swaldman/c3p0/pull/138 https://github.com/swaldman/c3p0/issues/137
           Thanks François JACQUES!
        -- Add support for JDBC 4.3 beginRequest and endRequest methods.
           See https://github.com/swaldman/c3p0/pull/170
           Thanks Fernanda Meheust!
        -- Consider ourselves to be a wrapper for a thing if the thing we wrap itself declares itself
           as the wrapper of that thing. See https://github.com/swaldman/c3p0/pull/149
           Thanks François JACQUES!
        -- Fix rare ConcurrentModificationException in GooGooStatementCache when Connections are
           closed. See https://github.com/swaldman/c3p0/pull/22
           Thanks Mathilde Ffrench, Joel Caplin!
c3p0-0.10.0-pre1
        -- Fix doc comments no longer acceptable under persnicketty JDK 11
        -- Build with JDK 11 JVM (still emitting JDK 1.6 compatible sources)
        -- Get tests working under new mill build
        -- Reorganize to switch build from ant to mill
        -- Update to mchange-commons-java 0.2.20
c3p0-0.9.5.5
        -- Update docs to describe new com.mchange.v2.log.MLog.useRedirectableLoggers setting, implemented
           in mchange-commons-java 0.2.19
        -- Update to mchange-commons-java 0.2.19
        -- Properly implement the JDBC 4.1 abort method. Thanks to Andrew Johnson for calling attention
           to this issue.
c3p0-0.9.5.4
        -- Disabling entity expansions, as we did in v.0.9.5.3 turns out not to be sufficient to prevent all
           XML-config parsing related attacks (if an attacker can control the XML config file that will be
           parsed). We now make XML parsing much more restrictove by default, but allow users to revert to the
           old, permissive pre-0.9.5.3 behavior by setting config property 'com.mchange.v2.c3p0.cfg.xml.usePermissiveParser'
           to true. That property replaces and leaves deprecated the 'com.mchange.v2.c3p0.cfg.xml.expandEntityReferences'
           property introduced on 0.9.5.3. Many thanks to Aaron Massey (amassey) at HackerOne for calling attention
           to the continued vulnerability of XML parsing to these kinds of attacks.
        -- Address situation where a throwable during forceKillAcquires() left the force_kill_acquires flag
           set to true, making it impossible for the pool to restart acquisition attempts on recovery. We
           now unset the flag under any circumstance, but log interrupts or unexpected throwables, and make
           a best effort to complete the intended expiration of waiting clients by throwing InterruptException
           Many thanks to Stefan Cordes (@rscadrde on github), Vipin Nair (@swvist on github), and Łukasz Jąder
           (@ljader on github) for their work on this issue.
c3p0-0.9.5.3
        -- Address CVE-2018-20433, https://nvd.nist.gov/vuln/detail/CVE-2018-20433 re liberal parsing of
           XML config. By default, c3p0 no longer expands entity references in XML config files. This
           behavior can be overridden via config property 'com.mchange.v2.c3p0.cfg.xml.expandEntityReferences'
           by applications that understand the security concerns but wish to make use of entity references.
           Thanks to user @zhutougg on GitHub for calling attention to and suggesting a fix for this issue.
        -- Upgrade dependency to mchange-commons-java 0.2.15, which includes support for log4j2 (implemented
           in mchange-commons-java by GitHub user @fireandfuel. Many thanks!)

c3p0-0.9.5.2
        -- Fix a bug in MLog bridge to slf4j logging, in which loggability of levels of wrapped loggers
           was misreported, leading to useless allocation of log Strings below the logging threshold. Grr.
           [change is in mchange-commons-java 0.2.11]. Many thanks to Lewis Wong on Stack Exchange for calling
           attention to this issue.
        -- Embed last acquistion failure as nested Exception in CannotAcquireResourceException. Thanks to
           @nigam on github for this addition.
c3p0-0.9.5.1
        -- Implemented configuration property com.mchange.v2.c3p0.impl.DefaultConnectionTester.isValidTimeout
           to define timeouts on tests based on Connection.isValid(...). Many thanks to @james-hu on github
           for suggesting this.
        -- Added a forceSynchronousCheckins config param, which can be a significant performance boost
           if no tests are performed on checkin and no long work is performed in ConnectionCustomizer.onCheckIn(...).
           The parameter is particularly useful for installations in which the Thread pool is under stress,
           as it permits prompt checkins without use of the Thread pool, and helps reduce Thread pool congestion.
           Many thanks to Vamsi Krishna for calling attention to this issue.
        -- Removed embarrassingly frivolous nested locking in C3P0Registry which provoked rare deadlocks
           when users lookup extensions. Many thanks to Vlad Skarzhevskyy for calling attention to this
           issue.
        -- ScatteredAcquireTask now tests to see if a BasicResourcePool has already been closed before
           attempting an acquisition. Thanks to @kenicky on github for calling attention to this issue.
c3p0-0.9.5
        -- Fixed small typo in log message, thanks Jaran Nilsen
        -- DriverManagerDataSource: Added synchronization missing for the very rare case of an on-the-fly
           reset of 'driverClass'; minor optimization, properly marked driver class loaded if an instantiation
           of the driver has succeeded.
c3p0-0.9.5-pre10
        -- Removed support for try-with-resources (implementation of marker interface java.lang.AutoCloseable)
           as it breaks Java6 support. I'll save it for 0.9.6 (unless I get a lot of complaints).
           Thanks again to @dwscott on github.
        -- Added config parameter com.mchange.v2.c3p0.management.ExcludeIdentityToken that allows users to
           have c3p0 generate predictable, reproducible full JMX ObjectNames (at the cost of extra user
           responsibility in ensuring the uniqueness of those names). Updated and expanded documentation
           with respect to JMX support. Thanks to @dwscott on github for suggesting this improvement.
c3p0-0.9.5-pre9
        -- In mchange-commons-java, modified log library to consider slf4j library unfound if it gets bound to its
           no-op ('NOP') back-end.
        -- Gave proxies a toString() method that embeds the toString() method of the objects they are wrapping, including
           Statement text if the underlying driver supports that. Thanks to Ketan Padegaonkar for the suggestion.
        -- Added API [in mchange-commons-java] to make it easier for users to create a MultiPropertiesConfig object from a
           Properties object, which will enable use of the new C3P0Config.refreshMainConfig( overrides, overridesDescription )
           method, which may enable some useful dynamic configuarion possibilities, see e.g. https://sourceforge.net/p/c3p0/bugs/121/
           Thanks to Vlad Skarzhevskyy on SourceForge for the proposed use case.
        -- Modified mchange-commons-java (and c3p0 docs) to prioritize slf4j over log4j if both are available in the application
           classpath and com.mchange.v2.log.MLog has not been explicitly set. Thanks to Steve Ramage for the suggestion.
        -- If a problem occurs while acquiring a cached Statement from the Statement pool, the Exception we throw includes
           both the actual problem (which occurs in a helper thread) and the stack trace of the client which provoked the
           failed acquisition. The problem that occurred within the helper thread is captured as the root cause Throwable.
           Many thanks to Michele Rossi for the suggestion.
        -- Finally wrapped StackOverflowError that comes in the rare, pathological case when every attempt to checkout
           a resource fails some test or check until eventually recursive retries blow the stack. A NoGoodResourcesException
           is now thrown in this case. Thanks to @Ibenda on github for calling attention to the issue (and others annoyed by
           it long ago). [Note: The StackOverflowError remains accessible, wrapped as the root cause Exception. So I expect
           continuing bug reports / complaints about a StackOverflowException from users who don't notice it is caught and
           handled.]
        -- Some documentation updates and fixes.
        -- Made PooledDataSource AutoCloseable, so that try with resources can be used to clean up after them.
        -- Added some warnings in BasicResourcePool's constructor if min, max, and start are misordered.
           Misordered values are reordered. Thanks to @bronzenose on github for the suggestion.
        -- Overloaded AbstractPoolBackedDataSource / AbstractComboPoolBackedDataSource toString,
           so we've a toString( boolean show_config ). The full reflective config is now shown only when logging
           pool manager initialization. Otherwise we revert to a fast, nonreflective toString(). We'll see whether anyone
           minds the abbreviation. Thanks to @kibertoad and @Xerosigma on github for the suggestion.
        -- Fixed implementations of wrap( ... ) / isWrapperFor( ... ) to properly conform to spec when given an interface implemented
           directly by the receiver of the wrap( ... ) call. Many thanks to @baracil on github for calling attention to this issue.
c3p0-0.9.5-pre8
        -- Resolved a Serialization problem introduced in c3p0-0.9.5-pre7 (Broke serializability of DefaultConnectionTester
           and therefore typical instances of WrapperConnectionPoolDataSource.) Many thanks to Petar Tachiev for calling attention to this issue.
        -- [in mchange-commons-java] Fixed a latent issue where decoding of JNDI References would fail if the Object factory
           was not loaded by the System ClassLoader. (This issue was revealed when Serialization failures provoked fallback
           to a Reference Serialization strategy.) Many thanks to Petar Tachiev for calling attention to this issue.
c3p0-0.9.5-pre7
        -- Cleaned up (and exposed a configuration property to tweak) selection of Connection tests when
           no query is provided. Do we use Connection.isValid(...), the traditional DatabaseMetaData-based test,
           something else? Now, by default we try isValid(...) but we back-off to the traditional test on error.
           But this behavior is configurable via the property 'com.mchange.v2.c3p0.impl.DefaultConnectionTester.querylessTestRunner'
           (which is documented with 'Other Properties').
        -- Added config parameter 'forceUseNamedDriverClass', which ensures that an instance of the class named in
           'driverClass' is used as the JDBC driver, rather than simply preloading the named class and then
           relying upon DriverManager to determine which driver to use. Thanks to Martin Coene and meinc on SourceForge
           for calling attention to this issue.
        -- We now support the parentLogger property of DataSources (rather than just throwing an SQLFeatureNotSupportedException).
           This should resolve the issue identified by Maarten Coene (thanks!), where JMX clients repeatedly see
           Exceptions as they try to read the parentLogger property.
        -- [in mchange commons java] MLog levels WARNING and SEVERE were misordered due to bad copy/paste of
           the integer value of levels. Many thanks to Martin Coene for discovering and tracking down the problem.
        -- [in mchange commons java] An error in MLog logging to log4j caused an IllegalArgumentException
           at log level OFF. This problem was identified and fixed by Sebastian Baumhekel
        -- [in mchange commons java] Defines a jdk14logging ForwardingLogger that adapts MLog Loggers into
           JDK14 (java.util.logging) Loggers
        -- Unused resources cleaned up on BasicResourcePool close() are properly added to the formerResources
           WeakHashMap, to prevent multiple checkins of those resources from triggering foreign resource warnings.
           Thanks again to Brett Wooldridge for calling attention to this issue.
        -- Guarded marking of transactions as maybe dirty in Statement proxies, so that they don't trigger NPEs
           then Exceptions for illegal operation on a closed Connection for methods like Connection.isClosed.
           Many thanks to Brett Wooldridge for calling attention to this issue.
        -- Prevent JMX clients from updating properties on underlying pools (and therefore potentially
           triggering a wind-down / reconstruction of internal pools) if the new value of the property
           is the same as the original value. Thanks to ask-dev on Stack Overflow for calling attention
           to this issue.
        -- Guard against case where connectionCustomizerClassName is an empty or blank String.
           Thanks to ask-dev on Stack Overflow for calling attention to this issue.
        -- Fixed typos is docs where testConnectionOnCheckout and testConnectionOnCheckin
           erroneously included excess capital letters, testConnectionOnCheckOut and testConnectionOnCheckIn.
           Thanks to Usman Mutawakil for finding and reporting this issue.
        -- For drivers that support JDBC4 Connection.isValid(), this becomes the default
           Connection test if no preferredTestQuery / automaticTestTable is specified.
           HOWEVER, for older drivers that do not support Connection.isValid(), the already
           slow default test becomes EVEN SLOWER than its already legendary slowness. If
           you are using a driver that you know supports Connection.isValid(), you can skip
           setting preferredTestQuery or automaticTestTable. But if you are not sure, better
           set one of these or endure painfully slow tests.
c3p0-0.9.5-pre6
        -- Fixed a rare problem caused when some JDBC drivers are simultaneously autoloaded
           on initialization of DriverManager.class and by DriverManagerDataSource.
           DriverManagerDataSource's class init now preloads DriverManager.class
        -- Fixed a ClassCastException in some codepaths of BasicResourceFactory construction.
           Thanks to petrjanata on SourceForge for reporting and tracking down the issue.
        -- Modified mlog logging library to permit dynamic refresh if config (again, for
           integration with dynamically-reloading appservers).
        -- Refactored C3P0Config to permit refreshing of config information on-demand at
           runtime, plus imposing overrides. (This is in preperation for integration with
           application servers, whose native config files might be used to configure c3p0,
           and might change more frequently than a VM or ClassLoader recycle).
        -- Improvements to loading of resources for hocon/typesafe-config. We now properly
           load and merge multiple resources (if found), and use typesafe conventions for
           merging xxx.conf, xxx.json, and xxx.properties files. [mchange-commons-java]
        -- Cleaned up reflection of default properties, such that only coercible properties
           get Stringified (since Stringifying non-coercible properties render them useless
           for setting as bean params), and to eliminate treating C3P0Defaults.getKnownProperties
           as itself a default. Many thanks to @wuSam on github for exercising the library in an
           unusual way and revealing these issues.
c3p0-0.9.5-pre5
        -- Made JMX names of C3P0Registry customizable via the config property
           'com.mchange.v2.c3p0.management.RegistryName', so that multiple installations/ClassLoaders
           can be managed by a single MBean server. Many thanks to Vlad Skarzhevskyy for
           calling attention to this issue.
        -- Fixed a rare Connection leak in WrapperConnectionPoolDataSource that occurs
           when Connection acquisition succeeds but construction of a PooledConnection
           to wrap it fails with an Exception. Many thanks to Edward Chan for reporting
           the issue.
        -- Fixed an error introduced in the 0.9.2 series, which caused MBeans
           for PooledDataSources to be unregistered on close() under names different
           from that under which they were registered, creating a memory leak.
           Many thanks to Vlad Skarzhevskyy for reporting this issue.
c3p0-0.9.5-pre4
        -- Updated documentation with user-defined configuration extensions and
           information on how to define named configuration, per-user overrides,
           and user-defined extensions in all three supported config file formats.
        -- Implemented user-defined configuration extensions.
        -- Implemented properties file and HOCON definition of named configurations
           and per-user overrides.
        -- Added privilegeSpawnedThreads config parameter, mostly to detach caller's
           AccessControlContext from Threads that provoke the init, to prevent references from
           c3p0 Threads to app server (esp tomcat) ClassLoaders that ought to be garbage-
           collectable on hot undeploy. Might also be useful for helping c3p0 run from less
           trusted code, although that has not come up yet. Thanks to Claudio D'angelo for
           calling attention to the issue.
        -- Added new config parameter 'contextClassLoaderSource', which can be set to one of
           'caller', 'library', or 'none'. By default, the Thread that provokes pool initialization
           passes its ContextClassLoader to c3p0-spawned Threads, which makes it impossible to garbage
           collect those classloaders in e.g. application server undeploys. Setting this parameter to
           'library' (rather than the default 'caller') forces c3p0-spawned Threads to use the
           ClassLoader that loaded c3p0 as the contextClassLoader.
        -- clone() System.getProperties() when reading config, to avoid potential
           ConcurrentModificationExceptions if other Threads are messing with System properties.
           Thanks Keith Amling! [mchange-commons-java]
        -- Access to EncounterCounter in C3P0ImplUtils ought to have been synchronized. It was
           not. Fixed, by placing the counter underneath an sync'ed wrapper. Many thanks to
           Keith Amling and Dan Berindei for calling attention to this issue.
c3p0-0.9.5-pre3
        -- For reasons that remain obscure, the published build of c3p0-0.9.5-pre2 is missing
           JDBC4 methods (many thanks to @edysli on github for pointing this out). Apparently
           it was accidentally built against JDBC3 libraries. Added a compile-time check
           for JDBC4 api in generated code to C3P0ImplUtils.
        -- Divided ComboPooledDataSource into final implementation class and an abstract class
           which can be extended to derive debugging filters. Created two such filters,
           com.mchange.v2.c3p0.debug.AfterCloseLoggingComboPooledDataSource and
           com.mchange.v2.c3p0.debug.CloseLoggingComboPooledDataSource
        -- C3P0PooledConnectionPool destroyResource() calls are now protected by in-use resource
           locks to prevent rare deadlocks during simultaneous test / destroy.
        -- HOCON resources are now loaded as a single group, so that resolution of substitutions
           works across multiple files.
        -- Fixed bug in HOCON support where files that include substitutions like ${myScope.varName}
           would throw a ConfigException.NotResolved. These substitutions are now resolved. Many thanks
           to Stjepan Buljat for calling attention to this issue.
        -- Support standard HOCON config files application.properties and application.json as well
           as application.conf
        -- Fixed ClassCastException when (now deprecated!) usesTraditionalReflectiveProxies is set to
           true. Many thanks to Konrad Garus for reporting the issue.
        -- NewProxyConnectionGenerator has been modified so that Connections only mark transactions
           as known-resolved after the putatively resolving operation has successfully completed,
           rather than when it is merely attempted.
        -- With FINEST/TRACE debug logging, full JVM stack traces are now emitted during any
           ThreadPoolAsynchronousRunner APPARENT DEADLOCKS, to help debug any deadlocks within the JVM.
        -- Made constructors of delegated proxies package-visible rather than public. Many thanks to
           Oliver Zemann for calling attention to this issue.
        -- Some fixes and improvements to cfg and log libraries, so that fewer superfluous warnings
           get emitted on startup.
c3p0-0.9.5-pre2
        -- Modified unwrap / isWrapperFor methods in proxies to be more permissive, to accept class
           objects for superinterfaces of the wrapped interface as well as of implementation
           classes.
        -- Added support for SLF4J / logback logging, defined short aliases for adapters to
           the various logging libraries, updated documentation with new logging features
        -- Added and documented HOCON / typesafe-config libary support, available if (and only if)
           the typesafe-config library is included with the application.
        -- Refactored mchange-commons-java to eliminate very rare potential deadlocks under simultaneous
           ClassLoading of file in cfg and log packages, and defined a facade into the cfg library use of
           which should eliminate the possibility of such deadlocks if it is used assiduously.
        -- actually documented 'com.mchange.v2.log.jdk14logging.suppressStackWalk'. i said i had earlier
           but apparently not
        -- set 'com.mchange.v2.log.jdk14logging.suppressStackWalk' to true by default in mchange-commons-java
c3p0-0.9.5-pre1
        -- Included 'com.mchange.v2.log.jdk14logging.suppressStackWalk' in c3p0 docs.
        -- In mchange-commons: Added a config property for jdk14 logging users:
           'com.mchange.v2.log.jdk14logging.suppressStackWalk' allows clients to speed up logging
           by suppressing analyzing the stack trace for the caller. (Only the name of the logger will
           be given.)
        -- Modified DataSource to include an (unsupported) getParentLogger() method for JDK7 builds
        -- Handle JDBC4 Connection.isValid properly
        -- Lots of updates to get c3p0 to proxy and compile JDBC4
        -- Removed some jdk14 support stuff from build.properties
c3p0-0.9.2.1
        -- Dual licensed c3p0, LGPL v.2.1 and EPL 1.0. Modified license files, source headers, etc.
c3p0-0.9.2
        -- Updated documentation re hibernate configuration. (Documentation was several years stale.)
        -- Merged John Sumsion's remarkable integration of c3p0's full SourceForge history into the
           git repository. (Enormous, huge thanks to John Sumsion!)
c3p0-0.9.2-pre8
        -- Added logging (at level FINE, in com.mchange.v2.c3p0.impl.C3P0PooledConnectionPoolManager) when
           a pool is initialized for a new authentication within a DataSource.
        -- We now allow users to place an XML formatted config file in arbitrary locations under
           the classpath (i.e. as ClassLoader resource), including jar file META-INF directories.
           If the config property com.mchange.v2.c3p0.cfg.xml begins with "classloader:", the remainder of
           the String will be interpreted as a ClassLoader resource path. Thanks to Sam Razialruh for
           suggesting this feature.
        -- In DataSources.pooledDataSource( DataSource unpooledDataSource, Properties props ), switched
           from using keySet().iterator() to the propertyNames() Enumeration to properly capture keys
           set in the Properties object's defaults. Thanks to Jisakiel in SourceForge for calling attention
           to this issue.
        -- Modified DelegatorGenerator [in mchange-commons-java] to delegate reflectively at
           runtime via the main delegation interface (by default, and in c3p0's proxies), rather
           than via the runtime class, which may not be public. (Added a bit of API to DelegatorGenerator
           so that users can specify whether reflective delegation should be via the main
           delegation interface, some other expected superclass or interface, or the actual
           runtime class.) Many thanks to Kiran Kollipara for pointing out the risk of IllegalAccessExceptions
           under the previous implementation.
c3p0-0.9.2-pre7
        -- Added hooks [in mchange-commons-java] to com.mchange.v2.codegen.intc.DelegatorGenerator
           to permit reflective delegation of methods not declared by the main interface. Added
           some unproblematic JDBC4 methods to generated PreparedStatement proxies in order (hopefully)
           to workaround hibernate issues. (see https://hibernate.onjira.com/browse/HHH-7801 and
           https://hibernate.onjira.com/browse/HHH-7778 )
        -- Added some extra logging (at level FINER [or DEBUG] to NewPooledConnection, in hopes
           that it will be helpful in tracking down Exceptions that occur during automatic cleanup
           of unclosed Statements and ResultSets.
c3p0-0.9.2-pre6
        -- Added some logic that continues to enforce sequential (i.e. nonsimultaneous) use of
           PooledConnections in Connection tests, without requiriing Threads to use NewPooledConnection's
           lock. Clients of NewPooledConnection should not hold its lock directly, to avoid
           potential deadlocks due to Connection eent handlers. [Many thanks to Jan Zuchhold
           for calling attention to this problem.]
        -- Added a DEBUG STACK TRACE at log level FINEST in BasicResourcePool for tracking the cause
           of resource exclusion.
        -- Added a README.md file for github.
        -- Updated documentation to include dataSourceName as a config parameter, and to describe
           its use in generating stable JMX identifers.
        -- Made dataSourceName a first-class config parameter, configurable in all the usual ways,
           to help support its use for stable JMX names.
        -- Included (excellent, very lightweight) patch by Bryan Varner [ https://github.com/bvarner ]
           that includes the property dataSourceName in the registered name of c3p0
           JMX mbeans. As Varner writes, "This allows you to query mbeans by stable name patterns,
           allowing for reliable instrumentation via JMX between VM instances." Many thanks
           to Bryan Varner.
        -- Updated RELEASE_NOTES
c3p0-0.9.2-pre5
        -- Some fixes of issues with per-user config overrides, verified and
           updated docs with respect to per-user configs.
        -- Unsynchronized access to identityToken in the various identityTokenized
           beans, marking the property volatile instead. This should resolve an
           occasional deadlock. Many thanks to Phillip Henry, see
           https://sourceforge.net/tracker/?func=detail&atid=383690&aid=3552097&group_id=25357
        -- Fixed a bug whereunder PoolBackedDataSources threw an Exception
           trying to bind per-user overrides that properly should be bound
           only to WrapperConnectionPoolDataSource (or to ComboPooledDataSource,
           which wraps that). Many thanks to Walter Marcelo Pedrozo Barboza
           for calling attention to this issue.
        -- Factored out VMID generation into mchange-commons-java.
c3p0-0.9.2-pre4
        -- Fixed broken version on Maven dependency to mchange-commons-java.
           Version was hardcoded, now uses version number that c3p0 was built
           against.
c3p0-0.9.2-pre3
        -- Added workaround for bug in Maven 2.2.1 that sometimes leads to corruption
           of deployed artifacts. See http://jira.codehaus.org/browse/MNG-4301
        -- Eliminated bead RELEASE suffix from use in staging to Maven repository,
           which should fix managed dependency problems for Maven users.
        -- Required tests of PooledConnections to own the locks associated with those
           PooledConnections in order to prevent occasional deadlocks when PooledConnection.close()
           coincides with a Connection test. Many thanks to an anonymous SourceForge user for
           calling attention to this issue.
c3p0-0.9.2-pre2
        -- Added support for deployment to Maven central repository to build.xml,
           and noted this version's coordinates in the repository.
        -- Added a src directory to the distribution, containing jarred java
           sources (including codegenerated sources) intended for debuggers/IDEs.
           As a convenience, mchange-commons-java sources are included as well.
        -- Fixed issue where idle Connections being tested by the pool
           were not properly marked with the statement cache as "in-use".
        -- Updated the build file to make it easy to update versions and dates
           on source code headers.
        -- ResultSets are now automatically closed and their proxies dereferenced
           as soon as parent Statements are closed, rather than waiting for the parent
           Connection to close as we did before. Thanks to jo-hennig and soronthar for
           calling attention to this issue.
        -- Modified (in mchange commons library) ThreadPoolAsynchronousRunner to
           occasionally (stochastically) call Timer.purge() when maxAdministrativeTaskTime
           settings leads to frequent cancellations of TimerTasks. Thanks to Kevin Conaway,
           who observed memory issues from the piling up of canceled but unpurged TimerTasks.
        -- Modified (in mchange commons library) VersionUtils to be more tolerant
           of unusual version Strings. Thanks to martyhu for the suggestion.
        -- When a ProxyConnection is marked closed, we now fire a connectionClosed
           event even if an Exception occurred during cleanup, to be sure that proxies
           detach. We still fire a connectionErrorOccurred prior to connectionClosed,
           so that listeners (especially C3P0PooledConnectionPool) can invalidate the
           can't-be-cleaned-up PooledConnection.
        -- Modified GooGooStatementCache to call clearBatch on PreparedStatement checkin,
           so that stale batches from prior use of Statements are never visible to new
           users. Many thanks to David Carr for pointing out the problem and the fix.
        -- getWarnings and clearWarnings no longer set the txn_known_resolved flag to false.
           Thanks to Manuel Darveau for pointing out the unnecessary caution.
        -- Gave C3P0PooledConnectionPoolManager's timer a name. Thanks to Matt Kusnierz
           for the suggestion.
        -- Fixed an infinite loop in ComboPooledDataSource, which occurred following
           some Exceptions, which provoked calls to toString() to build the Exception
           message, which call itself provoked an Exception, ad infinitum. All potentially
           Exception-provoking attribute lookups are now excluded from toString(). Many
           thanks to Svante v. Erichsen for calling attention to this problem and
           suggesting a fix.
        -- Modified the build so that JDK 1.4 compatible versions of c3p0-0.9.2
           can be generated easily. (c3p0-0.9.2 will be the last version of c3p0
           to support JDK 1.4 builds.)
        -- Moved development onto github. See https://github.com/swaldman/c3p0, with
           a dependency against https://github.com/swaldman/mchange-commons-java
c3p0-0.9.2-pre1
        -- Rationalized management of the ConnectionEventListener that checks in
           PooledConnections on proxy Connection close(). Now added on check-out and
           removed on check-in, rather than being always present but temporarily removed
           during administrative tasks.
        -- Implemented asynchronous Statement destroyer, hopefully completing the task of
           making the statement cache robust to drivers that cannot deal with Statements
           being closed underneath Connections still in use (e.g. Oracle, JTDS). Note
           that this implementation requires at least one dedicated Thread for statement
           destruction (if we used the common Thread pool, there will be deadlocks as
           Statement close tasks await not-in-use Connections, while Connection-related
           tasks can't be completed because the Thread pool is saturated with Statement
           close tasks. Stats about the asynchronous Statement destroyer are available
           via the JMX MBean, prefixed statementDestroyer. Setting the new config parameter
           c3p0.statementCacheNumDeferredCloseThreads enables the fix.
        -- Resolved a potential race condition that could lead to pool freezes, especially
           when acquisitions occasionally fail and acquireIncrement is set to 1. [Many
           thanks to Brendan Dougherty for carefully describing this issue.]
        -- Added a guard to BasicResourcePool.doAcquire() to ensure that the pool has
           not been closed or broken before assimilating a task [Many thanks to
           Sean Rohead for tracking down this issue and suggesting the fix.]
        -- Made SCATTERED_ACQUIRE_TASK default to true. This provides much better overall
           performance for Connection acquisition from potentially unreliable sources
        -- Modifed to ensure that unresolved transaction settings apply to expired
           unreturned Connections. (see config params autoCommitOnClose and
           forceIgnoreUnresolvedTransactions) [Thanks to Matthew Lieder for calling
           attention to this issue.]
        -- Cleaned up Statement cache fix that ensures no statements are closed while
           their parent Connection is in use. By default, the fix is not enabled, because
           it's extra work that most databases don't need. [Most drivers support Statement
           close() while a parent Connection is in use, so the extra work is unnecessary.]
        -- Separated traditional build into two libraries, mchange-commons and c3p0.
        -- Modified GooGooStatementCache and C3P0PooledConnectionPool to ensure that
           1) the Statement cache knows which Connections are currently in use by outside
           clients; and 2) the Statement cache refuses to cull Statements belonging to
           Connections in use. Theoretically, drivers should support asynchronous statement
           close. In practice, some drivers don't do so nicely, or block pending completion
           of other (potentially long) operations, leading to APPARENT DEADLOCKS. (Oracle
           users in particular have reported deadlocks in which all pool threads are blocked
           on Statement close tasks.) [Many, many thanks to Ovidiu Feodorov for a very detailed
           account of problems that occur under c3p0 when very long queries are executed under
           Oracle!]
        -- Defined a NullMLogger, and modified Log4jMLog to use that, instead of a broken
           log4j MLogger, if c3p0's logging library fails to acquire a non-null Log4j logger.
           Thanks to Oli Glimmer for calling attention to this issue. (Strange NPEs due to
           apparently null log4j loggers have been encountered before, and previous attempts
           to resolve apparently weren't adequate.)
        -- Fixed a problem whereby ThreadPoolAsynchronousRunner was not robust to Errors provoked
           during task execution. [Thanks to George Khoshy for reporting this issue.]
        -- Made VersionUtils more robust to cases where some components of the java.version system
           property are non-integral [Thanks to Dirk Weigenand for calling attention to this problem,
           and suggesting a solution!]
c3p0-0.9.1.2
        -- Fixed a variety of latent, hidden bugs discovered by "findbugs". Many thanks to Carsten Heyl
           for running this utility and reporting the issues.
        -- Added lastAcquisitionFailureDefaultUser to ComboPooledDataSource's TO_STRING_IGNORE_PROPS,
           as some moments' Exception doesn't belong in a DataSource's toString(), and as trying to
           find this when stringifying close()ed DataSources provoked an infinte recursion (as an Exception
           was triggered trying to get the last failure info, which tries to include the stringified
           DataSource in its message, again provoking an Exception, ad infinitum.) Many thanks to Santiago
           Aguiar for finding and diagnosing this problem.
        -- Added better documentation of the com.mchange.v2.c3p0.cfg.xml configuration property.
           [Thanks to Legolas Wood for calling attention to this shortcoming.]
        -- Calling getHoldability() to find the default Connection holdability provokes an Error
           on some DB2 drivers. Added a "careful" check which catches and works around this.
           [Thanks to Lari Hotari for finding the problem, and providing a solution!]
        -- Refactored NewPooledConnection to not call event multicaster methods while holding
           the NewPooledConnection's lock. Holding locks while firing events is an old-fashioned
           way of provoking deadlocks, and it turns out c3p0 was not immune. Whoops! Another
           embarrassing one. Many thanks to Rhythm Tyagi and Pappu Sharadavani for finding this
           deadlock!
c3p0-0.9.1.1
        -- Marked variable "logger" in Log4jMLogger. Rare null pointer exceptions apparently
           result from a stale value of the previously set variable. Did the same for
           Log4jMLogger, although no analoguous issue has thus far been reported. [Thanks to
           Noa Resare and Denis on sourceforge for calling attention to this issue.]
        -- Hid the attribute "properties" from access via JMX, since it often contains password
           information. I don't think properties is particularly useful via JMX, and this seems
           like a better solution than returning properties with a hidden/modified password
           property, since users might break things unintuitively by resetting a property to
           a value that, according to the mbean, was the original value. [Thanks to John Sumsion
           for calling attention to this issue.]
    -- Fixed bug whereby setting any positive unreturnedConnectionTimeout forced c3p0's default
       effectivePropertyCycle down to 1 second. [Many thanks to Luke Dang for tracking down
       this bug.]
    -- Fixed an embarrassing bug whereby c3p0 was reflectively testing for methods (setHoldability
       and setReadOnly) whose argument types are primitive int and boolean, by looking for
       Integer.class instead of int.class and Boolean.class instead of boolean.class. [Many
       thanks to John Kristian for tracking down this subtle, and embarrassing issue very
       precisely and suggesting the fix.]
c3p0-0.9.1
        -- Modified logging of uncleared SQLWarnings, so that warnings are emitted at INFO rather
           than WARNING, and via a dedicated logger [com.mchange.v2.c3p0.SQLWarnings], so that users
           can easily turn this behavior off. [Thanks to Oleksandr Alesinskyy for calling attention
           to the annoyingness of unconditionally logging all of this at WARNING.]
c3p0-0.9.1-pre12a
    -- Fixed a NullPointerException in DoubleWeakHashMap that showed up thanks to the newly
       implemented canonicalization of Jdk14MLog instances. [Many thanks to Carlos Cajina for
       finding and reporting this bug.]
c3p0-0.9.1-pre12
        -- Modified Jdk14MLog to canonicalize named MLogger instances. In doing so, put the getLogger()
           method behind a synchronization barrier, which hopefully will resolve an odd visibility issue
           bug reported by a user (wherein the underlying jdk Logger appeared occasionally to be null
           in threads that might have initialized prior to the logger) [Thanks to Denis on Sourcefore
           for reporting this subtle and interesting issue.]
        -- Added a lastAcquisitionFailure property to PooledDataSource (and the JMX view thereof).
           Thanks to Troy Whittier for the suggestion, and the patch!
        -- SQL Warnings present at Connection acquisition, or uncleared upon Connection checkin
           are now logged (at WARNING level) and cleared prior to being made available as part
           of the pool. This is necessary to sustain the invariant that all pooled Connections
           are identical and interchangible; warnings are Connection state that must be managed
           and homogenized. [Thanks to Naxe on the hibernate forums for calling attention to this
           issue!]
        -- Resolved a rare NullPointerException which occurs when a Statement cache is closed
           beneath an active, checked out Connection. A client tries to prepare a Statement,
           but the closed Statement cache throws an NPE. Resolved this by having the closed
           Statement cache throw a ResourceClosedException, and having c3p0's proxy Statement
           recover by generating an uncached PreparedStatement. [Thanks to Sven / ford_perfect
           on sourceforge for finding and calling attention to this issue.]
    -- Added c3p0 version to C3P0RegistryManagerMBean [Thanks to Sven / ford_perfect
       on sourceforge for the suggestion.]
c3p0-0.9.1-pre11
        -- Documentation updates, and style-sheet fixes for FireFox.

        -- Despite the ugliness, added logic to prepend a VMID to identity
           tokens generated for c3p0 DataSources. See the docs (Appendix A,
           other configuration properties) for more information. Though there's
           little harm in the longer, uglier identityTokens, users who dislike
           them can turn them off using the property com.mchange.v2.c3p0.VMID.

        -- Wrote ScatteringAcquireTask, which represents a significant change to
           how c3p0's underlying resource pool deals with Connections acquisition
           failures. c3p0 is designed to retry Connection acquisition up to
           "c3p0.acquireRetryAttempts" times (30 by default) with a delay of
           "c3p0.acquireRetryDelay" milliseconds (1000 by default) between tries.
           Should no Connection be successfully acquired after acquireRetryAttempts,
           c3p0 gives up, logs an error, and frees clients waiting to check out
           a Connection with an Exception (declaring the pool permanently broken
           iff c3p0.breakOnAcquireFailure is set to true).

           Connection acquisition is performed asynchronously by c3p0's thread
           pool. Under the old implementation, when database Connections could
           not be acquired, a single task dispatched to the thread pool would
           hog a thread for the full length of the cycle -- 30 seconds by
           default -- spending most of that time sleeping between retries.
           Under the new implementation, each acquisition attempt is its own
           separate task, and if an acquire attempt fails, a timer is used to
           schedule a retry adter acquireRetryDelay without hogging any thread.

           I think the new implementation is unambiguously superior to the old,
           as it permits clients to use smaller thread pools (c3p0.numHelperThreads)
           and diminishes the likelihood of apparent thread pool deadlocks.
           However, it is too significant a change to introduce this late
           in the "mature" c3p0-0.9.1 series, so the old implementation is enabled
           by default until the c3p0-0.9.2 development cycle begins.

           TO USE THE NEW IMPLEMENTATION WITH c3p0-0.9.1, set...

             com.mchange.v2.resourcepool.experimental.useScatteredAcquireTask=true

           in a c3p0.properties file or as a system property. Users are strongly
           encouraged to set this property. You'll see better resource utilization,
           and I'll get to hear issue reports if I've screwed anything up in
           the implementation.
        -- Modified BasicResourcePool so that checkin (and removal) of resources
           is always synchronous if the pool is marked broken. [Otherwise the
           check-ins to a closed or broken pool may fail, as they try to use an
           already close()ed asynchronous task runner.]
        -- Modified BasicResourcePool.AcquireTask so that an interrupt always
           forces the whole task to end, not just a single acquisition
           attempt.
        -- Exposed numThreadsAwaitingCheckout in PooledDataSource interface
           and its associated MBean. [Thanks to John Sumsion for suggesting
           this property.]
        -- Prevented password from being exposed via
           DynamicPooledDataSourceManagerMBean. [Thanks to John Sumsion
           for calling attention to this oversight!]
        -- Fixed an error whereby DataSources.pooledDataSource( ... ) methods
           failed to properly set configuration properties defined on
           PoolBackedDataSource [e.g. numHelperThreads]. Many thanks to
           John Sumsion for noticing the problem and sending the fix!
        -- Fixed AbstractConnectionCustomizer to implement (with no-op) methods
           the current definition of the ConnectionCustomizer interface. (Failed
           to update after modifying an early version of this interface.)
        -- Modified NewPooledConnection to only collect stack trace information
           on close() when we are debugging at FINEST or DEBUG (log4j) level.
           Previously, stack trace information was collected anytime a
           c3p0 PooledConnection was close()ed. This was unnecessary, although
           the performance cost was probably small to negligible, since
           PooledConnections are typically reused many times before they are
           close()ed. Stack trace information is still captured when
           PooledConnections are destroyed due to an error, rather than an
           ordinary call to close().
        -- Hid the getLastXXXFailure(user, password) from the operations list of
           DynamicPooledDataSourceManagerMBean. The stack traces of failures
           are visible via the sampleLastXXXFailureStackTrace(); there's no
           need to expose the Throwbales as well via JMX.
        -- Added convenience methods getNumPooledDataSources() and getNumPoolsAllDataSources()
           to C3P0Registry and the related MBean. [Thanks to lukeda on hibernate
           forums for calling attention to the need for a pool count, since
           DataSources can wrap multiple pools associated with different
           authentications.]
        -- Eliminated the "trial Connection acquisition" added to c3p0-0.9.1-pre10
           when PooledDataSources construct the pool with their default authentification
           information. Effectively we trust that the default auntentification is
           good, while we distrust client-specified (or JMX-queried) username/password
           combinations, and perform the extra check. This is a compromise, as users
           who frequently create and destroy DataSources don't like the extra overhead
           of the trial Connection acquisition, but we really want to avoid the initialization
           of bad pools when users misspecify authentification information. We've also prevented
           mere queries of pool status from triggering the initialization of a
           non-default-authentification pool. Only calls to getConnection(user, password)
           will provoke the initialization of a non-default-auth pool. Querying
           a non-default pool -- e.g. getNumBusyConnections( "steve", "test" ) -- will
           throw an Exception if no Conections have ever been requested for ("steve", "test")
           rather than initializing a new pool. [Thanks to Jiji Sasidharan for calling
           attention to this issue.]
        -- Finally rationalized C3P0Registry's Object retention policy. C3P0Registry
           retains references to all C3P0 DataSources, to provide a central
           point of client access for users, and to ensure that multiple JNDI
           lookups within a single VM result in the same DataSource instance.
           This is both intuitive, and avoids multiplying Threads and pools.
           In previous versions of c3p0, hard references were retained indefinitely.
           Closed DataSources hold no non-memory resources, and are small Objects,
           but in unusual scenarios wherein very many c3p0 DataSources are created
           and destroyed within the lifetime of a single VM, this amounts to a
           memory leak. C3P0Registry now retains hard references to DataSources
           so long as they have not been close()ed (or DataSources.destroy()ed).
           When they have been close()ed, only weak references to c3p0 DataSources
           persist, and they are eligible for garbage collection. [Thanks to
           Jeremy Grodberg for calling attention to this as a real-world issue.]
        -- Removed some of the new pool stat params which distractingly appear in
           ComboPooledDataSource's toString() method (and c3p0 pools' config dump).
c3p0-0.9.1-pre10
        -- Exposed statement pool stats via PooledDataSource interface and MBean.
           Added accessors to the statement cache, pool, pool manager, and
           AbstractPoolBackedDataSource.
        -- Fixed a bug whereby multiple near-simultaneous Connection requests failed
           to provoke sufficient pool growth/Connection acquisition. This is a bug
           reintroduced in c3p0-0.9.1-pre4, and is a duplicate of an early issue,
           resolved under the old pool size management scheme. c3p0 must (and does)
           keep track not only of its current size and pending growth, but also the
           number of potentially unserved recent Connection requests. c3p0-0.9.1-pre4
           thru c3p0-0.9.1-pre9 failed to make use of the incoming request count when
           deciding whether and how much to grow the pool. Many thanks to John Kristian
           for calling attention to this subtle issue.
        -- Exposed information about Connection test failures (failure count of
           each type of test, stack trace of last failure and last failure of each
           type) via the PooledDataSource interface and its assiciated MBean.
        -- Fixed a rare situation where a Connection test on check-out could
           be performed by a Thread holding the pool's lock, if an initial
           attempt to checkout a Connection failed and a second checkout attempt
           is initiated internally. The recursive checkout is now performed
           without the pool's lock.
        -- Established a consisent policy re logging of Connection test failures.
           They are now logged at FINE level (DEBUG under log4j). Previously tests
           on checkin and checkout were logged at FINE, but idle tests were logged
           at INFO. Is it worth letting this be configurable, as some users may prefer
           to see test failures under normal operation?
        -- Modified C3P0PooledConnectionPoolManager to perform a trial Connection
           acquisition before trying to establish a pool, as pools established
           on bad database or authentification information churn indefinitely trying
           to acquire minPoolSize Connections, clogging up the thread pool and
           sometimes leading to "APPARENT DEADLOCKS" if users touch a pool with
           bad authentification information.
        -- Defined UnifiedConnectionTester (and AbstractConnectionTester) so that
           ConnectionTesters can provide any Exception associated with a failure,
           which will show up as the "root cause" of the Exception eventually
           thrown to signal the failure.
        -- Added logging at WARNING level when a Connection tester reports the
           database is invalid, triggering a reset of the Connection pool.
c3p0-0.9.1-pre9
        -- Updated the documentation. It is now fully current.
        -- Changed the name of the jboss configuration mbean from
           com.mchange.v2.c3p0.mbean.C3P0PooledDataSource to com.mchange.v2.c3p0.jboss.C3P0PooledDataSource,
           in order to distinguish the jboss configuration stuff from the normal management
           beans, which really are quite different. The old com.mchange.v2.c3p0.mbean.C3P0PooledDataSource
           still exists, so that existing users don't see anything break, but only the new version will
           be updated to support new parameters.
        -- Added a means by which users can suppress JMX MBean registration if they
           wish. Setting the property com.mchange.v2.c3p0.management.ManagementCoordinator
           to com.mchange.v2.c3p0.management.NullManagementCoordinator will
           prevent mbean registration. (Advanced users can also use this to install
           their own implementations of the ManagementCoordinator interface, though
           I doubt many people will find this useful.)
        -- Fixed infinitely loop in ComboPooledDataSource.setFactoryClassLocation( ... ) [introduced with
           the reorganization of ComboPooledDataSource to inherit from AbstractPoolBackedDataSource (?)]
        -- Added some code to warn on common spelling errors of c3p0.properties
           and c3p0-config.xml (Users have frequently mistaken the digit 0 for
           the letter O in c3p0.)
    -- Wrote a DynamicMBean for PooledDataSources. It seems to work,
       covers both ComboPooledDataSource and "wrapping" PoolBackedDataSources,
       and should cover new config parameters and accessors automatically.
        -- More refinements to connection test logic. We test proxy Connections
           when there's a statement cache and a test query (to save time, since
           the test query is likely cached), we test physical connections if we'll
           need to do the slow, default test (statement caching doesn't help), or
           if there is no statement cache.
        -- Removed the stub servlet I'd previously added. Although it jdk1.5+, the
           JMX approach is a better one for monitoring and modifying c3p0 pools at
           runtime, and I'm going to focus on that for now. (If there's a lot of
           clamor for it, I'll add back and flesh out the servlet. It just doesn't
           seem like a great use of my time for now.)
        -- Modified build to create a separate jdk1.3 compatable jar by stripping
           source of lines beginning with "assert". I want to start using assertions,
           but will keep them to recognizable, strippable one-liners.
        -- Modified DriverManagerDataSource to handle its driverClass parameter
           in a less fragile way. Rather than attempting to load the driverClass on
           property set, DriverManagerDataSource now lazily tries to load the class
           upon its first call to getConnection() after the property is initialized
           or updated.
c3p0-0.9.1-pre8
        -- Fixed bug whereby jdbcUrl and driverClass were not initialized properly
           if set in config files rather than in code. [Thanks to Felipe Dominguez
           for calling attention to this problem!]
        -- Changed AbstractPoolBackedDataSource from a non-public class in
           com.mchange.v2.c3p0 to a public class in com.mchange.v2.c3p0.impl to
           workaround fragilities associated with sun bug id #6342411, wherein
           reflective invocation of public methods on a non-public class fail,
           even when involed via a public base-class.
        -- Fixed NullPointerException (introduced on -pre7) on initializing with
           a named config.
        -- Continuing along the same lines, modified C3P0Registry and
           C3P0ManagementCoordinator to unregister (both from C3P0Registry and
           associated MBeans on DataSource close. When all PooledDataSources
           are unregistered, the C3P0RegistryManager MBean unregisters as well.
        -- Modified ActiveManagementCoordinator to check for, and unregister, the
           C3P0Registry mbean prior to registration, to prevent conflicts on
           undeploy/redepoloy cycle. [Thanks to Ben Groeneveld for calling attention
           to this problem, and suggesting the fix.]
        -- Modified C3P0PooledConnectionPool to perform Connection tests on the raw
           physical Connection rather than the proxy Connection, when possible (i.e.
           when we're using a C3P0 PooledConnection implementation that we know how to
           get underneath of). This is better because 1) it's slightly faster; 2) it's
           significantly faster on failure, as C3P0 PooledConnections test Connections
           after a failure with statusOnException(), leading to an unnecessary
           double-check; and 3) authors of custom ConnectionTesters can use vendor-specific
           API to test Connections if they wish.
c3p0-0.9.1-pre7
        -- Defined the ConnectionCustomizer interface as a hook through which clients
           can "set up" newly acquired or checked out connections (and clean up prior
           to check-in or destruction). Added config param connectionCustomizerClassName.
        -- Formerly unused config parameter propertyCycle now controls how frequently
           c3p0 checks timestamps against expiration parameters (maxIdleTime,
           maxIdleTimeExcessConnections, maxConnectionAge, unreturnedConnectionTimeout)
        -- Added config parameters unreturnedConnectionTimeout and
           debugUnreturnedConnectionStackTraces, reluctantly but by popular demand.
           If unreturnedConnectionTimeout is set, Connections will be automatically
           destroyed and removed from the pool if not returned in the given number
           of seconds. If debugUnreturnedConnectionStackTraces is also set, stack
           traces will be captured on check-out of any Connection, and the stack traces
           that were unreturned and cleaned up by the pool will be logged. Any clean-up
           of an unreturned Connection is logged at INFO level, in hopes of annoying
           people into cleaning up their code and close()-ing their Connections reliably.
        -- Added config parameter maxIdleTimeExcessConnections. Connections in excess of
           the pool's minimum size will be expired out if they remain idle for longer
           than maxIdleTimeExcessConnections. [Thanks to Navin M. and Ben Groeneveld for
           the suggestion.]
        -- Added configuration parameter maxConnectionAge to limit the absolute age
           of Connections (age in seconds from acquisition, rather than in seconds
           form last check-in).
        -- Put more status accessors in ThreadPoolAsynchronousRunner and exposed
           thread pool state via JMX (PooledDataSourceManagerMBean).
        -- Preliminary support for management via mbeans/jmx under jdk1.5+ is
           implemented. (These mbeans are distinct from the mbean designed for
           configuring c3p0 under jboss, and are in the package
           com.mchange.c3p0.management.) Currently, pool statistics are instrumented,
           as well as pool reset operations, but viewing and modifying the pool
           configuration parameters is not supported. (I'll write a dynamic mbean to
           capture this stuff; there are too many config properties I'm already
           updating by hand in too many places. Later.) [Thanks to Ben Groeneveld for
           the suggestion, including some nice sample code!]
        -- Added configuration parameter maxAdministrativeTaskTime, which forces
           interrupt() to be called on pool administrative tasks (Connection acquisition,
           destruction and testing; prepared statement destruction) if these tasks seem
           to hang. This is one strategy for dealing with database that hang and lead to
           deadlock messages and eventually large memory footprints. It's useful only if
           the hanging operations respond to interrupt()s, not thread-monitor related
           deadlocks (which hopefully don't ever happen). c3p0 should recover from any
           Exceptions provoked by the interrupt() calls. (Hopefully improvements to
           GooGooStatementCache have rendered this parameter largely unnecessary by
           resolving the most common source of deadlocks.)
        -- Major revision to GooGooStatementCache that may eliminate most APPARENT
           DEADLOCK messages. c3p0-0.9.0 introduced a complicated implementation
           of closeAll(), in order to ensure that Statement and Connection close did
           not happen simultaneously. Upon review, there was a significant bug in the
           implementation, and even when corrected, the strategy is itself prone to
           deadlocks should the ThreadPool become saturated with destroy tasks, which
           block awaiting statement remove tasks. Rewrote closeAll() as a simple
           synchronous method, rather than simulating synchrony with wait()/notifyAll(),
           but with care not to hold the StatementCache's lock during Statement.close()
           calls. There is a slight loss of asynchrony, as Statement.close() methods
           are executed sequentially rather than simultaneously, but as a practical
           matter, since the sequential destruction occurs asynchronously in the
           thread pool and is invisible to clients, both client-observed and over-all
           performance should not suffer. (It may even be improved, as the 0.9.0.x
           strategy was complicated and had some overhead.) Note: This revision should
           also eliminate occasional ConcurrentModificationExceptions associated
           with the Statement cache.
        -- Changed asynchronous tasks implemented as anonymous inner classes to named
           inner classes, so that users reviewing active and pending tasks (usually
           in trying to make sense of an APPARENT DEADLOCK) have a better idea of
           what's going on.
        -- Major revision to GooGooStatementCache that may eliminate most APPARENT
           DEADLOCK messages. c3p0-0.9.0 introduced a complicated implementation
           of closeAll(), in order to ensure that Statement and Connection close did
           not happen simultaneously. Upon review, there was a significant bug in the
           implementation, and even when corrected, the strategy is itself prone to
           deadlocks should the ThreadPool become saturated with destroy tasks, which
           block awaiting statement remove tasks. Rewrote closeAll() as a simple
           synchronous method, rather than simulating synchrony with wait()/notifyAll(),
           but with care not to hold the StatementCache's lock during Statement.close()
           calls. There is a slight loss of asynchrony, as Statement.close() methods
           are executed sequentially rather than simultaneously, but as a practical
           matter, since the sequential destruction occurs asynchronously in the
           thread pool and is invisible to clients, both client-observed and over-all
           performance should not suffer. (It may even be improved, as the 0.9.0.x
           strategy was complicated and had some overhead.)
        -- Users still occasionally report seeing "APPARENT DEADLOCK" messages
           from ThreadPoolAsynchronousRunner. Previously, most reports had to
           do with cached PreparedStatements that hang when closed. Previous
           fixes (in 0.9.0) seemed to resolve these problems. Most new reports
           have to do with Connection acquisition or Connection close() tasks
           hanging indefinitely, with statement cacheing not necessarily involved.
           It's unclear whether these reports stem from a c3p0 bug, or rare
           situations in which various JDBC driver hangs hang c3p0. (If the
           condition is temporary, c3p0 recovers after the "APPARENT DEADLOCK"
           warning. In any case, ThreadPoolAsynchronousRunner has been modified
           to provide much better debug information, particularly in jdk1.5
           environments, where hung Thread stack traces are dumped.
        -- Modified the build file and refactored C3P0Config / C3P0ConfigUtils / C3P0ConfigXmlUtils
           to make sure that c3p0 still runs under jdk1.3, even though it only builds
           under jdk 1.5. JMX support is 1.5 only, and XML config depends on the
           availability of standard XML extensions under jdk 1.3. (This is going to get harder,
           as I hope to start using assertions. For the moment, assertions are
           commented out. I think I'll have ant filter away the assertions for 1.3
           builds and leave them in otherwise, based on a build property.
        -- Significantly reorganized (hopefully simplified) of C3P0Registry and
           ComboPooledDataSource. Much of the complication of all this is supporting
           the most annoying, least used, but nevertheless very important feature
           of supporting JNDI lookups across JVM boundaries via Serialization or JNDI
           References.
        -- Reorganized ComboPooledDataSource to inherit from PoolBackedDataSource.
           In doing so, changed setConnectionPoolDataSource() of PoolBackedDataSource
           to throw a PropertyVetoException. (It is a "constrained property" now.)
           The very, very few users who call this method directly may have to update
           their code to handle the potential Exception. This change does not affect
           compatability for clients that use ComboPooledDataSource or who create
           PoolBackedDataSources via the c3p0's factories (e.g. DataSources).
        -- Fixed bug whereby config parameter breakAfterAcquireFailure did not take
           effect at the ResourcePool level.
        -- Fixed bug whereby initialPoolSize parameter failed to take effect at the
           ResourcePool level.
        -- Fixed a bug whereby Connection tests on checkout held the pool's lock,
           preventing other activity during the Connection test. [Thanks to John
           Sumsion for calling attention to this subtle problem.]
        -- ThreadPoolAsynchronousRunner has seen some minor efficiency improvements
           (a task that calls interrupt() long-running tasks on post-deadlock blocked,
           replaced threads no longer runs when there are no post deadlock blocked,
           replaced threads).
        -- Previous versions used a Stringified identityHashCode() as a unique ID
           for various C3P0 objects. This was not correct (and bit at least one
           user in practice), as identityHashCode()s are not guaranteed unique,
           and in practice are not on 64-bit VMs. c3p0 now checks identityHashCodes
           to make sure they are not reused, and if seen before appends a count to
           keep unique IDs unique. [Many thanks to Prishan Makandurage for calling
           attention to this issue.]
        -- Fixed fact that statusOnException() in NewPooledConnection() ignored
           preferredTestQuery parameter, always using the very slow default
           connection test rather than the user-defined test. [Thanks to Andrea
           Luciano for calling attention to this issue.]
        -- C3P0PooledConnection (part of the "traditionalReflectiveProxies"
           codebase that's largely been superceded, but that is still nominally
           supported) held a static reference to a ClassLoader, in some cases
           preventing the ClassLoader from being garbage collected (for example
           when webapp contexts, with context specific Classloaders are
           undeployed by some app servers). This was entirely unnecessary, as
           the cached reference was used exactly once in the lifecycle of the
           class. The reference to the ClassLoader is no longer stored. [Many
           thanks to Michael Fortin for very specifically tracking down this
           subtle problem!]
        -- Added logic to log individual acquisition failures at INFO level
           if acquireRetryAttempts <= 0. if num_acq_attempts <= 0, we try to
           acquire forever, so the end-of-batch log message below will never
           be triggered if there is a persistent problem so in this case,
           it's better flag a higher-than-debug-level message for
           each failed attempt. [Thanks to Eric Crahen for calling attention
           to this issue.]
c3p0-0.9.1-pre6
        -- Wrote a stub of a status-monitoring servlet. Not yet documented, or
           even usefully functional, but hopefully will be soon.
        -- Updated documentation to include new config file format, including
           named and per-user config. Docs could still use some work, but the
           functionality is now described.
        -- For consistency, the parameters user and password are now configurable
           via config files and System properties.
        -- Modified DefaultC3P0ConfigFinder to properly give greater precedence to
           System properties than to XML-defined unspecified user, default config
           values.
        -- Added WARNING logging of create SQL and original database Exception when
           creation of an automaticTestTable fails. [Thanks to Alexander Grivnin.]
        -- Added logic so that the Exception assoicated with the last failed acquisition
           attempt in a round of attempts is logged along with the failure if the
           acquisition attempts. [Thanks to Barthel Steckemetz and Patrick Eger for
           calling attention to this issue.]
        -- Fixed a problem whereby modifying the config of a ComboPooledDataSource
           programmatically, while in use, causes previously checked-out Connections
           to be close()ed underneath the user. Changing configs midstream still
           causes a complete resetting of the pool (because the pool holds most
           config params as immutable to avoid having to synchronized for every
           config param read), but old Connections from superceded pools will remain
           valid until they are rechecked into the pool. [Thanks to hhu for noticing
           this problem!]
        -- Fixed a resource leak whereby Connections which could not be reset after
           client-initiated close() were properly "excluded" from future inclusion
           in the pool, but never checked back into the pool to be destroyed. (Excluded
           resources are simply marked for destruction rather than reassimilation on
           checkin.) [Many thanks to Levi Purvis for tracking this down!]
c3p0-0.9.1-pre5a
        -- "test-classpath" was erroneously specified in build.xml to include some
           extra jar files, which rendered undetectable (to my tests) the fact
           that com.mchange.v1.lang.BooleanUtils was not jarred up into
           c3p0-0.9.1-pre5.jar as it needed to be. Very, very embarrrassing. [Thanks
           to Goksel Uyulmaz for calling attention to this gaffe.]
c3p0-0.9.1-pre5
        -- reorganized synchronization of getConnection() in DriverManagerDataSource,
           so that a lock-up in one Connection acquisition attempt does not prevent
           other threads from accessing the DataSource. [Thanks to Fabian Gonzalez
           for calling attention to this occasional deadlock.]
c3p0-0.9.1-pre4
        -- added overrideDefaultUser and overrideDefaultPassword parameters, and
           a pooledDataSource( ) factory method which specifies override
           authentification info, regardless of the user and password properties
           set on the DataSource.
        -- Reimplemented resource acquisition in BasicResourcePool so that each
           Connection acquisition is a separate asynchronous task, to avoid tying
           up the pool with very long, multiple acquisition tasks. Ended up being
           a total rewrite of pool size management. Pools should be much more
           conservative in acquiring new Connections. They won't grow to maxPoolSize
           as easily as before. This is a big change. We'll see how it holds up as
           people beat the crap out of it.
c3p0-0.9.1-pre3
        -- Added some extra logging of resource destruction, to help debug cases
           where the resources are removed from the pool, but appear not to have
           been properly cleaned up.
        -- Finished implementation of new C3P0Config, added constructor methods to
           various DataSource implementations that accept a configName parameter for
           named configurations, and modified the DataSources class to use the new
           configuration approach instead of PoolConfig wherever possible.
c3p0-0.9.1-pre2
        -- Continued implementation of new C3P0Config, including XML parsing
           and setting of default values. Still have to test XML config, and
           implement named and per-user configs.
        -- Changed policy of BasicResourcePool to keep accidentally overacquired
           resources so long as the pool is kept below maxPoolSize, rather than
           immediately discarding Connections beyond the number we intended to
           acquire.
        -- Fixed two issues whereby checking in resources to closed pools (both
           Connection and Statement pools) provoked Exceptions. Check-ins should
           succeed, even to close()ed pools, with resources silently destroyed if
           the pools ae closed. [Thanks to Chris Kessel for finding both of these
           issues.]
        -- Modified to a one-statement-cache-per-pool model, rather than a
           global-statement-cache-for-all-pools, consistent with the general
           philosophy that config parameters are on a per-auth-pool basis.
        -- Fixed a deadlock which could occur if a pool is closed at the same time as
           one of its Connections is closed. One thread gets the pool's lock, then tries
           to get a PooledConnections lock to close it. An ordinary client closes a
           Connection, which acquires the PooledConnection's lock, and then tries to
           check back in to the pool, requiring the pool's lock. Broke the deadlock by
           making the destruction of resources on pool close asynchronous, by a Thread
           without the resource pool's lock.. [Many thanks to Roger Westerlund for
           sending a full thread-stack dump capturing this deadlock!]
        -- Completed transformation to one C3P0PooledConnectionPoolManager per
           PoolBackedDataSource model.
c3p0-0.9.1-pre1
        [This is a half-assed internal release... it compiles and works, but mostly
        it's just a checkpoint as c3p0 undergoes significant transformations.]
        -- Deprecated PoolConfig, and began implementation of new C3P0Config approach
           to configuration.
        -- Partial transformation of C3P0PooledConnectionPoolManager from shared-manager
           for several DataSources model to simple one-pool-per-DataSource model enabled
           by canonicalization of DataSources.
c3p0-0.9.0.4
        -- In a subtle but major modification of BasicResourcePool, changed checkin/checkout
           behavior from FIFO to LIFO to increase the likelihood that unnecessary Connections
           pooled at peak times idle long enough to expire. [Many thanks to Vlad Ilyushchenko
           and hontvari on sourceforge for noticing this important issue and suggesting the
           fix.]
c3p0-0.9.0.3
        -- Added code to mbean C3P0PooledDataSource to automatically create JNDI
           subcontexts if a JNDI name is specified for which the full path has not
           been created (analogous to mkdir -p in UNIX). [Thanks to David D. Kilzer
           for noticing the issue, and for submitting the fix!]
        -- Added logic to GooGooStatementCache to ensure that multiple threads do not
           try to close the same PreparedStatement, in order to try to resolve longstanding
           PreparedStatement.close() freeze issues. [Thanks to cardgames on sourceforge for
           noticing that the freezes seem to occur when several threads are trying to close()
           just one statement!]
        -- Added some checks in DriverManagerDataSource (as well as WrapperConnectionPoolDataSource)
           so that a mismatch between JDBC URL and driver does not lead to null Connection
           references and downstrem NullPointerExceptions. [Thanks to Richard Maher for
           calling attention to this issue.]
        -- Undid some unnecessary synchronization in WrapperConnectionPoolDataSource,
           which would cause deadlocks when the acquisition of a Connection from the
           underlying driver froze for some Thread. (Other threads would then block
           trying to access the WrapperConnectionPoolDataSource.) [Thanks to Fabian
           Gonzales for calling attention to this issue, and for providing a VM thread
           stack dump to help chase it down!]
        -- modified BasicMultiPropertiesConfig to never attempt to read the resource "/",
           representing (in this case) System properties, as a stream, which under some
           classloaders caused ClassCastExceptions. [Thanks to Joost Schouten for calling
           attention to this issue.]
        -- fixed initial check of the readOnly and typeMap properties of Connections,
           so that users don't see disconcerting Exceptions at debug log levels if their drivers don't
           support these parameters.
        -- Added jar attributes Extension-Name, Specification-Vendor, Specification-Version,
           Implementation-Vendor-Id, Implementation-Vendor, and Implementation-Version
           [per request of Pascal Grange].
        -- Added some extra debugging information for peculiar situation where an IdentityTokenized
           is constructed and registered with C3P0Registry, but coalesces to a different Object.
           This should never happen, as freshly constructed IdentityTokenizeds should have String
           versions of their identity hashcodes as tokens, and upon their registration, no copies
           should yet have been created and registered. [Thanks to Jose Rodriguez for noting this
           issue.]
c3p0-0.9.0.2
        -- added debug-level logging of connection tests and results
        -- tightened up means by which the readOnly and typeMap properties of Connections are reset,
           so that users don't see disconcerting Exceptions at debug log levels if their drivers don't
           support these parameters.
        -- fixed problem in BasicResourcePool that left the immediately-close-checked-out-connections option
           in the close() method ineffective, meaning Connections checked-out from a pool would
           leak unless clients remembered to check them into pool for destruction.
        -- fixed bug wherein connection-testing on checking occured in a thread holding the pool's
           lock, leading to pool hangs or deadlocks if a connection hangs. [Thanks to Tobias Jenkner
           for calling attention to this problem!]
c3p0-0.9.0.1
        -- modify BasicPropertiesConfig to not throw class cast Exceptions in the rare case that
           a Properties object (presumably System properties rather than a file derived props Object)
           contains (via the Map/Hastable API) non-String keys or values. [Thanks to Prima Upot for
           calling attention to this issue.]
        -- fixed a build issue where some classes required for code generation were not necessarily
           compiled prior to the code generation step, causing builds to fail. [Thanks to James
           Neville for calling attention to this issue.]
c3p0-0.9.0
        -- under some circumstances, the current list of ThreadPoolAsynchronousRunner's deadlock detector
           seems to hold onto a lot of memory... presumably this is when long pending task lists build up
           for some reason... nevertheless, we now dereference the "current" list in between deadlocker detector
           invocations. The "last" list has to be retained between invocations, but the "current" list need
           not be. [Thanks to Venkatesh Seetharamaiah for calling attention to this
           issue, and for documenting the apparent source of object retention.]
        -- modified log4j and jdk14logging MLog implementations to test for library classes upon
           classload (MLog class only tests for the presence of the mlog implementations, which
           doesn't notice if their dependant classes aren't there -- dependent classes must test
           for the presence of the libraries.)
        -- Modified GooGooStatementCache to warn as INFO (and with a descriptive message in debug)
           of multple PreparedStatement preparation. [Thanks to mxnmatch on hibernate's forum for
           calling attention to this issue.]
        -- Modified BasicResourcePool to not warn on expected InterruptExceptions that occur if
           clients are waiting for a Connection when the pool is closed. [Thanks to Blunted on
           hibernate's forum for calling attention to this issue.]
c3p0-0.9.0-pre6
        -- Modified thread pool's strategy for dealing with deadlocks to prevent OutOfMemoryErrors
           from sudden spawning of multiple threads to clear backlogged tasks. [Thanks to Greg Whalin
           for calling attention to this problem.]
        -- Fixed bugs in debug reporting of nested Exceptions/Warnings when converting or
           rethrowing SQLExceptions [thanks to an anonymous sourceforge poster for finding this]
        -- modified BasicResourcePool to shorten the period during which the pool's lock
           is held during resource acquisition
        -- maxIdleTime is generally enforced every (maxIdleTime / 8) seconds. Added logic to ensure that
           even for very long maxIdleTimes, the longest maxIdleTime will ever go unenforced is 15 minutes.
        -- Very tentative initial support in build for JUnit tests
        -- Fixed documentation typos and added sample config for Tomcat 5.5. [Thanks to David Newcomb
           for finding the typos and to Carl F. Hall for the sample config!]
        -- ProxyConnections were not properly resetting readOnly, holdability, catalog, and typeMap
           properties on Connection close. Fixed. [Thanks to Andy (bjorkmann?) for calling attention
           to this bug.]
        -- Added a complicated workaround to issues that may occur when a Connection
           and its child statements simultaneously try to close. GooGooStatementCache's closeAll(Connection c)
           method now wait()s for all Statements to close prior to returning, avoiding such issues (Oracle deadlock,
           mysql NullPointerException), though dramatically complicating the code. Grrr. Theoretically, drivers should
           be robust to the simultaneous closing of Statements and Connections, but they're not, so
           my code gets to be more complicated. [Thanks to Juan Perez, Daniel Edberg, and Damien Evans for calling
           attention to this issue.]
c3p0-0.9.0-pre5
        -- Proxy classes were overaggressively invalidating themselves in response to a signalled
           Connection error. This problem was very similar to the problem fixed in 0.8.5-pre9, except
           for rather than the PooledConnection too quickly closing its inner Connection, the proxies
           too quickly detached themselves from the pooled Connection, considering themselves broken,
           after a Connection error event. Users expect to be able to work with their Connections even
           after c3p0 has in its conservatism decided they no are no longer worthy of a place in the
           pool. [Thanks to "Geoff Fortytwo" for finding and helping to track down this issue.]
        -- Fixed issue that prevented user-defined ConnectionTesters from being used.
c3p0-0.9.0-pre4
        -- Fixed NullPointerException on double-close of proxy Statements. [Thanks to Stephen Waud
           for finding this bug and tracking it down.]
        -- Modified C3P0PooledConnectionPool to generate a more informative Exception (one that
           includes the stack trace of the initial problem) when a Connection test fails. [Thanks
           to novotny from the hibernate forums for calling attention to this issue.]
`       -- PooledDataSources now set SQLState 08001 on SQLExceptions resulting from a determination
           by the pool that the database is down or unavailable. [Thanks to ml2709 on the hibernate
           forums for calling attention to this issue.]
        -- Modified ThreadPoolAsynchronousRunner to enforce its max task time even on one-off
           "emergency threads" used to flush the pool of tasks after an apparent deadlock.
           Hopefully this will help to eliminate the OutOfMemoryErrors that users occasionally
           see if some Database operation starts to fail by blocking indefinitely, and is attempted
           many many times. As long as these operations are susceptable to interrupt(), this should
           resolve the problem. (If tasks block in a way that is immune to interrupt(), there is
           little c3p0 can do to recover the Threads and prevent the number of blocked Threads
           from growing until memory runs out.) [Thanks to Jean-Christophe Rousseau and Arup Vidyerthy
           for calling attention to this issue.]
        -- Wrapped System.getProperties() calls in try / catch blocks that  catch and log
           the SecurityExceptions, and ignore System properties if access to them is forbidden.
           c3p0.properties configuration should work fine in security-controlled apps, but you
           won't be able to configure c3p0 using "java -Dc3p0.xxxx=yyy ..." Since most users use
           c3p0.properties for configuration, I don't think this will be a major problem. In the
           future, I may be able to work around the restriction by having ask only for c3p0-specific
           System properties, rather than calling the unrestricted System.getProperties() method.
           [Thanks to zambak on SourceForge for calling attention to this issue.]
c3p0-0.9.0-pre3
        -- Modified generated proxy classes to properly report the type of the closed Object
           if used after call to close().
        -- Fixed a really embarrassing oversight, wherein cached PreparedStatements
           were being physically close()ed prior to their return to the cache! Tests
           on psql failed to reveal this, because psql-7.4 Statement.close() does nothing
           to invalidate the Statement! [Many thanks to tbayboy on hibernate's forum for
           discovering this issue, and to fassev, also on hibernate's forum, for correctly
           deducing the cause!]
        -- Fixed an embarrassing oversight where operations of proxy Statements
           and ResultSets failed to mark transactions as potentially dirty, leading
           to the possibility that Connections with unresolved transactional work could
           be checked into the pool.
        -- Modified c3p0 Statements to no longer permit calls to getConnection()
           after Statement close, and to null out the backreference to the
           parent Connection. [Thanks to Edward Bridges for pointing out the issue.]
        -- NewPooledConnection threw a NullPointerException on close() of
           a ResultSet whose creating Statement had already been closed.
           Fixed. [Thanks to Edward Bridges for pointing out the problem.]
        -- Modified PoolConfig to trim() read-in c3p0.properties to avoid
           NumberFormatExceptions if there is extra spacing in the file.
           [Thanks to johnchan for calling attention to this issue.]
c3p0-0.9.0-pre2
        -- Documentation updates and improvements
        -- Integrated configurable wrapper logging library, so that
           c3p0 can log to log4j or jdk14logging.
c3p0-0.9.0-pre1
        -- First pass at documentation of JBoss integration.
        -- Better one-per-JVM canonicalization (IdentityTokenized,
           IdentityTokenResolvable, C3P0Registry)
        -- First implementation of MBean for JBoss compatability
        -- Fixed JNDI ref-based DataSources
c3p0-0.8.5.1
        -- Fixed a really embarrassing bug that made Statement pooling worse than
           useless where users have set maxStatements but not maxStatementsPerConnection.
           maxStatementsPerConnection -- that is, 0 -- was being used in place of maxStatements
           on Statement cache initialization. [Thanks to Gwendal Tanguy for not only,
           calling attention to this issue, but tracking down the precise location of
           the bug!]
c3p0-0.8.5
        -- Documentation updates and improvements
        -- Fixed an issue where failures on reset() of a pooled Connection caused
           a Connection error to be signalled, without updating the status of the
           PooledConnection to indicate that it is broken. Thanks to Henry Le for
           calling attention to this issue.
c3p0-0.8.5-pre9
        -- Modified c3p0's behavior on detecting an apparently broken Connection.
           Previously c3p0 would very aggressively close any Connections that, after
           an Exception, failed to pass a Connection test. This sometimes surprised
           and confused users, when Conections they expected to remain open were
           closed from underneath them. Under normal circumstances, a Connection
           which has failed its Connection test is broken anyway, so closing it
           does no harm. But under some circumstances, a Connection may fail its
           Connection test, but still be partly functional from the application's
           point of view. So, now c3p0 simply marks Connections that fail their
           Connection test following an Exception as broken, and excludes them from
           future re-entry into the pool, but leaves those Connections open for users
           to continue working with them prior to their explicit close() of the
           Connection. [Thanks to Julian Legeny for calling attention to this issue.]
        -- Modified c3p0's logging behavior to be a little bit less annoying. Rather than
           frequently printing duplicate stack traces to be sure root cause Exceptions are
           logged as well as converted, rethrown Exceptions, c3p0 now checks the Java
           version, and uses the initCause() method to log the root cause in versions 1.4
           and above. Also, some Exceptions that were expected and thrown without information
           as to the cause now use the initCause() method to provide this in JDK 1.4 and
           above. [Thanks to Ruslan Gainutdinov, Anthiny Pereira, Carsten ????, and
           Eric Hsieh for calling attention to these issues.]
        -- Fixed bug whereby proxy wrappers were sometimes placed around null return values
           from native Objects, particularly Statement's getResultSets() method. [Thanks to
           Ruslan Gainutdinov for calling attention to this issue.]
        -- Fixed bug in NewProxyConnection whereby setTransactionIsolation was called even
           if the Connections' isolation level had not been changed from its default. [Thanks
           to Levent Aksu for reporting this bug.]
c3p0-0.8.5-pre8
        -- Added C3P0ProxyStatement and rawStatementOperations for accessing vendor-specific
           Statement API.
        -- Fixed bug whereby recently added properties could not be configured properly
           via a PoolConfig Object passed to the DataSources factory method. [Thanks to
           Julian Legeny for finding this bug.]
        -- Undid new behavior whereby c3p0 warns when it detects that a transaction
           has not been comitted or rolled-back prior to close and must be automatically
           rolled-back. Because c3p0 autorollsback conservatively, whenever it is possible
           that there may be any transactional resources held by the Connection being
           checked in, users who make read-only queries, then close without commit or
           rollback, saw the warning, and became annoyed. Warning when it's "right" is hard,
           and would involve paying attention to the substance of user-queries, as well
           as the transaction's isolation level. In the future, when c3p0 offers better
           control over logging, we'll make the warning optional. Note that this release
           only undoes the warning -- the new logic that detects potential transactional work
           and only rollsback when there has been some remains. [Thanks to David Graham for
           calling attention to this issue.]
        -- Synchronized StatementCacheKey.find( ... ) method. Subclasses of StatementCacheKey
           have always explicitly relied upon this method being synchronized in the parent class,
           but somehow it was not... [Thanks to Manfred Hutt for reporting this bug.]
        -- Modified both PooledConnection implementations to reset the transaction
           isolation level on PooledConnection.reset()
        -- Finalized PooledDataSource api for pool stats and resets.
c3p0-0.8.5-pre7a
        -- Fixed some bugs in new Proxy classes relating to close(), methods,
           especially NullPointerExceptions on duplicate close() operations.
        -- Fixed some misleading documentation re: testConnectionOnCheckin and
           automaticTestTable vs. preferredTestQuery
        -- Changed wording of warning message on purge of idle-test-failing
           resource to no longer suggest that some user action is required.
           [Thanks to Krishna Kuchibhotla for calling attention to this
           issue.]
        -- Modified GooGooStatementCache so that its close() is synchronous,
           since when the Statement cache is closed, it's asynchronous
           runner has often been closed already underneath it. (Actually
           changed as of c3p0-0.8.5-pre7, but forgot to log it.)
c3p0-0.8.5-pre7
        -- Added flag (in both new and tradional reflective proxies) to
           prevent automatic rollbacks on Connection close()es immediately post-
           commit(), rollback(), or setAutoCommit().
        -- DatabaseMetaData now properly returns proxy rather than naked
           raw Connection. [Thanks to jhoeller on the hibernate forums]
        -- In response to an apparent BEA WebLogic specific problem with
           DriverManager.getConnection( ... ), DriverManagerDataSource now
           caches its driver and uses Driver.connect( ... ) rather than
           DriverManager.getConnection() when acquiring Connections. Thanks to
           Lars Torunski for calling attention to this issue.
        -- Fixed some missing synchroniztion that really should be provided for accessors
           and mutators of DataSource bean properties.
        -- Added config parameter automaticTestTable, which takes the name of a table
           that c3p0 will create and use as the basis for Connection tests. It's easier
           to use than preferred test query, because you don't have to ensure the existance
           of any tables in the schema prior to using a Pooled data source.
        -- Fixed idiotic oversight whereby Connections didn't get their transaction status
           resolved and reset on check-in...
c3p0-0.8.5-pre6
        -- Modified resource pools to only conditionally support async ResourcePoolEvent
           generation. Since c3p0 doesn't use ResourcePoolEvents, we can do without the
           superfluous CarefulRunnableQueue, and its associated Thread, which was serving
           as an event queue.
        -- Fixed bug where asynchronous refurbishment (testing) of resources would be
           attempted even on check-in to a closed pool, whose async threads had terminated.
        -- c3p0 now supports the following new configuraion parameters: preferredTestQuery,
           testConnectionOnCheckin, checkoutTimeout, and maxStatementsPerConnection.
           preferredTestQuery should allow c3p0 to test Connections (whether on checkout,
           checkin, or after a specified idle time) much more efficiently than with
           it's default test [a call to getTables(...) on the Connection's DatabaseMetaData.].
           checkoutTimeout allows clients to break out of a getConnection() call after a
           a specified time period, rather than waiting (potentially indefinitely) for
           a new Connection to be acquired from the database, or a checked-out Connection
           to be rechecked in. testConnectionOnCheckin should be self-explanatory.
           maxStatementsPerConnections allows users to specify how many statements to cache
           on a per-connection base instead of, or in addition to, the global limit maxStatements.
        -- Fixed various bugs relating to the referenceMaker and getReference() method of
           ComboPooledDataSource.
        -- Added TestUtils class to util package (modified from an old C3P0TestUtils
           class now removed from the test directory), which now contains facilities
           for establishing the identity of the physical Connection beneath a proxy,
           so that tests can check to see when they are seeing the same physical
           Connections recycled. [Thanks to Julian Legeny for calling attention to this
           issue.]
        -- Modified code generators so that inner objects of all NewProxy classes
           go to null on object close(). Closed proxies should be hopelessly broken.
        -- Added missing parameter "usesTraditionalReflectiveProxies"
           to ComboPooledDataSource
        -- Fixed bug whereby CarefulRunnableQueue threads linger indefinitely, even
           though their close() method has been called. [Thanks to muirwa on the
           hibernate forums for calling attention to this issue.]
c3p0-0.8.5-pre5
        -- added utility class for Oracle users who wish to access vendor specific
           Connection API relating to BLOBs and CLOBs. [Thanks to Dave Smith for calling
           attention to this issue.]
        -- modified ThreadPoolAsynchronousRunner to provide more information should an
           "apparent deadlock" occur, and fixed that class' recovery strategy from such
           an event. [Thanks to Damien Evans for calling attention to this issue.]
c3p0-0.8.5-pre4
        -- added config parameter usesTraditionalReflectiveProxies, which defaults to false,
           and stitched in the 'new' codegenerated, non-reflective proxy implementation for
           the default case.
c3p0-0.8.5-pre3
        -- Added new config parameters breakAfterAcquireFailure, acquireRetryAttempts, and
           acquireRetryDelay to ComboPoolBackedDataSource (forget to modify this class when
           I added the params earlier.)
        -- Added description of raw connection operations to docs.
c3p0-0.8.5-pre2
        -- Defined AuthMaskedProperties object, and used this to prevent usernames
           and passwords from being dumped to logs (a security issue). [Thanks to Zac Jacobson
           for calling attention to this issue.]
        -- Made BasicResourcePool's refurbishment of checked-in resources
           asynchronous, and used this to add a test of the resource on check-in.
           But since the extra test may slow stuff down substantially, I've disabled it
           pending a testConnectionsOnCheckin config parameter.
        -- Fixed NullPointerException in C3P0ImplUtils.findAuth(Object o) which
           occurred when the Object at issue had write-only properties. [Thanks to
           mrfekson for calling attention to this issue.]
        -- Added acquireRetryAttempts, acquireRetryDelay, and breakAfterAcquireFailure
           as configurable properties. Supporting breakAfterAcquireFailure == false
           required substantial changes to BasicResourcePool. [Thanks to Zac Jacobson
           for suggesting the behavior for breakAfterAcquireFailure == false.]
        -- Added poolOwnerIdentityToken property to PoolBackedDataSource,
           which becomes part of the state of C3P0PooledConectionPoolManager,
           to avoid possibility that multiple, identically configured pools
           that users create separately and consider distinct would be closed
           if any one of them were closed. This parameter ensures that for
           each user-created DataSource, there will be a distinct
           C3P0PooledConectionPoolManager. Multiple copies, as often arise
           via deserialization and/or dereferencing JNDI DataSources, will
           still share a single pool and configuration.
        -- Added reset methods, hard and soft, to PooledDataSource and
           its implementations. Also added some extra aggregate pool statistics
           methods. [Thanks to Travis Reeder for suggesting the hardReset() behavior.]
        -- Fixed bug that PoolBackedDataSource always provided statistics for the
           default authentication pool, even when alternate usernames and passwords
           were provided.
c3p0-0.8.5-pre1
        -- Defined the C3P0ProxyConnection interface, and modified both reflective and unreflective
           proxy Connection code to implement it. The interface provides a method through which
           advanced users can work with the raw, unproxied database Connection. This was motivated
           by some Oracle-specific API that could not be passed through the generic Connections
           returned by c3p0 pools. Thanks to Dave Smith for calling attention to this issue.
        -- Fixed a NullPointerException that resulted when users called DriverManagerDataSource's
           getConnection( username, password ) with either username or password as null. Users
           will now see the SQLException provided by their database for bad authentication, which
           should make the problem more obvious.
c3p0-0.8.4.5
        -- Modified all variants of StatementCacheKey, as well as C3P0PooledConnection (proxy Statements)
           to support jdbc3.0 API for autogenerated keys and ResultSet holdability. All jdbc 3.0 API
           is now supported.
c3p0-0.8.4.2
        -- Fixed bug in which proxy Statements and ResultSets returned their
           naked, unproxied parents from their getConnection() / getStatement()
           methods. Thanks to Christian Josefsson for noticing this!
        -- Added check to ensure that ResourcePools are not broken prior to
           posting asynchronous events. It'd be better to factor the (as yet
           unutilized async event stuff into a subclass to simplify
           BasicResourcePool).
        -- Fixed documentation typo that said default numHelperThreads was "false"...
           now it's correctly set to "3".
        -- Added extra System.err information to instrument the causes of broken
           resource pools.
        -- finalize() method of BasicResourcePool checks to be sure user has not
           already closed the pool before closing, to avoid spurious multiple
           close warnings. Thanks to Gavin King.
c3p0-0.8.4.1
        -- Added (hopefully not too annoying) dump of DataSource configuration
           on pool initialization to assist user debugging.
        -- Added methods to force destroy all resources used by a PooledDataSource,
           even if other DataSource instances are sharing those resources. This is
           intended primarily for applications that wish to discard the ClassLoader that
           loaded c3p0, regardless of whatever's currently going on.
        -- Turned off annoying trace messages when a C3P0PooledConnection closes.
        -- Fixed issue in statement cache whereby statements that fail to check-in
           properly (that throw an exception in "clearParameters") cause an exception
           in removeStatement, because removeStatement sees a statement that appears
           neither to be checked-out, nor in the deathmarch for checked-in statements.
           Resolved by re-adding truculent statement to the checkedOut set, and then
           destroying using removeStatement's codepath for removing and (force-)destroying
           checked-out statements. Thanks to Zach Scott for calling attention to
           this issue.
c3p0-0.8.4
        -- Updated and HTML-ized documentation, updated READMEs.
c3p0-0.8.4-test5
        -- Includes, but does not yet use, cleaner, nonreflective
           reimplementation of C3P0PooledConnection and all of the
           JDBC proxy wrappers. (c3p0-0.8.4 will stick with the old,
           tested implementation, c3p0-0.8.5 will replace.)
        -- Removed temporary debug wrapper around acquired Connections
           added in c3p0-0.8.4-test4-3.
c3p0-0.8.4-test4-3
        -- Fixed race condition in BasicResourcePool close(), whereby
           pooled resources were to be destroyed by an asynchronous thread
           that itself was shut down by the close() method, so the resource
           closures did not necessarily occur. Pooled resources are now
           destroyed synchronously in BasicResourcePool.close()
        -- Fixed erroneous call to C3P0PooledConnection reset() even when
           the PooledConnection is known to be broken.
        -- Added temporary debug wrapper that dumps a stack trace on physical
           Connection close() to help Adrian track down a stubborn issue.
c3p0-0.8.4-test4
        -- Made sure PooledConnection's that are known to be broken are not reset()
           when the ProxyConnection that noticed the break cleans itself up.
        -- Fixed a problem in C3P0PooledConnection's ProxyConnectionInvocationHandler
           when Connection-invalidating exceptions occurred inside the factored-out
           doSilentClose() method rather than in the invoke() method. This could lead to
           broken PooledConnections not being noticed and expunged from the pool
           prior to recheck-out.
        -- Ensured stack-trace of any Connection-invalidating Exceptions are
           logged. (Previously only the messages were logged.)
        -- Access to ProxyConnections is now synchronized to avoid a possible
           race condition where a Connection could close while another method
           was in progress.
        -- Cleaned up C3P0PooledConnection a bit, got rid of no longer used
           reflective code, modified to use new SQL interface filter classes.
        -- Reorganized bean generation stuff to sit under com.mchange.v2.codegen
        -- Added com.mchange.v2.sql.filter package, and code generation stuff so
           that abstract filter classes that implement JDBC interfaces can be
           easily regenerated from current versions. (This is preparation for
           JDK 1.4.x build support.)
c3p0-0.8.4-test3
        -- Reorganized C3P0PooledConnection and C3P0PooledConnectionPool so that
           PooledConnections only fire connectionErrorOccurred events on errors that
           signal the Connection is invalid. (Previously we fired the event in all
           cases, then tested the validity of the connection in the event handler.)
        -- Fixed a bug where SQLExceptions that do not signal invalid Connections
           (such as an exception on transaction commit under optimistic concurrency)
           caused Connections to be closed, but still returned to the pool, leaving
           the pool corrupt. [Thanks to Adrian Petru Dimulescu for discovering and
           reporting this subtle problem!]
c3p0-0.8.4-test2
        -- Backed off a binary incompatible change to DataSources API. Users
           interested in statistics about running DataSources will need to
           cast the result of DataSources.pooledDataSource() to a
           com.mchange.v2.c3p0.PooledDataSource object. Other users should
           be able to use DataSources without recompilinbg libraries that
           depend upon it.
        -- Defined com.mchange.v2.c3p0.ComboPooledDataSource, a single, directly-instantiable
           JavaBean-style DataSource backed by a c3p0 pool, which makes integration
           with various app servers easier (e.g. works with Tomcat), and which may
           provide a more straightforward API for users than DataSources and PoolConfig.
c3p0-0.8.4-test1
        -- Switched various classes from using RoundRobinAsynchronousRunner
           to a new ThreadPoolAsynchronousRunner.
        -- Defined PoolingDataSource interface, which permits clients to access
           statistics about the state of underlying pools, and made C3P0 pool-backed
           DataSources implement that interface.
        -- fixed a subtle bug with respect to ownership of shared resources in which
           finalize() methods for discarded DataSources could cause helper threads and
           other resources to be cleaned up prematurely, while they are still in use
           by other DataSources.
        -- major reorganization of code generation for DataSources and the
           resulting objects.
        -- reorganization of Serializable and Referenceable code of DataSources
           for JNDI Binding
        -- made PoolConfig defaults (which are set by system properties, a
           c3p0.properties file, or else hardcoded defaults) apply to DataSources
           that are directly instantiated rather than created via the
           com.mchange.v2.c3p0.DataSources factory class.
        -- organized scattered stuff into a self-contained, distributable build
           directly, and divided source and binary distributions
        -- relicensed library; now available under LGPL.
        -- THERE ARE SOME MAJOR REORGANIZATIONS IN THIS RELEASE. ANY HELP IN
           TESTING AND FEEDBACK WOULD BE APPRECIATED! THANKS!
c3p0-0.8.3.1
        -- take greater care to abort if a helper thread wakes from wait()
           inside of a broken resource pool
        -- log more debug information if a pool unexpectedly breaks
c3p0-0.8.3
        -- resolved a deadlock arising from ConnectionEventSupport objects
           calling event listener methods while holding the ConnectionEventSupport's
           lock. (Thanks to an anonymous Sourceforge bug submitter for tracking this
           down.)
        -- added two configuration parameters to modify how c3p0 deals with
           potentially unresolved transactions on transaction close --
           autoCommitOnClose and forceIgnoreUnresolvedTransactions. c3p0's
           default behavior is as it always was (and as I think it nearly
           always should be) -- by default we roll back any uncommitted work
           on close. See PoolConfig class for complete documentation.
        -- fixed stupid build error that made unzipping c3p0 archives messy
           since c3p0-0.8.2. (SORRY!)
c3p0-0.8.3-pre-travis
        -- fixed problem with c3p0 trying endlessly to connect to a database
           that is down or not present. c3p0 now tries thirty time, once per
           second, then gives up. if there's demand, I'll make the delay and
           number of attempts user configurable. Thanks to Alfonso da Silva
           for calling attention to this problem.
        -- modified RoundRobinAsynchronousRunner to die more gracefully if,
           somehow, one of its CarefulAsynchronousRunners somehow dies. Thanks to
           Travis Reeder for calling attention to this issue.
        -- modified ResourcePools to allow resources to be tested periodically
           and asynchronously while they are idle in the pool.
        -- added to a new configuration property to PoolConfig and related
           classes, idleConnectionTestPeriod, which if set to a greater-than-zero
           value will cause c3p0 to periodically test idle, pooled connection,
           and remove them from the pool if they are broken.  Thanks to
           Travis Reeder for calling attention to this issue.
        -- removed SQLState 08S01 from the set of SQL states presumed to mean
           all connections in the pool have become invalid. Apparently MySQL
           uses this SQLState to indicate the timing out of idle, individual
           connections.  Thanks to Travis Reeder for calling attention to this issue.
        -- many (!) bug-fixes, small tweaks and improvements.
        -- temporarily sprinkled some debugging output prefixed "c3p0-TRAVIS" to
           try to resolve some issues for Travis Reeder
c3p0-0.8.2
        -- Addressed a rare problem that ocurred when application servers or
           other external code calls interrupt() on c3p0 helper threads. Thanks
           to Travis Reeder for reporting this issue! The endless cascade of
           ArrayIndexOutOfBoundsException that would occasionallY result has
           been fixed, and c3p0 helper threads now ignore interupts,
           which should almost completely prevent such interrupts()
           from leaving c3p0 pools in a corrupt state. [In the very, very
           unlikely event that multiple, well-timed interrupts() cause
           a pool to diagnose itself broken, c3p0 will start throwing clear
           exceptions to indicate that -- there shouldn't be any deadlock or
           any subtle kind of corruption.]
        -- Deprecated PoolBackedDataSourceFactory and DriverManagerDataSourceFactory
           in favor of the newer DataSources class.
        -- Updated example code and documentation.
        -- Moved constants from DataSources to PoolConfig where they belong!
c3p0-0.8.2-pre10
        -- Removed use of properties default mechanism in setting up JDBC
           properties for DriverManagerDataSource, as some drivers use get()
           rather than getProperties(), and the Properties.get() method ignores
           defaults. [Thanks go to Michael Jakl <mj@int-x.org> for both finding
           and fixing this problem!!!]
        -- Fixed subtle problem whereby the introspective constructor of
           C3P0PooledConnectionPoolManager would inadvertently check out an
           extra pooled connection, by treating the getPooledConnection() as
           a simple property read and invoking it. [Thanks go to Michael Jakl
           <mj@int-x.org> for both finding and fixing this bug!!!]
c3p0-0.8.2-pre9
        -- Finished DataSources static factory for, um, DataSources.
        -- Added PoolConfig class to encapsulate all configuration
           information from factories
        -- Set up PoolConfig to pay attention to (in order):
             1) explicit, user-defined parameters
             2) parameters defined as System properties
             3) parameters defined in a Properties file resource, at
                resource pasth /c3p0.properties in PoolConfig's classloader
             4) Hardcoded defaults from the C3P0Defaults class
        -- Defined a new pool configuration property, "testConnectionOnCheckout".
           If set to true (it defaults to false), each pooled Connection will be
           verified at checkout time, before being supplied to clients. THIS SLOWS
           CONNECTION CHECKOUT DRAMATICALLY (by an order of magnitude on my machine),
           but some folks may want it. The expensive, verified Connections are still
           faster to acquire than brand new ones.
        -- If a Connection experiences an SQLException with a defined SQL State of
           08001, 08007, or 08S01, the entire database is considered to have been
           shutdown, and the pool whose connection experienced the problem is reset
           -- i.e. all existing Connections are discarded, and new Connections are
           acquired for the pool. (Thanks! to Gavin King for suggesting the SQL State
           approach to detecting disconnects.)
        -- ConnectionTester interface and its default implementation were modified
           to support reporting DATABASE_IS_INVALID (rather than simply testing a
           disconnected, individual Connection).
c3p0-0.8.2-pre8
        -- Fixed some really stupid bugs from pre-7, in particular
           the static factory methods of the DataSources class were
           not declared static. Oops.
c3p0-0.8.2-pre7
        -- Major reorganization of data source implementations. These
           are now generated from XML templates, because it was becoming
           difficult to keep multiple versions of multiple types of
           datasources in sync with one another
        -- a new factory / utility class has been added,
           com.mchange.v2.c3p0.DataSources.
           Soon the older factories (DriverManagerDataSourceFactory and
           PoolBackedDataSourceFactory) will be deprecated in favor of this.
        -- Began adding support for wrapper DataSources that lazily bind to
           an unpooled DataSource specified via JNDI. (Current wrappers require
           an actual instance, not a mere reference in order to construct a
           PoolBacked or ConnectionPoolDataSource).
c3p0-0.8.2-pre6
        -- Fixed bug that led to ConcurrentModificationException
           when Connection.close() iterates through and closes
           its unclosed Statements.
        -- Fixed bug that caused uncached Statements to sometimes
           be closed twice, as they were not properly removed from
           the set of Connection-associated statements on user-
           initiated Statement.close(), and would thus be closed
           again on Connection.close().
        -- Reorganized classes to clean up top-level com.mchange.v2.c3p0
           package. The gory innards of c3p0 now live in an impl package.
        -- Reorganized DataSources so that there are "Base" versions suitable
           for DBMS-specific subclassing.
c3p0-0.8.2-pre5
        -- DataSources looked up by JNDI now "coalesce" -- i.e., if
           two separate calls look-up the same JNDI bound DataSource,
           they will both see the same DataSource instance in the local
           VM. This is especially important for PoolBackedDataSources, as they
           own "helper threads" that help to manage the pool. Now each
           logical DataSource shares the same pool of helper threads,
           regardless of whether it is looked up once and cached, or
           looked up multiple times and at multiple places by an application.
        -- Number of helper-threads managing a PoolBackedDataSource is now
           user-configurable
c3p0-0.8.2-pre4
        -- Fixed BAD memory leak -- cachedStatements were being retained
           on close. This brings a performance improvement to
           the StatementCache as well.
        -- Set-up StatementCacheKey to coalesce, such that its equals
           method can look like {return (this == o);}. Unfortunately, I
           did not see the kind of performance increase I'd anticipated
           from this... in fact, whatever performance changes I did see were
           pretty negligable. Performed some other, mostly useless, optimizations
           to the process of acquiring StatementCacheKeys. (I can't decide...
           I've got 3 usuable, broadly similar versions of StatementCacheKey now.)
        -- Fixed bugs having to do with when to create and the daemon status
           of Timers
        -- Appropriately synchronized access to PoolBackedDataSource. (This
           should permit me to pull back on synchronization / marking of
           volatile in some dependent classes, as access to these is now
           controlled via PoolBackedDataSource.)
        -- Made instantion of C3P0PooledConnectionPoolManager
           by WrapperPoolBackedDataSource "lazy", so that Timer / Async task
           threads are only started up when a Connection is actually requested
           from a DataSource. This is useful especially for the instance residing
           in the JNDI server VM, whose purpose is likely only to serve as an
           instance to be looked up over the network. There's no reason why
           it should keep several stalled Threads open.
        -- Fixed DefaultConnectionTester, whose logic was bass-ackwards.
c3p0-0.8.2-pre3
        -- Factory method for StatementCacheKeys now "coalesce" equivalent
           instances to conserve memory and to enable a fast (this == o) test
           to usually work in equals methods. [Value test remains for when
           identity test fails... maybe later I'll be more comfortable with a
           1 instance per value guarantee, and remove the rest of the test.
           As the constructor is private, the factory method coalesces, and the
           class is not Serializable, an identity test should suffice. But
           I'm paranoid.]

        -- All asynchronous tasks are now distributed to 3 helper threads per
           DataSource rather than queuing on just one. (Culing of expired
           Connections is still managed by a single java.util.Timer... I don't
           think this will be a problem.)

c3p0-0.8.2-pre2
        -- Total rewite of Statement cache!
