How to improve statement caching efficiency with IN clause parameter padding

Imagine having a tool that can automatically detect if you are using JPA and Hibernate properly. Hypersistence Optimizer is that tool!

Introduction

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 that supports Execution Plan caching.

Default behavior

Now, considering we have the following JPA entity:

@Entity(name = "Post")
@Table(name = "post")
public class Post {

    @Id
    private Integer id;

    private String title;

    //Getters and setters omitted for brevity
}

And, let’s say we want to load multiple Post entities by their identifiers using the following JPA entity query:

List<Post> getPostByIds(
        EntityManager entityManager, 
        Integer... ids) {
    return entityManager.createQuery(
        "select p " +
        "from Post p " +
        "where p.id in :ids", Post.class)
    .setParameter("ids", Arrays.asList(ids))
    .getResultList();
}

When running the following test case:

assertEquals(
    3, 
    getPostByIds(entityManager, 1, 2, 3).size()
);

assertEquals(
    4, 
    getPostByIds(entityManager, 1, 2, 3, 4).size()
);

assertEquals(
    5, 
    getPostByIds(entityManager, 1, 2, 3, 4, 5).size()
);

assertEquals(
    6, 
    getPostByIds(entityManager, 1, 2, 3, 4, 5, 6).size()
);

Hibernate will execute the following SQL statements:

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (? , ? , ?)
"], 
Params:[
    1, 2, 3
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (?, ?, ?, ?)
"], 
Params:[
    1, 2, 3, 4
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (? , ? , ? , ? , ?)
"], 
Params:[
    1, 2, 3, 4, 5
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (? , ? , ? , ? , ? , ?)
"], 
Params:[
    1, 2, 3, 4, 5, 6
]

Each invocation generates a new SQL statement because the IN query clause requires a different number of bind parameters.

However, if the underlying relational database provides an Execution Plan cache, these 4 SQL queries will generate 4 different Execution Plans.

Therefore, in order to reuse an already generated Execution Plan, we need to use the same SQL statement String value for multiple combinations of IN clause bind parameters.

In clause parameter padding

If you enable the hibernate.query.in_clause_parameter_padding Hibernate

<property>
    name="hibernate.query.in_clause_parameter_padding"
    value="true"
</property>

And rerun the previous test case, Hibernate will generate the following SQL queries:

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (?, ?, ?, ?)
"], 
Params:[
    1, 2, 3, 3
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (?, ?, ?, ?)
"], 
Params:[
    1, 2, 3, 4
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (? , ? , ? , ? , ? , ? , ? , ?)
"], 
Params:[
    1, 2, 3, 4, 5, 5, 5, 5
]

Query:["
    SELECT  p.id AS id1_0_, p.title AS title2_0_
    FROM    post p
    WHERE   p.id IN (? , ? , ? , ? , ? , ? , ? , ?)
"], 
Params:[
    1, 2, 3, 4, 5, 6, 6, 6
]

Therefore, this time, only 2 Execution Plans are needed since both the first two queries and the last two ones have the same number of bind parameter values.

This is possible because Hibernate is now padding parameters until the next power of 2 number. So, for 3 and 4 parameters, 4 bind parameters are being used. For 5 and 6 parameters, 8 bind parameters are being used.

Cool, right?

If you enjoyed this article, I bet you are going to love my Book and Video Courses as well.

Conclusion

If you’re using Oracle or SQL Server, then you can benefit from Execution Plan caching. The IN clause parameter padding feature increases the chance of reusing an already generated Execution Plan, especially when using a large number of IN clause parameters.

FREE EBOOK

7 Comments on “How to improve statement caching efficiency with IN clause parameter padding

    • There is this Pull Request, but I would not do it for Batch fetching. I’d do it for the IN clause JPQL and Criteria API queries only. Anyway, the 5.x branches do not accept any improvements, so this one can only be done in 6.x. I’ll wait for the 6.0 branch to be stable enough to investigate the best way to do it.

  1. Do I get that right that this only applies to jpql/hql queries, but neither to legacy criteria nor to jpa criteria? At least my smoke tests indicate that.

    • It applies to Criteria API too as long as you bind the variable as parameters, not as literals.

      • I see, just tested this and it worked (JPA criteria). Correct me if I’m wrong, but there isn’t any possibility to bind parameters to the legacy criteria API (we have several spots where we still use this), so this is another reason to migrate to JPA criteria.

      • The legacy Criteria is deprecated for a very long time. If it does not support passing parameters, you might want to switch to JPA Criteria API.

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.