Home > Java > Hibernate hard facts – Part 5

Hibernate hard facts – Part 5

In the fifth article of this serie, I will show you how to manage logical DELETE in Hibernate.

Most of the time, requirements are not concerned about deletion management. In those cases, common sense and disk space plead for physical deletion of database records. This is done through the DELETE keyword in SQL. In turn, Hibernate uses it when calling the Session.delete() method on entities.

Sometimes, though, for audit or legal purposes, requirements enforce logical deletion. Let’s take a products catalog as an example. Products regularly go in and out of the catalog. New orders shouldn’t be placed on outdated products. Yet, you can’t physically remove product records from the database since they could have been used on previous orders.

Some strategies are available in order to implement this. Since I’m not a DBA, I know of only two. From the database side, both add a column, which represents the deletion status of the record:

  • either a boolean column which represent either active or deleted status
  • or, for more detailed information, a timestamp column which states when the record was deleted; a NULL meaning the record is not deleted and thus active

Managing logical deletion is a two steps process: you have to manage both selection so that only active records are returned and deletion so that the status marker column is updated the right way.


A naive use of Hibernate would map this column to a class attribute. Then, selecting active records would mean a WHERE clause on the column value and deleting a record would mean setting the attribute and calling the update() method. This approach has the merit of working. Yet, it fundamentally couples your code to your implementation. In the case you migrate your status column from boolean to timestamp, you’ll have to update your code everywhere it is used.

The first thing you have to do to mitigate the effects of such a migration is to use a filter.

Hibernate3 provides an innovative new approach to handling data with “visibility” rules. A Hibernate filter is a global, named, parameterized filter that can be enabled or disabled for a particular Hibernate session.

Such filters can the be used throughout your code. Since the filtering criteria is thus coded in a single place, updating the database schema has only little incidence on your code. Back to the product example, this is done like this:

@FilterDef(name = "activeProducts")
@Filter(name = "activeProducts", condition = "DELETION_DATE IS NULL")
public class Product {

  @Column(nullable = false)
  @GeneratedValue(strategy = AUTO)
  private Integer id;


Note: in the attached source, I also map the DELETION_DATE on an attribute. This is not needed in most cases. In mine, however, it permits me to auto-create the schema with Hibernate.

Now, the following code will filter out logically deleted records:


In order to remove the filter, either use Session.disableFilter() or use a new Session object (remember that factory.getCurrentSession() will probably use the same, so factory.openSession() is in order).


The previous step made us factorize the “select active-only records” feature. Logically deleting a product is still coupled to your implementation. Hibernate let us decouple further: you can overload any CRUD operations on entities! Thus, deletion can be overloaded to use an update of the right column. Just add the following snippet to your entity:


Now, calling session.delete() on an Product entity will produce the updating of the record and the following output in the log:


With CRUD overloading, you can even suppress the ability to select inactive records altogether. I wouldn’t recommend this approach however, since you wouldn’t be able to select inactive records then. IMHO, it’s better to stick to filters since they can be enabled/disabled when needed.


Hibernate let you loosen the coupling between your code and the database so that you can migrate from physical deletion to logical deletion with very localized changes. In order to do this, Hibernate offers two complementary features: filters and CRUD overloading. These features should be part of any architect’s bag of tricks since they can be lifesavers, like in previous cases.

You can find the sources of this article here in Maven/Eclipse format.

To go further:

Send to Kindle
Categories: Java Tags:
  1. March 26th, 2010 at 16:34 | #1

    Nice and helpful writeup. I will definitely give it a try.

    Can you clarify if this overloading of delete operation handles the cascading delete as well?

  2. March 26th, 2010 at 18:54 | #2

    I don’t understand the question: if you delete logically, where’s the need to cascade?

  3. October 8th, 2010 at 05:01 | #3

    We implemented a solution using Hibernate Filter. But since you have to activate the filter on the session and since our domain project was being pulled into a bunch of other Web application projects, we decided to go with the @Where on the domain class instead. This way we don’t have to touch the SessionFactory in all the applications and they still get the filtered data we expect.

  4. Tathagat
    November 5th, 2010 at 08:02 | #4

    Boy, you saved my life :). Excellent post!

  5. EB
    June 8th, 2011 at 06:47 | #5

    @Nicolas Frankel

    If you logically delete the parent record in a primary-foreign key relationship shouldn’t the child records not be fetched as well? How would that be handled if its a requirement?

  6. June 8th, 2011 at 08:50 | #6

    You would have to craft your DELETE statement accordingly.

  7. Greg Clark
    June 12th, 2013 at 14:11 | #7

    Nicolas, thank you very much. You saved me a significant amount of time today, with this article.

  1. No trackbacks yet.