Workaround for Spring Boot 4/Hibernate 6 issue with Root.equals (#294)

* Workaround for Spring Boot 4/Hibernate 6 issue with Root.equals


---------

Co-authored-by: Tomasz Kaczmarzyk <tomasz.kaczmarzyk@tratif.com>

Author: tkaczmarzyk

pom.xml

@@ -206,7 +206,7 @@
 		 	 <dependency>
 	            <groupId>org.springframework.boot</groupId>
 	            <artifactId>spring-boot-dependencies</artifactId>
-	            <version>4.0.0-M1</version>
+		    <version>4.0.0</version>
 	            <type>pom</type>
 	            <scope>import</scope>
 	        </dependency>

src/main/java/net/kaczmarzyk/spring/data/jpa/domain/Join.java

@@ -16,6 +16,7 @@
 package net.kaczmarzyk.spring.data.jpa.domain;
 
 import jakarta.persistence.criteria.*;
+import net.kaczmarzyk.spring.data.jpa.utils.Alias;
 import net.kaczmarzyk.spring.data.jpa.utils.QueryContext;
 import org.springframework.data.jpa.domain.Specification;
 
@@ -88,7 +89,7 @@ private void putValToQueryContext(String alias, Root<T> root, Function<Root<?>,
 		// because most typical scenario tends to be a LEFT join with distinct = true
 		// and in such scenario if there is no filtering on the joined part (e.g. no related http param was sent)
 		// then we can optimize behaviour by not joining at all
-		queryContext.putLazyVal(alias, lazyVal);
+		queryContext.putLazyVal(Alias.of(alias, root), lazyVal);
 		// but inner joins or non-distinct queries must have them evaluated eagerly
 		// because they affect query result even when there is no filtering applied
 		if (!distinctQuery || joinType == JoinType.INNER) {

src/main/java/net/kaczmarzyk/spring/data/jpa/utils/Alias.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2014-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.kaczmarzyk.spring.data.jpa.utils;
+
+import jakarta.persistence.criteria.Root;
+
+import java.util.Objects;
+
+/**
+ * This is a pair of alias (text from query) and query Root.
+ *
+ * Equals uses identity comparison for Root part. Why? Because in Hibernate 6 2 roots from 2 different queries
+ * may yield true in equals. This caused problems with paginated queries: join was evaluated and cached but
+ * then Hibernate threw exception on attempt to reuse cached join in count query. It used to work in previous versions...
+ *
+ * Identity comparison seems to fix that. I don't like this solution, but I don't see any other for now.
+ *
+ * @author Tomasz Kaczmarzyk
+ */
+public class Alias {
+
+    private String alias;
+    private Root<?> queryRoot;
+
+    public Alias(String alias, Root<?> queryRoot) {
+        this.alias = alias;
+        this.queryRoot = queryRoot;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Alias alias1 = (Alias) o;
+        return Objects.equals(alias, alias1.alias) && queryRoot == alias1.queryRoot; // identity comparison for Root!
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(alias, queryRoot);
+    }
+
+    public static Alias of(String alias, Root<?> queryRoot) {
+        return new Alias(alias, queryRoot);
+    }
+}

src/main/java/net/kaczmarzyk/spring/data/jpa/utils/QueryContext.java

@@ -18,6 +18,7 @@
 import jakarta.persistence.criteria.Fetch;
 import jakarta.persistence.criteria.Join;
 import jakarta.persistence.criteria.Root;
+
 import java.util.function.Function;
 
 /**
@@ -32,7 +33,7 @@ public interface QueryContext {
 
     Join<?, ?> getEvaluated(String key, Root<?> root);
 
-    void putLazyVal(String key, Function<Root<?>, Join<?, ?>> value);
+    void putLazyVal(Alias key, Function<Root<?>, Join<?, ?>> value);
 
     Fetch<?, ?> getEvaluatedJoinFetch(String key);
 

src/main/java/net/kaczmarzyk/spring/data/jpa/web/DefaultQueryContext.java

@@ -15,6 +15,7 @@
  */
 package net.kaczmarzyk.spring.data.jpa.web;
 
+import net.kaczmarzyk.spring.data.jpa.utils.Alias;
 import net.kaczmarzyk.spring.data.jpa.utils.QueryContext;
 import org.apache.commons.lang3.tuple.Pair;
 
@@ -31,10 +32,10 @@
  */
 public class DefaultQueryContext implements QueryContext {
 
-	private Map<String, Function<Root<?>, Join<?, ?>>> contextMap;
+	private Map<Alias, Function<Root<?>, Join<?, ?>>> contextMap;
 	private Map<String, Fetch<?, ?>> evaluatedJoinFetch;
 
-	private Map<Pair<String, Root>, Join<?, ?>> rootCache;
+	private Map<Alias, Join<?, ?>> rootCache;
 
 	public DefaultQueryContext() {
 		this.contextMap = new HashMap<>();
@@ -44,18 +45,18 @@ public DefaultQueryContext() {
 
 	@Override
 	public boolean existsJoin(String key, Root<?> root) {
-		return contextMap.containsKey(key);
+		return contextMap.containsKey(Alias.of(key, root));
 	}
 
 	@Override
 	public Join<?, ?> getEvaluated(String key, Root<?> root) {
-		Function<Root<?>, Join<?, ?>> value = contextMap.get(key);
+		Function<Root<?>, Join<?, ?>> value = contextMap.get(Alias.of(key, root));
 
 		if (value == null) {
 			return null;
 		}
 
-		Pair<String, Root> rootKey = Pair.of(key, root);
+		Alias rootKey = Alias.of(key, root);
 
 		if (!rootCache.containsKey(rootKey)) {
 			Join<?, ?> evaluated = value.apply(root);
@@ -65,7 +66,7 @@ public boolean existsJoin(String key, Root<?> root) {
 	}
 
 	@Override
-	public void putLazyVal(String key, Function<Root<?>, Join<?, ?>> value) {
+	public void putLazyVal(Alias key, Function<Root<?>, Join<?, ?>> value) {
 		contextMap.put(key, value);
 	}