{"id":18647,"date":"2013-11-04T16:00:43","date_gmt":"2013-11-04T14:00:43","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=18647"},"modified":"2013-11-01T10:16:34","modified_gmt":"2013-11-01T08:16:34","slug":"efficiently-delete-data-with-jpa-and-hibernate","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2013\/11\/efficiently-delete-data-with-jpa-and-hibernate.html","title":{"rendered":"Efficiently delete data with JPA and Hibernate"},"content":{"rendered":"

You may come to the situation where you have to perform a bulk deletion on a huge amount of datasets stored in a relational database. If you use JPA with Hibernate as underlying OR mapper, you might try to call the remove() method of the EntityManager in a way like the following:
\n 
\n 
\n 
\n 
\n 
\n 
\n <\/p>\n

public void removeById(long id) {\r\n    RootEntity rootEntity = entityManager.getReference(RootEntity.class, id);\r\n    entityManager.remove(rootEntity);\r\n}<\/pre>\n
First of all, we load a reference representation of the entity we want to delete and then pass this reference to the EntityManager. Let\u2019s assume the RootEntity from above has a child relation to a class called ChildEntity:<\/p>\n
@OneToMany(mappedBy = \"rootEntity\", fetch = FetchType.EAGER, cascade = CascadeType.ALL)\r\nprivate Set childEntities = new HashSet(0);<\/pre>\n
If we now turn on the property show_sql of hibernate, we will wonder what SQL statements are issued:<\/p>\n
select\r\n        rootentity0_.id as id5_1_,\r\n        rootentity0_.field1 as field2_5_1_,\r\n        rootentity0_.field2 as field3_5_1_,\r\n        childentit1_.PARENT as PARENT5_3_,\r\n        childentit1_.id as id3_,\r\n        childentit1_.id as id4_0_,\r\n        childentit1_.field1 as field2_4_0_,\r\n        childentit1_.field2 as field3_4_0_,\r\n        childentit1_.PARENT as PARENT4_0_\r\n    from\r\n        ROOT_ENTITY rootentity0_\r\n    left outer join\r\n        CHILD_ENTITY childentit1_\r\n            on rootentity0_.id=childentit1_.PARENT\r\n    where\r\n        rootentity0_.id=?\r\n\r\n    delete\r\n    from\r\n        CHILD_ENTITY\r\n    where\r\n        id=?\r\n\r\n   delete\r\n   from\r\n       ROOT_ENTITY\r\n   where\r\n       id=?<\/pre>\n
Why does Hibernate first load all data into memory in order to delete this data immediately afterwards? The reason is that JPA\u2019s lifecycle requires that the object is in \u201cmanaged\u201d state, before it can be deleted. Only in this state all lifecycle functionality like interceptors is available (see here<\/a>). Therefore Hibernate issues a SELECT query before the deletion in order to transfer both RootEntity and ChildEntity to the \u201cmanaged\u201d state. But what can we do, if we just want to delete RootEntity and ChildEntity, if we know the id of RootEntity? The answer is to use a simple DELETE query like the following one. But due to the integrity constraint on the child table, we first have to delete all depending child entities. The following code demonstrates how:
 
<\/div> <\/div><\/p>\n
List childIds = entityManager.createQuery(\"select c.id from ChildEntity c where c.rootEntity.id = :pid\").setParameter(\"pid\", id).getResultList();\r\nfor(Long childId : childIds) {\r\n    entityManager.createQuery(\"delete from ChildEntity c where c.id = :id\").setParameter(\"id\", childId).executeUpdate();\r\n}\r\nentityManager.createQuery(\"delete from RootEntity r where r.id = :id\").setParameter(\"id\", id).executeUpdate();<\/pre>\n
The above code results in the three SQL statements we would have expected by calling remove(). Now you may argue, that this way of deletion is more complicated than just calling the EntityManager\u2019s remove() method. It also ignores annotations like @OneToMany and @ManyToOne we have placed in the two entity classes. So why not write some code that uses the knowledge about the two entities that already exists in the two class files? First of all, we look for @OneToMany annotations using reflection in the RootEntity class, extract the type of the child entity and then look for its back relation field annotated with @ManyToOne. Having done this, we can easily write the three SQL statements in a more generic way:<\/p>\n
public void delete(EntityManager entityManager, Class parentClass, Object parentId) {\r\n    Field idField = getIdField(parentClass);\r\n    if (idField != null) {\r\n        List oneToManyFields = getOneToManyFields(parentClass);\r\n        for (Field field : oneToManyFields) {\r\n            Class childClass = getFirstActualTypeArgument(field);\r\n            if (childClass != null) {\r\n                Field manyToOneField = getManyToOneField(childClass, parentClass);\r\n                Field childClassIdField = getIdField(childClass);\r\n                if (manyToOneField != null && childClassIdField != null) {\r\n                    List childIds = entityManager.createQuery(String.format(\"select c.%s from %s c where c.%s.%s = :pid\", childClassIdField.getName(), childClass.getSimpleName(), manyToOneField.getName(), idField.getName())).setParameter(\"pid\", parentId).getResultList();\r\n                    for (Long childId : childIds) {\r\n                        entityManager.createQuery(String.format(\"delete from %s c where c.%s = :id\", childClass.getSimpleName(), childClassIdField.getName())).setParameter(\"id\", childId).executeUpdate();\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        entityManager.createQuery(String.format(\"delete from %s e where e.%s = :id\", parentClass.getSimpleName(), idField.getName())).setParameter(\"id\", parentId).executeUpdate();\r\n    }\r\n}<\/pre>\n
The methods getFirstActualTypeArgument(), getManyToOneField(), getIdField() and getOneToManyFields() in the code above are not depicted here, but do what their name sounds like. Once implemented we can easily delete all entities beginning with the root of the tree.<\/p>\n