I have two models, with a third model to represent the relationship (can't just use @ManyToMany as the relationship has attributes). The primary key on the relationship model is a composite primary key of two other models. When I add a new relationship model to the @OneToMany set on one of the first models, can I get the relationship model's key to change automatically, or do I have to do it manually?
e.g. with three models like (psuedo-Java-Scala coming up)
class Order(val customerName)
@OneToMany
Set<OrderItem> items;
class Item(itemDescription)
@OneToMany
Set<OrderItem> orders;
class OrderItem(val quantity)
@Id
@PrimaryJoinColumn
@ManyToOne
Order order;
@Id
@PrimaryJoinColumn
@ManyToOne
Item item;
OrderItem oi;
oi.item = bananas;
order.items.add(oi);
order.save(); // This saves oi, but with a null value for order_id
oi.order = order; //This seems redundant, but the save is wrong without it.
It seems like I have to do it manually, but to my mind adding it to the Set should be enough information to change the keys. Is my thinking wrong or am I using JPA wrong?I implemented my own ORM (http://joist.ws) a few years ago to solve this and my other JPA/Hibernate annoyances. It works really well, modulo the fact that I suck at docs/promotion/etc. so it doesn't have many users (working on that).
Also note that, specific for the playframework, someone seems to have implemented the necessary magic in a plugin:
http://www.playframework.org/modules/associations
Which is nifty, other than I'm slightly wary of the "magic that happens via runtime class rewriting" that seems to be Play's standard way of doing things. The results are admittedly impressive, but it seems like you're coupling yourself to yet-another-runtime-environment/container for things to work right.
Hibernate is generally far more concerned with being flexible and robust than it is with being DRY or providing a perfect database abstraction. You really do still have to think about your data from the point of view of the DBMS regards 'Owning' Associations etc.
One thing with Play! is that it does try to over abstract hibernate a little bit and turn it into ActiveRecord which is fine for simple things but hibernate is not like ActiveRecord!