Asynchronous Database Access (ADBA) defines a non-blocking database access API for Java platform. At the time of writing, it is still a draft, and JDBC Expert Group is discussing what it should look like. ADBA was announced at the JavaOne 2016 conference and has been under discussion for a couple of years now. ADBA is intended to complement the current JDBC API and propose an asynchronous alternative (not a replacement) geared toward high-throughput programs. ADBA is designed to support the fluent programming style and provide a builder pattern for composing database queries. ADBA is not an extension to JDBC and has no dependencies on it. When ready, most likely, ADBA will live in the java.sql2 package.

ADBA it is an asynchronous API, so no method calls should block while doing a network call. All potentially blocking actions are represented as separate ADBA operations. A client application builds and submits one ADBA operation or a graph of ADBA operations. A driver that implements ADBA asynchronously executes the operation and reports the result via java.util.concurrent.CompletionStage or callbacks. When ready, an asynchronous SQL that requests issues over ADBA may look as follows:

CompletionStage<List<String>> employeeNames =                        // (1)
connection
   .<Integer>rowOperation("select * from employee")                  // (2)
   .onError(this::userDefinedErrorHandler)                           // (3)
   .collect(Collector.of(                                            // (4)
      () -> new ArrayList<String>(),
      (ArrayList<String> cont, Result.RowColumn row) ->
          cont = cont.add(row.at("name").get(String.class)),
      (l, r) -> l,
      container -> container))
   .submit()                                                         // (5)
   .getCompletionStage();                                            // (6)

Note that the preceding code is still based on an ADBA draft so that the API may change at any time. However, the numbered lines mean the following:

1. The query returns result in CompletionStage. In our case, we return a list of employees' names.
2. This initiates a new row operation by calling the rowOperation method of the database connection.
3. The operation allows registering error handlers by invoking the onError method. Error handling happens in our custom userDefinedErrorHandler method.

4. The collect method allows gathering results using Java Stream API collectors.
5. The submit method starts processing the operation.
6. The getCompletionStage method gives the user an instance of CompletionStage that will hold the result when the processing is finished.

Of course, ADBA is going to provide the ability to write and execute more complex database queries, including conditional, parallel, and dependent operations. ADBA has support for transactions. However, in contrast with JDBC, ADBA is not intended to be used directly by business code (even though it is possible), but rather intended to provide an asynchronous basis for more high-level libraries and frameworks.

At the time of writing, ADBA has only one implementation, called AoJ. AoJ (https://gitlab.com/asyncjdbc/asyncjdbc/tree/master) is an experimental library that implements a subset of the ADBA API by invoking the standard JDBC on a separate thread pool. AoJ is not suitable for production use, but provides the ability to play with ADBA without the need to implement a full-blown asynchronous driver.