When I talk about jOOQ at conferences, I always show this slide containing a bunch of very common JDBC mistakes that people often commit:
Six common JDBC bugs in this image
Can you find the bugs? Some of them are obvious, such as:
- Line 4: Syntax errors resulting from bad concatenation on line 3
- Line 7: Syntax errors and SQL injection risk due to variable inlining
- Line 8: Wrong bind index resulting from a potential mismatch on line 3
- Line 14: Wrong column name due to sloppy rename
- Line 18: Bad resource management
But then, there’s another very subtle bug that most people are unaware of because the fix was only possible since the upgrade in Java 6 / JDBC 4.0. See the solution, below:
Solution to the previous six bugs
- Line 15:
Clob.free()is not called
With JDBC 4.0, the
Clob.free() and the
Blob.free() methods were introduced. While calling them is optional, it may be a very bad idea not to call them as early as possible, as you should not rely on the garbage collector to kick in early enough to free these resources. In fact, in certain databases / JDBC drivers, LOBs can outlive individual statements and/or transactions. They’re beasts of their own. If you’re reading through the JDBC tutorial (and also in the JDBC specification), it says:
Blob, Clob, and NClob Java objects remain valid for at least the duration of the transaction in which they are created. This could potentially result in an application running out of resources during a long running transaction.
The same is true for arrays, which also have an
Array.free() method since Java 6 / JDBC 4.0.
So if your application has long-running transactions, do call these
free() methods, or make it a habit to always call them. We’ll file an issue to FindBugs to make this a potential bug pattern.
Get ready to program in a whole new way!
Functional Programming in Java will help you quickly get on top of the new, essential Java 8 language features and the functional style that will change and improve your code. This short, targeted book will help you make the paradigm shift from the old imperative way to a less error-prone, more elegant, and concise coding style that’s also a breeze to parallelize. You’ll explore the syntax and semantics of lambda expressions, method and constructor references, and functional interfaces. You’ll design and write applications better using the new standards in Java 8 and the JDK.