There are many Hibernate articles try to explain the “inverse” with many Hibernate “official” jargon, which is very hard to understand (at least to me). In few articles, they even suggested that just forget about what is “inverse”, and always put inverse=”true” in the collection variable.
This statement is always true – “put inverse=true in collection variable”, but do not blindfold on it, try to understand the reason behind is essential to optimal your Hibernate performance.
What is “inverse” ?
This is the most confusing keyword in Hibernate, at least i took quite a long time to understand it. The “inverse” keyword is always declare in one-to-many and many-to-many relationship (many-to-one doesn’t has inverse keyword), it means which side is responsible to take care of the relationship.
“inverse”, should change to “relationship owner”?
In Hibernate, only the “relationship owner” should maintain the relationship, and the “inverse” keyword is created to defines which side is the owner to maintain the relationship. However the “inverse” keyword itself is not verbose enough, I would suggest change the keyword to “relationship_owner“.
In short, inverse=”true” means this is the relationship owner, and inverse=”false” (default) means it’s not.
1. One to many Relationship
This is a one-to-many relationship table design, a STOCK table has many occurrences in STOCK_DAILY_RECORD table.
2. Hibernate Implementation
See the Hibernate implementation in XML mapping files.
File : Stock.java
public class Stock implements java.io.Serializable {
...
private Set<StockDailyRecord> stockDailyRecords =
new HashSet<StockDailyRecord>(0);
...
File : StockDailyRecord.java
public class StockDailyRecord implements java.io.Serializable {
...
private Stock stock;
...
File : Stock.hbm.xml
<hibernate-mapping>
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" fetch="select">
<key>
<column name="STOCK_ID" not-null="true" />
</key>
<one-to-many class="com.mkyong.common.StockDailyRecord" />
</set>
...
File : StockDailyRecord.hbm.xml
<hibernate-mapping>
<class name="com.mkyong.common.StockDailyRecord" table="stock_daily_record" ...>
...
<many-to-one name="stock" class="com.mkyong.common.Stock">
<column name="STOCK_ID" not-null="true" />
</many-to-one>
...
3. inverse = true / false
Inverse keyword is applied in one to many relationship. Here’s the question, if save or update operation perform in “Stock” object, should it update the “stockDailyRecords” relationship?
File : Stock.hbm.xml
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" inverse="{true/false}" fetch="select">
<key>
<column name="STOCK_ID" not-null="true" />
</key>
<one-to-many class="com.mkyong.common.StockDailyRecord" />
</set>
...
1. inverse=”true”
If inverse=”true” in the set variable, it means “stock_daily_record” is the relationship owner, so Stock will NOT UPDATE the relationship.
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" inverse="true" >
2. inverse=”false”
If inverse=”false” (default) in the set variable, it means “stock” is the relationship owner, and Stock will UPDATE the relationship.
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" inverse="false" >
See more examples below :
4. inverse=”false” Example
If keyword “inverse” is not define, the inverse = “false” will be used, which is
<!--Stock.hbm.xml-->
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" inverse="false">
It means “stock” is the relationship owner, and it will maintains the relationship.
Insert example …
When a “Stock” object is saved, Hibernate will generated three SQL statements, two inserts and one update.
session.beginTransaction();
Stock stock = new Stock();
stock.setStockCode("7052");
stock.setStockName("PADINI");
StockDailyRecord stockDailyRecords = new StockDailyRecord();
stockDailyRecords.setPriceOpen(new Float("1.2"));
stockDailyRecords.setPriceClose(new Float("1.1"));
stockDailyRecords.setPriceChange(new Float("10.0"));
stockDailyRecords.setVolume(3000000L);
stockDailyRecords.setDate(new Date());
stockDailyRecords.setStock(stock);
stock.getStockDailyRecords().add(stockDailyRecords);
session.save(stock);
session.save(stockDailyRecords);
session.getTransaction().commit();
Output…
Hibernate:
insert
into
mkyongdb.stock
(STOCK_CODE, STOCK_NAME)
values
(?, ?)
Hibernate:
insert
into
mkyongdb.stock_daily_record
(STOCK_ID, PRICE_OPEN, PRICE_CLOSE, PRICE_CHANGE, VOLUME, DATE)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
update
mkyongdb.stock_daily_record
set
STOCK_ID=?
where
RECORD_ID=?
Stock will update the “stock_daily_record.STOCK_ID” through Set variable (stockDailyRecords), because Stock is the relationship owner.
The third statement is really NOT necessary.
Update example …
When a “Stock” object is updated, Hibernate will generated two SQL statements, one inserts and one update.
session.beginTransaction();
Stock stock = (Stock)session.get(Stock.class, 57);
StockDailyRecord stockDailyRecords = new StockDailyRecord();
stockDailyRecords.setPriceOpen(new Float("1.2"));
stockDailyRecords.setPriceClose(new Float("1.1"));
stockDailyRecords.setPriceChange(new Float("10.0"));
stockDailyRecords.setVolume(3000000L);
stockDailyRecords.setDate(new Date());
stockDailyRecords.setStock(stock);
stock.getStockDailyRecords().add(stockDailyRecords);
session.save(stockDailyRecords);
session.update(stock);
session.getTransaction().commit();
Output…
Hibernate:
insert
into
mkyongdb.stock_daily_record
(STOCK_ID, PRICE_OPEN, PRICE_CLOSE, PRICE_CHANGE, VOLUME, DATE)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
update
mkyongdb.stock_daily_record
set
STOCK_ID=?
where
RECORD_ID=?
Again, the third statement is NOT necessary.
5. inverse=”true” Example
If keyword “inverse=true” is defined :
<!--Stock.hbm.xml-->
<class name="com.mkyong.common.Stock" table="stock" ...>
...
<set name="stockDailyRecords" table="stock_daily_record" inverse="true">
Now, it means “stockDailyRecords” is the relationship owner, and “stock” will not maintains the relationship.
Insert example …
When a “Stock” object is saved, Hibernate will generated two SQL insert statements.
session.beginTransaction();
Stock stock = new Stock();
stock.setStockCode("7052");
stock.setStockName("PADINI");
StockDailyRecord stockDailyRecords = new StockDailyRecord();
stockDailyRecords.setPriceOpen(new Float("1.2"));
stockDailyRecords.setPriceClose(new Float("1.1"));
stockDailyRecords.setPriceChange(new Float("10.0"));
stockDailyRecords.setVolume(3000000L);
stockDailyRecords.setDate(new Date());
stockDailyRecords.setStock(stock);
stock.getStockDailyRecords().add(stockDailyRecords);
session.save(stock);
session.save(stockDailyRecords);
session.getTransaction().commit();
Output …
Hibernate:
insert
into
mkyongdb.stock
(STOCK_CODE, STOCK_NAME)
values
(?, ?)
Hibernate:
insert
into
mkyongdb.stock_daily_record
(STOCK_ID, PRICE_OPEN, PRICE_CLOSE, PRICE_CHANGE, VOLUME, DATE)
values
(?, ?, ?, ?, ?, ?)
Update example …
When a “Stock” object is updated, Hibernate will generated one SQL statement.
session.beginTransaction();
Stock stock = (Stock)session.get(Stock.class, 57);
StockDailyRecord stockDailyRecords = new StockDailyRecord();
stockDailyRecords.setPriceOpen(new Float("1.2"));
stockDailyRecords.setPriceClose(new Float("1.1"));
stockDailyRecords.setPriceChange(new Float("10.0"));
stockDailyRecords.setVolume(3000000L);
stockDailyRecords.setDate(new Date());
stockDailyRecords.setStock(stock);
stock.getStockDailyRecords().add(stockDailyRecords);
session.save(stockDailyRecords);
session.update(stock);
session.getTransaction().commit();
Output…
Hibernate:
insert
into
mkyongdb.stock_daily_record
(STOCK_ID, PRICE_OPEN, PRICE_CLOSE, PRICE_CHANGE, VOLUME, DATE)
values
(?, ?, ?, ?, ?, ?)
Many people like to compare between inverse and cascade, but both are totally different notions, see the differential here.
Conclusion
Understanding the “inverse” is essential to optimize your Hibernate code, it helps to avoid many unnecessary update statements, like “insert and update example for inverse=false” above. At last, try to remember the inverse=”true” mean this is the relationship owner to handle the relationship.
Thank you. Very helpful !!
confusing
clearest explanation I read.
Can you please explain, if inverse=false, and if stock_id inside stock_daily_record is a not null record then how will this work.
Do we not get an error while executing insert into stock_daily_record?
Probably it’s me, but I found this article very confusing. I appreciate your effort expetially for the SQL generated query part but IMHO your article can be improved.
The main source of confusion comes from the part when you say that inverse should be renamed “relationship_owner” while it is clear that it is rather the opposite. It should be renamed “relationship_NOT_owner”. In one of your example you say that having “inverse=true” makes the Stock object not to update the other side of the relationship. Thus at the end of the day I find that “Inverse” is the correct name for the flag, It means that THIS side is the INVERSE side of a relationship that means the other side is the owner.
Another way of improving your article IMHO would be to clearly explain what a relationship owner actually is and what it is expected to do.
Actually it’s from the Set’s perspective
…
The set stockDailyRecords is the owner
Hi, where is the update query for stock object in both update examples.
thanks for the post
ya it is awsome explation…but can we used inverse with list tag..m trying but seq column return null value
I don’t see link to download source code. Could you please make it available?
Awesome! What a confusing topic “inverse”. Eventually, I got tired of figuring it out myself, and tried this and that. You my man, provided a great example.
Good work.
For your case 4. inverse=”false” Example
When a “Stock” object is saved, Hibernate will generated three SQL statements, two inserts and one update.
Then, you mention:
Note
Again, the third statement is NOT necessary.
stockDailyRecords.setStock(stock);
//stock.getStockDailyRecords().add(stockDailyRecords); // COMMENTED OUT THIS LINE
session.save(stock);
session.save(stockDailyRecords);
Then I was able to prevent that update which is really not necessary. And i got the resultsimilar to that of case 5. So, what is the difference then?
lot of thanx
As you say someone is relationship owner and it will take responsibility to maintain relationship.. Let me tell you this line becomes a most confusing one. In example you save both the objects STOCK as well as Stock_Daily_Record.
In inverse=true, Stock_Daily_Record is relationship owner OR inverse=false where STOCK is relationship owner. In both of these case why do you save both objects ?
Because if you see code wise both looks similar.
Hi Mkyong,
Thanks for writing such a good article. Your article really makes it easy to understand.
But my problem is I am using inverse=”true” i.e. stockDailyRecords is the owner.
In first step I inserted stockDailyRecords record so it will generate two queries
1) insert in stockDailyRecords table and
2) insert in stock table
In second step I am updating stockDailyRecords so it will generate two queries..
1) update stockDailyRecords table and
2) insert in stock table
but in this case I am getting unique constraint violated because it is trying to insert in the same record in stock twoice.
Is there any solution?
Use not not-null= false both side.
Thank you. Much clear now.
Once again clear my confusion.
Awesome, lucid and straight-forward explanation. Thanks a lot.
You saved my day! Thanks!
However, I have one query. I saw this statement in this post:
“In few articles, they even suggested that just forget about what is “inverse”, and always put inverse=”true” in the collection variable.”
Are we not supposed to use inverse=”false”. Why?
My implementation is like this:
I am maintaining only one-to-many association in XML, not many-to-one. In java, I am not giving reference of parent to the child. And, by keeping inverse=”false”, the foreign key is getting updated through the update query.
Is this practice ok? Or should I switch to more conventional two way relationship style?
Very nice explaination…It’s a big confusion portion of NHibernate,you resolved it very nicely…
Thanks a Ton…
MKyoung,
First of all, let me congratulate you for this awesome job, your website has been a life saver lately. Keep going.
It’d be nice if you could make some reference to inverse control using annotations too. It worthwhile to say that mappedBy attribute does the same thing when you are using an biderection relationship between @OneToMany(mappedBy=”attributeyouwanttomap”) and @ManyToOne()
Thanks once more for you great job!
if inverse=”false”
and
When Stock object is saved,
Why we need stockDailyRecord to be saved?
“session.save(stockDailyRecords);”
saving the stockDailyRecord is based on Cascade .. not on inverse … inverse just make sure who is the owner of the relationship
very well written & explained.
very clear . thanks
Thanks Mkyong for the nice artice.
In the section:[ inverse=”false” Example], I am not getting what you meant by the below:
“Note
Again, the third statement is NOT necessary.”
Which third statement are you referring to? Please explain.
In the Update Example of the (Inverse = false) , Actually there was not any third statement ,it was by mistake written that “Again, the third statement is NOT necessary.” , so Instead of third statement he is referring to the second update statement actually.
Hence it was “Again, the second statement is NOT necessary.”
Hi MkYong,
Its a really nice article.
Can you please post your code for download purpose.
It will definitely make our understanding lot better.Thanks in advance.
Abhishek J
very good artical with practical example.Very clear.Thanks a lot for making me understand.
This is a link very short definition of when to use inverse=true/false
http://tadtech.blogspot.com/2007/02/hibernate-when-is-inversetrue-and-when.html
I used to work for RH and I asked the same thing
Why does Gavin use variable-names that have nothing to do with the function the variable performs.
inverse means nothing..he should change it to relationship-owner
I think Gavin coded this before Collection came into play..so from what i see
1)Hibernates extension of Java collection classes makes no sense with new generic impl’s
2)I worked at one installation on the Pacific Coast that ripped Hibernate out of their code because the CTO said it is an ill-named,undocumented,resource-hogging piece of !!!!
Martin-
Confusion and Obfuscation are the main tactics used in battling adversaries..Sun Tsu
Gr8 Example!
As clear as ever. Thanks mkyong.
Hi ,
I am still confused with inverse attribute.
In the above ex when cascade is none and inverse is false. then it firing three quires one for parent insert one for child insert and one for constraint update.
My ques is when we are using cascade none then why we need to write below line.
stock.getStockDailyRecords().add(stockDailyRecords);
one extra update query I am seeing because of above line in cascade none. Please clear my confusion.
so nice Example..
now it is very clear to me..
thanx a lot..
Nice example!
how to use annotations to define inverse=”true” ?
how to annotate classes for same example
Thanks for this article which is descriptive and at the same time informative.
Hi,
Thanks, it helped a lot…
Hi, Good article Indeed. But I have a doubt, In Hibernate using annotation how to provide “inverse=true”
Hi,
Very simple and clear example. Great article, Thanks!
Can you please provide an example where to use inverse=false?
Thanks in advance..
Nice Example…………….
I have a confusion. This is what I understand from your article – If inverse=true, an insert on stock will trigger 2 inserts. First insert is on the stock record and the second one on the stockDailyRecord. But since in your code, you have taken care of the relationship using java. What I mean is you have set the stock object to the stockDailyRecord (in this line…stockDailyRecords.setStock(stock); ). This tells me that after 2 inserts, the relationship is actually present in the DB..i.e, the foreign key in the stockDailyRecord will actually have a value (the id of the stock record). This happens because you have used java to relate them. Am I right ?
VeryGood Explanation.
Clear and simple explanation Thanks! Sometimes the “oficial” documentation is not as clear as we would like.
Great article, thanx
I’m not sure, why this article making inverse so complicated to understand. JBoss web site clearly mentioned that in one-2-many, inverse = true has to be at many side, and in many-2-many, it does not matter which side you put. Following is excerpt from the site.
=========================================================
The rules are straightforward: all bi-directional associations need one side as inverse. In a one-to-many association it has to be the many-side, and in many-to-many association you can select either side.
=========================================================
As i said in the first paragraph, often times, just forget about the keyword and use what mentioned in the documentation, it worked in most cases.
However, understand how “inverse” works may help you fine tune your query in some cases.
Best Article so far on explaining what goes underneath inverse=true/false
Thanks a lot Mkyong !!
Hi,
It is nice explanation, however after reading this: it seems to me what’s the use of inverse=false then!!! As it’s create an extra update statement, why Hibernate core lib set inverse=true instead of default false?
Thanks,
Anish
excellent writeup esp since u explained what will happen if inverse=false. i was thinking if i dont specify inverse=true then hibernate will give error or do a wrong update.keep it up.
See http://docs.jboss.org/hibernate/core/3.3/reference/en/html/associations.html#assoc-bidirectional
inverse=”true” means that THE OTHER side is the relationship owner and this one is just the inverse, so relationship_owner=”true” would be equal to inverse=”false”.
Since this post is among the first returned by Google when searching for “hibernate inverse” and since you already got it right here: https://mkyong.com/hibernate/hibernate-one-to-many-relationship-example/ – it would be nice if you could correct this.
Nice Article explain an important concept. I use JPA 2.0 with hibernate as the underlying persistence provider. Can you tell me how to specify inverse=true using jpa/hibernate annotations.
Hi,
It is an excellent article…
I went through many articles but they could not explain the term so well. Now it is crystal clear…
Thanks!! a lot..
OMG!!!!!! Thank you soooo much!!!! I have been pulling my hair out trying to get a set to persist! Hugs and Kisses!!! XXOOXXOOXXOO
You have something completely wrong in your article:
However the “inverse” keyword itself is not verbose enough, I would suggest change the keyword to “relationship_owner”.
“inverse” attribute should be interpreted as “ignore relationship” or something like that, it seems that you’ve completely wrong here.
Hi dima,
Thanks for sharing your idea, but i do not think i’m wrong, as least the “relationship_owner” notion is much more make sense for me, however i like your “ignore relationship” notion as well.
Of course, different people have their prefer easy-to-understand notion, just use whatever make sense. 🙂
Hi,
Great article, very good example!
However, I would also like to join to dima remark –
If the inverse is the “relationship owner” and inverse = false means that the entity is NOT the relationship owner, than I would assume that in that case both ends of the relationship would have to maintain their own side since no one is the owner.. However, in your example when the “relationship owner” is false, one side does maintain the relationship for the other end, suggesting it IS the owner…
Having said that – its really good explained article -Thanks !
Sorry for the poor English, your inputs make this article more accurate 🙂
Yes I have gone through a site which explained it through the “ignore relationship”. May be the text of that site or something, I really couldn’t understand what he was trying to say. Here with the “relationship_owner” example I could very easy understand.
Thanks mkyong for this wonderful piece of information
Hi Mahesh, welcome, i just use whatever make sense to me 🙂
In the above example:
update the foreign key “stock_daily_record.ITEM_ID” in StockDailyRecord table–>
I am confused stock_daily_record.ITEM_ID means the Stock_Id(Foreign key) inthe stockDailyRecord table am i right..if not please clarify.
post updated, thanks for the correction