AO Database Connectivity Changelog

DatabaseAccess now implements transactional methods instead of them only being on Database. This allows code to accept DatabaseAccess while still being able to efficiently have its own transactional block. Previously, DatabaseAccess was typically used only for one-off database calls.

When transactional methods are via a Database instance, the implementation is the same as before. When the transactional methods are via a DatabaseConnection, they are directly implemented on the connection.

Breaking change: Single-row DatabaseAccess.queryObject(…), DatabaseAccess.updateObject(…), and all related more specific type methods will no longer return null when there is a row with a SQL NULL value, instead will throw NullDataException. This was already the behavior for primitive types (and related wrappers). This aligns the behavior across all types.

When SQL NULL values are expected, use one of the new DatabaseAccess.queryObjectNullable(…), DatabaseAccess.queryObjectOptionalNullable(…), or related more specific type methods.

Fixed bug where NoRowException (and similar) were being wrapped, which was interfering with catch blocks.

Removed all uses of WrappedSQLException. Now registers SQL statements directly with ErrorPrinter instead. This allows the SQL statements to be logged while not altering exception types underneath the application.

1. DatabaseConnection.rollback() now throws SQLException, instead of logging and returning.
2. New DatabaseConnection.rollback(Throwable) that adds any exceptions occurring during rollback to the given throwable via Throwable.addSuppressed(Throwable).
3. Deprecated DatabaseConnection.rollbackAndClose() in favor of either explicit DatabaseConnection.rollback() or relying on the automatic rollback of transactions in-progress during DatabaseConnection.close(). Furthermore, any connection with an unresolved fail-fast state will be validated and closed as-needed before being returned to the underlying connection pool.
4. DatabaseConnection.rollbackAndClose() (now deprecated) now throws SQLException, instead of logging and returning.
5. New DatabaseConnection.rollbackAndClose(Throwable) (also deprecated) that adds any exceptions occurring during rollback to the given throwable via Throwable.addSuppressed(Throwable).
6. Database.getConnection(…) now adds any exceptions occurring during clean-up (close and/or release connection) to the first throwable via Throwable.addSuppressed(Throwable).
7. DatabaseConnection now implements AutoCloseable, with the expectation to by used via try-with-resources.

execute*Query(…) and execute*Update(…) that return Java primitives, along with the specialized primitive-list executeIntList*(…) and executeLongList*(…), now throw a new NullDataException when the result returns a NULL value.

Previously, the default conversion was used. Any code that relied on this default conversion will need to be updated: a small lambda on queryObject(…) or updateObject(…) would do the trick.

1. New protected method Database.release(Connection) that performs the release.
2. This implementation adds AO Concurrent as new dependency.

Now registering exception types for use with Throwables.newSurrogate(…) that supports creating new instances of throwables in order to have caller stack trace. When wrapped, the original throwable is the cause of the new throwable. When not wrapped, the original throwable is used directly and caller stack trace is lost.

This is used to maintain exception types and states across thread boundaries, such as when an exception cause is obtained from an ExecutionException.

Fetch size increased from 1000 to 10000 rows.

This value may be increased over time as the amount of typical system memory increases. As this may affect the number of round trips, and the speed of light is not likely to change, future increases may be of benefit.

1. This project uses managed dependencies.
2. This project's managed dependencies may also be imported by other projects.

The lock contention profiler in NetBeans is just showing "java.lang.Object" all over, and can't seem to get from the lock object id to the actual object in the heap dump using OQL (id not found).