Is @ManyToMany(mappedBy = ... ) + @OrderColumn supported by the JPA?

Question

I have an entity mapped as following:

@Entity
@Table(name = "Groups")
@IdClass(value = GroupId.class)
public class Group implements Serializable
{
    @Id
    @Column(name = "round_id")
    private Integer roundId;

    @Id
    @Column(name = "ordinal_nbr")
    private Integer ordinalNbr = 0;

    ...
}

It has a composite key (round_id, ordinal_nbr) to indicate the order of groups in a round.

Now imagine a join table containing entities that link the ordered groups via a self reference (from Group to Group):

CREATE TABLE GroupLinks
(
  parent_round_id INTEGER NOT NULL,
  parent_ordinal_nbr SMALLINT NOT NULL,
  child_round_id INTEGER NOT NULL,
  child_ordinal_nbr SMALLINT NOT NULL,
  PRIMARY KEY (parent_round_id, parent_ordinal_nbr, child_round_id, child_ordinal_nbr),
  FOREIGN KEY (parent_round_id, parent_ordinal_nbr) REFERENCES Groups (round_id, ordinal_nbr),
  FOREIGN KEY (child_round_id, child_ordinal_nbr) REFERENCES Groups (round_id, ordinal_nbr)
);

I know it's possible to map @ManyToMany + @JoinTable + @OrderColumn for the owning entity (whichever I choose):

@ManyToMany
@JoinTable(name = "GroupLinks", joinColumns = {@JoinColumn(name = "parent_round_id", referencedColumnName = "round_id"), @JoinColumn(name = "parent_ordinal_nbr", referencedColumnName = "ordinal_nbr")}, inverseJoinColumns = {@JoinColumn(name = "child_round_id", referencedColumnName = "round_id"), @JoinColumn(name = "child_ordinal_nbr", referencedColumnName = "ordinal_nbr")})
@OrderColumn(name = "child_ordinal_nbr")
private List<Group> children;

Question:

For the owned side, is it supported to map the @ManyToMany(mappedBy = ...) inverse relationship with an @OrderColumn, too?

@ManyToMany(mappedBy = "parents")
@OrderColumn(name = "parent_ordinal_nbr")
private List<Group> parents;

Does the JPA 2 spec define to allow or deny this?

Thanks

---

Update 1:

The above is essentially a graph structure. Here's an example:

The GroupLinks table contains the boxed entities. When looking at the B2 Group entity only, the parents list will contain (a,1,b,2) and (a,2,b,2). As for the children list, it will contain (b,2,c,1), (b,2,c,2), and (b,2,c,3).

As you can see the entities in the lists of B2 won't collide, so an @OrderColumn should work okay for both relationships parents and children - at least in theory. But what's the practice here (JPA)?

Note, that simply trying it on Hibernate and/or EclipseLink doesn't really answer the question whether the JPA 2 spec or a JPA-compatible provider should or must support this scenario.

---

Update 2:

Trying the above mappings on Hibernate results in the following mapping exception:

Caused by: org.hibernate.MappingException: Repeated column in mapping for collection: com.kawoolutions.bbstats.model.Group.parents column: parent_ordinal_nbr
    at org.hibernate.mapping.Collection.checkColumnDuplication(Collection.java:340)
    at org.hibernate.mapping.Collection.checkColumnDuplication(Collection.java:363)
    at org.hibernate.mapping.Collection.validate(Collection.java:320)
    at org.hibernate.mapping.IndexedCollection.validate(IndexedCollection.java:89)
    at org.hibernate.cfg.Configuration.validate(Configuration.java:1291)
    at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1729)
    at org.hibernate.ejb.EntityManagerFactoryImpl.<init>(EntityManagerFactoryImpl.java:84)
    at org.hibernate.ejb.Ejb3Configuration.buildEntityManagerFactory(Ejb3Configuration.java:904)
    ... 9 more

Removing the @OrderColumn for parent_ordinal_nbr results in the same exception for the children relationship. It looks like Hibernate doesn't like order columns which are also used in foreign keys.

---

Update 3:

Tested with EclipseLink on GlassFish... this works, no mapping exceptions.

This raises two followup questions:

1. Does the JPA disallow foreign key order columns? It doesn't make sense to me why they shouldn't simply work...
2. Is this a Hibernate bug?

Answer 1

The javadoc or OrderColumn has the information you're looking for:

The OrderColumn annotation is specified on the side of the relationship that references the collection that is to be ordered. The order column is not visible as part of the state of the entity or embeddable class.

The OrderBy annotation should be used for ordering that is visible as persistent state and maintained by the application. The OrderBy annotation is not used when OrderColumn is specified.

OrderColumn is used to add an additional column to the join table, used to maintain the order of the list. The order column, as mentioned in the javadoc, is not part of the entity state. In your case, it seems you want to order the elements in the list by one of their persistent property. In that case, you must use the OrderBy annotation (or have a getter that sorts the list before returning it).

Answer 2

In OPENJPA there is a problem regarding @OrderColumn, the retrieve operation works, but saving an entity gets an error "detached object", this error is associated to adding this annotation (@OrderColumn)

The solution is to use comparator in the parent.getChildEntity class to order the child entity list, thus, this avoids using @OrderColumn.

Collections.sort(this.child, new Comparator<class_type>() {
@Override
        public int compare(class_type p1, class_type p2) {
            return (int) (p1.getId() - p2.getId());
        }

    });

Solved :) John V, Col