Criteria Update/Delete – The easy way to implement bulk operations with JPA2.1

---

Take your skills to the next level!

The Persistence Hub is the place to be for every Java developer. It gives you access to all my premium video courses, monthly Java Persistence News, monthly coding problems, and regular expert sessions.

Join the Persistence Hub!

---

JPA 2.1 added a list of nice features to the specification. One of them is the support for bulk update and delete operations in the Criteria API. We will have a look at the new CriteriaUpdate and CriteriaDelete classes in this article.

If you like to learn more about the other features added in JPA 2.1, have a look at this overview or download the free New Features in JPA 2.1 cheat sheet.

CriteriaUpdate

The CriteriaUpdate interface can be used to implement bulk update operations. But be careful, these operations are directly mapped to database update operations. Therefore the persistence context is not synchronized with the result and there is no optimistic locking of the involved entities. If you use optimistic locking, you need to update the version column as part of your update statement.

The following code shows a bulk update of the amount of multiple orders.

@Stateless
@LocalBean
public class OrderManagement {
    @PersistenceContext
    private EntityManager em;

    ...

    public void updateOrder(Double oldAmount, Double newAmount) {
        CriteriaBuilder cb = this.em.getCriteriaBuilder();

        // create update
        CriteriaUpdate<Order> update = cb.
        createCriteriaUpdate(Order.class);

        // set the root class
        Root e = update.from(Order.class);

        // set update and where clause
        update.set("amount", newAmount);
        update.where(cb.greaterThanOrEqualTo(e.get("amount"), oldAmount));

        // perform update
        this.em.createQuery(update).executeUpdate();
    }

    ...
 
}

As you can see, the implementation is very similar to implementing a CriteriaQuery known from JPA2.0. The main differences are the usage of the CriteriaUpdate interface and the call of the update specific set method.

CriteriaDelete

The usage of the CriteriaDelete interface for bulk delete operations is nearly the same as of the CriteriaUpdate interface. Like the CriteriaUpdate operations, the CriteriaDelete operations are directly mapped to database delete operations. Therefore the persistence context is not synchronized with the result of this operation.

The example of a CriteriaDelete operation looks similar to the usage of CriteriaQuery known from JPA2.0 and the CriteriaUpdate operation described above:

@Stateless
@LocalBean
public class OrderManagement {
    @PersistenceContext
    private EntityManager em;
 
    ...
 
    public void deleteOrder(Double amount) {
        CriteriaBuilder cb = this.em.getCriteriaBuilder();

        // create delete
        CriteriaDelete<Order> delete = cb.
         createCriteriaDelete(Order.class);

        // set the root class
        Root e = delete.from(Order.class);

        // set where clause
        delete.where(cb.lessThanOrEqualTo(e.get("amount"), amount));

        // perform update
        this.em.createQuery(delete).executeUpdate();
    }
}

OK, I don’t think this needs any explanation …

Conclusion

The new CriteriaUpdate and CriteriaDelete interfaces add the missing bulk update and delete operations to the Criteria API. From my point of view this is a small but great enhancement that allows us to use the Criteria API in even more situations. I like it!
If you want to try it yourself, you can use any JPA 2.1 implementation like Hibernate or EclipseLink . You can find the source code of the examples in my github repo.

And don’t forget to download your New Features in JPA 2.1 cheat sheet.

And if you like to read more about the new JPA 2.1 features, make sure to have a look at my other articles …