Hi all,

I'm currently trying to crack Hibernate. Here's what I conceptually want to achieve:

A "Parent" class has a set of "Children". Each "Child" has a Mother (a Parent) and a Father (Parent).

My proposed hbm's are:



Now obviously this does not work, as there are two things mapping on to ADULT_ID.

But I'm unsure how to achieve this using Hibernate's mapping model. In legacy database design, I'd have two foreign keys on the child table, mother and father, then to produce a children set for the Parent, i'd do a UNION or simple OR clause in my SQL SELECT.

I'm hopeful I might be able to add something like this to the Adult class:



... and magically produce the children set (all who have the Adult as their Father or Mother), but I'm not sure if this is possible with mappings or whether it might needlessly complicate things.

A related problem (and here the biological Parent/Child analogy falls down!), is what happens if I want to have a separate method for getFatheredChildren (Child who has Adult as father) or getMotheredChildren (Child who has Adult as mother). I could add the following to my mapping:



Again this doesn't work. If I could persuade it to work, how would Hibernate properly work out which set should contain which items? This doesn't seem to be specified anywhere in the mapping.

Am I approaching this entirely from the wrong direction?

Thoughts appreciated...

Hello,

I do not have that much experience in the field but I think that you can make sub-classes in each class. Use the gender field to define a father and a mother class for this. Then you can make the many-to-one to that sub-class. Check the documentation on that.

Regards,

Marco

Which of the following parenting options do you need to support:
1. mother AND father
2. mother only
3. father only
4. No mother nor father

If #1 is needed, you simply need to have two separent columns: FATHER_ID and MOTHER_ID:
<many-to-one name="father" class="events.Father" column="FATHER_ID"/>
<many-to-one name="mother" class="events.Mother" column="MOTHER_ID"/>

If #2, #3 or #4 is needed, make a single "many-to-one" declaration to a "parent", instead of two declarations:
<many-to-one name="parent" class="events.Adult" column="PARENT_ID"/>

In either case, you need to create mother and father Adult subclasses (in a table-per-hierarchy model):

<hibernate-mapping>
<class name="events.Adult" table="ADULT"
discriminator-value="A"
>
<id name="id" column="ADULT_ID">
<generator class="native"/>
</id>
<discriminator column="type" type="string"/>
</class>
</hibernate-mapping>

<hibernate-mapping>
<subclass name="events.Father"
extends="events.Adult"
discriminator-value="F">
</subclass>
</hibernate-mapping>

<hibernate-mapping>
<subclass name="events.Mother"
extends="events.Adult"
discriminator-value="M">
</subclass>
</hibernate-mapping>

An alternative to subclassing would be for the Adult class to hold a "gender" field, two private sets of children (for hibernate), and one computed public set of children (for the app):



Only the two private children sets are mapped, of course:


The child would have two references, one for the father and one for the mother:


This isn't particularly pretty, but it works. On the other hand, subclassing just for this doesn't strike me as being a lot prettier, unless of course you have other reasons to subclass in addition to this.

Mathieu