hack around an issue with mapping arrays of Date as SQL ARRAYs

I don't know why we even need to be doing this. We deprecated that stuff.
But we have one single test which is relying on this, so perhaps users
are using it too.

Author: gavinking

hibernate-core/src/main/java/org/hibernate/type/AbstractStandardBasicType.java

@@ -14,7 +14,6 @@
 import java.util.Map;
 
 import org.hibernate.Hibernate;
-import org.hibernate.HibernateException;
 import org.hibernate.MappingException;
 import org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
@@ -268,21 +267,17 @@ public final boolean isMutable() {
 	}
 
 	@Override
-	public final Object deepCopy(Object value, SessionFactoryImplementor factory) {
-		return deepCopy( javaType.cast( value )  );
-	}
-
-	protected final T deepCopy(T value) {
-		return getMutabilityPlan().deepCopy( value );
+	public Object deepCopy(Object value, SessionFactoryImplementor factory) {
+		return getMutabilityPlan().deepCopy( javaType.cast( value ) );
 	}
 
 	@Override
-	public final Serializable disassemble(Object value, SharedSessionContractImplementor session, Object owner) throws HibernateException {
-		return getMutabilityPlan().disassemble( javaType.cast( value ) , session );
+	public final Serializable disassemble(Object value, SharedSessionContractImplementor session, Object owner) {
+		return getMutabilityPlan().disassemble( javaType.cast( value ), session );
 	}
 
 	@Override
-	public final Object assemble(Serializable cached, SharedSessionContractImplementor session, Object owner) throws HibernateException {
+	public final Object assemble(Serializable cached, SharedSessionContractImplementor session, Object owner) {
 		return getMutabilityPlan().assemble( cached, session );
 	}
 

hibernate-core/src/main/java/org/hibernate/type/BasicArrayType.java

@@ -6,6 +6,8 @@
 
 import java.util.Objects;
 
+import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.type.descriptor.java.AbstractArrayJavaType;
 import org.hibernate.type.descriptor.java.JavaType;
 import org.hibernate.type.descriptor.jdbc.JdbcType;
 import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators;
@@ -16,17 +18,19 @@
  * @author Jordan Gigov
  * @author Christian Beikov
  */
-public class BasicArrayType<T,E>
+public final class BasicArrayType<T,E>
 		extends AbstractSingleColumnStandardBasicType<T>
 		implements AdjustableBasicType<T>, BasicPluralType<T, E> {
 
 	private final BasicType<E> baseDescriptor;
 	private final String name;
+	private final AbstractArrayJavaType<T,?> arrayTypeDescriptor;
 
 	public BasicArrayType(BasicType<E> baseDescriptor, JdbcType arrayJdbcType, JavaType<T> arrayTypeDescriptor) {
 		super( arrayJdbcType, arrayTypeDescriptor );
 		this.baseDescriptor = baseDescriptor;
 		this.name = determineArrayTypeName( baseDescriptor );
+		this.arrayTypeDescriptor = (AbstractArrayJavaType<T, ?>) arrayTypeDescriptor;
 	}
 
 	static String determineElementTypeName(BasicType<?> baseDescriptor) {
@@ -75,4 +79,26 @@ public boolean equals(Object object) {
 	public int hashCode() {
 		return baseDescriptor.hashCode();
 	}
+
+	// Methods required to support Horrible hack around the fact
+	// that java.sql.Timestamps in an array can be represented as
+	// instances of java.util.Date (Why do we even allow this?)
+
+	@Override
+	public boolean isEqual(Object one, Object another) {
+		if ( one == another ) {
+			return true;
+		}
+		else if ( one == null || another == null ) {
+			return false;
+		}
+		else {
+			return arrayTypeDescriptor.isEqual( one, another );
+		}
+	}
+
+	@Override
+	public Object deepCopy(Object value, SessionFactoryImplementor factory) {
+		return arrayTypeDescriptor.deepCopy( value );
+	}
 }

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

@@ -19,6 +19,7 @@
 import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators;
 import org.hibernate.type.spi.TypeConfiguration;
 
+
 import static java.lang.reflect.Array.newInstance;
 
 @AllowReflection
@@ -123,4 +124,15 @@ BasicType<T> resolveType(
 						() -> new BasicArrayType<>( elementType, arrayJdbcType, arrayJavaType ) );
 	}
 
+	// Methods required to support Horrible hack around the fact
+	// that java.sql.Timestamps in an array can be represented as
+	// instances of java.util.Date (Why do we even allow this?)
+
+	public T deepCopy(Object value) {
+		return getMutabilityPlan().deepCopy( cast( value ) );
+	}
+
+	public boolean isEqual(Object one, Object another) {
+		return areEqual( cast( one ), cast( another) );
+	}
 }

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

@@ -111,7 +111,7 @@ public String extractLoggableRepresentation(T[] value) {
 	}
 
 	@Override
-	public boolean areEqual(T[] one, T[] another) {
+	public boolean areEqual(Object[] one, Object[] another) {
 		if ( one == null && another == null ) {
 			return true;
 		}
@@ -123,7 +123,13 @@ public boolean areEqual(T[] one, T[] another) {
 		}
 		int l = one.length;
 		for ( int i = 0; i < l; i++ ) {
-			if ( !getElementJavaType().areEqual( one[i], another[i] )) {
+			final var elementJavaType = getElementJavaType();
+			if ( !elementJavaType.areEqual(
+					// Horrible hack around the fact that java.sql.Timestamps
+					// can be represented as instances of java.util.Date
+					// (Why do we even allow this? We deprecated java.sql stuff!)
+					elementJavaType.coerce( one[i], null ),
+					elementJavaType.coerce( another[i], null ) )) {
 				return false;
 			}
 		}
@@ -376,15 +382,38 @@ private T[] fromBytes(byte[] bytes) {
 		}
 	}
 
+	@Override
+	public ArrayMutabilityPlan<T> getMutabilityPlan() {
+		return (ArrayMutabilityPlan<T>) super.getMutabilityPlan();
+	}
+
+	// Methods required to support Horrible hack around the fact
+	// that java.sql.Timestamps in an array can be represented as
+	// instances of java.util.Date (Why do we even allow this?)
+
+	@Override
+	public T[] deepCopy(Object value) {
+		return getMutabilityPlan().deepCopy( (Object[]) value );
+	}
+
+	@Override
+	public boolean isEqual(Object one, Object another) {
+		return areEqual( (Object[]) one, (Object[]) another );
+	}
+
 	@AllowReflection
 	private static class ArrayMutabilityPlan<T> implements MutabilityPlan<T[]> {
 
 		private final Class<T> componentClass;
 		private final MutabilityPlan<T> componentPlan;
+		private final Class<T[]> arrayClass;
+		private final JavaType<T> baseDescriptor;
 
 		public ArrayMutabilityPlan(JavaType<T> baseDescriptor) {
+			this.baseDescriptor = baseDescriptor;
 			this.componentClass = baseDescriptor.getJavaTypeClass();
 			this.componentPlan = baseDescriptor.getMutabilityPlan();
+			this.arrayClass = arrayClass( componentClass );
 		}
 
 		@Override
@@ -393,16 +422,21 @@ public boolean isMutable() {
 		}
 
 		@Override
-		public T[] deepCopy(T[] value) {
+		public T[] deepCopy(Object[] value) {
 			if ( value == null ) {
 				return null;
 			}
-			//noinspection unchecked
-			final T[] copy = (T[]) newInstance( componentClass, value.length );
-			for ( int i = 0; i < value.length; i ++ ) {
-				copy[ i ] = componentPlan.deepCopy( value[ i ] );
+			else {
+				final var copy = arrayClass.cast( newInstance( componentClass, value.length ) );
+				for ( int i = 0; i < value.length; i++ ) {
+					copy[i] = componentPlan.deepCopy(
+							// Horrible hack around the fact that java.sql.Timestamps
+							// can be represented as instances of java.util.Date
+							// (Why do we even allow this? We deprecated java.sql stuff!)
+							baseDescriptor.coerce( value[i], null ) );
+				}
+				return copy;
 			}
-			return copy;
 		}
 
 		@Override

hibernate-core/src/test/java/org/hibernate/orm/test/mapping/array/MySqlArrayOfTimestampsTest.java

@@ -22,7 +22,6 @@
 import org.junit.jupiter.api.Test;
 
 import java.sql.Timestamp;
-import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.Month;
 import java.util.Calendar;
@@ -109,10 +108,6 @@ public void testDate(SessionFactoryScope scope) {
 		} );
 	}
 
-	private static final LocalDateTime SUMMER = LocalDate.of( 2024, 6, 20 ).atStartOfDay();
-	private static final LocalDateTime WINTER = LocalDate.of( 2023, 12, 22 ).atStartOfDay();
-	private static final LocalDate EPOCH = LocalDate.of( 1970, Month.JANUARY, 1 );
-
 	private static final TimeZone[] TEST_TIME_ZONES = Stream.of(
 			"Africa/Monrovia",
 			"Europe/Zagreb",