I have two objects Container and Thingy. Container has fields for a specific number of Thingys. Each fields has its own getter/setter methods. The container own's every thingy under it outright (there is no sharing with other instances of Containers nor any sharing between fields within one Container).

I wish to be able to create transient Container and Thingys and mess around with them as much as I'd like, assiging null Thingy's if I want to, then make one call to on the Container object and have it cascade save everything.




Then later, I want to be able to load Container objects and edit/assign null Thingy's and then commit the changes.

I want hibernate to work out which old-thingy's need to be deleted in SQL and cascade delete those objects (all-delete-orphan?) and create new Thingy rows or even re-use Thingy row's (i dont care if they are re-used) if assiend new instances of Thingys.

I'm sure this is a simple relational pattern but for the life of me I can't see it.

I have one row in one table (mytable_container) referencing multiple unique rows in another (mytable_thingy) by their primary key.

At the moment I get an error when I try to persist (going from transient state) :

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [com.company.Thingy#0]

I read that to mean the "identifier" is zero "#0" but that is correct for a transient object with an integral primary key (generate=native) as I want hibernate to work out its not yet persisted and persist it for me, assign its id from that op then finally persist the Container object.

Hibernate 3.0.2

I enclose the best mapping I think I've managed to put together. My problem at the moment is saving my transient objects with a single save() call and letting cascade=all do the work.

I am struggling to understand first what to call the relationship, so I can then apply the appropiate section of the hibernate manual at it.

I think the relationship is actually "one-to-many" as in one row in mytable_container references many rows in mytable_thingy (but under different joining columns from mytable_container).

However such a hibernate config mapping (according to XML DTD assitance in Eclipse does not even let me specify the column="" attribute, which can't be right at all, as the joinging column name in mytable_container is an important thing to need to specify).


To describe how the load would work:

Hibernate can either do a SELECT on the mytable_container and 1 or 3 selects on mytable_thingy during the load or it can load with a single join (as long as it re-opens the mytable_thingy under an alias for each thingyOne, thingyTwo, thingyThree).

SELECT
c.mytable_container_id,
t1.value_integer,
t1.value_string,
t2.value_integer,
t2.value_string,
t3.value_integer,
t3.value_string
FROM
mytable_container AS c,
mytable_thingy AS t1,
mytable_thingy AS t2,
mytable_thingy AS t3
WHERE
c.mytable_container_id = :priKey_I_want AND
c.thingy_one = t1.mytable_thingy_id AND
c.thingy_two = t2.mytable_thingy_id AND
c.thingy_three = t3.mytable_thingy_id;


The Thingy's are fully managed inside Container object, they never exist in their own right. For every container row there is between zero and 3 thingy rows that, the container row effectively 100% owns.


In the hibernate docs there is a attribute unsaved-value="", from the documentation this is already set to a sane default. I'm happy (and my SQL database is happy) that the value of 0 never exists in either a runtime object or a persisted record.

Unless of course the runtime object is new and transient and about to be persisted. I'm expecting hibernate to work out that "This is a new instance of this object" and therefore do INSERTs. I also expect it to work out that my Container object was the result of a previous load and when I replaced a Thingy object to also do the DELETE of the now orphaned row.

Is this possible with hibernate ?


My best effort at a mapping file: