HHH-11155 - Lazy properties are not updated if not all lazy properties (e.g. collections) are initialized

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/LazyAttributesMetadata.java

@@ -35,8 +35,8 @@ public class LazyAttributesMetadata implements Serializable {
 	 * @return The built LazyFetchGroupMetadata
 	 */
 	public static LazyAttributesMetadata from(PersistentClass mappedEntity) {
-		final Map<String, LazyAttributeDescriptor> lazyAttributeDescriptorMap = new LinkedHashMap<String, LazyAttributeDescriptor>();
+		final Map<String, LazyAttributeDescriptor> lazyAttributeDescriptorMap = new LinkedHashMap<>();
-		final Map<String, Set<String>> fetchGroupToAttributesMap = new HashMap<String, Set<String>>();
+		final Map<String, Set<String>> fetchGroupToAttributesMap = new HashMap<>();
 
 		int i = -1;
 		int x = 0;
@@ -48,11 +48,10 @@ public class LazyAttributesMetadata implements Serializable {
 				final LazyAttributeDescriptor lazyAttributeDescriptor = LazyAttributeDescriptor.from( property, i, x++ );
 				lazyAttributeDescriptorMap.put( lazyAttributeDescriptor.getName(), lazyAttributeDescriptor );
 
-				Set<String> attributeSet = fetchGroupToAttributesMap.get( lazyAttributeDescriptor.getFetchGroupName() );
+				final Set<String> attributeSet = fetchGroupToAttributesMap.computeIfAbsent(
-				if ( attributeSet == null ) {
+						lazyAttributeDescriptor.getFetchGroupName(),
-					attributeSet = new LinkedHashSet<String>();
+						k -> new LinkedHashSet<>()
-					fetchGroupToAttributesMap.put( lazyAttributeDescriptor.getFetchGroupName(), attributeSet );
+				);
-				}
 				attributeSet.add( lazyAttributeDescriptor.getName() );
 			}
 		}
@@ -82,7 +81,7 @@ public class LazyAttributesMetadata implements Serializable {
 	private final Map<String,Set<String>> fetchGroupToAttributeMap;
 
 	public LazyAttributesMetadata(String entityName) {
-		this( entityName, Collections.<String, LazyAttributeDescriptor>emptyMap(), Collections.<String, Set<String>>emptyMap() );
+		this( entityName, Collections.emptyMap(), Collections.emptyMap() );
 	}
 
 	public LazyAttributesMetadata(

hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java

@@ -70,6 +70,7 @@ import org.hibernate.engine.spi.LoadQueryInfluencers;
 import org.hibernate.engine.spi.Mapping;
 import org.hibernate.engine.spi.PersistenceContext.NaturalIdHelper;
 import org.hibernate.engine.spi.PersistentAttributeInterceptable;
+import org.hibernate.engine.spi.SelfDirtinessTracker;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.engine.spi.ValueInclusion;
@@ -1060,26 +1061,40 @@ public abstract class AbstractEntityPersister
 					final Object[] snapshot = entry.getLoadedState();
 					for ( LazyAttributeDescriptor fetchGroupAttributeDescriptor : fetchGroupAttributeDescriptors ) {
 						final boolean previousInitialized = initializedLazyAttributeNames.contains( fetchGroupAttributeDescriptor.getName() );
-						final Object loadedValue = fetchGroupAttributeDescriptor.getType().nullSafeGet(
+
+						if ( previousInitialized ) {
+							// todo : one thing we should consider here is potentially un-marking an attribute as dirty based on the selected value
+							// 		we know the current value - getPropertyValue( entity, fetchGroupAttributeDescriptor.getAttributeIndex() );
+							// 		we know the selected value (see selectedValue below)
+							//		we can use the attribute Type to tell us if they are the same
+							//
+							//		assuming entity is a SelfDirtinessTracker we can also know if the attribute is
+							//			currently considered dirty, and if really not dirty we would do the un-marking
+							//
+							//		of course that would mean a new method on SelfDirtinessTracker to allow un-marking
+
+							// its already been initialized (e.g. by a write) so we don't want to overwrite
+							continue;
+						}
+
+
+						final Object selectedValue = fetchGroupAttributeDescriptor.getType().nullSafeGet(
 								rs,
 								lazyPropertyColumnAliases[fetchGroupAttributeDescriptor.getLazyIndex()],
 								session,
 								entity
 						);
+
 						final boolean set = initializeLazyProperty(
 								fieldName,
 								entity,
 								session,
 								snapshot,
 								fetchGroupAttributeDescriptor.getLazyIndex(),
-								loadedValue
+								selectedValue
 						);
-						if ( previousInitialized ) {
-							// its already been initialized (e.g. by a write) so we don't want to overwrite
-							continue;
-						}
 						if ( set ) {
-							result = loadedValue;
+							result = selectedValue;
 							interceptor.attributeInitialized( fetchGroupAttributeDescriptor.getName() );
 						}
 

hibernate-core/src/main/java/org/hibernate/tuple/entity/EntityMetamodel.java

@@ -334,8 +334,11 @@ public class EntityMetamodel implements Serializable {
 				LOG.entityMappedAsNonAbstract(name);
 			}
 		}
+
 		selectBeforeUpdate = persistentClass.hasSelectBeforeUpdate();
-		dynamicUpdate = persistentClass.useDynamicUpdate();
+
+		dynamicUpdate = persistentClass.useDynamicUpdate()
+				|| ( getBytecodeEnhancementMetadata().isEnhancedForLazyLoading() && getBytecodeEnhancementMetadata().getLazyAttributesMetadata().getFetchGroupNames().size() > 1 );
 		dynamicInsert = persistentClass.useDynamicInsert();
 
 		polymorphic = persistentClass.isPolymorphic();

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/EnhancerTest.java

@@ -10,6 +10,7 @@ import javassist.CtClass;
 
 import org.hibernate.test.bytecode.enhancement.association.InheritedAttributeAssociationTestTask;
 import org.hibernate.test.bytecode.enhancement.lazy.group.LazyGroupUpdateTestTask;
+import org.hibernate.test.bytecode.enhancement.lazy.group.SimpleLazyGroupUpdateTestTask;
 import org.hibernate.test.bytecode.enhancement.otherentityentrycontext.OtherEntityEntryContextTestTask;
 import org.hibernate.testing.FailureExpected;
 import org.hibernate.testing.TestForIssue;
@@ -137,11 +138,16 @@ public class EnhancerTest extends BaseUnitTestCase {
 
 	@Test
 	@TestForIssue( jiraKey = "HHH-11155" )
-	@FailureExpected( jiraKey = "HHH-11155" )
 	public void testLazyGroupsUpdate() {
 		EnhancerTestUtils.runEnhancerTestTask( LazyGroupUpdateTestTask.class );
 	}
 
+	@Test
+	@TestForIssue( jiraKey = "HHH-11155" )
+	public void testLazyGroupsUpdateSimple() {
+		EnhancerTestUtils.runEnhancerTestTask( SimpleLazyGroupUpdateTestTask.class );
+	}
+
 	@Test
 	public void testLazyCollectionNoTransactionHandling() {
 		EnhancerTestUtils.runEnhancerTestTask( LazyCollectionNoTransactionLoadingTestTask.class );

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/group/LazyGroupUpdateTestTask.java

@@ -80,7 +80,7 @@ public class LazyGroupUpdateTestTask extends AbstractEnhancerTestTask {
 		// Now lets update nickName which ought to initialize nickName and parent, but not alternateParent
 		c1.setNickName( "new nickName" );
 		assertLoaded( c1, "nickName" );
-		assertLoaded( c1, "parent" );
+		assertNotLoaded( c1, "parent" );
 		assertNotLoaded( c1, "alternateParent" );
 		assertEquals( "Hibernate", c1.getParent().getNombre() );
 		assertFalse( c1.getParent() instanceof HibernateProxy );

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/group/SimpleLazyGroupUpdateTestTask.java

@@ -0,0 +1,162 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later
+ * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
+ */
+package org.hibernate.test.bytecode.enhancement.lazy.group;
+
+import javax.persistence.Basic;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+import org.hibernate.Session;
+import org.hibernate.annotations.DynamicUpdate;
+import org.hibernate.annotations.LazyGroup;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.cfg.Environment;
+
+import org.hibernate.testing.bytecode.enhancement.EnhancerTestUtils;
+import org.hibernate.test.bytecode.enhancement.AbstractEnhancerTestTask;
+
+import static junit.framework.Assert.assertNull;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * @author Steve Ebersole
+ */
+public class SimpleLazyGroupUpdateTestTask extends AbstractEnhancerTestTask {
+	public static final String REALLY_BIG_STRING = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+
+	@Override
+	public Class<?>[] getAnnotatedClasses() {
+		return new Class[] { TestEntity.class };
+	}
+
+	@Override
+	public void prepare() {
+		Configuration cfg = new Configuration();
+		cfg.setProperty( Environment.ENABLE_LAZY_LOAD_NO_TRANS, "true" );
+		cfg.setProperty( Environment.USE_SECOND_LEVEL_CACHE, "false" );
+		super.prepare( cfg );
+
+		Session s = getFactory().openSession();
+		s.beginTransaction();
+
+		s.save( new TestEntity( 1, "entity 1", "blah", REALLY_BIG_STRING ) );
+
+		s.getTransaction().commit();
+		s.close();
+	}
+
+	@Override
+	public void execute() {
+		Session s = getFactory().openSession();
+		s.beginTransaction();
+
+		TestEntity entity = s.load( TestEntity.class, 1 );
+		assertLoaded( entity, "name" );
+		assertNotLoaded( entity, "lifeStory" );
+		assertNotLoaded( entity, "reallyBigString" );
+
+		entity.setLifeStory( "blah blah blah" );
+		assertLoaded( entity, "name" );
+		assertLoaded( entity, "lifeStory" );
+		assertNotLoaded( entity, "reallyBigString" );
+
+		s.getTransaction().commit();
+		s.close();
+
+
+		s = getFactory().openSession();
+		s.beginTransaction();
+
+		entity = s.load( TestEntity.class, 1 );
+		assertLoaded( entity, "name" );
+		assertNotLoaded( entity, "lifeStory" );
+		assertNotLoaded( entity, "reallyBigString" );
+		assertEquals( "blah blah blah", entity.getLifeStory() );
+		assertEquals( REALLY_BIG_STRING, entity.getReallyBigString() );
+
+		s.getTransaction().commit();
+		s.close();
+	}
+
+	private void assertLoaded(Object owner, String name) {
+		// NOTE we assume null == not-loaded
+		Object fieldByReflection = EnhancerTestUtils.getFieldByReflection( owner, name );
+		assertNotNull( "Expecting field '" + name + "' to be loaded, but it was not", fieldByReflection );
+	}
+
+	private void assertNotLoaded(Object owner, String name) {
+		// NOTE we assume null == not-loaded
+		Object fieldByReflection = EnhancerTestUtils.getFieldByReflection( owner, name );
+		assertNull( "Expecting field '" + name + "' to be not loaded, but it was", fieldByReflection );
+	}
+
+	@Override
+	protected void cleanup() {
+		Session s = getFactory().openSession();
+		s.beginTransaction();
+
+		s.createQuery( "delete TestEntity" ).executeUpdate();
+
+		s.getTransaction().commit();
+		s.close();
+	}
+
+	@Entity( name = "TestEntity" )
+	public static class TestEntity {
+		@Id
+		Integer id;
+		String name;
+		@Basic(fetch = FetchType.LAZY)
+		@LazyGroup( "grp1" )
+		String lifeStory;
+		@Basic(fetch = FetchType.LAZY)
+		@LazyGroup( "grp2" )
+		String reallyBigString;
+
+		public TestEntity() {
+		}
+
+		public TestEntity(Integer id, String name, String lifeStory, String reallyBigString) {
+			this.id = id;
+			this.name = name;
+			this.lifeStory = lifeStory;
+			this.reallyBigString = reallyBigString;
+		}
+
+		public Integer getId() {
+			return id;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getLifeStory() {
+			return lifeStory;
+		}
+
+		public void setLifeStory(String lifeStory) {
+			this.lifeStory = lifeStory;
+		}
+
+		public String getReallyBigString() {
+			return reallyBigString;
+		}
+
+		public void setReallyBigString(String reallyBigString) {
+			this.reallyBigString = reallyBigString;
+		}
+	}
+}