Hibernate.orgCommunity Documentation
Batch processing has traditionally been difficult in full object/relational mapping. ORM is all about object state management, which implies that object state is available in memory. However, Hibernate has some features to optimize batch processing which are discussed in the Hibernate reference guide, however, EJB3 persistence differs slightly.
As already discussed, automatic and transparent object/relational
mapping is concerned with the management of object state. This implies
that the object state is available in memory, hence updating or deleting
(using SQL UPDATE
and DELETE
) data
directly in the database will not affect in-memory state. However,
Hibernate provides methods for bulk SQL-style UPDATE
and DELETE
statement execution which are performed
through JP-QL (Chapter 8, JP-QL: The Object Query Language).
The pseudo-syntax for UPDATE
and
DELETE
statements is: ( UPDATE | DELETE )
FROM? ClassName (WHERE WHERE_CONDITIONS)?
. Note that:
In the from-clause, the FROM keyword is optional.
There can only be a single class named in the from-clause, and it cannot have an alias (this is a current Hibernate limitation and will be removed soon).
No joins (either implicit or explicit) can be specified in a bulk JP-QL query. Sub-queries may be used in the where-clause.
The where-clause is also optional.
As an example, to execute an JP-QL UPDATE
, use
the Query.executeUpdate()
method:
EntityManager entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
String jpqlUpdate = "update Customer set name = :newName where name = :oldName"
int updatedEntities = entityManager.createQuery( jpqlUpdate )
.setParameter( "newName", newName )
.setParameter( "oldName", oldName )
.executeUpdate();
entityManager.getTransaction().commit();
entityManager.close();
To execute an JP-QL DELETE
, use the same
Query.executeUpdate()
method (the method is named for
those familiar with JDBC's
PreparedStatement.executeUpdate()
):
EntityManager entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
String hqlDelete = "delete Customer where name = :oldName";
int deletedEntities = entityManager.createQuery( hqlDelete )
.setParameter( "oldName", oldName )
.executeUpdate();
entityManager.getTransaction().commit();
entityManager.close();
The int
value returned by the
Query.executeUpdate()
method indicate the number of
entities effected by the operation. This may or may not correlate with the
number of rows effected in the database. A JP-QL bulk operation might
result in multiple actual SQL statements being executed, for
joined-subclass, for example. The returned number indicates the number of
actual entities affected by the statement. Going back to the example of
joined-subclass, a delete against one of the subclasses may actually
result in deletes against not just the table to which that subclass is
mapped, but also the "root" table and potentially joined-subclass tables
further down the inheritance hierarchy.
Copyright © 2005 Red Hat Inc. and the various authors