While doing my High-Performance Java Persistence training, I realized that not all developers are familiar with the
getReference method of the JPA
EntityManager and most of them use
find almost exclusively.
In this article, we are going to see the difference between the
getReference method so that it’s clear when to apply them depending on the underlying use case.
Continue reading “How do find and getReference EntityManager methods work when using JPA and Hibernate”
Traditionally, both MySQL and MariaDB relied on AUTO_INCREMENT columns to generate an IDENTITY Primary Key. Although IDENTITY columns are very efficient in generating the Primary Key value, when it comes to using JPA and Hibernate, the IDENTITY generator prevents us from using JDBC batch inserts.
To automatically enroll multiple INSERT, UPDATE or DELETE statements, Hibernate requires delaying the SQL statement until the Persistence Context is flushed. This works very well for the SEQUENCE identifier since the entity identifier can be fetched prior to executing the INSERT statement.
However, for IDENTITY columns, the only way to know the entity identifier is if we execute the SQL INSERT statement. And, Hibernate needs the entity identifier when persisting an entity because otherwise, it cannot build the key which is used for locating an entity in the currently running Persistence Context.
Continue reading “MariaDB 10.3 supports database sequences”
Recently, I stumbled on the following Twitter thread:
This jOOQ feature is indeed really useful since it reduces the number of SQL statements that have to be generated when varying the IN clause parameters dynamically.
Starting with Hibernate ORM 5.2.18, it’s now possible to use IN clause parameter padding so that you can improve SQL Statement Caching efficiency.
In this article, I’m going to explain how this new mechanism works and why you should definitely consider it when using a relational database system which supports Execution Plan caching.
Continue reading “How to improve statement caching efficiency with IN clause parameter padding”
Linearizability is a lesser-known, yet omnipresent property of a data registry in the context of read and write operations that might happen concurrently.
This article aims to explain what linearizability consists of, and why it’s more prevalent that you might have previously thought.
Continue reading “A beginner’s guide to Linearizability”
While answering this StackOverflow question, I realized that it’s a good idea to summarize how various bidirectional associations should be synchronized when using JPA and Hibernate.
Therefore, in this article, you are going to learn how and also why you should always synchronize both sides of an entity relationship, no matter if it’s
Continue reading “How to synchronize bidirectional entity associations with JPA and Hibernate”