Hibernate CollectionOfElements EAGER fetch duplicates elements

P

6

46

I have a class called SynonymMapping which has a collection of values mapped as a CollectionOfElements

@Entity(name = "synonymmapping")
public class SynonymMapping {

    @Id private String keyId;

    //@CollectionOfElements(fetch = FetchType.EAGER)
    @CollectionOfElements
    @JoinTable(name="synonymmappingvalues", joinColumns={@JoinColumn(name="keyId")})
    @Column(name="value", nullable=false)
    @Sort(type=SortType.NATURAL)
    private SortedSet<String> values;

    public SynonymMapping() {
        values = new TreeSet<String>();
    }

    public SynonymMapping(String key, SortedSet<String> values) {
        this();
        this.keyId = key;
        this.values = values;
    }

    public String getKeyId() {
        return keyId;
    }

    public Set<String> getValues() {
        return values;
    }
}

I have a test where I store two SynonymMapping objects to the database and then ask the database to return all saved SynonymMapping objects, expecting to receive the two objects I stored.

When I change the mapping of values to be eager (as shown in in the code by the commented out line) and run the test again, I receive four matches.

I have cleared out the database between runs and I can duplicate this problem swapping between eager and lazy.

I think it has to do with the joins that hibernate creates underneath but I can't find a definite answer online.

Can anyone tell me why an eager fetch is duplicating the objects?

Thanks.

Pyrenees answered 7/7, 2009 at 15:49 Comment(1)

Every one with the Exception "More than one row with the given identifier was found" should know about this. It really spares alot of hours not knowing what the hell is going wrong. See @user176668 answer!! – Sovereign 27/5, 2016 at 10:31

U

34

It's generally not a good idea to enforce eager fetching in the mapping - it's better to specify eager joins in appropriate queries (unless you're 100% sure that under any and all circumstances your object won't make sense / be valid without that collection being populated).

The reason you're getting duplicates is because Hibernate internally joins your root and collection tables. Note that they really are duplicates, e.g. for 2 SynonymMappings with 3 collection elements each you would get 6 results (2x3), 3 copies of each SynonymMapping entity. So the easiest workaround is to wrap results in a Set thereby ensuring they're unique.

Unlicensed answered 7/7, 2009 at 17:34 Comment(8)

But why can Hibernate not filter these out, I cannot see why you would ever want it this this like this. – Mirabelle 28/2, 2012 at 17:20

I can confirm it works. I was using a Collection<T> just in general, and that was a mistake. – Riverhead 22/6, 2015 at 8:39

Note: wrapping in a Set will render incorrect any pagination done on the results – Sorcerer 9/7, 2021 at 18:22

Is it in general good habit to use Set<>? It solves this "duplicate" problem so I'd use it for all my collections. Is there any downside of it? – Pantywaist 10/8, 2021 at 10:14

@Pantywaist Well, in my case, switching from a List to a Set made it worse: I went from “all elements in three copies” to nine copies. – Colorless 30/6, 2022 at 17:43

@SandySimonton, your comment is irrelevant, because initial issue was about "subset" of objects, and if you are talking about pagination, most probably you need to work with "subobjects" as a "root". – Phrase 1/5, 2023 at 11:12

@Alice-m, it possible only in case when you did not redefine equals and hashcode. Otherwise check what kind of collection is used for your set. – Phrase 1/5, 2023 at 11:12

@dpelisek, yes, sure, objects order is lost. – Phrase 1/5, 2023 at 11:14

H

80

I stepped into the same problem - when you set the FetchType.EAGER for a @CollectionOfElements, the Hibernate tries to get everything in one shot, i.e. using one single query for each entry of element linked to a "master" object. This problem can be successfully solved at a cost of N+1 query, if you add the @Fetch (FetchMode.SELECT) annotation to your collection. In my case I wanted to have a MediaObject entity with a collection of its metadata items (video codec, audio codec, sizes, etc.). The mapping for a metadataItems collection looks as follows:


@CollectionOfElements (targetElement = String.class, fetch = FetchType.EAGER)
@JoinTable(name = "mo_metadata_item", joinColumns = @JoinColumn(name = "media_object_id"))
@MapKey(columns = @Column(name = "name"))
@Column (name = "value")
@Fetch (FetchMode.SELECT)
private Map<String, String> metadataItems = new HashMap<String, String>();

Hesperidin answered 21/9, 2009 at 16:46 Comment(7)

I liked the solution, because we dont need to wrap the result with a Set to get uniqueness. – Supernatural 8/1, 2013 at 22:0

can it also be caused by caching such as EHcache? – Huntington 24/2, 2015 at 23:10

This solution works great, however, it's implementation-dependent. – Sociality 28/4, 2015 at 19:25

Thank you. I have done a lot search about it. Every body said to use Set. – Osswald 15/10, 2016 at 8:13

It works for me. Too bad @Fetch is not a JPA annotation, but who cares. I'm wondering what you are supposed to do when using pure JPA though. It's a bit frustrating. – Scotsman 6/2, 2018 at 16:23

Took ages to debug this, and even longer to find an answer that wasn't a tutorial on implementing collections. Thanks for sharing. – Pentameter 27/9, 2018 at 14:14

@Hesperidin Why you don't use SUBSELECT instead of SELECT? – Cholecyst 13/5, 2023 at 10:8