[ http://opensource.atlassian.com/projects/hibernate/browse/HHH-2690?page=c... ] Carl Gilbert commented on HHH-2690: ----------------------------------- I am using postgres 8.1 with driver 8.1-409 and java 1.5.0_11 Same problem. Fell back to 3.2.0.ga and its working again. My mapping is just about the same. dbvariant.hbm.xml [code] <hibernate-mapping> <joined-subclass name="com.rgdsft.hib.core.DBVariant" table="VARIANT" extends="com.rgdsft.hib.core.DBNamedObject"> <key column="OBJECT_ID"/> <properties name="uniqueVirtualSysNameConstraint" unique="true"> <property name="name" not-null="true" type="string"/> <many-to-one name="project" class="com.rgdsft.hib.core.DBProject" column="ProjectID" not-null="true" lazy="proxy"/> </properties> <!-- problem here because we do not want the variant referenced by the variantcollholder. That would interfere with the serialization. Since we do not put the variant in the holder, we can not get hibernate to create the foreign key constraints that I would want here. What I want is unique (variant,system) also maybe not-null in the systemID key? --> <map name="varholderMap" table="VARHOLDER_MAP" access="field" cascade="all,delete-orphan"> <key column="DBVariant_ID" not-null="true"/> <map-key-many-to-many column="KEY_SystemID" class="com.rgdsft.hib.core.DBSystem"/> <one-to-many class="com.rgdsft.hib.core.VariantCollHolder"/> </map> </joined-subclass> </hibernate-mapping> <hibernate-mapping> <joined-subclass name="com.rgdsft.hib.core.DBNamedObject" abstract="true" extends="com.rgdsft.hib.core.DBObject"> <key column="OBJECT_ID"/> <map name="properties" table="PROPERTIES" access="field"> <key column="DBNamedObject_ID" not-null="true"/> <map-key-many-to-many column="PROPERTY_ID" class="com.rgdsft.hib.core.DBPropertyType"/> <element column="PROPERTY_VALUE" type="string" not-null="true"/> </map> </joined-subclass> </hibernate-mapping> <hibernate-mapping> <class name="com.rgdsft.hib.core.DBObject" abstract="true"> <id name="id" column="OBJECT_ID"> <generator class="native"/> </id> <property name="identifier" not-null="true" unique="true"/> </class> </hibernate-mapping> [/code] VariantCollHolder.hbm.xml [code] <hibernate-mapping> <class name="com.rgdsft.hib.core.VariantCollHolder" table="VARIANTCOLLHOLDER" lazy="false"> <id name="id" type="long"> <generator class="native"/> </id> <!-- no cascading here since we will only ever deal in remove/add from collection and deal in querying values from the comp instance --> <set name="instances" table="COMPINST_VARIANT" lazy="false" access="field"> <key column="VariantID"/> <!-- change to varCollHolderID --> <many-to-many column="CompinstanceID" class="com.rgdsft.hib.core.DBComponentInstance"/> </set> <!-- no cascading here since we will only ever deal in remove/add from collection and deal in querying values from the comp instance --> <set name="connections" table="CONNECTION_VARIANT" lazy="false" access="field"> <key column="VariantID"/> <!-- change to varCollHolderID --> <many-to-many column="ConnectionID" class="com.rgdsft.hib.core.DBFunctionConnection"/> </set> </class> </hibernate-mapping> [/code] And a few classes [code] public class DBVariant extends DBNamedObject { private String name; private DBProject project; private Map<DBSystem,VariantCollHolder> varholderMap = new HashMap<DBSystem,VariantCollHolder>();//not in default fetch public DBVariant(String name, DBProject project, Long identifier) { super(identifier); assert name != null; assert project != null; this.name = name; this.project = project; } DBVariant(){ } //edited-Not a test case } public final class VariantCollHolder implements Serializable { private static final long serialVersionUID = 1L; /* * Hibernate spec version 3.2.0.ga section 4.1.2 states that transitive * reattachment of detached objects requires an identifier. So we have one. */ private Long id; // identifier /** * The set of component instances in the associated variant. */ private Set<DBComponentInstance> instances = new HashSet<DBComponentInstance>(); /** * The set of connections in the associated variant. */ private Set<DBFunctionConnection> connections = new HashSet<DBFunctionConnection>(); private transient boolean dirty; public VariantCollHolder() { } /** * @return the instances */ public Set<DBComponentInstance> getInstances() { return instances; } /** * @param instances the instances to set */ void setInstances(Set<DBComponentInstance> instances) { this.instances = instances; } /** * @return the connections */ public Set<DBFunctionConnection> getConnections() { return connections; } /** * @param connections the connections to set */ void setConnections(Set<DBFunctionConnection> connections) { this.connections = connections; } public boolean isDirty() { return dirty; } public void setDirty(boolean dirty) { this.dirty = dirty; } public Long getId() { return id; } private void setId(Long id) { this.id = id; } } public abstract class DBNamedObject extends DBObject { private Map<DBPropertyType,String> properties = new HashMap<DBPropertyType,String>();//not in default fetch public DBNamedObject(Long identifier) { super(identifier); } DBNamedObject(){ } /************************ Begin Property Stuff ****************************/ public final Set<DBPropertyType> getPropertyKeys(){ return properties.keySet(); } /* * This probably works but is less efficient than calling for the key set * and constructing objects that way. At least to the WAD object because * we construct a map here, and they will have to construct a new map there. */ public Map<DBPropertyType,String> getProperties(){ return properties; } public String getProperty(DBPropertyType key) { return properties.get(key); } public String setProperty(DBPropertyType key, String value){ return properties.put(key,value); } /************************ End Property Stuff ******************************/ public abstract String getName(); public abstract void setName(String name); } public abstract class DBObject { /* * Hibernate spec version 3.2.0.ga section 4.1.2 states that transitive * reattachment of detached objects requires an identifier. So we have one. */ private Long id; private Long identifier; /* * An object is dirty when it is modified. */ private transient boolean dirty; DBObject(){ } public DBObject(Long identifier) { assert identifier != null; this.identifier = identifier; } private void setId(Long id) { this.id = id; } public Long getId() { return id; } public Long getIdentifier() { return identifier; } private void setIdentifier(Long identifier) { this.identifier = identifier; } public boolean isDirty() { return dirty; } public void setDirty(boolean dirty) { this.dirty = dirty; } //we need a system based on something that does not change and is assignable at commit time //I think identifier does not change and is assignable at commit time! @Override public boolean equals(Object obj) { if(obj instanceof DBObject){ return ((DBObject)obj).identifier.equals(identifier); } return false; } @Override public int hashCode() { return identifier.hashCode(); } /** * Do not show hashcode if equals is not based on hashcode */ @Override public String toString() { return "(" + getClass().getSimpleName() + "::" + identifier +"@" + super.hashCode() +")"; } } [/code] -- This message is automatically generated by JIRA. - If you think it was sent incorrectly contact one of the administrators: http://opensource.atlassian.com/projects/hibernate/secure/Administrators.... - For more information on JIRA, see: http://www.atlassian.com/software/jira