well, I think the best way is first to create a “true” async driver for PostgreSQL (actually PostgreSQL is async, so it might be benefitical the most).
Currently there is already one async driver that could probably be integrated into slick: https://github.com/mauricio/postgresql-async/ I don’t think that this driver is suitable.
The problem with this driver is, that there can only be one query per connection, which means that without correct pooling this driver is probably not really useful at all.
A better approach would probably to use either Finagle (I have no experience with that) or Akka-Stream and actually represent a connection as a Stream and Each “transaction” can be a stream as well, that means that you can configure how much queries are inside the queue.
I actually toyed with that kind of idea already: https://github.com/schmitch/akka-pg however besides a demonstration that it might be possible, I didn’t came too far.
Currently I use this driver to have a simple pub/sub over a single PostgreSQL instance (more instances don’t work since notifies won’t get replicated) which works fully async.
Kind of missing is actually a way to reconnect flow, however that can be implemented relativly easily on future akka versions, thanks to jroper: https://github.com/akka/akka/pull/23367
I think the good thing about a akka-stream database driver would not only be the async nature, but also the backpressure of reactive-streams, so that there is no possible way to kill the database server with too many queries.
What I basically wanted to say is, that I think before Slick get’s integration for a async driver, scala should basically first have a stable and well looking driver, that has a nice internal design.