HHH-6825 - AuditException with @OneToOne-mappedBy and @PrimaryKeyJoinColumn

hibernate-envers/src/main/java/org/hibernate/envers/configuration/metadata/AuditMetadataGenerator.java

@@ -49,6 +49,7 @@
 import org.hibernate.envers.tools.Triple;
 import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.Join;
+import org.hibernate.mapping.OneToOne;
 import org.hibernate.mapping.PersistentClass;
 import org.hibernate.mapping.Property;
 import org.hibernate.mapping.Table;
@@ -193,8 +194,15 @@ void addValue(Element parent, Value value, CompositeMapperBuilder currentMapper,
         } else if (type instanceof OneToOneType) {
             // only second pass
             if (!firstPass) {
-                toOneRelationMetadataGenerator.addOneToOneNotOwning(propertyAuditingData, value,
-                        currentMapper, entityName);
+                OneToOne oneToOne = (OneToOne) value;
+                if (oneToOne.getReferencedPropertyName() != null) {
+                    toOneRelationMetadataGenerator.addOneToOneNotOwning(propertyAuditingData, value,
+                            currentMapper, entityName);
+                } else {
+                    // @OneToOne relation marked with @PrimaryKeyJoinColumn
+                    toOneRelationMetadataGenerator.addOneToOnePrimaryKeyJoinColumn(propertyAuditingData, value,
+                            currentMapper, entityName, insertable);
+                }
             }
         } else if (type instanceof CollectionType) {
             // only second pass

hibernate-envers/src/main/java/org/hibernate/envers/configuration/metadata/ToOneRelationMetadataGenerator.java

@@ -32,6 +32,7 @@
 import org.hibernate.envers.entities.mapper.CompositeMapperBuilder;
 import org.hibernate.envers.entities.mapper.id.IdMapper;
 import org.hibernate.envers.entities.mapper.relation.OneToOneNotOwningMapper;
+import org.hibernate.envers.entities.mapper.relation.OneToOnePrimaryKeyJoinColumnMapper;
 import org.hibernate.envers.entities.mapper.relation.ToOneIdMapper;
 import org.hibernate.envers.tools.MappingTools;
 import org.hibernate.mapping.OneToOne;
@@ -41,6 +42,7 @@
 /**
  * Generates metadata for to-one relations (reference-valued properties).
  * @author Adam Warski (adam at warski dot org)
+ * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
  */
 public final class ToOneRelationMetadataGenerator {
     private final AuditMetadataGenerator mainGenerator;
@@ -131,7 +133,29 @@ void addOneToOneNotOwning(PropertyAuditingData propertyAuditingData, Value value
 
         // Adding mapper for the id
         PropertyData propertyData = propertyAuditingData.getPropertyData();
-        mapper.addComposite(propertyData, new OneToOneNotOwningMapper(owningReferencePropertyName,
-                referencedEntityName, propertyData));
+        mapper.addComposite(propertyData, new OneToOneNotOwningMapper(entityName, referencedEntityName,
+                owningReferencePropertyName, propertyData));
+    }
+
+    @SuppressWarnings({"unchecked"})
+    void addOneToOnePrimaryKeyJoinColumn(PropertyAuditingData propertyAuditingData, Value value,
+                                         CompositeMapperBuilder mapper, String entityName, boolean insertable) {
+        String referencedEntityName = ((ToOne) value).getReferencedEntityName();
+
+        IdMappingData idMapping = mainGenerator.getReferencedIdMappingData(entityName, referencedEntityName,
+                                                                           propertyAuditingData, true);
+
+        String lastPropertyPrefix = MappingTools.createToOneRelationPrefix(propertyAuditingData.getName());
+
+        // Generating the id mapper for the relation
+        IdMapper relMapper = idMapping.getIdMapper().prefixMappedProperties(lastPropertyPrefix);
+
+        // Storing information about this relation
+        mainGenerator.getEntitiesConfigurations().get(entityName).addToOneRelation(propertyAuditingData.getName(),
+                                                                                   referencedEntityName, relMapper, insertable);
+
+        // Adding mapper for the id
+        PropertyData propertyData = propertyAuditingData.getPropertyData();
+        mapper.addComposite(propertyData, new OneToOnePrimaryKeyJoinColumnMapper(entityName, referencedEntityName, propertyData));
     }
 }

hibernate-envers/src/main/java/org/hibernate/envers/entities/mapper/relation/AbstractOneToOneMapper.java

@@ -0,0 +1,54 @@
+package org.hibernate.envers.entities.mapper.relation;
+
+import org.hibernate.NonUniqueResultException;
+import org.hibernate.envers.configuration.AuditConfiguration;
+import org.hibernate.envers.entities.PropertyData;
+import org.hibernate.envers.exception.AuditException;
+import org.hibernate.envers.reader.AuditReaderImplementor;
+
+import javax.persistence.NoResultException;
+import java.io.Serializable;
+import java.util.Map;
+
+/**
+ * Template class for property mappers that manage one-to-one relation.
+ * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
+ */
+public abstract class AbstractOneToOneMapper extends AbstractToOneMapper {
+    private final String entityName;
+    private final String referencedEntityName;
+
+    protected AbstractOneToOneMapper(String entityName, String referencedEntityName, PropertyData propertyData) {
+        super(propertyData);
+        this.entityName = entityName;
+        this.referencedEntityName = referencedEntityName;
+    }
+
+    @Override
+    public void nullSafeMapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
+                                           AuditReaderImplementor versionsReader, Number revision) {
+        EntityInfo referencedEntity = getEntityInfo(verCfg, referencedEntityName);
+
+        Object value = null;
+        try {
+            value = queryForReferencedEntity(versionsReader, referencedEntity, (Serializable) primaryKey, revision);
+        } catch (NoResultException e) {
+            value = null;
+        } catch (NonUniqueResultException e) {
+            throw new AuditException("Many versions results for one-to-one relationship " + entityName +
+                                     "." + getPropertyData().getBeanName() + ".", e);
+        }
+
+        setPropertyValue(obj, value);
+    }
+
+    /**
+     * @param versionsReader Audit reader.
+     * @param referencedEntity Referenced entity descriptor.
+     * @param primaryKey Referenced entity identifier.
+     * @param revision Revision number.
+     * @return Referenced object or proxy of one-to-one relation.
+     */
+    protected abstract Object queryForReferencedEntity(AuditReaderImplementor versionsReader, EntityInfo referencedEntity,
+                                                       Serializable primaryKey, Number revision);
+}

hibernate-envers/src/main/java/org/hibernate/envers/entities/mapper/relation/AbstractToOneMapper.java

@@ -0,0 +1,103 @@
+package org.hibernate.envers.entities.mapper.relation;
+
+import org.hibernate.collection.spi.PersistentCollection;
+import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.envers.configuration.AuditConfiguration;
+import org.hibernate.envers.entities.EntityConfiguration;
+import org.hibernate.envers.entities.PropertyData;
+import org.hibernate.envers.entities.mapper.PersistentCollectionChangeData;
+import org.hibernate.envers.entities.mapper.PropertyMapper;
+import org.hibernate.envers.reader.AuditReaderImplementor;
+import org.hibernate.envers.tools.reflection.ReflectionTools;
+import org.hibernate.property.Setter;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Base class for property mappers that manage to-one relation.
+ * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
+ */
+public abstract class AbstractToOneMapper implements PropertyMapper {
+    private final PropertyData propertyData;
+
+    protected AbstractToOneMapper(PropertyData propertyData) {
+        this.propertyData = propertyData;
+    }
+
+    @Override
+    public boolean mapToMapFromEntity(SessionImplementor session, Map<String, Object> data, Object newObj, Object oldObj) {
+        return false;
+    }
+
+    @Override
+    public void mapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
+                                   AuditReaderImplementor versionsReader, Number revision) {
+        if (obj != null) {
+            nullSafeMapToEntityFromMap(verCfg, obj, data, primaryKey, versionsReader, revision);
+        }
+    }
+
+    @Override
+    public List<PersistentCollectionChangeData> mapCollectionChanges(String referencingPropertyName,
+                                                                     PersistentCollection newColl,
+                                                                     Serializable oldColl, Serializable id) {
+        return null;
+    }
+
+    /**
+     * @param verCfg Audit configuration.
+     * @param entityName Entity name.
+     * @return Entity class, name and information whether it is audited or not.
+     */
+    protected EntityInfo getEntityInfo(AuditConfiguration verCfg, String entityName) {
+        EntityConfiguration entCfg = verCfg.getEntCfg().get(entityName);
+        boolean isRelationAudited = true;
+        if (entCfg == null) {
+            // a relation marked as RelationTargetAuditMode.NOT_AUDITED
+            entCfg = verCfg.getEntCfg().getNotVersionEntityConfiguration(entityName);
+            isRelationAudited = false;
+        }
+        Class entityClass = ReflectionTools.loadClass(entCfg.getEntityClassName());
+        return new EntityInfo(entityClass, entityName, isRelationAudited);
+    }
+
+    protected void setPropertyValue(Object targetObject, Object value) {
+        Setter setter = ReflectionTools.getSetter(targetObject.getClass(), propertyData);
+        setter.set(targetObject, value, null);
+    }
+
+    /**
+     * @return Bean property that represents the relation.
+     */
+    protected PropertyData getPropertyData() {
+        return propertyData;
+    }
+
+    /**
+     * Parameter {@code obj} is never {@code null}.
+     * @see PropertyMapper#mapToEntityFromMap(AuditConfiguration, Object, Map, Object, AuditReaderImplementor, Number)
+     */
+    public abstract void nullSafeMapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
+                                                    AuditReaderImplementor versionsReader, Number revision);
+
+    /**
+     * Simple descriptor of an entity.
+     */
+    protected class EntityInfo {
+        private final Class entityClass;
+        private final String entityName;
+        private final boolean audited;
+
+        public EntityInfo(Class entityClass, String entityName, boolean audited) {
+            this.entityClass = entityClass;
+            this.entityName = entityName;
+            this.audited = audited;
+        }
+
+        public Class getEntityClass() { return entityClass; }
+        public String getEntityName() { return entityName; }
+        public boolean isAudited() { return audited; }
+    }
+}

hibernate-envers/src/main/java/org/hibernate/envers/entities/mapper/relation/OneToOneNotOwningMapper.java

@@ -22,78 +22,35 @@
  * Boston, MA  02110-1301  USA
  */
 package org.hibernate.envers.entities.mapper.relation;
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-import javax.persistence.NoResultException;
 
-import org.hibernate.NonUniqueResultException;
-import org.hibernate.collection.spi.PersistentCollection;
-import org.hibernate.engine.spi.SessionImplementor;
-import org.hibernate.envers.configuration.AuditConfiguration;
-import org.hibernate.envers.entities.EntityConfiguration;
 import org.hibernate.envers.entities.PropertyData;
-import org.hibernate.envers.entities.mapper.PersistentCollectionChangeData;
-import org.hibernate.envers.entities.mapper.PropertyMapper;
-import org.hibernate.envers.exception.AuditException;
 import org.hibernate.envers.query.AuditEntity;
 import org.hibernate.envers.reader.AuditReaderImplementor;
-import org.hibernate.envers.tools.reflection.ReflectionTools;
-import org.hibernate.property.Setter;
+
+import javax.persistence.OneToOne;
+import java.io.Serializable;
 
 /**
+ * Property mapper for not owning side of {@link OneToOne} relation.
  * @author Adam Warski (adam at warski dot org)
  * @author Hern�n Chanfreau
+ * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
  */
-public class OneToOneNotOwningMapper implements PropertyMapper {
-    private String owningReferencePropertyName;
-    private String owningEntityName;
-    private PropertyData propertyData;
+public class OneToOneNotOwningMapper extends AbstractOneToOneMapper {
+    private final String owningReferencePropertyName;
 
-    public OneToOneNotOwningMapper(String owningReferencePropertyName, String owningEntityName,
+    public OneToOneNotOwningMapper(String notOwningEntityName, String owningEntityName, String owningReferencePropertyName,
                                    PropertyData propertyData) {
+        super(notOwningEntityName, owningEntityName, propertyData);
         this.owningReferencePropertyName = owningReferencePropertyName;
-        this.owningEntityName = owningEntityName;
-        this.propertyData = propertyData;
-    }
-
-    public boolean mapToMapFromEntity(SessionImplementor session, Map<String, Object> data, Object newObj, Object oldObj) {
-        return false;
-    }
-
-    public void mapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey, AuditReaderImplementor versionsReader, Number revision) {
-        if (obj == null) {
-            return;
-        }
-
-    	EntityConfiguration entCfg = verCfg.getEntCfg().get(owningEntityName);
-    	if(entCfg == null) {
-    		// a relation marked as RelationTargetAuditMode.NOT_AUDITED 
-    		entCfg = verCfg.getEntCfg().getNotVersionEntityConfiguration(owningEntityName);
-    	}
-
-        Class<?> entityClass = ReflectionTools.loadClass(entCfg.getEntityClassName());
-
-        Object value;
-
-        try {
-            value = versionsReader.createQuery().forEntitiesAtRevision(entityClass, owningEntityName, revision)
-                    .add(AuditEntity.relatedId(owningReferencePropertyName).eq(primaryKey)).getSingleResult();
-        } catch (NoResultException e) {
-            value = null;
-        } catch (NonUniqueResultException e) {
-            throw new AuditException("Many versions results for one-to-one relationship: (" + owningEntityName +
-                    ", " + owningReferencePropertyName + ")");
-        }
-
-        Setter setter = ReflectionTools.getSetter(obj.getClass(), propertyData);
-        setter.set(obj, value, null);
     }
 
-    public List<PersistentCollectionChangeData> mapCollectionChanges(String referencingPropertyName,
-                                                                                    PersistentCollection newColl,
-                                                                                    Serializable oldColl,
-                                                                                    Serializable id) {
-        return null;
+    @Override
+    protected Object queryForReferencedEntity(AuditReaderImplementor versionsReader, EntityInfo referencedEntity,
+                                              Serializable primaryKey, Number revision) {
+        return versionsReader.createQuery().forEntitiesAtRevision(referencedEntity.getEntityClass(),
+                                                                  referencedEntity.getEntityName(), revision)
+                                           .add(AuditEntity.relatedId(owningReferencePropertyName).eq(primaryKey))
+                                           .getSingleResult();
     }
 }

hibernate-envers/src/main/java/org/hibernate/envers/entities/mapper/relation/OneToOnePrimaryKeyJoinColumnMapper.java

@@ -0,0 +1,54 @@
+package org.hibernate.envers.entities.mapper.relation;
+
+import org.hibernate.envers.Audited;
+import org.hibernate.envers.entities.PropertyData;
+import org.hibernate.envers.query.AuditEntity;
+import org.hibernate.envers.reader.AuditReaderImplementor;
+import org.hibernate.persister.entity.EntityPersister;
+
+import javax.persistence.OneToOne;
+import javax.persistence.PrimaryKeyJoinColumn;
+import java.io.Serializable;
+
+/**
+ * Property mapper for {@link OneToOne} with {@link PrimaryKeyJoinColumn} relation.
+ * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
+ */
+public class OneToOnePrimaryKeyJoinColumnMapper extends AbstractOneToOneMapper {
+    public OneToOnePrimaryKeyJoinColumnMapper(String entityName, String referencedEntityName, PropertyData propertyData) {
+        super(entityName, referencedEntityName, propertyData);
+    }
+
+    @Override
+    protected Object queryForReferencedEntity(AuditReaderImplementor versionsReader, EntityInfo referencedEntity,
+                                              Serializable primaryKey, Number revision) {
+        if (referencedEntity.isAudited()) {
+            // Audited relation.
+            return versionsReader.createQuery().forEntitiesAtRevision(referencedEntity.getEntityClass(),
+                                                                      referencedEntity.getEntityName(), revision)
+                                               .add(AuditEntity.id().eq(primaryKey))
+                                               .getSingleResult();
+        } else {
+            // Not audited relation.
+            return createNotAuditedEntityReference(versionsReader, referencedEntity.getEntityClass(),
+                                                   referencedEntity.getEntityName(), primaryKey);
+        }
+    }
+
+    /**
+     * Create Hibernate proxy or retrieve the complete object of referenced, not audited entity. According to
+     * {@link Audited#targetAuditMode()}} documentation, reference shall point to current (non-historical) version
+     * of an entity.
+     */
+    private Object createNotAuditedEntityReference(AuditReaderImplementor versionsReader, Class<?> entityClass,
+                                                   String entityName, Serializable primaryKey) {
+        EntityPersister entityPersister = versionsReader.getSessionImplementor().getFactory().getEntityPersister(entityName);
+        if (entityPersister.hasProxy()) {
+            // If possible create a proxy. Returning complete object may affect performance.
+            return versionsReader.getSession().load(entityClass, primaryKey);
+        } else {
+            // If proxy is not allowed (e.g. @Proxy(lazy=false)) construct the original object.
+            return versionsReader.getSession().get(entityClass, primaryKey);
+        }
+    }
+}