Remove custom array-handling code

stIncMale · stIncMale · commit 4ed1ce709d80 · 2025-06-17T09:11:02.000-06:00
HIBERNATE-58
diff --git a/src/integrationTest/java/com/mongodb/hibernate/ArrayAndCollectionIntegrationTests.java b/src/integrationTest/java/com/mongodb/hibernate/ArrayAndCollectionIntegrationTests.java
@@ -63,7 +63,6 @@
         })
 @ServiceRegistry(settings = {@Setting(name = WRAPPER_ARRAY_HANDLING, value = "allow")})
 @ExtendWith(MongoExtension.class)
-// TODO-HIBERNATE-48 verify that we support `null`s in arrays/collections
 class ArrayAndCollectionIntegrationTests implements SessionFactoryScopeAware {
     @InjectMongoCollection("items")
     private static MongoCollection<BsonDocument> mongoCollection;
diff --git a/src/main/java/com/mongodb/hibernate/internal/type/MongoStructJdbcType.java b/src/main/java/com/mongodb/hibernate/internal/type/MongoStructJdbcType.java
@@ -197,9 +197,8 @@ public Object[] extractJdbcValues(@Nullable Object rawJdbcValue, WrapperOptions
                         new MongoArray(value.asArray().toArray()),
                         options);
             } else {
-                domainValue = toDomainValue(
-                        value,
-                        ValueConversions.Type.of(jdbcMapping.getMappedJavaType().getJavaType()));
+                domainValue =
+                        toDomainValue(value, jdbcMapping.getMappedJavaType().getJavaTypeClass());
             }
             result[elementIdx++] = domainValue;
         }
diff --git a/src/main/java/com/mongodb/hibernate/internal/type/ValueConversions.java b/src/main/java/com/mongodb/hibernate/internal/type/ValueConversions.java
@@ -24,15 +24,13 @@
 import com.mongodb.hibernate.internal.FeatureNotSupportedException;
 import com.mongodb.hibernate.jdbc.MongoArray;
 import java.lang.reflect.Array;
-import java.lang.reflect.ParameterizedType;
 import java.math.BigDecimal;
 import java.sql.JDBCType;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.util.ArrayList;
-import java.util.Collection;
 import org.bson.BsonArray;
 import org.bson.BsonBinary;
 import org.bson.BsonBoolean;
@@ -82,12 +80,8 @@ private ValueConversions() {}
             return toBsonValue(v);
         } else if (value instanceof ObjectId v) {
             return toBsonValue(v);
-        } else if (value instanceof MongoArray v) {
-            return toBsonValue(v);
-        } else if (value.getClass().isArray()) {
-            return arrayToBsonValue(value);
-        } else if (value instanceof Collection<?> v) {
-            return toBsonValue(v);
+        } else if (value instanceof Object[] v) {
+            return arrayToBsonValue(v);
         } else {
             throw new SQLFeatureNotSupportedException(format(
                     "Value [%s] of type [%s] is not supported",
@@ -148,7 +142,7 @@ public static BsonBinary toBsonValue(byte[] value) {
      * href="https://docs.jboss.org/hibernate/orm/6.6/userguide/html_single/Hibernate_User_Guide.html#basic-chararray">
      * Hibernate ORM maps {@code char[]} to {@link java.sql.JDBCType#VARCHAR} by default</a>.
      *
-     * @see #toDomainValue(BsonString, Type.ArrayOrCollection)
+     * @see #toDomainValue(BsonString)
      */
     private static BsonString toBsonValue(char[] value) {
         return new BsonString(String.valueOf(value));
@@ -165,9 +159,6 @@ public static BsonArray toBsonValue(java.sql.Array value) throws SQLFeatureNotSu
         } catch (SQLException e) {
             throw fail(e.toString());
         }
-        // Hibernate ORM always passes an `java.sql.Array` with contents of the Java array type to
-        // `PreparedStatement.setArray`
-        assertTrue(contents.getClass().isArray());
         return arrayToBsonValue(contents);
     }
 
@@ -180,15 +171,7 @@ private static BsonArray arrayToBsonValue(Object value) throws SQLFeatureNotSupp
         return new BsonArray(elements);
     }
 
-    private static BsonArray toBsonValue(Collection<?> value) throws SQLFeatureNotSupportedException {
-        var elements = new ArrayList<BsonValue>(value.size());
-        for (var e : value) {
-            elements.add(toBsonValue(e));
-        }
-        return new BsonArray(elements);
-    }
-
-    static Object toDomainValue(BsonValue value, Type domainType) throws SQLFeatureNotSupportedException {
+    static Object toDomainValue(BsonValue value, Class<?> domainType) throws SQLFeatureNotSupportedException {
         // TODO-HIBERNATE-48 decide if `value` is nullable and the method may return `null`
         assertNotNull(value);
         if (value instanceof BsonDocument v) {
@@ -204,26 +187,21 @@ static Object toDomainValue(BsonValue value, Type domainType) throws SQLFeatureN
         } else if (value instanceof BsonDecimal128 v) {
             return toDomainValue(v);
         } else if (value instanceof BsonString v) {
-            if (domainType instanceof Type.Simple simpleType) {
-                return toDomainValue(v, simpleType.type());
-            } else if (domainType instanceof Type.ArrayOrCollection arrayOrCollectionType) {
-                return toDomainValue(v, arrayOrCollectionType).getArray();
+            if (domainType.isArray()) {
+                return toDomainValue(v);
             } else {
-                throw fail(domainType.toString());
+                return toDomainValue(v, domainType);
             }
         } else if (value instanceof BsonBinary v) {
             return toDomainValue(v);
         } else if (value instanceof BsonObjectId v) {
             return toDomainValue(v);
-        } else if (value instanceof BsonArray v) {
-            if (!(domainType instanceof Type.ArrayOrCollection arrayOrCollectionDomainType)) {
-                throw fail("VAKOTODO SQLException/RuntimeException about invalid data");
-            }
-            return toDomainValue(v, arrayOrCollectionDomainType).getArray();
+        } else if (value instanceof BsonArray v && domainType.isArray()) {
+            return toDomainValue(v, assertNotNull(domainType.getComponentType()));
         } else {
             throw new SQLFeatureNotSupportedException(format(
-                    "Value [%s] of type [%s] is not supported",
-                    value, value.getClass().getTypeName()));
+                    "Value [%s] of type [%s] is not supported for the domain type [%s]",
+                    value, value.getClass().getTypeName(), domainType));
         }
     }
 
@@ -313,109 +291,29 @@ private static ObjectId toDomainValue(BsonObjectId value) {
         return value.getValue();
     }
 
-    public static MongoArray toArrayDomainValue(BsonValue value, Type.ArrayOrCollection domainArrayContentsType)
-            throws SQLFeatureNotSupportedException {
-        if (value instanceof BsonArray v) {
-            return toDomainValue(v, domainArrayContentsType);
-        } else if (value instanceof BsonString v) {
-            return toDomainValue(v, domainArrayContentsType);
-        } else {
-            throw new RuntimeException(
-                    format("Invalid data: value [%s], domainArrayContentsType [%s]", value, domainArrayContentsType));
-        }
+    public static MongoArray toArrayDomainValue(BsonValue value) throws SQLFeatureNotSupportedException {
+        return new MongoArray(toDomainValue(value.asArray(), Object.class));
     }
 
-    private static MongoArray toDomainValue(BsonArray value, Type.ArrayOrCollection domainArrayContentsType)
-            throws SQLFeatureNotSupportedException {
+    private static Object toDomainValue(BsonArray value, Class<?> elementType) throws SQLFeatureNotSupportedException {
         var size = value.size();
-        var domainValueBuilder = MongoArray.builder(domainArrayContentsType, size);
+        var result = Array.newInstance(elementType, size);
         for (int i = 0; i < size; i++) {
-            var element = toDomainValue(value.get(i), domainArrayContentsType.elementType());
-            domainValueBuilder.add(i, element);
+            var element = toDomainValue(value.get(i), elementType);
+            Array.set(result, i, element);
         }
-        return domainValueBuilder.build();
+        return result;
     }
 
     /** @see #toBsonValue(char[]) */
-    private static MongoArray toDomainValue(BsonString value, Type.ArrayOrCollection domainArrayContentsType) {
+    private static char[] toDomainValue(BsonString value) {
         var charsAsString = toDomainValue(value, String.class);
         var size = charsAsString.length();
-        var domainValueBuilder = MongoArray.builder(domainArrayContentsType, size);
+        var result = new char[size];
         for (int i = 0; i < size; i++) {
             var element = charsAsString.charAt(i);
-            domainValueBuilder.add(i, element);
-        }
-        return domainValueBuilder.build();
-    }
-
-    public sealed interface Type permits Type.Simple, Type.ArrayOrCollection {
-        sealed interface Simple extends Type permits SimpleType {}
-
-        // VAKOTODO rename to Plural
-        sealed interface ArrayOrCollection extends Type permits ArrayType, CollectionType {
-            Simple elementType();
-        }
-
-        static Type of(java.lang.reflect.Type type) {
-            if (type instanceof Class<?> klass) {
-                return of(klass);
-            } else if (type instanceof ParameterizedType parameterizedType) {
-                if (!(parameterizedType.getRawType() instanceof Class<?> rawKlass)) {
-                    throw fail(type.toString());
-                }
-                if (Collection.class.isAssignableFrom(rawKlass)) { // VAKOTODO equals?
-                    var collectionTypeArguments = parameterizedType.getActualTypeArguments();
-                    assertTrue(collectionTypeArguments.length == 1);
-                    return new CollectionType(rawKlass, collectionTypeArguments[0]);
-                } else {
-                    return of(rawKlass);
-                }
-            } else {
-                throw fail(type.toString());
-            }
-        }
-
-        private static Type of(Class<?> type) {
-            if (type.isArray() && !type.equals(byte[].class)) {
-                return array(type);
-            } else {
-                return simple(type);
-            }
-        }
-
-        private static Simple simple(Class<?> type) {
-            return new SimpleType(type);
-        }
-
-        static ArrayOrCollection array(Class<?> type) {
-            return new ArrayType(type);
-        }
-
-        Class<?> type();
-    }
-
-    private record SimpleType(Class<?> type) implements Type.Simple {}
-
-    private record ArrayType(Class<?> type, Simple elementType) implements Type.ArrayOrCollection {
-        ArrayType(Class<?> arrayType) {
-            this(arrayType, elementType(arrayType));
-        }
-
-        private static Simple elementType(Class<?> arrayType) {
-            return Type.simple(assertNotNull(arrayType.componentType()));
-        }
-    }
-
-    private record CollectionType(Class<?> type, Simple elementType) implements Type.ArrayOrCollection {
-        CollectionType(Class<?> rawCollectionType, java.lang.reflect.Type collectionTypeArgument) {
-            this(rawCollectionType, elementType(collectionTypeArgument));
-        }
-
-        private static Simple elementType(java.lang.reflect.Type collectionTypeArgument) {
-            if (!(collectionTypeArgument instanceof Class<?> collectionTypeArgumentClass)) {
-                throw fail(); // VAKOTODO try Collection<?>/Collection<? extends>/Collection<? super>
-            }
-            return Type.simple(collectionTypeArgumentClass);
+            result[i] = element;
         }
+        return result;
     }
 }
diff --git a/src/main/java/com/mongodb/hibernate/jdbc/MongoArray.java b/src/main/java/com/mongodb/hibernate/jdbc/MongoArray.java
@@ -16,80 +16,16 @@
 
 package com.mongodb.hibernate.jdbc;
 
-import com.mongodb.hibernate.internal.type.ValueConversions;
-import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.List;
-
 public final class MongoArray implements ArrayAdapter {
     private final Object contents;
 
-    private MongoArray(Object contents) {
+    public MongoArray(Object contents) {
         this.contents = contents;
     }
 
-    public MongoArray(Object[] contents) {
-        this((Object) contents);
-    }
-
     @Override
     public Object getArray() {
         // Hibernate ORM does not call `Connection.getTypeMap`/`setTypeMap`, therefore we are free to ignore it
         return contents;
     }
-
-    public static Builder builder(ValueConversions.Type.ArrayOrCollection contentsType, int size) {
-        var type = contentsType.type();
-        if (type.isArray()) {
-            return new ArrayBuilder(Array.newInstance(contentsType.elementType().type(), size));
-        } else {
-            // VAKOTODO remove, it's no longer used
-            return new CollectionBuilder(new ArrayList<>(size));
-        }
-    }
-
-    public abstract static class Builder {
-        private Builder() {}
-
-        public abstract void add(int i, Object element);
-
-        public abstract MongoArray build();
-    }
-
-    @SuppressWarnings("ArrayRecordComponent")
-    private static final class ArrayBuilder extends Builder {
-        private final Object contents;
-
-        ArrayBuilder(Object contents) {
-            this.contents = contents;
-        }
-
-        @Override
-        public void add(int i, Object element) {
-            Array.set(contents, i, element);
-        }
-
-        @Override
-        public MongoArray build() {
-            return new MongoArray(contents);
-        }
-    }
-
-    private static final class CollectionBuilder extends Builder {
-        private final List<Object> contents;
-
-        CollectionBuilder(List<Object> contents) {
-            this.contents = contents;
-        }
-
-        @Override
-        public void add(int i, Object element) {
-            contents.add(i, element);
-        }
-
-        @Override
-        public MongoArray build() {
-            return new MongoArray(contents);
-        }
-    }
 }
diff --git a/src/main/java/com/mongodb/hibernate/jdbc/MongoResultSet.java b/src/main/java/com/mongodb/hibernate/jdbc/MongoResultSet.java
@@ -34,7 +34,6 @@
 
 import static com.mongodb.hibernate.internal.MongoAssertions.assertFalse;
 import static com.mongodb.hibernate.internal.MongoAssertions.assertNotNull;
-import static com.mongodb.hibernate.internal.type.ValueConversions.toArrayDomainValue;
 import static java.lang.String.format;
 
 import com.mongodb.client.MongoCursor;
@@ -196,8 +195,7 @@ public double getDouble(int columnIndex) throws SQLException {
     public @Nullable Array getArray(int columnIndex) throws SQLException {
         checkClosed();
         checkColumnIndex(columnIndex);
-        return getValue(
-                columnIndex, bsonValue -> toArrayDomainValue(bsonValue, ValueConversions.Type.array(Object[].class)));
+        return getValue(columnIndex, ValueConversions::toArrayDomainValue);
     }
 
     @Override

Original file line number	Diff line number	Diff line change
`@@ -197,9 +197,8 @@ public Object[] extractJdbcValues(@Nullable Object rawJdbcValue, WrapperOptions`
`197`	`197`	`new MongoArray(value.asArray().toArray()),`
`198`	`198`	`options);`
`199`	`199`	`} else {`
`200`		`- domainValue = toDomainValue(`
`201`		`- value,`
`202`		`- ValueConversions.Type.of(jdbcMapping.getMappedJavaType().getJavaType()));`
	`200`	`+ domainValue =`
	`201`	`+ toDomainValue(value, jdbcMapping.getMappedJavaType().getJavaTypeClass());`
`203`	`202`	`}`
`204`	`203`	`result[elementIdx++] = domainValue;`
`205`	`204`	`}`