HHH-20661 Return shared DateJavaType instances per temporal precision

DateJavaType#resolveTypeForPrecision created a new DateJavaType on every
call, so the same java.util.Date reached through different attribute paths
(e.g. an entity field vs. one inherited from a @MappedSuperclass) resolved
to distinct JavaType instances. A union of two such columns was then
rejected by SqmQueryGroup's identity comparison with "Select items of the
same index must have the same java type across all query parts", even
though the equivalent Criteria query worked.

Follow the pattern used by the other temporal JavaTypes: override
forDatePrecision/forTimePrecision/forTimestampPrecision to return shared
per-precision instances instead of allocating a new one. Resolving the
same precision now yields the same instance, so the existing identity
comparison keeps working and genuinely different types are still rejected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 2 people

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/DateJavaType.java

@@ -26,6 +26,10 @@
  */
 public class DateJavaType extends AbstractTemporalJavaType<Date> implements VersionJavaType<Date> {
 	public static final DateJavaType INSTANCE = new DateJavaType();
+	@SuppressWarnings("deprecation")
+	private static final DateJavaType DATE_INSTANCE = new DateJavaType( TemporalType.DATE );
+	@SuppressWarnings("deprecation")
+	private static final DateJavaType TIME_INSTANCE = new DateJavaType( TemporalType.TIME );
 	private final @SuppressWarnings("deprecation") TemporalType precision;
 
 	public static class DateMutabilityPlan extends MutableMutabilityPlan<Date> {
@@ -92,10 +96,18 @@ public Date cast(Object value) {
 	}
 
 	@Override
-	public TemporalJavaType<Date> resolveTypeForPrecision(
-			@SuppressWarnings("deprecation") TemporalType precision,
-			TypeConfiguration typeConfiguration) {
-		return precision == null ? this : new DateJavaType( precision );
+	protected TemporalJavaType<Date> forDatePrecision(TypeConfiguration typeConfiguration) {
+		return DATE_INSTANCE;
+	}
+
+	@Override
+	protected TemporalJavaType<Date> forTimePrecision(TypeConfiguration typeConfiguration) {
+		return TIME_INSTANCE;
+	}
+
+	@Override
+	protected TemporalJavaType<Date> forTimestampPrecision(TypeConfiguration typeConfiguration) {
+		return INSTANCE;
 	}
 
 	@Override

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/UnionSameJavaTypeDifferentPathTest.java

@@ -0,0 +1,97 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.orm.test.query.hql;
+
+import java.util.Date;
+import java.util.List;
+
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.JiraKey;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.junit.jupiter.api.Test;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.MappedSuperclass;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DomainModel(annotatedClasses = UnionSameJavaTypeDifferentPathTest.EntityA.class)
+@SessionFactory
+@JiraKey("HHH-20661")
+public class UnionSameJavaTypeDifferentPathTest {
+
+	@Test
+	public void testUnionOfSameJavaTypeFromDifferentPaths(SessionFactoryScope scope) {
+		scope.inTransaction( session -> {
+			final List<Object[]> results = session.createQuery(
+					"select a.code, a.eventDate as d from EntityA a " +
+					"union " +
+					"select a2.code, a2.createdAt as d from EntityA a2",
+					Object[].class
+			).list();
+			assertThat( results ).isNotNull();
+		} );
+	}
+
+	@Test
+	public void testUnionOfGenuinelyDifferentJavaTypesStillRejected(SessionFactoryScope scope) {
+		scope.inTransaction( session -> assertThatThrownBy( () -> session.createQuery(
+				"select a.code from EntityA a " +
+				"union " +
+				"select a2.eventDate from EntityA a2",
+				Object.class
+		).list() ).hasMessageContaining( "must have the same java type across all query parts" ) );
+	}
+
+	@MappedSuperclass
+	public static class BaseAuditable {
+		private Date createdAt;
+
+		public Date getCreatedAt() {
+			return createdAt;
+		}
+
+		public void setCreatedAt(Date createdAt) {
+			this.createdAt = createdAt;
+		}
+	}
+
+	@Entity(name = "EntityA")
+	public static class EntityA extends BaseAuditable {
+		@Id
+		private Long id;
+
+		private String code;
+
+		private Date eventDate;
+
+		public Long getId() {
+			return id;
+		}
+
+		public void setId(Long id) {
+			this.id = id;
+		}
+
+		public String getCode() {
+			return code;
+		}
+
+		public void setCode(String code) {
+			this.code = code;
+		}
+
+		public Date getEventDate() {
+			return eventDate;
+		}
+
+		public void setEventDate(Date eventDate) {
+			this.eventDate = eventDate;
+		}
+	}
+}