Develop Reference

Using a column in one mandatory and one optional foreign key in hibernate ORM

I want to use a field in one optional and one mandatory composite foreign key within one entity.
I have three different entities, Team, Person and Shard. Persons belong to a team ManyToOne. Both entities have a ShardID, which is a FK to Shard.
All teams and persons have IDs that are only unique per shard, but they will also only reference the other entities with the same shard ID. Their ShardID is part of their Primary key.
Shard
---
PK ID
UNIQUE Name
Team
---
PK, FK1 ShardID
PK ID
---
FK1 (ShardID -> Shard)
Person
---
PK, FK1, FK2 ShardID
PK ID
FK2 TeamID
---
FK1 (ShardID -> Shard)
FK2 (ShardID, TeamID -> Team)
Additionally, the Person -> Team relationship is optional. A Person may not be member of a Team, and this may change over time.
In trying to model the Person object in JPA, I run into a problem. Obviously, when I model both the ShardID as part of the primary key and as a foreign key column, hibernate gives me the Repeated column in mapping for entity error. I can prevent this using insertable = false, updatable = false:
// This contains the shard_id column
#EmbeddedId
protected PersonId id;
#ManyToOne(optional = true)
#JoinColumns({
#JoinColumn(name = "shard_id", insertable = false, updatable = false),
#JoinColumn(name = "team_id", nullable = true)
})
But I cannot do this because hibernate requires all JoinColumns to have identical settings for insertable and updatable, and I need the ability to add a team to the person later down the line. ShardID will always be present, but TeamID may not be.
How can I achieve this in hibernate JPA ORM? I've browsed the hibernate docs for O/R modeling and can't find a way. I've been looking at table inheritance, but that feels very unnatural and doesn't fix the "optional problem".
This example does not contain my actual data model, but serves as a simplified example.

You can try to use #JoinColumnOrFormula like this:
#JoinColumnOrFormulas({
#JoinColumnOrFormula(formula = #JoinFormula(value = "shard_id", referencedColumnName = "shard_id")),
#JoinColumnOrFormula(column = #JoinColumn(name = "team_id", referencedColumnName = "id", nullable = true))
})

How to tell hibernate to generate a foreign key constraint with 'on update/delete restrict'

Hibernate generates foreign key constraints like this in PostgreSQL:
ADD CONSTRAINT fk4027e58ea8b36313 FOREIGN KEY (fk_responsible_person)
REFERENCES employee (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION;
I would like
ON UPDATE RESTRICT ON DELETE RESTRICT
My current annotations:
#ManyToOne(optional = true, fetch = FetchType.EAGER)
#JoinColumn(name = "fk_responsible_person", updatable = true, nullable = true)
public Employee getResponsiblePerson()
{
return m_responsiblePerson;
}
What kind of configuration/annotation do I have to use to get 'restrict' instead of 'no action'?

Hibernate makes insert twice and results in unique key constraint violation

hi I'm getting this "javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: ERROR: duplicate key value violates unique constraint"
I have two tables A and B,
A has id, b_id, B has id,A_id's.
A - oneToMany , B - manyToOne relationship.
on A,
#OneToOne(cascade = { CascadeType.ALL })
#JoinColumn(name = "LATEST_VERSION_ID") #Valid
#EntityProperty(type = "GuidKey", relation = "B.id")
on B,
#ManyToOne(cascade = {CascadeType.ALL})
#JoinColumn(name = "A_ID") #Valid
#EntityProperty(type = "Key", relation = "A.id")
when I create Page A I was able to Do so, But when I try to update I get unique constraint violation on table 'B'.
It says the record already exist.

You have to make a bi-directional relation using the mappedBy property.
See:
one to one bidirectional hibernate mapping
http://www.mkyong.com/hibernate/hibernate-one-to-one-relationship-example-annotation
http://www.codereye.com/2009/04/hibernate-bi-directional-one-to-one.html
Also, #EntityProperty isn't required for this. The foreign key should be in one table in one-to-one.

#OrderColumn generates a request to update the primary key

I use a list. The list is comprised of a compound primary key which is also used for sorting the list.
The problem is that if I delete an element in the list (key compound),
annotation #OrderColumn generates a request to update a primary key, and the cost rises an exception of type:
[26-05-2011 10:34:18:835] WARN org.hibernate.util.JDBCExceptionReporter - SQL Error: 1062, SQLState: 23000
[26-05-2011 10:34:18:835] ERROR org.hibernate.util.JDBCExceptionReporter -Duplicate entry '10-10' for key 'PRIMARY'
[26-05-2011 10:34:18:835] ERROR org.hibernate.event.def.AbstractFlushingEventListener - Could not synchronize database state with session org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
Here is the definition of the mapping :
#ManyToMany(cascade=CascadeType.ALL, fetch = FetchType.LAZY)
#JoinTable(name = "chapter_item", joinColumns = { #JoinColumn(name = "chapter_id", nullable = false, updatable = false) }, inverseJoinColumns = { #JoinColumn(name = "item_id", nullable = false, updatable = false) })
#OrderColumn(name="iorder")
public List<Item> getItems() {
return items;
}
Here is the update query where I have a problem:
Hibernate:
update
chapter_item
set
item_id=?
where
chapter_id=?
and iorder=?
I wonder if this is a known bug, and if anyone has a solution?

Regarding #OrderColumn, following documentation is found at http://docs.oracle.com/javaee/6/api/javax/persistence/OrderColumn.html
Specifies a column that is used to maintain the persistent order of a
list. The persistence provider is responsible for maintaining the
order upon retrieval and in the database. The persistence provider is
responsible for updating the ordering upon flushing to the database to
reflect any insertion, deletion, or reordering affecting the list.
So we see that the persistence provider i.e. hibernate is responsible for updating the column named iorder. It is also said that:
The OrderColumn annotation is specified on a OneToMany or ManyToMany
relationship or on an element collection. 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.
Please take note of the sentence that says:
The order column is not visible as part of the state of the entity or
embeddable class.
So, may I suggest you to consider not selecting the column iorder for #OrderColumn since it is a part of your composite key and hibernate is sure to update this value when you delete or insert an element in list (List<Item>).
Hope, this helps.

Maybe one option could be change the order annotation and use:
#ManyToMany(cascade=CascadeType.ALL, fetch = FetchType.LAZY)
#JoinTable(name = "chapter_item", joinColumns = { #JoinColumn(name = "chapter_id", nullable = false, updatable = false) }, inverseJoinColumns = {#JoinColumn(name = "item_id", nullable = false, updatable = false) })
#org.hibernate.annotations.Sort(type = SortType.COMPARATOR, comparator = ItemComparator)
public List<Item> getItems() {
return items;
}
https://dzone.com/articles/sorting-collections-hibernate
Check performance solution because maybe is too slow for big amount of data, and if you can share if was a possible solution would be great to know

Hibernate: Where do insertable = false, updatable = false belong in composite primary key constellations involving foreign keys?

When implementing composite primary keys in Hibernate or other ORMs there are up to three places where to put the insertable = false, updatable = false in composite primary key constellations that use identifying relationships (FKs that are part of the PK):
Into the composite PK class' #Column annotation (#Embeddable classes only) or
Into the entity class' association #JoinColumn/s annotation or
Into the entity class' redundant PK property's #Column annotation (#IdClass classes only)
The third is the only way to do with #IdClass and JPA 1.0 AFAIK. See http://en.wikibooks.org/wiki/Java_Persistence/Identity_and_Sequencing#Primary_Keys_through_OneToOne_Relationships. I will consider only cases 1. and 2.
Q:
Which way is the preferred place to put the "insertable = false, updatable = false" to generally?
I have experienced problems with Hibernate concerning this question. For example, Hibernate 3.5.x will complain about the Zips table
CREATE TABLE Zips
(
country_code CHAR(2),
code VARCHAR(10),
PRIMARY KEY (country_code, code),
FOREIGN KEY (country_code) REFERENCES Countries (iso_code)
)
with:
org.hibernate.MappingException: Repeated column in mapping for entity: com.kawoolutions.bbstats.model.Zip column: country_code (should be mapped with insert="false" update="false")
org.hibernate.mapping.PersistentClass.checkColumnDuplication(PersistentClass.java:676)
org.hibernate.mapping.PersistentClass.checkPropertyColumnDuplication(PersistentClass.java:698)
...
As you can see the country_code column is both PK and FK. Here are its classes:
Entity class:
#Entity
#Table(name = "Zips")
public class Zip implements Serializable
{
#EmbeddedId
private ZipId id;
#ManyToOne
#JoinColumn(name = "country_code", referencedColumnName = "iso_code")
private Country country = null;
...
}
Composite PK class:
#Embeddable
public class ZipId implements Serializable
{
#Column(name = "country_code", insertable = false, updatable = false)
private String countryCode;
#Column(name = "code")
private String code;
...
}
When putting the insertable = false, updatable = false into the entity class association's #JoinColumn all exceptions disappear and everything work fine. However, I don't see why the above code should not be working. It might be Hibernate having problems with this. Is the described a Hibernate bug, as it doesn't seem to evaluate #Column "insertable = false, updatable = false"?
In essence, what's the standard JPA way, the best practice, or preference where to put "insertable = false, updatable = false"?

Let me answer step by step.
1. When do you need ` insertable = false, updatable = false`?
Let's look at the below mapping,
public class Zip {
#ManyToOne
#JoinColumn(name = "country_code", referencedColumnName = "iso_code")
private Country country = null
#Column(name = "country_code")
private String countryCode;
}
Here we are referring to the same column in the table using two different properties. In the below code,
Zip z = new Zip();
z.setCountry(getCountry("US"));
z.setCountryCode("IN");
saveZip(z);
What will Hibernate do here??
To prevent these kind of inconsistency, Hibernate is asking you to specify the update point of relationships. Which means you can refer to the same column in the table n number of times but only one of them can be used to update and all others will be read only.
2. Why is Hibernate complaining about your mapping?
In your Zip class you are referring to the Embedded id class ZipId that again contains the country code. As in the above scenario now you have a possibility of updating the country_code column from two places. Hence the error given by Hibernate is proper.
3. How to fix it in your case?
No. Ideally you want your ZipId class to generate the id, so you should not add insertable = false, updatable = false to the countryCode inside the ZipId. So the fix is as below modify the country mapping in your Zip class as below,
#ManyToOne
#JoinColumn(name = "country_code", referencedColumnName = "iso_code",
insertable = false, updatable = false)
private Country country;
Hope this helps your understanding.

You can also solve this problem by using #PrimaryKeyJoinColumn annotation . The PrimaryKeyJoinColumn annotation specifies a primary key column that is used as a foreign key to join to another table.
The PrimaryKeyJoinColumn annotation is used to join the primary table of an entity subclass in the JOINED mapping strategy to the primary table of its superclass; it is used within a SecondaryTable annotation to join a secondary table to a primary table; and it may be used in a OneToOne mapping in which the primary key of the referencing entity is used as a foreign key to the referenced entity.
If no PrimaryKeyJoinColumn annotation is specified for a subclass in the JOINED mapping strategy, the foreign key columns are assumed to have the same names as the primary key columns of the primary table of the superclass.