private String getMappedBy(Collection collectionValue) {
PersistentClass referencedClass = null;
if (collectionValue.getElement() instanceof OneToMany) {
OneToMany oneToManyValue = (OneToMany) collectionValue.getElement();
referencedClass = oneToManyValue.getAssociatedClass();
} else if (collectionValue.getElement() instanceof ManyToOne) {
// Case for bi-directional relation with @JoinTable on the owning @ManyToOne side.
ManyToOne manyToOneValue = (ManyToOne) collectionValue.getElement();
referencedClass =
manyToOneValue.getMappings().getClass(manyToOneValue.getReferencedEntityName());
}
// If there's an @AuditMappedBy specified, returning it directly.
String auditMappedBy = propertyAuditingData.getAuditMappedBy();
if (auditMappedBy != null) {
return auditMappedBy;
}
// searching in referenced class
String mappedBy = this.searchMappedBy(referencedClass, collectionValue);
if (mappedBy == null) {
LOG.debugf(
"Going to search the mapped by attribute for %s in superclasses of entity: %s",
propertyName, referencedClass.getClassName());
PersistentClass tempClass = referencedClass;
while ((mappedBy == null) && (tempClass.getSuperclass() != null)) {
LOG.debugf("Searching in superclass: %s", tempClass.getSuperclass().getClassName());
mappedBy = this.searchMappedBy(tempClass.getSuperclass(), collectionValue);
tempClass = tempClass.getSuperclass();
}
}
if (mappedBy == null) {
throw new MappingException(
"Unable to read the mapped by attribute for "
+ propertyName
+ " in "
+ referencedClass.getClassName()
+ "!");
}
return mappedBy;
}
public static void bindCollectionSecondPass(
Collection collection,
java.util.Map persistentClasses,
Mappings mappings,
java.util.Map inheritedMetas)
throws MappingException {
if (collection.isOneToMany()) {
OneToMany oneToMany = (OneToMany) collection.getElement();
PersistentClass persistentClass = mappings.getClass(oneToMany.getReferencedEntityName());
if (persistentClass == null)
throw new MappingException(
"Association "
+ collection.getRole()
+ " references unmapped class: "
+ oneToMany.getReferencedEntityName());
oneToMany.setAssociatedClass(persistentClass); // Child
}
}
/**
* @param rc
* @param processed
* @param table
* @param object
*/
private Property bindOneToMany(
PersistentClass rc, ForeignKey foreignKey, Set processed, Mapping mapping) {
Table collectionTable = foreignKey.getTable();
// Collection collection = new org.hibernate.mapping.Set(rc); // MASTER TODO: allow overriding
// collection type
Collection collection =
new org.hibernate.mapping.List(rc); // MASTER TODO: allow overriding collection type
collection.setCollectionTable(collectionTable); // CHILD+
boolean manyToMany = revengStrategy.isManyToManyTable(collectionTable);
if (manyToMany) {
// log.debug("Rev.eng said here is a many-to-many");
// TODO: handle "the other side should influence the name"
}
if (manyToMany) {
ManyToOne element = new ManyToOne(collection.getCollectionTable());
// TODO: find the other foreignkey and choose the other side.
Iterator foreignKeyIterator = foreignKey.getTable().getForeignKeyIterator();
List keys = new ArrayList();
while (foreignKeyIterator.hasNext()) {
Object next = foreignKeyIterator.next();
if (next != foreignKey) {
keys.add(next);
}
}
if (keys.size() > 1) {
throw new JDBCBinderException(
"more than one other foreign key to choose from!"); // todo: handle better ?
}
ForeignKey fk = (ForeignKey) keys.get(0);
String tableToClassName = bindCollection(rc, foreignKey, fk, collection);
element.setReferencedEntityName(tableToClassName);
element.addColumn(fk.getColumn(0));
collection.setElement(element);
} else {
String tableToClassName = bindCollection(rc, foreignKey, null, collection);
OneToMany oneToMany = new OneToMany(collection.getOwner());
oneToMany.setReferencedEntityName(tableToClassName); // Child
mappings.addSecondPass(new JDBCCollectionSecondPass(mappings, collection));
collection.setElement(oneToMany);
}
// bind keyvalue
KeyValue referencedKeyValue;
String propRef = collection.getReferencedPropertyName();
if (propRef == null) {
referencedKeyValue = collection.getOwner().getIdentifier();
} else {
referencedKeyValue = (KeyValue) collection.getOwner().getProperty(propRef).getValue();
}
SimpleValue keyValue = new DependantValue(collectionTable, referencedKeyValue);
// keyValue.setForeignKeyName("none"); // Avoid creating the foreignkey
// key.setCascadeDeleteEnabled( "cascade".equals( subnode.attributeValue("on-delete") ) );
Iterator columnIterator = foreignKey.getColumnIterator();
while (columnIterator.hasNext()) {
Column fkcolumn = (Column) columnIterator.next();
if (fkcolumn.getSqlTypeCode()
!= null) { // TODO: user defined foreign ref columns does not have a type set.
guessAndAlignType(
collectionTable,
fkcolumn,
mapping,
false); // needed to ensure foreign key columns has same type as the "property" column.
}
keyValue.addColumn(fkcolumn);
}
collection.setKey(keyValue);
mappings.addCollection(collection);
return makeCollectionProperty(
StringHelper.unqualify(collection.getRole()),
true,
rc.getTable(),
foreignKey,
collection,
true);
// return makeProperty(TableIdentifier.create( rc.getTable() ), StringHelper.unqualify(
// collection.getRole() ), collection, true, true, true, "none", null); // TODO: cascade isn't
// all by default
}