What is the use of @Synchronize in Hibernate

Question

As per Hibernate documentaion,

There is no difference between a view and a base table for a Hibernate mapping. This is transparent at the database level, although some DBMS do not support views properly, especially with updates. Sometimes you want to use a view, but you cannot create one in the database (i.e. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression using @org.hibernate.annotations.Subselect:

@Entity
@Subselect("select item.name, max(bid.amount), count(*) "
        + "from item "
        + "join bid on bid.item_id = item.id "
        + "group by item.name")
@Synchronize( {"item", "bid"} ) //tables impacted
public class Summary {
    @Id
    public String getId() { return id; }
    ...
}

Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly and that queries against the derived entity do not return stale data. The is available both as an attribute and a nested mapping element.

I am not clear on the statement given for Synchronize annotation here. What is the issue with auto-flush? What is the derived entity here and why we will get stale data? How Synchronize annotation is fixing this issue.

Can someone please help me in understanding this.

Answer 1

Hibernate entities hold persistent state in memory. And any change to these entities is automatically made persistent to the database. But the database is not updated each time you change a field of an entity. It's done at flush time: Hibernate decides that it has to make the in-memory changes persistent and thus executes the appropriate insert, update and delete statements so that the database state matches with the in-memory state.

When does that happen?

• before the transaction is committed
• when you explicitly call flush() on the session
• when a query against modified entities is executed

Let's focus on the third item here. Suppose you have an Order entity, mapped to the order table. Suppose you have loaded an Order by ID and modified its amount. The modification is only in memory. Now you execute the following query:

select sum(o.amount) from Order o

Obviously, the result of this query depends on the new amount of the modified entity. Hibernate detects this and flushes the changes to the Order entity before executing the query, to ensure the query returns the right result. If the query had been

select c from Customer c where c.name = 'John'

Hibernate would not have flushed the changes to the Order entity before executing the query, because its result doesn't depend on the new value of the order amount: the order table is not involved in this query.

Now to your question: since Hibernate doesn't have a @Table annotation to know which table the Summary is mapped to, it doesn't know when it should auto-flush or not before a query involving the Summary entity is executed. The Synchronize annotation allows telling Hibernate: this entity gets data from the item and the bid table, so if a query is executed against the Summary entity, make sure changes to the bid and item tables are flushed before executing the query.