In this article, I will show you how to manage logical DELETE in Hibernate.
This is the 5th post in the Hibernate hard facts focus series.Other posts include:
- Hibernate hard facts part 1
- Hibernate hard facts part 2
- Hibernate hard facts part 3
- Hibernate hard facts - Part 4
- Hibernate hard facts – Part 5 (this post)
- Hibernate hard facts - Part 6
- Hibernate hard facts – Part 7
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
NULLmeaning 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.
Selection
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:
@Entity
@FilterDef(name = "activeProducts")
@Filter(name = "activeProducts", condition = "DELETION_DATE IS NULL")
public class Product {
@Id
@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:
session.enableFilter("activeProducts");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).
Deletion
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:
@SQLDelete(sql = "UPDATE PRODUCT SET DELETION_DATE=CURRENT_DATE WHERE ID=?")Now, calling session.delete() on an Product entity will produce the updating of the record and the following output in the log:
UPDATE PRODUCT SET DELETION_DATE=CURRENT_DATE WHERE ID=?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.
Conclusion
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.