[#1831] Upgrade Hibernate ORM to 6.4.1.Final

DavideD · DavideD · commit 5c85650f7e7d · 2024-01-10T18:09:41.000+01:00
Some minor changes in Hibernate ORM
in the way entity are initialized caused
compilation and runtime errors in Hibernate Reactive.
diff --git a/build.gradle b/build.gradle
@@ -53,7 +53,7 @@ version = projectVersion
 // ./gradlew clean build -PhibernateOrmVersion=5.6.15-SNAPSHOT
 ext {
     if ( !project.hasProperty('hibernateOrmVersion') ) {
-        hibernateOrmVersion = '6.4.0.Final'
+        hibernateOrmVersion = '6.4.1.Final'
     }
     if ( !project.hasProperty( 'hibernateOrmGradlePluginVersion' ) ) {
         // Same as ORM as default
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/event/impl/DefaultReactiveLoadEventListener.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/event/impl/DefaultReactiveLoadEventListener.java
@@ -380,8 +380,6 @@ private CompletionStage<Object> loadWithRegularProxy(LoadEvent event, EntityPers
 			return narrowedProxy( event, persister, keyToLoad, options, proxy );
 		}
 		else if ( options.isAllowProxyCreation() ) {
-			// return a new proxy
-			// ORM calls DefaultLoadEventListener#proxyOrCache
 			return completedFuture( proxyOrCached( event, persister, keyToLoad, options ) );
 		}
 		else {
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/event/impl/DefaultReactivePostLoadEventListener.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/event/impl/DefaultReactivePostLoadEventListener.java
@@ -43,21 +43,24 @@ public void onPostLoad(PostLoadEvent event) {
 		callbackRegistry.postLoad( entity );
 
 		final EventSource session = event.getSession();
-		final EntityEntry entry = session.getPersistenceContextInternal().getEntry( entity );
+ 		final EntityEntry entry = session.getPersistenceContextInternal().getEntry( entity );
 		if ( entry == null ) {
 			throw new AssertionFailure( "possible non-threadsafe access to the session" );
 		}
 
-		final ReactiveActionQueue actionQueue = ((ReactiveSession) session).getReactiveActionQueue();
+		final ReactiveActionQueue actionQueue = ( (ReactiveSession) session ).getReactiveActionQueue();
 		switch ( entry.getLockMode() ) {
-//			case PESSIMISTIC_FORCE_INCREMENT:
-			// This case is handled by DefaultReactiveLoadEventListener
+			case PESSIMISTIC_FORCE_INCREMENT:
+				// This case is handled by DefaultReactiveLoadEventListener
+				break;
 			case OPTIMISTIC_FORCE_INCREMENT:
 				actionQueue.registerProcess( new ReactiveEntityIncrementVersionProcess( entity ) );
 				break;
 			case OPTIMISTIC:
 				actionQueue.registerProcess( new ReactiveEntityVerifyVersionProcess( entity ) );
 				break;
+			default:
+				// Nothing to do
 		}
 	}
 
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/ReactiveAbstractEntityInitializer.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/ReactiveAbstractEntityInitializer.java
@@ -87,7 +87,23 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta
 			return voidFuture()
 					.thenCompose( v -> {
 						if ( lazyInitializer != null ) {
-							return lazyInitialize( rowProcessingState, lazyInitializer );
+							final SharedSessionContractImplementor session = rowProcessingState.getSession();
+							final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
+							final EntityHolder holder = persistenceContext.getEntityHolder( getEntityKey() );
+							Object instance = holder.getEntity();
+							assert instance != null : "The real entity instance must be resolved in the `resolveInstance()` phase";
+							if ( holder.getEntityInitializer() == this ) {
+								return initializeEntity( instance, rowProcessingState )
+										.thenAccept( vv -> {
+											lazyInitializer.setImplementation( instance );
+											setEntityInstanceForNotify( instance );
+										} );
+							}
+							return voidFuture().thenAccept( vv -> {
+								lazyInitializer.setImplementation( instance );
+								setEntityInstanceForNotify( instance );
+
+							} );
 						}
 						else {
 							// FIXME: Read from cache if possible
@@ -103,35 +119,6 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta
 		return voidFuture();
 	}
 
-	private CompletionStage<Void> lazyInitialize(ReactiveRowProcessingState rowProcessingState, LazyInitializer lazyInitializer) {
-		final SharedSessionContractImplementor session = rowProcessingState.getSession();
-		final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
-		final EntityHolder holder = persistenceContext.getEntityHolder( getEntityKey() );
-		Object instance = holder.getEntity();
-		if ( instance == null ) {
-			return resolveInstance( rowProcessingState, lazyInitializer, persistenceContext );
-		}
-		lazyInitializer.setImplementation( instance );
-		setEntityInstanceForNotify( instance );
-		return voidFuture();
-	}
-
-	private CompletionStage<Void> resolveInstance(
-			ReactiveRowProcessingState rowProcessingState,
-			LazyInitializer lazyInitializer,
-			PersistenceContext persistenceContext) {
-		final Object instance = super.resolveInstance(
-				getEntityKey().getIdentifier(),
-				persistenceContext.getEntityHolder( getEntityKey() ),
-				rowProcessingState
-		);
-		return initializeEntity( instance, rowProcessingState )
-				.thenAccept( v -> {
-					lazyInitializer.setImplementation( instance );
-					setEntityInstanceForNotify( instance );
-				} );
-	}
-
 	private CompletionStage<Void> initializeEntity(Object toInitialize, RowProcessingState rowProcessingState) {
 		if ( !skipInitialization( toInitialize, rowProcessingState ) ) {
 			assert consistentInstance( toInitialize, rowProcessingState );
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/internal/ReactiveEntitySelectFetchByUniqueKeyInitializer.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/internal/ReactiveEntitySelectFetchByUniqueKeyInitializer.java
@@ -41,28 +41,29 @@ public ReactiveEntitySelectFetchByUniqueKeyInitializer(
 
 	@Override
 	public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingState rowProcessingState) {
-		if ( entityInstance != null || isInitialized ) {
+		if ( getEntityInstance() != null || isEntityInitialized() ) {
 			return voidFuture();
 		}
+		state = State.RESOLVED;
 
 		final EntityInitializer parentEntityInitializer = getParentEntityInitializer( parentAccess );
 		if ( parentEntityInitializer != null && parentEntityInitializer.getEntityKey() != null ) {
 			// make sure parentEntityInitializer.resolveInstance has been called before
 			parentEntityInitializer.resolveInstance( rowProcessingState );
 			if ( parentEntityInitializer.isEntityInitialized() ) {
-				isInitialized = true;
+				initializeState();
 				return voidFuture();
 			}
 		}
 
 		if ( !isAttributeAssignableToConcreteDescriptor() ) {
-			isInitialized = true;
+			initializeState();
 			return voidFuture();
 		}
 
 		final Object entityIdentifier = keyAssembler.assemble( rowProcessingState );
 		if ( entityIdentifier == null ) {
-			isInitialized = true;
+			initializeState();
 			return voidFuture();
 		}
 		final String entityName = concreteDescriptor.getEntityName();
@@ -104,7 +105,7 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta
 		if ( entityInstance != null ) {
 			setEntityInstance( persistenceContext.proxyFor( entityInstance ) );
 		}
-		isInitialized = true;
+		initializeState();
 		return voidFuture();
 	}
 
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/internal/ReactiveEntitySelectFetchInitializer.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/sql/results/graph/entity/internal/ReactiveEntitySelectFetchInitializer.java
@@ -102,17 +102,18 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta
 
 		final EntityInitializer parentEntityInitializer = parentAccess.findFirstEntityInitializer();
 		if ( parentEntityInitializer != null && parentEntityInitializer.isEntityInitialized() ) {
-			isInitialized = true;
+			initializeState();
 			return voidFuture();
 		}
 
 		if ( !isAttributeAssignableToConcreteDescriptor() ) {
+			initializeState();
 			return voidFuture();
 		}
 
 		final Object entityIdentifier = keyAssembler.assemble( rowProcessingState );
 		if ( entityIdentifier == null ) {
-			isInitialized = true;
+			initializeState();
 			return voidFuture();
 		}
 
@@ -145,7 +146,7 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta
 			entityInstance = holder.getEntity();
 			if ( holder.getEntityInitializer() == null ) {
 				if ( entityInstance != null && Hibernate.isInitialized( entityInstance ) ) {
-					isInitialized = true;
+					initializeState();
 					return voidFuture();
 				}
 			}
@@ -159,11 +160,11 @@ else if ( holder.getEntityInitializer() != this ) {
 							holder.getEntityInitializer()
 					);
 				}
-				isInitialized = true;
+				initializeState();
 				return voidFuture();
 			}
 			else if ( entityInstance == null ) {
-				isInitialized = true;
+				initializeState();
 				return voidFuture();
 			}
 		}
@@ -202,11 +203,15 @@ else if ( entityInstance == null ) {
 					if ( lazyInitializer != null ) {
 						lazyInitializer.setUnwrap( unwrapProxy );
 					}
-					isInitialized = true;
+					initializeState();
 					return voidFuture();
 				} );
 	}
 
+	protected void initializeState() {
+		state = State.INITIALIZED;
+	}
+
 	protected ToOneAttributeMapping toOneMapping() {
 		return (ToOneAttributeMapping) getInitializedPart();
 	}

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ version = projectVersion`
`53`	`53`	`// ./gradlew clean build -PhibernateOrmVersion=5.6.15-SNAPSHOT`
`54`	`54`	`ext {`
`55`	`55`	`if ( !project.hasProperty('hibernateOrmVersion') ) {`
`56`		`- hibernateOrmVersion = '6.4.0.Final'`
	`56`	`+ hibernateOrmVersion = '6.4.1.Final'`
`57`	`57`	`}`
`58`	`58`	`if ( !project.hasProperty( 'hibernateOrmGradlePluginVersion' ) ) {`
`59`	`59`	`// Same as ORM as default`
Original file line number	Diff line number	Diff line change
`@@ -380,8 +380,6 @@ private CompletionStage<Object> loadWithRegularProxy(LoadEvent event, EntityPers`
`380`	`380`	`return narrowedProxy( event, persister, keyToLoad, options, proxy );`
`381`	`381`	`}`
`382`	`382`	`else if ( options.isAllowProxyCreation() ) {`
`383`		`- // return a new proxy`
`384`		`- // ORM calls DefaultLoadEventListener#proxyOrCache`
`385`	`383`	`return completedFuture( proxyOrCached( event, persister, keyToLoad, options ) );`
`386`	`384`	`}`
`387`	`385`	`else {`
Original file line number	Diff line number	Diff line change
`@@ -41,28 +41,29 @@ public ReactiveEntitySelectFetchByUniqueKeyInitializer(`
`41`	`41`
`42`	`42`	`@Override`
`43`	`43`	`public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingState rowProcessingState) {`
`44`		`- if ( entityInstance != null \|\| isInitialized ) {`
	`44`	`+ if ( getEntityInstance() != null \|\| isEntityInitialized() ) {`
`45`	`45`	`return voidFuture();`
`46`	`46`	`}`
	`47`	`+ state = State.RESOLVED;`
`47`	`48`
`48`	`49`	`final EntityInitializer parentEntityInitializer = getParentEntityInitializer( parentAccess );`
`49`	`50`	`if ( parentEntityInitializer != null && parentEntityInitializer.getEntityKey() != null ) {`
`50`	`51`	`// make sure parentEntityInitializer.resolveInstance has been called before`
`51`	`52`	`parentEntityInitializer.resolveInstance( rowProcessingState );`
`52`	`53`	`if ( parentEntityInitializer.isEntityInitialized() ) {`
`53`		`- isInitialized = true;`
	`54`	`+ initializeState();`
`54`	`55`	`return voidFuture();`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`if ( !isAttributeAssignableToConcreteDescriptor() ) {`
`59`		`- isInitialized = true;`
	`60`	`+ initializeState();`
`60`	`61`	`return voidFuture();`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`final Object entityIdentifier = keyAssembler.assemble( rowProcessingState );`
`64`	`65`	`if ( entityIdentifier == null ) {`
`65`		`- isInitialized = true;`
	`66`	`+ initializeState();`
`66`	`67`	`return voidFuture();`
`67`	`68`	`}`
`68`	`69`	`final String entityName = concreteDescriptor.getEntityName();`
`@@ -104,7 +105,7 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta`
`104`	`105`	`if ( entityInstance != null ) {`
`105`	`106`	`setEntityInstance( persistenceContext.proxyFor( entityInstance ) );`
`106`	`107`	`}`
`107`		`- isInitialized = true;`
	`108`	`+ initializeState();`
`108`	`109`	`return voidFuture();`
`109`	`110`	`}`
`110`	`111`
Original file line number	Diff line number	Diff line change
`@@ -102,17 +102,18 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta`
`102`	`102`
`103`	`103`	`final EntityInitializer parentEntityInitializer = parentAccess.findFirstEntityInitializer();`
`104`	`104`	`if ( parentEntityInitializer != null && parentEntityInitializer.isEntityInitialized() ) {`
`105`		`- isInitialized = true;`
	`105`	`+ initializeState();`
`106`	`106`	`return voidFuture();`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`if ( !isAttributeAssignableToConcreteDescriptor() ) {`
	`110`	`+ initializeState();`
`110`	`111`	`return voidFuture();`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`final Object entityIdentifier = keyAssembler.assemble( rowProcessingState );`
`114`	`115`	`if ( entityIdentifier == null ) {`
`115`		`- isInitialized = true;`
	`116`	`+ initializeState();`
`116`	`117`	`return voidFuture();`
`117`	`118`	`}`
`118`	`119`
`@@ -145,7 +146,7 @@ public CompletionStage<Void> reactiveInitializeInstance(ReactiveRowProcessingSta`
`145`	`146`	`entityInstance = holder.getEntity();`
`146`	`147`	`if ( holder.getEntityInitializer() == null ) {`
`147`	`148`	`if ( entityInstance != null && Hibernate.isInitialized( entityInstance ) ) {`
`148`		`- isInitialized = true;`
	`149`	`+ initializeState();`
`149`	`150`	`return voidFuture();`
`150`	`151`	`}`
`151`	`152`	`}`
`@@ -159,11 +160,11 @@ else if ( holder.getEntityInitializer() != this ) {`
`159`	`160`	`holder.getEntityInitializer()`
`160`	`161`	`);`
`161`	`162`	`}`
`162`		`- isInitialized = true;`
	`163`	`+ initializeState();`
`163`	`164`	`return voidFuture();`
`164`	`165`	`}`
`165`	`166`	`else if ( entityInstance == null ) {`
`166`		`- isInitialized = true;`
	`167`	`+ initializeState();`
`167`	`168`	`return voidFuture();`
`168`	`169`	`}`
`169`	`170`	`}`
`@@ -202,11 +203,15 @@ else if ( entityInstance == null ) {`
`202`	`203`	`if ( lazyInitializer != null ) {`
`203`	`204`	`lazyInitializer.setUnwrap( unwrapProxy );`
`204`	`205`	`}`
`205`		`- isInitialized = true;`
	`206`	`+ initializeState();`
`206`	`207`	`return voidFuture();`
`207`	`208`	`} );`
`208`	`209`	`}`
`209`	`210`
	`211`	`+ protected void initializeState() {`
	`212`	`+ state = State.INITIALIZED;`
	`213`	`+ }`
	`214`	`+`
`210`	`215`	`protected ToOneAttributeMapping toOneMapping() {`
`211`	`216`	`return (ToOneAttributeMapping) getInitializedPart();`
`212`	`217`	`}`