Chronicle Map VS HikariCP

I decided to start with an overview of what open-source options are currently available. When it comes to the implementation of the on-heap cache mechanism, the options are numerous – there is well known: guava, ehcache, caffeine and many other solutions. However, when I began researching cache mechanisms offering the possibility of storing data outside GC control, I found out that there are very few solutions left. Out of the popular ones, only Terracotta is supported. It seems that this is a very niche solution and we do not have many options to choose from. In terms of less-known projects, I came across Chronicle-Map, MapDB and OHC. I chose the last one because it was created as part of the Cassandra project, which I had some experience with and was curious about how this component worked:

Chronicle-Map: Chronicle Map is an in-memory, key-value store, designed for low-latency, and/or multi-process applications.

I've wrangled data sets in the ~600gb range using nothing but plain old Java and a few beefy boxes. This can all be kept in memory, but you have to go off-heap. You can use Chronicle Map and Chronicle Values to model this data and work with it off-heap in a way that's still very clean and object oriented. 128gb of RAM is cheap these days, whether you're in the cloud or not.

Looks like HikariCP is also awaiting fixes for this https://github.com/brettwooldridge/HikariCP/pull/2055

I have used hikari and exposed to do this in the past with postgres, although other dialects are supported.

I found one suggestion from the author of HikariCP on how to address this, which I implemented and it worked. However, there are additional classes involved, and it feels a little clunky and hard to follow.

Not really, you can change some things in spring boot but doing so will typically trigger a refresh which is less reliable than restarting but still causes a large performance hit. You could probably do it with hikari if you really needed to but it's inadvisable to build your application around this mechanic.

# https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing

Not familiar with Python but this thread about a Java connection pool might be interesting: https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing

Whatever you choose, presuming your app is database heavy, I highly recommend spending time on DB schema design to make all queries as short as possible, avoid relying on transactions, and keep your connection pool tiny. For reference: https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing

You reminded me of the HikariCP library and it’s documentation: Clear and simple with references to other libraries trying to accomplish the same thing. It is not in the closure space though.

https://github.com/brettwooldridge/HikariCP