Question

I have problem with session and query execution, please see code below.

class A implements Lifecycle{
    public boolean onUpdate(Session session){
        Query test=session.createQuery("select * from Unknown");
        List list=test.list();
        B b=new B();
        session.save(b);
    }
}
class B{
    C c;
    public B(){
        c=new C();
        c.a=new A();
    }
}
class C implements Lifecycle{
    A a;
    public boolean onSave(Session session){
        a.onUpdate(session);
    }
}

I modified A object and called onUpdate method.but exception whenever I call method a.onUpdate();

org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: com.test.C

I know that above exception due to query execution in onUpdate method. please suggest me is there is way to stop to save unsaved objects during queries execution. or any other suggestion to above problem is great helpful.

Answer 1

please suggest me is there is way to stop to save unsaved objects during queries execution

To strictly answer this question, by default Hibernate will indeed flush the session when performing a query so that you don’t get stale results. You can change this behavior using a custom FlushMode (COMMIT or NEVER). From the documentation:

10.10. Flushing the Session

Sometimes the Session will execute the
SQL statements needed to synchronize
the JDBC connection’s state with the
state of objects held in memory. This
process, called flush, occurs by
default at the following points:

• before some query executions
• from org.hibernate.Transaction.commit()
• from Session.flush()

The SQL statements are issued in the
following order:

• all entity insertions in the same order the corresponding objects were
  saved using Session.save()
• all entity updates
• all collection deletions
• all collection element deletions, updates and insertions
• all collection insertions
• all entity deletions in the same order the corresponding objects were
  deleted using Session.delete()

An exception is that objects using
native ID generation are inserted when
they are saved.

Except when you explicitly flush(),
there are absolutely no guarantees
about when the Session executes the
JDBC calls, only the order in which
they are executed. However, Hibernate
does guarantee that the
Query.list(..) will never return
stale or incorrect data.

It is possible to change the default
behavior so that flush occurs less
frequently. The FlushMode class
defines three different modes: only
flush at commit time when the
Hibernate Transaction API is used,
flush automatically using the
explained routine, or never flush
unless flush() is called explicitly.
The last mode is useful for long
running units of work, where a Session
is kept open and disconnected for a
long time (see Section 11.3.2,
“Extended session and automatic
versioning”).

sess = sf.openSession();
Transaction tx = sess.beginTransaction();
sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state

Cat izi = (Cat) sess.load(Cat.class, id);
izi.setName(iznizi);

// might return stale data
sess.find("from Cat as cat left outer join cat.kittens kitten");

// change to izi is not flushed!
...
tx.commit(); // flush occurs
sess.close();

During flush, an exception might occur
(e.g. if a DML operation violates a
constraint). Since handling exceptions
involves some understanding of
Hibernate’s transactional behavior, we
discuss it in Chapter 11,
Transactions and Concurrency.

But honestly, I’m not sure to understand what you’re trying to do (and maybe it’s just a sample but your HQL query is not correct).

References

• 10.10. Flushing the Session