Preview 5 -- Bug when Inheritance used with @OneToMany

[ttarhan]

Take these three objects:

Person, Pet, Cat, and Dog.

Cat and Dog inherit from Pet using SINGLE_TABLE; id #1 is a Cat and id #2 is a Dog.

Person contains a @OneToMany reference to Cat and a seperate @OneToMany reference to Dog. That means there's both a getCats() and getDogs() method in Person.

If you use entityManager.find(Pet.class, 1), you will get a Cat object as expected.

If you do person.getCats(), all of the objects in the returned collection (which is lazy loaded) will be of the correct type, Cat, but some of the items in the collection will in fact be Dogs (that is, you'll get Pet id #1 and id #2 in the collection, when you only should have gotten id #1, as it is the only Cat). Looking at the query that hibernate created, you'll see that hibernate didn't even attempt to select the disriminator field. This seems like a bug.

However, if you remove the getCats and getDogs methods and replace them with a single getPets method which has a @OneToMany relationship with the base-type, Pet, then the objects in the collection are of the correct type with the correct data. The problem with this is that in some cases, we're only interested in Cats or Dogs, but not both.

It seems that making a reference to a sub-class should work as expected.

Let me know if you think it's a bug and I'll post to JIRA as appropriate.

[epbernard]

Are you using the same fk column "person_id" to refer to both Dogs and Cats. Try to explicit the @JoinColumn with different name to make it work.

[ttarhan]

Sorry it took so long to get back to this, but this problem still exists, and no combination of JoinColumn can fix the problem. Hibernate simply doesn't select the discriminator field. The only solution would be to have dog_person_id and cat_person_id in the Pets table, which obviously is a bad thing to do.

[epbernard]

"ttarhan" wrote:
The only solution would be to have dog_person_id and cat_person_id in the Pets table, which obviously is a bad thing to do.

I completly disagree, this is obviously the right thing to do.

[ttarhan]

Why wouldn't you reuse a single field, person_id? Regardless of if it's a Cat or a Dog, it's still linked to a Person. It seems like a waste to have two fields for that purpose.

Shouldn't hibernate just select the discriminator type, or better yet, use the discriminator as a WHERE condition when you're only looking for a certain type?

[epbernard]

There are ways to do that using @Where which is an hibernate specific annotations. But I still don't recommend that.