Connector/J load-balancing for auto-commit-enabled deployments
In a previous blog post, I wrote about Connector/J’s failover policies, I described three triggers which cause Connector/J to re-balance (potentially selecting a new physical connection to another host):
- At transaction boundaries (transactions are explicitly committed or rolled back)
- A communication exception (SQL State starting with “08”) is encountered
- When a SQLException matches conditions defined by user, using the extension points defined by the loadBalanceSQLStateFailover, loadBalanceSQLExceptionSubclassFailover or loadBalanceExceptionChecker properties.
Those conditions fit most needs very well, but there are situations where people are running with auto-commit enabled (no explicit transaction commit or rollback), and the end result is that Connector/J never re-balances, and keeps chugging away using the same physical connection. That’s a problem – particularly when load-balancing is being used under-the-hood to distribute read-only load across multiple slaves. And as of today, there is new functionality which allows Connector/J to be configured to re-balance after a certain number of statements when auto-commit is enabled. This functionality is dependent upon the following new properties:
- loadBalanceAutoCommitStatementThreshold – defines the number of matching statements which will trigger the driver to (potentially) swap physical server connections. The default value (0) retains the previously-established behavior that connections with auto-commit enabled are never balanced.
- loadBalanceAutoCommitStatementRegex – the regular expression against which statements must match. The default value (blank) matches all statements.
So, for example, using the following properties will cause Connector/J to re-balance after every third statement which contains the string “test”:
Why does loadBalanceAutoCommitStatementRegex exist? Maybe your application uses temporary tables. Maybe it uses server-side variables. Maybe it uses some other connection state that wouldn’t be good to lose by letting the driver arbitrarily swap physical connections before you are done with it (this post explores some of these scenarios). This allows you to identify a trigger statement which is only executed at times where it is known to be safe to swap physical connections. Generally, you likely won’t need to use it, but it may come in handy if you rely on server session-side state.