Hibernate EntityManager

User guide

Introducing JPA Persistence

1. Architecture

1.1. Definitions

1.2. In container environment (eg. EJB 3)

1.2.1. Container-managed entity manager

1.2.2. Application-managed entity manager

1.2.3. Persistence context scope

1.2.4. Persistence context propagation

1.3. Java SE environments

2. Setup and configuration

2.1. Setup

2.2. Configuration and bootstrapping

2.2.1. Packaging

2.2.2. Bootstrapping

2.3. Event listeners

2.4. Obtaining an EntityManager in a Java SE environment

2.5. Various

3. Working with objects

3.1. Entity states

3.2. Making objects persistent

3.3. Loading an object

3.4. Querying objects

3.4.1. Executing queries

3.5. Modifying persistent objects

3.6. Detaching a object

3.7. Modifying detached objects

3.8. Automatic state detection

3.9. Deleting managed objects

3.10. Flush the persistence context

3.10.1. In a transaction

3.10.2. Outside a transaction

3.11. Transitive persistence

3.12. Locking

3.13. Caching

3.14. Checking the state of an object

3.15. Native Hibernate API

4. Metamodel

4.1. Static metamodel

5. Transactions and Concurrency

5.1. Entity manager and transaction scopes

5.1.1. Unit of work

5.1.2. Long units of work

5.1.3. Considering object identity

5.1.4. Common concurrency control issues

5.2. Database transaction demarcation

5.2.1. Non-managed environment

5.2.2. Using JTA

5.2.3. Exception handling

5.3. EXTENDED Persistence Context

5.3.1. Container Managed Entity Manager

5.3.2. Application Managed Entity Manager

5.4. Optimistic concurrency control

5.4.1. Application version checking

5.4.2. Extended entity manager and automatic versioning

5.4.3. Detached objects and automatic versioning

6. Entity listeners and Callback methods

6.1. Definition

6.2. Callbacks and listeners inheritance

6.3. XML definition

7. Batch processing

7.1. Bulk update/delete

8. JP-QL: The Object Query Language

8.1. Case Sensitivity

8.2. The from clause

8.3. Associations and joins

8.4. The select clause

8.5. Aggregate functions

8.6. Polymorphic queries

8.7. The where clause

8.8. Expressions

8.9. The order by clause

8.10. The group by clause

8.11. Subqueries

8.12. JP-QL examples

8.13. Bulk UPDATE & DELETE Statements

8.14. Tips & Tricks

9. Criteria Queries

9.1. Typed criteria queries

9.1.1. Selecting an entity

9.1.2. Selecting a value

9.1.3. Selecting multiple values

9.1.4. Selecting a wrapper

9.2. Tuple criteria queries

9.2.1. Accessing tuple elements

9.3. FROM clause

9.3.1. Roots

9.3.2. Joins

9.3.3. Fetches

9.4. Path expressions

9.5. Using parameters

10. Native query

10.1. Expressing the resultset

10.2. Using native SQL Queries

10.3. Named queries

References

The JPA specification recognizes the interest and the success of the transparent object/relational mapping paradigm. It standardizes the basic APIs and the metadata needed for any object/relational persistence mechanism. Hibernate EntityManager implements the programming interfaces and lifecycle rules as defined by the JPA 2.0 specification. Together with Hibernate Annotations, this wrapper implements a complete (and standalone) JPA persistence solution on top of the mature Hibernate Core. You may use a combination of all three together, annotations without JPA programming interfaces and lifecycle, or even pure native Hibernate Core, depending on the business and technical needs of your project. You can at all times fall back to Hibernate native APIs, or if required, even to native JDBC and SQL.

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

@ResourcepublicUserTransaction utx;

@ResourcepublicEntityManagerFactory factory;


publicvoid 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;

@InjectEntityManager 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 )thrownewStaleObjectStateException();

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 from, param from Formula as form, Parameter as param

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<(1)Person> criteria = builder.createQuery( Person.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.selec(2)t( personRoot );
criteria.where(3)( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Person> people = em.createQuery( criteria ).getResultList();
for ( Person p(1)erson : people ) { ... }

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

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

CriteriaQuery<(1)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.selec(2)t( builder.array( idPath, agePath ) );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Object[]>(1) valueArray = em.createQuery( criteria ).getResultList();
for ( Object[] values : valueArray ) {
 final Long id = (Long) values[0];
 final Integer age = (Integer) values[1];
 ...
}

CriteriaQuery<(1)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.multi(2)select( idPath, agePath );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Object[]>(1) valueArray = em.createQuery( criteria ).getResultList();
for ( Object[] values : valueArray ) {
 final Long id = (Long) values[0];
 final Integer age = (Integer) values[1];
 ...
} 

public class P(1)ersonWrapper {
 private final Long id;
 private final Integer age;
 public Per(1)sonWrapper(Long id, Integer age) {
 this.id = id;
 this.age = age;
 }
 ...
}
...
CriteriaQuery<(2)PersonWrapper> criteria = builder.createQuery( PersonWrapper.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.selec(3)t(
 builder.co(3)nstruct(
 PersonWrapper.class,
 personRoot.get( Person_.id ),
 personRoot.get( Person_.age )
 )
);
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<PersonWra(2)pper> people = em.createQuery( criteria ).getResultList();
for ( PersonWrapper person : people ) { ... }

CriteriaQuery<(1)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.multi(2)select( idPath, agePath );
criteria.where( builder.equal( personRoot.get( Person_.eyeColor ), "brown" ) );
List<Tuple> tu(1)ples = em.createQuery( criteria ).getResultList();
for ( Tuple tuple : valueArray ) {
 assert tup(3)le.get( 0 ) == tuple.get( idPath );
 assert tup(3)le.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 ));

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

Root<Person> personRoot = person.from(Person.class);

//Person.address is an embedded attribute

Join<Person,Address> personAddress = personRoot.join(Person_.address );

//Address.country is a ManyToOne

Join<Address,Country> addressCountry = personAddress.join(Address_.country );

...

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

Root<Person> personRoot = person.from(Person.class);

Join<Person,Order> orders = personRoot.join(Person_.orders );

Join<Order,LineItem> orderLines = orders.join(Order_.lineItems );

...

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

Root<Person> personRoot = person.from(Person.class);

//Person.address is an embedded attribute

Join<Person,Address> personAddress = personRoot.fetch(Person_.address );

//Address.country is a ManyToOne

Join<Address,Country> addressCountry = personAddress.fetch(Address_.country );

...

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

Root<Person> personRoot = person.from(Person.class);

Join<Person,Order> orders = personRoot.fetch(Person_.orders );

Join<Order,LineItem> orderLines = orders.fetch(Order_.lineItems );

...

CriteriaQuery<Person> criteria = build.createQuery( Person.class );
Root<Person> personRoot = criteria.from( Person.class );
criteria.select( personRoot );
ParameterExpre(1)ssion<String> eyeColorParam = builder.parameter( String.class );
criteria.where(2)( builder.equal( personRoot.get( Person_.eyeColor ), eyeColorParam ) );
TypedQuery<Person> query = em.createQuery( criteria );
query.setParam(3)eter( eyeColorParam, "brown" );
List<Person> people = query.getResultList();

You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the CONNECT BY option in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate. Note that Hibernate allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations (please refer to the reference guide for more information.)

@SqlResultSetMapping(name="GetNightAndArea", entities={

  @EntityResult(name="org.hibernate.test.annotations.query.Night", fields ={

    @FieldResult(name="id", column="nid"),

    @FieldResult(name="duration", column="night_duration"),

    @FieldResult(name="date", column="night_date"),

    @FieldResult(name="area", column="area_id")

}),

  @EntityResult(name="org.hibernate.test.annotations.query.Area", fields ={

    @FieldResult(name="id", column="aid"),

    @FieldResult(name="name", column="name")

})

}

)


//or

@SqlResultSetMapping(name="defaultSpaceShip", entities=@EntityResult(name="org.hibernate.test.annotations.query.SpaceShip"))

@SqlResultSetMapping(name="ScalarAndEntities",

  entities={

    @EntityResult(name="org.hibernate.test.annotations.query.Night", fields ={

      @FieldResult(name="id", column="nid"),

      @FieldResult(name="duration", column="night_duration"),

      @FieldResult(name="date", column="night_date"),

      @FieldResult(name="area", column="area_id")

}),

    @EntityResult(name="org.hibernate.test.annotations.query.Area", fields ={

      @FieldResult(name="id", column="aid"),

      @FieldResult(name="name", column="name")

})

},

  columns={

    @ColumnResult(name="durationInSec")

}

)