What is the difference between DELETE_ORPHAN and DELETE ?

Cascade DELETE means if this entity is deleted, delete the related entity or entities.

DELETE_ORPHAN means is an entity is removed from a related one-to-many collection, then not only disassociate it from the current entity, but delete it.

To give you an example, consider two entities: House and Room.

DELETE on the Room list on House means that if you delete the House then delete all it's Rooms.

DELETE_ORPHAN on the Room list on House means if you remove a Room from that collection, delete it entirely. Without it, the Room would still exist but not be attached to anything (hence "orphan").

In UML and OO modelling terms, this is basically the difference between composition and aggregation. The House->Room relationship is an example of composition. A Room is part of a House and doesn't exist independently.

An example of aggregation is, say, Class (parent) to Student (child). Delete the Class and the Student still exists (undoubtedly in other classes). Removing the Student from the Class doesn't typically mean deleting him or her.


Ref :- http://stackoverflow.com/questions/1377585/what-is-the-difference-between-delete-orphan-and-delete

Basics of Hibernate

1.What is ORM ?

ORM stands for object/relational mapping. ORM is the automated persistence of objects in a Java application to the tables in a relational database.

2.What does ORM consists of ?

An ORM solution consists of the followig four pieces:

• API for performing basic CRUD operations
• API to express queries refering to classes
• Facilities to specify metadata
• Optimization facilities : dirty checking,lazy associations fetching

3.What are the ORM levels ?

The ORM levels are:

• Pure relational (stored procedure.)
• Light objects mapping (JDBC)
• Medium object mapping
• Full object Mapping (composition,inheritance, polymorphism, persistence by reachability)

4.What is Hibernate?

Hibernate is a pure Java object-relational mapping (ORM) and persistence framework that allows you to map plain old Java objects to relational database tables using (XML) configuration files.Its purpose is to relieve the developer from a significant amount of relational data persistence-related programming tasks.

5.Why do you need ORM tools like hibernate?

The main advantage of ORM like hibernate is that it shields developers from messy SQL. Apart from this, ORM provides following benefits:

• Improved productivity
  • High-level object-oriented API
  • Less Java code to write
  • No SQL to write
• Improved performance
  • Sophisticated caching
  • Lazy loading
  • Eager loading
• Improved maintainability
  • A lot less code to write
• Improved portability
  • ORM framework generates database-specific SQL for you

6.What Does Hibernate Simplify?

Hibernate simplifies:

• Saving and retrieving your domain objects
• Making database column and table name changes
• Centralizing pre save and post retrieve logic
• Complex joins for retrieving related items
• Schema creation from object model
  

7.What is the need for Hibernate xml mapping file?
Hibernate mapping file tells Hibernate which tables and columns to use to load and store objects. Typical mapping file look as follows:



8.What are the most common methods of Hibernate configuration?

The most common methods of Hibernate configuration are:

• Programmatic configuration
• XML configuration (hibernate.cfg.xml)

9.What are the important tags of hibernate.cfg.xml?

Following are the important tags of hibernate.cfg.xml:


10.What are the Core interfaces are of Hibernate framework?

The five core interfaces are used in just about every Hibernate application. Using these interfaces, you can store and retrieve persistent objects and control transactions.

• Session interface
• SessionFactory interface
• Configuration interface
• Transaction interface
• Query and Criteria interfaces

11.What role does the Session interface play in Hibernate?

The Session interface is the primary interface used by Hibernate applications. It is a single-threaded, short-lived object representing a conversation between the application and the persistent store. It allows you to create query objects to retrieve persistent objects.

Session session = sessionFactory.openSession();

Session interface role:

• Wraps a JDBC connection
• Factory for Transaction
• Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier

12.What role does the SessionFactory interface play in Hibernate?

The application obtains Session instances from a SessionFactory. There is typically a single SessionFactory for the whole applicationå¹¼reated during application initialization. The SessionFactory caches generate SQL statements and other mapping metadata that Hibernate uses at runtime. It also holds cached data that has been read in one unit of work and may be reused in a future unit of work

SessionFactory sessionFactory = configuration.buildSessionFactory();

13.What is the general flow of Hibernate communication with RDBMS?

The general flow of Hibernate communication with RDBMS is :

• Load the Hibernate configuration file and create configuration object. It will automatically load all hbm mapping files
• Create session factory from configuration object
• Get one session from this session factory
• Create HQL Query
• Execute query to get list containing Java objects

14.What is Hibernate Query Language (HQL)?

Hibernate offers a query language that embodies a very powerful and flexible mechanism to query, store, update, and retrieve objects from a database. This language, the Hibernate query Language (HQL), is an object-oriented extension to SQL.

15.How do you map Java Objects with Database tables?

• First we need to write Java domain objects (beans with setter and getter).
• Write hbm.xml, where we map java class to table and database columns to Java class variables.

Example :

<hibernate-mapping>  

  <class name="com.test.User"  table="user">   

     <property  column="USER_NAME" length="255"       name="userName" not-null="true"  type="java.lang.String"/>   

     <property  column="USER_PASSWORD" length="255"     name="userPassword" not-null="true"  type="java.lang.String"/> 

  </class>&

lt;/hibernate-mapping>





  16.What’s the difference between load() and get()?  

load() vs. get() :-

load()	get()
Only use the load() method if you are sure that the object exists.	If you are not sure that the object exists, then use one of the get() methods.
load() method will throw an exception if the unique id is not found in the database.	get() method will return null if the unique id is not found in the database.
load() just returns a proxy by default and database won’t be hit until the proxy is first invoked.	get() will hit the database immediately.

   17.What is the difference between and merge and update ? 

Use update() if you are sure that the session does not contain an already persistent instance with the same identifier, and merge() if you want to merge your modifications at any time without consideration of the state of the session.

18.How do you define sequence generated primary key in hibernate?

Using tag.
Example:-

< font=""> column="USER_ID" name="id" type="java.lang.Long"> 

    class="sequence"> 

     name="table">SEQUENCE_NAME

   







inverse - mark this collection as the "inverse" end of a bidirectional association.

inverse="true|false"

Essentially  "inverse" indicates which end of a relationship should be ignored, so  when persisting a parent who has a collection of children, should you  ask the parent for its list of children, or ask the children who the  parents are?


  20.What do you mean by Named – SQL query? 
Named SQL queries are defined in the mapping xml document and called wherever required.

Example:
  
name = "empdetails">

    alias="emp" class="com.test.Employee"/>

      SELECT emp.EMP_ID AS {emp.empid},

                 emp.EMP_ADDRESS AS {emp.address},

                 emp.EMP_NAME AS {emp.name}

      FROM Employee EMP WHERE emp.NAME LIKE :name





Invoke Named Query :
  List people = session.getNamedQuery("empdetails")

		     .setString("TomBrady", name)

		     .setMaxResults(50)

		     .list();



  21.How do you invoke Stored Procedures?



 name="selectAllEmployees_SP" callable="true">

  alias="emp" class="employee">

    name="empid" column="EMP_ID"/>       

    name="name" column="EMP_NAME"/>      

    name="address" column="EMP_ADDRESS"/>

    { ? = call selectAllEmployees() }

 





  22.Explain Criteria API 
Criteria is a simplified API for  retrieving entities by composing Criterion objects. This is a very  convenient approach for functionality like "search" screens where there  is a variable number of conditions to be placed upon the result set.

Example :
  List employees = session.createCriteria(Employee.class)

		         .add(Restrictions.like("name", "a%") )

		         .add(Restrictions.like("address", "Boston"))

			 .addOrder(Order.asc("name") )

			 .list();



  23.Define HibernateTemplate? 
org.springframework.orm.hibernate.HibernateTemplate   is a helper class which provides different methods for  querying/retrieving data from the database. It also converts checked  HibernateExceptions into unchecked DataAccessExceptions.


  24.What are the benefits does HibernateTemplate provide? 
The benefits of HibernateTemplate are :  
 
HibernateTemplate, a Spring Template class simplifies interactions with Hibernate Session. 	
Common functions are simplified to single method calls. 	
Sessions are automatically closed. 	
Exceptions are automatically caught and converted to runtime exceptions.
  25.How do you switch between relational databases without code changes? 
Using Hibernate SQL Dialects  , we  can switch databases. Hibernate will generate appropriate hql queries  based on the dialect defined.
  26.If you want to see the Hibernate generated SQL statements on console, what should we do? 
In Hibernate configuration file  set as follows:

 name="show_sql">true
  27.What are derived properties? 
The properties that are not mapped to  a column, but calculated at runtime by evaluation of an expression are  called derived properties. The expression can be defined using the  formula attribute of the element.



  28.What is component mapping in Hibernate?   
A component is an object saved as a value, not as a reference 
 A component can be saved directly without needing to declare interfaces or identifier properties 
 Required to define an empty constructor 
 Shared references not supported 


Example:




  29.What is the difference between sorted and ordered collection in hibernate? 
sorted collection vs. order collection :-

   
     
sorted collection 
     
order collection 
   
   
        
A sorted collection is sorting a  collection by utilizing the  sorting features provided by the Java  collections framework. The sorting occurs in the memory of JVM which  running Hibernate, after the data being read from database using java  comparator. 
 	    
Order collection is sorting a collection by specifying the order-by clause for sorting this collection when retrieval. 
   
   
     
If your collection is not large, it will be more efficient way to sort it. 
     
If your collection is very large, it will be more efficient way to sort it . 
   
 
    31.What is the advantage of Hibernate over jdbc?  
Hibernate Vs. JDBC :-

   
     
JDBC 
     
Hibernate 
   
   
     
With JDBC, developer has to write code to  map an object model's data representation to a relational data model  and its corresponding database schema.  
     
Hibernate is flexible and powerful ORM solution to  map Java classes to database tables. Hibernate itself takes care of this  mapping using XML files so developer does not need to write code for  this. 
   
   
     
With JDBC, the automatic mapping of Java objects with  database tables and vice versa conversion is to be taken care of by the  developer manually with lines of code.  
     
Hibernate provides transparent persistence and  developer does not need to write code explicitly to map database tables  tuples to application objects during interaction with RDBMS.  
   
    
     
JDBC supports only native Structured Query Language  (SQL). Developer has to find out the efficient way to access database,  i.e. to select effective query from a number of queries to perform same  task.   
     
Hibernate provides a powerful query language  Hibernate Query Language (independent from type of database) that is  expressed in a familiar SQL like syntax and includes full support for  polymorphic queries. Hibernate also supports native SQL statements. It  also selects an effective way to perform a database manipulation task  for an application.  
   
      
     
 Application using JDBC to handle persistent data  (database tables) having database specific code in large amount. The  code written to map table data to application objects and vice versa is  actually to map table fields to object properties. As table changed or  database changed then it’s essential to change object structure as well  as to change code written to map table-to-object/object-to-table. 
     
Hibernate provides this mapping itself. The actual  mapping between tables and application objects is done in XML files. If  there is change in Database or in any table then the only need to change  XML file properties.  
   
      
     
 With JDBC, it is developer’s responsibility to  handle JDBC result set and convert it to Java objects through code to  use this persistent data in application. So with JDBC, mapping between  Java objects and database tables is done manually.  
     
Hibernate reduces lines of code by maintaining  object-table mapping itself and returns result to application in form of  Java objects. It relieves programmer from manual handling of persistent  data, hence reducing the development time and maintenance cost.  
   
      
     
With JDBC, caching is maintained by hand-coding.   
     
Hibernate, with Transparent Persistence, cache is set  to application work space. Relational tuples are moved to this cache as  a result of query. It improves performance if client application reads  same data many times for same write. Automatic Transparent Persistence  allows the developer to concentrate more on business logic rather than  this application code.  
   
       
     
In JDBC there is no check that always every user has updated data. This check has to be added by the developer.   
     
Hibernate enables developer to define version type  field to application, due to this defined field Hibernate updates  version field of database table every time relational tuple is updated  in form of Java class object to that table. So if two users retrieve  same tuple and then modify it and one user save this modified tuple to  database, version is automatically updated for this tuple by Hibernate.  When other user tries to save updated tuple to database then it does not  allow saving it because this user does not have updated data.  
   
 
    32.What are the Collection types in Hibernate ? 
Bag 	
Set 	
List 	
Array 	
Map
  33.What are the ways to express joins in HQL? 
HQL provides four ways of  expressing (inner and outer) joins:-
 
An implicit association join 	
An ordinary join in the FROM  clause 	
A fetch join in the FROM clause. 	
A theta-style join in the WHERE clause. 	
  34.Define cascade and inverse option in one-many mapping? 
cascade -  enable operations to cascade to child entities.

cascade="all|none|save-update|delete|all-delete-orphan"



inverse - mark this collection as the "inverse" end of a bidirectional association.

inverse="true|false"

Essentially  "inverse" indicates which end of a relationship should be ignored, so  when persisting a parent who has a collection of children, should you  ask the parent for its list of children, or ask the children who the  parents are?
  35.What is Hibernate proxy?  
The proxy attribute  enables lazy initialization of persistent instances of the class.  Hibernate will initially return CGLIB proxies which implement the named  interface. The actual persistent object will be loaded when a method of  the proxy is invoked.
  36.How can Hibernate be configured to access an instance variable directly and not through a setter method ? 
By mapping the property with  access="field" in Hibernate metadata. This forces hibernate to bypass  the setter method and access the instance 	variable directly while  initializing a newly loaded object.


  37.How can a whole class be mapped as immutable?



Mark the class as mutable="false"  (Default is true),. This specifies that instances of the class are (not)  mutable. Immutable classes, may not be updated or deleted by the  application.


  38.What is the use of dynamic-insert and dynamic-update attributes in a class mapping? 
Criteria is a simplified API for  retrieving entities by composing Criterion objects. This is a very  convenient approach for functionality like "search" screens where there  is a variable number of conditions to be placed upon the result set.
  
dynamic-update (defaults to false): Specifies that UPDATE SQL should be generated at runtime and contain only those columns whose values have changed 	
dynamic-insert (defaults to false): Specifies that INSERT SQL should be generated at runtime and contain only the columns whose values are not null.  
  39.What do you mean by fetching strategy ? 
A fetching strategy is the  strategy Hibernate will use for retrieving associated objects if the  application needs to navigate the association. Fetch strategies may be  declared in the O/R mapping metadata, or over-ridden by a particular HQL  or Criteria query.



  40.What is automatic dirty checking? 
Automatic dirty checking is a feature  that saves us the effort of explicitly asking Hibernate to update the  database when we modify the state of an object inside a transaction.



  41.What is transactional write-behind? 

Hibernate uses a sophisticated  algorithm to determine an efficient ordering that avoids database  foreign key constraint violations but is still sufficiently predictable  to the user. This feature is called transactional write-behind.


  42.What are Callback interfaces? 

Callback interfaces allow the  application to receive a notification when something interesting happens  to an object—for example, when an object is loaded, saved, or deleted.  Hibernate applications don't need to implement these callbacks, but  they're useful for implementing certain kinds of generic functionality.
  43.What are the types of Hibernate instance states ? 
Three types of instance states: 
 
Transient -The instance is not associated with any persistence context 	
Persistent -The instance is associated with a persistence context 	
Detached -The instance was associated with a persistence context which has been closed – currently not associated  	
  44.What are the differences between EJB 3.0 & Hibernate  
Hibernate Vs EJB 3.0 :-

   
     
Hibernate 
     
EJB 3.0 
   
   
     
Session–Cache or collection of loaded objects relating to a single unit of work 
     
Persistence Context-Set of entities that can be managed by a given EntityManager is defined by a persistence unit 
   
   
     
XDoclet Annotations used to support Attribute Oriented Programming 
     
Java 5.0 Annotations used to support Attribute Oriented Programming 
   
     
     
Defines HQL for expressing queries to the database 
     
Defines EJB QL for expressing queries 
   
     
     
Supports Entity Relationships through mapping files and annotations in JavaDoc 
     
Support Entity Relationships through Java 5.0 annotations 
   
     
     
Provides a Persistence Manager API exposed via the Session, Query, Criteria, and Transaction API 
     
Provides and Entity Manager Interface for managing CRUD operations for an Entity 
   
     
     
Provides callback support through lifecycle, interceptor, and validatable interfaces 
     
Provides callback support through Entity Listener and Callback methods 
   
     
     
Entity Relationships are unidirectional. Bidirectional relationships are implemented by two unidirectional relationships 
     
Entity Relationships are bidirectional or unidirectional 
   
   
 

     45.What are the types of inheritance models  in Hibernate? 
There are three types of inheritance models in Hibernate:
  
Table per class hierarchy 	
Table per subclass 	
Table per concrete class






 

Hibernate Basics

Cascades

If you've worked with relational databases, you've no doubt encountered cascades. Cascades propagate certain operations on a table (such as a delete) to associated tables. (Remember that tables are associated through the use of foreign keys.) Suppose that when you delete an Event, you also want to delete each of the Speaker instances associated with the Event. Instead of having the application code perform the deletion, Hibernate can manage it for you.
Hibernate supports ten different types of cascades that can be applied to many-to-one associations as well as collections. The default cascade is none. Each cascade strategy specifies the operation or operations that should be propagated to child entities. The cascade types that you are most likely to use are the following:

• all -All operations are passed to child entities: save , update , and delete.
• save-update -Save and update ( and UPDATE , respectively) are passed to child entities.
• delete -Deletion operations are passed to child entities.
• delete-orphan -All operations are passed to child entities, and objects no longer associated with the parent object are deleted.

The cascade element is added to the desired many-to-one or collection element. For example, the following configuration instructs Hibernate to delete the child Speaker elements when the parent Event is deleted:

<set name="speakers"cascade="delete">
      <key column="event_id"/>
      <one-to-many class="Speaker"/>
    </set>

• 
  

That's all there is to configuring cascades. It's important to note that Hibernate doesn't pass the cascade off to the database. Instead, the Hibernate service manages the cascades internally. This is necessary because Hibernate has to know exactly which objects are saved, updated, and deleted.
With the configuration and mapping files in hand, you're ready to persist objects to the database with Hibernate.

Fetching associated objects

When an object has one or more associated objects, it's important to consider how associated objects will be loaded. Hibernate 3 offers you two options. You can either retrieve associated objects using an outer join or by using a separate SELECT statement. The fetch attribute allows you to specify which method to use:

<many-to-one name="location"class="Location"fetch="join"/>

When an Event instance is loaded, the associated Location instance will be loaded using an outer join. If you wanted to use a separate select, the many-to-one element would look like this:

<many-to-one name="location"class="Location"fetch="select"/>

This also applies to child collections, but you can only fetch one collection using a join per persistent object. Additional collections must be fetched using the SELECT strategy.
If you're using Hibernate 2, the fetch attribute is not available. Instead, you must use the outer-join attribute for many-to-one associations. (There is no support for retrieving collections using a SELECT in Hibernate 2.) The outer-join attribute takes either a true or false value.

Building the SessionFactory

Hibernate's SessionFactory interface provides instances of the Session class, which represent connections to the database. Instances of SessionFactory are thread-safe and typically shared throughout an application. Session instances, on the other hand, aren't thread-safe and should only be used for a single transaction or unit of work in an application.

Configuring the SessionFactory

The Configuration class kicks off the runtime portion of Hibernate. It's used to load the mapping files and create a SessionFactory for those mapping files. Once these two functions are complete, the Configuration class can be discarded. Creating a Configuration and SessionFactory instance is simple, but you have some options. There are three ways to create and initialize a Configuration object.
This first snippet loads the properties and mapping files defined in the hibernate.cfg.xml file and creates the SessionFactory:

Configuration cfg =new Configuration();
    SessionFactory factory =cfg.configure().buildSessionFactory();

The configure()method tells Hibernate to load the hibernate.cfg.xml file. Without that, only hibernate.properties would be loaded from the classpath. The Configuration class can also load mapping documents programmatically:

Configuration cfg =new Configuration();
    cfg.addFile("com/manning/hq/ch03/Event.hbm.xml");

Another alternative is to have Hibernate load the mapping document based on the persistent class. This has the advantage of eliminating hard-coded filenames in the source code. For instance, the following code causes Hibernate to look for a file named com/manning/hq/ Event.hbm.xml in the classpath and load the associated class:

Configuration cfg =new Configuration();
    cfg.addClass(com.manning.hq.ch03.Event.class);

Since applications can have tens or hundreds of mapping definitions, listing each definition can quickly become cumbersome. To get around this, the hibernate.cfg.xml file supports adding all mapping files in a JAR file. Suppose your build process creates a JAR file named application.jar, which contains all the classes and mapping definitions required. You then update the hibernate.cfg.xml file:

<mapping jar="application.jar"/>

Of course, you can also do this programmatically with the Configuration class:

Configuration.addJar(new java.io.File("application.jar"));

Keep in mind that the JAR file must be in the application classpath. If you're deploying a web application archive (WAR) file, your application JAR file should be in the /WEB-INF/lib directory in the WAR file.
The four methods used to specify mapping definitions to the Hibernate runtime can be combined, depending the requirements for your project. However, once you create the SessionFactory from the Configuration instance, any additional mapping files added to the Configuration instance won't be reflected in the SessionFactory . This means you can't add new persistent classes dynamically.
You can use the SessionFactory instance to create Session instances:

Session session =factory.openSession();

Instances of the Session class represent the primary interface to the Hibernate framework. They let you persist objects, query persistent objects, and make persistent objects transient. Let's look at persisting objects with Hibernate.

Persisting objects

Persisting a transient object with Hibernate is as simple as saving it with the Session instance:

Event event =new Event();
    //populate the event
    Session session =factory.openSession();
    session.save(event);
    session.flush();

Calling save(...)for the Event instance assigns a generated ID value to the instance and persists the instance. (Keep in mind that Hibernate doesn't set the ID value if the generator type is assigned.) The flush() call forces persistent objects held in memory to be synchronized to the database. Session’s don't immediately write to the database when an object is saved. Instead, the Session queues a number of database writes to maximize performance.
If you would like to update an object that is already persistent, the update(...)method is available. Other than the type of SQL operation executed, the difference between save(...)and update(...)is that update(...)doesn't assign an ID value to the object. Because of this minor difference, the Session interface provides the saveOrUpdate(...) methods, which determine the correct operation to execute on the object. How does Hibernate know which method to call on an object?
When we described the mapping document, we mentioned the unsaved-value attribute. That attribute comes into play when you use the saveOrUpdate(...)method. Suppose you have a newly created Event instance. The id property is null until it's persisted by Hibernate. If the value is null, Hibernate assumes that the object is transient and assigns a new id value before saving the instance. A non-null id value indicates that the object is already persistent; the object is updated in the database, rather than inserted.
You could also use a long primitive to store the primary key value. However, using a primitive type also means that you must update the unsaved-value attribute value to 0, since primitive values can't be null.

TIP

In general, we suggest that you use object wrapper classes for primitive types in your persistent classes. To illustrate this, suppose you have a legacy database with a boolean column, which can be null. Your persistent class, mapped to the legacy table, also has a boolean property. When you encounter a row in the legacy table with a null boolean value, Hibernate throws a Property-AccessException since a boolean primitive can't be null-only true or false. However, you can avoid this problem if your persistent class property is of type java.lang.Boolean, which can be null, true, or false.

Here's the necessary code to persist an Event instance:

Configuration cfg =new Configuration();
    SessionFactory factory =cfg.buildSessionFactory();
    Event event =new Event();
    //populate the Event instance
    Session session =factory.openSession();
    session.saveOrUpdate(event);
    session.flush();
    session.close();

The first two lines create the SessionFactory after loading the configuration file from the classpath. After the Event instance is created and populated, the Session instance, provided by the SessionFactory , persists the Event. The Session is then flushed and closed, which closes the JDBC connection and performs some internal cleanup. That's all there is to persisting objects.
Once you've persisted a number of objects, you'll probably want to retrieve them from the database. Retrieving persistent objects is the topic of the next section.

Retrieving objects

Suppose you want to retrieve an Event instance from the database. If you have the Event ID, you can use a Session to return it:

Event event =(Event)session.load(Event.class,eventId);
    session.close();

This code tells Hibernate to return the instance of the Event class with an ID equal to eventId. Notice that you're careful to close the Session, returning the database connection to the pool. There is no need to flush the Session, since you're not persisting objects-only retrieving them. What if you don't know the ID of the object you want to retrieve? This is where HQL enters the picture.
The Session interface allows you to create Query objects to retrieve persistent objects. (In Hibernate 2, the Session interface supported a number of overloaded find methods. They were deprecated in Hibernate 3.) HQL statements are object-oriented, meaning that you query on object properties instead of database table and column names. Let’s look at some examples using the Query interface.
This example returns a collection of all Event instances. Notice that you don't need to provide a select ...clause when returning entire objects:

Query query =session.createQuery("from Event");
    List events =query.list();

This query is a little more interesting since we're querying on a property of the Event class:

Query query =session.createQuery("from Event where name ="+
                                    "'Opening Presentation'");
    List events =query.list();

We've hardcoded the name value in the query, which isn't optimal. Let's rewrite it:

Query query =session.createQuery("from Event where name =?",
                                     "Opening Presentation");
    query.setParameter(0,"Opening Presentation",Hibernate.STRING);
    List events =query.list();

The question mark in the query string represents the variable, which is similar to the JDBC PreparedStatement interface. The second method parameter is the value bound to the variable, and the third parameter tells Hibernate the type of the value. (The Hibernate class provides constants for the built-in types, such as STRING , INTEGER , and LONG , so they can be referenced programmatically.)
One topic we haven't touched on yet is the cache maintained by the Session. The Session cache tends to cause problems for developers new to Hibernate, so we'll talk about it next.

The Session cache

One easy way to improve performance within the Hibernate service, as well as your applications, is to cache objects. By caching objects in memory, Hibernate avoids the overhead of retrieving them from the database each time. Other than saving overhead when retrieving objects, the Session cache also impacts saving and updating objects. Let's look at a short code listing:

Session session =factory.openSession();
    Event e =(Event)session.load(Event.class,myEventId);
    e.setName("New Event Name");
    session.saveOrUpdate(e);
    //later,with the same Session instance
    Event e =(Event)session.load(Event.class,myEventId);
    e.setDuration(180);
    session.saveOrUpdate(e);
    session.flush();

This code first retrieves an Event instance, which the Session caches internally. It then does the following: updates the Event name, saves or updates the Event instance, retrieves the same Event instance (which is stored in the Session cache), updates the duration of the Event,and saves or updates the Event instance. Finally, you flush the Session.
All the updates made to the Event instance are combined into a single update when you flush the Session. This is made possible in part by the Session cache.
The Session interface supports a simple instance cache for each object that is loaded or saved during the lifetime of a given Session. Each object placed into the cache is keyed on the class type, such as The Session cache com.manning.hq.ch03.Event, and the primary key value. However, this cache presents some interesting problems for unwary developers.
A common problem new developers run into is associating two instances of the same object with the same Session instance, resulting in a NonUniqueObjectException. The following code generates this exception:

Session session =factory.openSession();
    Event firstEvent =(Event)session.load(Event.class,myEventId);
    //...perform some operation on firstEvent
    Event secondEvent =new Event();
    secondEvent.setId(myEventId);
    session.save(secondEvent);

This code opens the Session instance, loads an Event instance with a given ID, creates a second Event instance with the same ID, and then attempts to save the second Event instance, resulting in the Non-UniqueObjectException.
Any time an object passes through the Session instance, it's added to the Session’s cache. By passes through, we're referring to saving or retrieving the object to and from the database. To see whether an object is contained in the cache, call the Session.contains()method. Objects can be evicted from the cache by calling the Session.evict() method. Let's revisit the previous code, this time evicting the first Event instance:

Session session =factory.openSession();
    Event firstEvent =(Event)session.load(Event.class,myEventId);
    //...perform some operation on firstEvent
    if (session.contains(firstEvent)){
          session.evict(firstEvent);
    }
    Event secondEvent =new Event();
    secondEvent.setId(myEventId);
    session.save(secondEvent);

The code first opens the Session instance and loads an Event instance with a given ID. Next, it determines whether the object is contained in the Session cache and evicts the object if necessary. The code then creates a second Event instance with the same ID and successfully saves the second Event instance.
If you simply want to clear all the objects from the Session cache, you can call the aptly named Session.clear()method.
So far, we've covered the basics of Hibernate configuration and use. Now we'll address some of the advanced configuration options that come into play when you deploy Hibernate in an application server.