hibernate-->HQL

1.HQL is commonly used for object retrieval, not for updating, inserting, or
deleting data. Object state synchronization is the job of the persistence manager,
not the developer. But, as we’ve shown in the previous chapter, HQL and JPA QL
support direct bulk operations for updating, deleting, and inserting, if required
by the use case (mass data operations). 

HQL is powerful, and even though you may not use the more advanced features
all the time, they’re needed for more difficult problems. For example,
HQL supports
■ The ability to apply restrictions to properties of associated objects related
by reference or held in collections (to navigate the object graph using
query language).
■ The ability to retrieve only properties of an entity or entities, without the
overhead of loading the entity itself into the persistence context. This is
sometimes called a report query; it is more correctly called projection.
■ The ability to order the results of the query.
■ The ability to paginate the results.
■ Aggregation with group by, having, and aggregate functions like sum, min,
and max/min.
■ Outer joins when retrieving multiple objects per row.
■ The ability to call standard and user-defined SQL functions.
■ Subqueries (nested queries

2.Querying with a criteria

The Hibernate query by criteria (QBC) API allows a query to be built by manipulation
of criteria objects at runtime. This lets you specify constraints dynamically
without direct string manipulations, but you don’t lose much of the flexibility or
power of HQL. On the other hand, queries expressed as criteria are often much
less readable than queries expressed in HQL.
Retrieving a user by first name is easy with a Criteria object:
Criteria criteria = session.createCriteria(User.class);
criteria.add( Restrictions.like("firstname", "John") );
List result = criteria.list();
A Criteria is a tree of Criterion instances. The Restrictions class provides
static factory methods that return Criterion instances. Once the desired criteria
tree is build, it’s executed against the database.

 The query syntax(Crieria)may beparsed and validated at compile time, whereas HQL expressions aren’t parsed until runtime (or startup, if externalized named queries are used).

3.Querying by example

As part of the Criteria facility, Hibernate supports query by example (QBE). The
idea behind query by example is that the application supplies an instance of the
queried class, with certain property values set (to nondefault values). The query
returns all persistent instances with matching property values. Query by example
isn’t a particularly powerful approach. However, it can be convenient for some
applications, especially if it’s used in combination with Criteria:
Criteria criteria = session.createCriteria(User.class);
User exampleUser = new User();
exampleUser.setFirstname("John");
criteria.add( Example.create(exampleUser) );
criteria.add( Restrictions.isNotNull("homeAddress.city") );
List result = criteria.list();
This example first creates a new Criteria that queries for User objects. Then you
add an Example object, a User instance with only the firstname property set.
Finally, a Restriction criterion is added before executing the query.