Hibernate EntityManager

The metamodel is a set of objects that describe your domain model. javax.persistence.metamodel.Metamodel acts as a repository of these metamodel objects and provides access to them, and can be obtained from either the javax.persistence.EntityManagerFactory or the javax.persistence.EntityManager via their getMetamodel method.

This metamodel is important in 2 ways. First, it allows providers and frameworks a generic way to deal with an application's domain model. Persistence providers will already have some form of metamodel that they use to describe the domain model being mapped. This API however defines a single, independent access to that existing information. A validation framework, for example, could use this information to understand associations; a marshaling framework might use this information to decide how much of an entity graph to marshal. This usage is beyond the scope of this documentation.

Second, from an application writer's perspective, it allows very fluent expression of completely type-safe criteria queries, especially the Static Metamodel approach. The [JPA 2 Specification] defines a number of ways the metamodel can be accessed and used, including the Static Metamodel approach, which we will look at later. The Static Metamodel approach is wonderful when the code has a priori knowledge of the domain model. Chapter 9, Criteria Queries uses this approach exclusively in its examples.

package org.hibernate.jpa2.metamodel.example;

import java.util.Set;
import javax.persistence.Entity;

@Entity
public class Person {
    @Id private Long id;
    private String name;
    private int age;
    private Address address;
    @OneToMany  private Set<Order> orders;
}

package org.hibernate.jpa2.metamodel.example;

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.SetAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@StaticMetamodel( Person.class )
public class Person_ {
    public static volatile SingularAttribute<Person, Long> id;
    public static volatile SingularAttribute<Person, String> name;
    public static volatile SingularAttribute<Person, Integer> age;
    public static volatile SingularAttribute<Person, Address> address;
    public static volatile SetAttribute<Person, Order> orders;
}

The most important point about Hibernate Entity Manager and concurrency control is that it is very easy to understand. Hibernate Entity Manager directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system. Hibernate Entity Manager only adds automatic versioning but does not lock objects in memory or change the isolation level of your database transactions. Basically, use Hibernate Entity Manager like you would use direct JDBC (or JTA/CMT) with your database resources.

We start the discussion of concurrency control in Hibernate with the granularity of EntityManagerFactory, and EntityManager, as well as database transactions and long units of work..

In this chapter, and unless explicitly expressed, we will mix and match the concept of entity manager and persistence context. One is an API and programming object, the other a definition of scope. However, keep in mind the essential difference. A persistence context is usually bound to a JTA transaction in Java EE, and a persistence context starts and ends at transaction boundaries (transaction-scoped) unless you use an extended entity manager. Please refer to Section 1.2.3, “Persistence context scope” for more information.

// Non-managed environment idiom

EntityManager em = emf.createEntityManager();

EntityTransaction tx = null;

try {

    tx = em.getTransaction();

    tx.begin();


    // do some work

    ...


    tx.commit();

}

catch (RuntimeException e) {

    if ( tx != null && tx.isActive() ) tx.rollback();

    throw e; // or display error message

}

finally {

    em.close();

}

// BMT idiom

@Resource public UserTransaction utx;

@Resource public EntityManagerFactory factory;


public void doBusiness() {

    EntityManager em = factory.createEntityManager();

    try {


    // do some work

    ...


    utx.commit();

}

catch (RuntimeException e) {

    if (utx != null) utx.rollback();

    throw e; // or display error message

}

finally {

    em.close();

}

//CMT idiom through injection

@PersistenceContext(name="sample") EntityManager em;

@Inject EntityManager em;

// foo is an instance loaded by a previous entity manager

em = factory.createEntityManager();

EntityTransaction t = em.getTransaction();

t.begin();

int oldVersion = foo.getVersion();

Foo dbFoo = em.find( foo.getClass(), foo.getKey() ); // load the current state

if ( dbFoo.getVersion()!=foo.getVersion ) throw new StaleObjectStateException();

dbFoo.setProperty("bar");

t.commit();

em.close();

// foo is an instance loaded earlier by the extended entity manager

em.getTransaction.begin(); // new connection to data store is obtained and tx started

foo.setProperty("bar");

em.getTransaction().commit();  // End tx, flush and check version, disconnect

// foo is an instance loaded by a non-extended entity manager

foo.setProperty("bar");

entityManager = factory.createEntityManager();

entityManager.getTransaction().begin();

managedFoo = session.merge(foo); // discard foo and from now on use managedFoo

entityManager.getTransaction().commit();

entityManager.close();

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.

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();

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 Java Persistence Query Language (JP-QL) has been heavily inspired by HQL, the native Hibernate Query Language. Both are therefore very close to SQL, but portable and independent of the database schema. People familiar with HQL shouldn't have any problem using JP-QL. In fact HQL is a strict superset of JP-QL and you use the same query API for both types of queries. Portable JPA applications however should stick to JP-QL.

select c from eg.Cat c

select c from Cat c

select cat from Cat as cat

select formula, param from Formula as formula, Parameter as parameter

select cat, mate, kitten from Cat as cat
    inner join cat.mate as mate
    left outer join cat.kittens as kitten

select cat from Cat as cat left join cat.mate.kittens as kittens

select cat, mate, kitten from Cat as cat
    join cat.mate as mate
    left join cat.kittens as kitten

select cat from Cat as cat
    inner join fetch cat.mate
    left join fetch cat.kittens

select cat from Cat as cat 
    inner join fetch cat.mate
    left join fetch cat.kittens child
    left join fetch child.kittens

select doc from Document doc fetch all properties order by doc.name

select doc from Document doc fetch all properties where lower(doc.name) like '%cats%'

select mate 
from Cat as cat 
    inner join cat.mate as mate

select cat.mate from Cat cat

select cat.name from DomesticCat cat
where cat.name like 'fri%'

select cust.name.firstName from Customer as cust

select mother, offspr, mate.name 
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

select new list(mother, offspr, mate.name)
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

select new Family(mother, mate, offspr)
from DomesticCat as mother
    join mother.mate as mate
    left join mother.kittens as offspr

select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat

select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat

select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat

select cat.weight + sum(kitten.weight) 
from Cat cat 
    join cat.kittens kitten
group by cat.id, cat.weight

select firstName||' '||initial||' '||upper(lastName) from Person

select distinct cat.name from Cat cat

select count(distinct cat.name), count(cat) from Cat cat

select cat from Cat as cat

from java.lang.Object o // HQL only

from Named n, Named m where n.name = m.name // HQL only

select cat from Cat cat where cat.name='Fritz'

select foo 
from Foo foo, Bar bar
where foo.startDate = bar.date

select cat from Cat cat where cat.mate.name is not null

select foo from Foo foo  
where foo.bar.baz.customer.address.city is not null

select cat, rival from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate 
from Cat cat, Cat mate
where cat.mate = mate

select cat from Cat as cat where cat.id = 123

select cat from Cat as cat where cat.mate.id = 69

select person from bank.Person person
where person.id.country = 'AU' 
    and person.id.medicareNumber = 123456

select account from bank.Account account
where account.owner.id.country = 'AU' 
    and account.owner.id.medicareNumber = 123456

select cat from Cat cat where cat.class = DomesticCat

store.owner.address.city    // okay
store.owner.address         // error!

from AuditLog log, Payment payment 
where log.item.class = 'Payment' and log.item.id = payment.id

select cat from DomesticCat cat where cat.name between 'A' and 'B'

select cat from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

select cat from DomesticCat cat where cat.name not between 'A' and 'B'

select cat from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

hibernate.query.substitutions true 1, false 0

select cat from Cat cat where cat.alive = true

select cat from Cat cat where cat.kittens.size > 0

select cat from Cat cat where size(cat.kittens) > 0

select cal from Calendar cal where maxelement(cal.holidays) > current date

select order from Order order where maxindex(order.items) > 100

select order from Order order where minelement(order.items) > 10000

select mother from Cat as mother, Cat as kit
where kit in elements(foo.kittens)

select p from NameList list, Person p
where p.name = some elements(list.names)

select cat from Cat cat where exists elements(cat.kittens)

select cat from Player p where 3 > all elements(p.scores)

select cat from Show show where 'fizard' in indices(show.acts)

SELECT i.name, VALUE(p) FROM Item i JOIN i.photos p WHERE KEY(p) LIKE ‘%egret’

select order from Order order where order.items[0].id = 1234

select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
    and person.nationality.calendar = calendar

select item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11

select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item

select item, index(item) from Order order 
    join order.items item
where index(item) < 5

select cat from DomesticCat cat where upper(cat.name) like 'FRI%'

select cust
from Product prod,
    Store store
    inner join store.customers cust
where prod.name = 'widget'
    and store.location.name in ( 'Melbourne', 'Sydney' )
    and prod = all elements(cust.currentOrder.lineItems)

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
FROM customers cust,
    stores store,
    locations loc,
    store_customers sc,
    product prod
WHERE prod.name = 'widget'
    AND store.loc_id = loc.id
    AND loc.name IN ( 'Melbourne', 'Sydney' )
    AND sc.store_id = store.id
    AND sc.cust_id = cust.id
    AND prod.id = ALL(
        SELECT item.prod_id
        FROM line_items item, orders o
        WHERE item.order_id = o.id
            AND cust.current_order = o.id
    )

select cat from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color

select foo.id, avg(name), max(name) 
from Foo foo join foo.names name
group by foo.id

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color 
having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

select cat
from Cat cat
    join cat.kittens kitten
group by cat
having avg(kitten.weight) > 100
order by count(kitten) asc, sum(kitten.weight) desc

select fatcat from Cat as fatcat 
where fatcat.weight > ( 
    select avg(cat.weight) from DomesticCat cat 
)

select cat from DomesticCat as cat 
where cat.name = some ( 
    select name.nickName from Name as name 
)

select cat from Cat as cat 
where not exists ( 
    from Cat as mate where mate.mate = cat 
)

select cat from DomesticCat as cat 
where cat.name not in ( 
    select name.nickName from Name as name 
)

select cat from Cat as cat 
where not ( cat.name, cat.color ) in ( 
    select cat.name, cat.color from DomesticCat cat 
)

select cat from Person where name = ('Gavin', 'A', 'King')

select cat from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog.effectiveDate < sysdate
    and catalog.effectiveDate >= all (
        select cat.effectiveDate 
        from Catalog as cat
        where cat.effectiveDate < sysdate
    )
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog = :currentCatalog
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

select count(payment), status.name 
from Payment as payment 
    join payment.currentStatus as status
    join payment.statusChanges as statusChange
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or (
        statusChange.timeStamp = ( 
            select max(change.timeStamp) 
            from PaymentStatusChange change 
            where change.payment = payment
        )
        and statusChange.user <> :currentUser
    )
group by status.name, status.sortOrder
order by status.sortOrder

select count(payment), status.name 
from Payment as payment
    join payment.currentStatus as status
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser
group by status.name, status.sortOrder
order by status.sortOrder

select account, payment
from Account as account
    join account.holder.users as user
    left outer join account.payments as payment
where :currentUser = user
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

select usr.id, usr.name
from User as usr 
    left join usr.messages as msg
group by usr.id, usr.name
order by count(msg)

from User usr where size(usr.messages) >= 1

select usr.id, usr.name
from User usr.name
    join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1

select usr.id, usr.name
from User as usr
    left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0

Criteria queries are a programmatic, type-safe way to express a query. They are type-safe in terms of using interfaces and classes to represent various structural parts of a query such as the query itself, or the select clause, or an order-by, etc. They can also be type-safe in terms of referencing attributes as we will see in a bit. Users of the older Hibernate org.hibernate.Criteria query API will recognize the general approach, though we believe the JPA API to be superior as it represents a clean look at the lessons learned from that API.

Criteria queries are essentially an object graph, where each part of the graph represents an increasing (as we navigate down this graph) more atomic part of query. The first step in performing a criteria query is building this graph. The javax.persistence.criteria.CriteriaBuilder interface is the first thing with which you need to become acquainted to begin using criteria queries. Its role is that of a factory for all the individual pieces of the criteria. You obtain a javax.persistence.criteria.CriteriaBuilder instance by calling the getCriteriaBuilder method of the javax.persistence.EntityManagerFactory

CriteriaBuilder builder = entityManagerFactory.getCriteriaBuilder();

The next step is to obtain a javax.persistence.criteria.CriteriaQuery. You do this by one of the 3 methods on javax.persistence.criteria.CriteriaBuilder for this purpose.

CriteriaQuery<T> createQuery(Class<T>)

CriteriaQuery<Tuple> createTupleQuery()

CriteriaQuery<Object> createQuery()

Each serves a different purpose depending on the expected type of the query results.

CriteriaQuery<T> createQuery(Class<T>)

CriteriaQuery<Person> criteria = builder.createQuery( Person.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( personRoot );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Person> people = em.createQuery( criteria ).getResultList();
for ( Person person : people ) { ... }

CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( personRoot.get( Person_.age ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Integer> ages = em.createQuery( criteria ).getResultList();
for ( Integer age : ages ) { ... } 

CriteriaQuery<Integer> criteria = builder.createQuery( Integer.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( builder.max( personRoot.get( Person_.age ) ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
Integer maxAge = em.createQuery( criteria ).getSingleResult();

CriteriaQuery<Object[]> criteria = builder.createQuery( Object[].class );
Root<Person> personRoot = criteria.from( Person.class );
Path<Long> idPath = personRoot.get( Person_.id );
Path<Integer> agePath = personRoot.get( Person_.age );
criteria.select( builder.array( idPath, agePath ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Object[]> valueArray = em.createQuery( criteria ).getResultList();
for ( Object[] values : valueArray ) {
    final Long id = (Long) values[0];
    final Integer age = (Integer) values[1];
    ...
}

CriteriaQuery<Object[]> criteria = builder.createQuery( Object[].class );
Root<Person> personRoot = criteria.from( Person.class );
Path<Long> idPath = personRoot.get( Person_.id );
Path<Integer> agePath = personRoot.get( Person_.age );
criteria.multiselect( idPath, agePath );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Object[]> valueArray = em.createQuery( criteria ).getResultList();
for ( Object[] values : valueArray ) {
    final Long id = (Long) values[0];
    final Integer age = (Integer) values[1];
    ...
} 

public class PersonWrapper {
    private final Long id;
    private final Integer age;
    public PersonWrapper(Long id, Integer age) {
        this.id = id;
        this.age = age;
    }
    ...
}
...
CriteriaQuery<PersonWrapper> criteria = builder.createQuery( PersonWrapper.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select(
    builder.construct(
        PersonWrapper.class,
        personRoot.get( Person_.id ),
        personRoot.get( Person_.age )
    )
);
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<PersonWrapper> people = em.createQuery( criteria ).getResultList();
for ( PersonWrapper person : people ) { ... }

CriteriaQuery<Tuple> criteria = builder.createTupleQuery();
Root<Person> personRoot = criteria.from( Person.class );
Path<Long> idPath = personRoot.get( Person_.id );
Path<Integer> agePath = personRoot.get( Person_.age );
criteria.multiselect( idPath, agePath );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Tuple> tuples = em.createQuery( criteria ).getResultList();
for ( Tuple tuple : valueArray ) {
    assert tuple.get( 0 ) == tuple.get( idPath );
    assert tuple.get( 1 ) == tuple.get( agePath );
    ...
} 

<X> Root<X> from(Class<X>)

<X> Root<X> from(EntityType<X>)

CriteriaQuery<Person> personCriteria = builder.createQuery( Person.class );

// create and add the root

person.from( Person.class );

...

CriteriaQuery query = builder.createQuery();

Root<Person> men = query.from( Person.class );

Root<Person> women = query.from( Person.class );

Predicate menRestriction = builder.and(

    builder.equal( men.get( Person_.gender ), Gender.MALE ),

    builder.equal( men.get( Person_.relationshipStatus ), RelationshipStatus.SINGLE )

);

Predicate womenRestriction = builder.and(

    builder.equal( women.get( Person_.gender ), Gender.FEMALE ),

    builder.equal( women.get( Person_.relationshipStatus ), RelationshipStatus.SINGLE )

);

query.where( builder.and( menRestriction, womenRestriction ) );