diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/ArrayAndElementArgumentValidator.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/ArrayAndElementArgumentValidator.java
index d7ba0e0ec5b9..f389086bc56e 100644
--- a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/ArrayAndElementArgumentValidator.java
+++ b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/ArrayAndElementArgumentValidator.java
@@ -11,6 +11,8 @@
 import org.hibernate.query.sqm.produce.function.FunctionArgumentException;
 import org.hibernate.query.sqm.tree.SqmTypedNode;
 
+import static org.hibernate.query.sqm.internal.TypecheckUtil.isTypeAssignable;
+
 /**
  * A {@link ArgumentsValidator} that validates the array type is compatible with the element type.
  */
@@ -36,7 +38,10 @@ public void validate(
 				final var elementArgument = arguments.get( elementIndex );
 				final var expressible = elementArgument.getExpressible();
 				final var elementType = expressible != null ? expressible.getSqmType() : null;
-				if ( expectedElementType != null && elementType != null && expectedElementType != elementType ) {
+				if ( expectedElementType != null && elementType != null
+						&& !isTypeAssignable( expectedElementType, elementType.getSqmType(), bindingContext ) ) {
+//						&& !expectedElementType.getRelationalJavaType().getJavaTypeClass()
+//							.isAssignableFrom( elementType.getRelationalJavaType().getJavaTypeClass() ) ) {
 					throw new FunctionArgumentException(
 							String.format(
 									"Parameter %d of function '%s()' has type %s, but argument is of type '%s'",
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java
index 97e86d7ef3a8..60eec3a16995 100644
--- a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java
+++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java
@@ -312,7 +312,7 @@ else if ( rhsType instanceof SqmBindableType<?> rhsExpressible ) {
 	 *
 	 * @see #areTypesComparable(SqmBindableType, SqmBindableType, BindingContext)
 	 */
-	private static boolean isTypeAssignable(
+	public static boolean isTypeAssignable(
 			SqmBindableType<?> targetType, SqmBindableType<?> expressionType,
 			BindingContext bindingContext) {
 
diff --git a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java
index dbfa354a69ff..92e0a6e13423 100644
--- a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java
+++ b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java
@@ -46,7 +46,6 @@ public class BasicTypeRegistry implements Serializable {
 
 	private final TypeConfiguration typeConfiguration;
 
-	private final Map<JdbcType, Map<JavaType<?>, BasicType<?>>> registryValues = new ConcurrentHashMap<>();
 	private boolean primed;
 
 	private final Map<String, BasicType<?>> typesByName = new ConcurrentHashMap<>();
@@ -94,7 +93,6 @@ private <T> BasicType<T> createBasicType(String name, BasicTypeReference<T> type
 		final var javaType = getJavaTypeRegistry().resolveDescriptor( typeReference.getJavaType() );
 		final var jdbcType = getJdbcTypeRegistry().getDescriptor( typeReference.getSqlTypeCode() );
 		final var createdType = createBasicType( typeReference, javaType, jdbcType );
-		primeRegistryEntry( createdType );
 		typesByName.put( typeReference.getName(), createdType );
 		typesByName.put( name, createdType );
 		return createdType;
@@ -245,11 +243,7 @@ public <J> BasicType<J> resolve(JavaType<J> javaType, JdbcType jdbcType, String
 	 * JdbcType combo or create (and register) one.
 	 */
 	public <J> BasicType<J> resolve(JavaType<J> javaType, JdbcType jdbcType, Supplier<BasicType<J>> creator) {
-		final var registeredBasicType = registryForJdbcType( jdbcType ).get( javaType );
-		//noinspection unchecked
-		return registeredBasicType != null
-				? (BasicType<J>) registeredBasicType
-				: createIfUnregistered( javaType, jdbcType, creator );
+		return createIfUnregistered( javaType, jdbcType, creator );
 	}
 
 	private <J> BasicType<J> createIfUnregistered(
@@ -277,7 +271,6 @@ private static <J> boolean registeredTypeMatches(JavaType<J> javaType, JdbcType
 
 	private <J> void register(JavaType<J> javaType, JdbcType jdbcType, BasicType<J> createdType) {
 		if ( createdType != null ) {
-			registryForJdbcType( jdbcType ).put( javaType, createdType );
 			// if we are still building mappings, register this adhoc
 			// type via a unique code. (This is to support Envers.)
 			try {
@@ -313,8 +306,6 @@ public void register(BasicType<?> type, String... keys) {
 			throw new HibernateException( "Type to register cannot be null" );
 		}
 
-		applyOrOverwriteEntry( type );
-
 		// explicit registration keys
 		if ( isEmpty( keys ) ) {
 			LOG.typeDefinedNoRegistrationKeys( type );
@@ -324,19 +315,6 @@ public void register(BasicType<?> type, String... keys) {
 		}
 	}
 
-	private void applyOrOverwriteEntry(BasicType<?> type) {
-		final var jdbcType = type.getJdbcType();
-		final var existing = registryForJdbcType( jdbcType ).put( type.getMappedJavaType(), type );
-		if ( existing != null ) {
-			LOG.tracef(
-					"BasicTypeRegistry registration overwritten (%s + %s); previous =`%s`",
-					jdbcType.getFriendlyName(),
-					type.getJavaTypeDescriptor(),
-					existing
-			);
-		}
-	}
-
 	public <T> CustomType<T> register(UserType<T> type, String... keys) {
 		final var customType = new CustomType<>( type, keys, typeConfiguration );
 		register( customType );
@@ -381,8 +359,6 @@ public void addPrimeEntry(BasicType<?> type, String legacyTypeClassName, String[
 			throw new HibernateException( "Type to register cannot be null" );
 		}
 
-		primeRegistryEntry( type );
-
 		// Legacy name registration
 		if ( isNotEmpty( legacyTypeClassName ) ) {
 			typesByName.put( legacyTypeClassName, type );
@@ -420,26 +396,6 @@ public void addPrimeEntry(BasicTypeReference<?> type, String legacyTypeClassName
 		}
 	}
 
-	private void primeRegistryEntry(BasicType<?> type) {
-		final var jdbcType = type.getJdbcType();
-		final var existing = registryForJdbcType( jdbcType ).get( type.getMappedJavaType() );
-		if ( existing != null ) {
-			LOG.tracef(
-					"Skipping registration of BasicType (%s + %s); still priming. existing = %s",
-					jdbcType.getFriendlyName(),
-					type.getJavaTypeDescriptor(),
-					existing
-			);
-		}
-		else {
-			registryForJdbcType( jdbcType ).put( type.getMappedJavaType(), type );
-		}
-	}
-
-	private Map<JavaType<?>, BasicType<?>> registryForJdbcType(JdbcType jdbcType) {
-		return registryValues.computeIfAbsent( jdbcType, key -> new ConcurrentHashMap<>() );
-	}
-
 	private void applyRegistrationKeys(BasicType<?> type, String[] keys) {
 		for ( String key : keys ) {
 			if ( key != null ) {