Support arrays/collections mapping

src/integrationTest/java/com/mongodb/hibernate/MongoTestAssertions.java

@@ -40,11 +40,11 @@ public static void assertUsingRecursiveComparison(
             @Nullable Object actual,
             BiConsumer<RecursiveComparisonAssert<?>, Object> assertion) {
         assertion.accept(
-                assertThat(expected)
+                assertThat(actual)
                         .usingRecursiveComparison()
                         .usingOverriddenEquals()
                         .withStrictTypeChecking(),
-                actual);
+                expected);
     }
 
     /**

src/main/java/com/mongodb/hibernate/dialect/MongoAggregateSupport.java

@@ -19,6 +19,7 @@
 import static java.lang.String.format;
 
 import com.mongodb.hibernate.internal.FeatureNotSupportedException;
+import com.mongodb.hibernate.internal.type.MongoArrayJdbcType;
 import com.mongodb.hibernate.internal.type.MongoStructJdbcType;
 import org.hibernate.dialect.aggregate.AggregateSupportImpl;
 import org.hibernate.mapping.AggregateColumn;
@@ -38,10 +39,11 @@ public String aggregateComponentCustomReadExpression(
             AggregateColumn aggregateColumn,
             Column column) {
         var aggregateColumnType = aggregateColumn.getTypeCode();
-        if (aggregateColumnType == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()) {
+        if (aggregateColumnType == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()
+                || aggregateColumnType == MongoArrayJdbcType.HIBERNATE_SQL_TYPE) {
             return format(
-                    "unused from %s.aggregateComponentCustomReadExpression",
-                    MongoAggregateSupport.class.getSimpleName());
+                    "unused from %s.aggregateComponentCustomReadExpression for SQL type code [%d]",
+                    MongoAggregateSupport.class.getSimpleName(), aggregateColumnType);
         }
         throw new FeatureNotSupportedException(format("The SQL type code [%d] is not supported", aggregateColumnType));
     }
@@ -53,17 +55,19 @@ public String aggregateComponentAssignmentExpression(
             AggregateColumn aggregateColumn,
             Column column) {
         var aggregateColumnType = aggregateColumn.getTypeCode();
-        if (aggregateColumnType == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()) {
+        if (aggregateColumnType == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()
+                || aggregateColumnType == MongoArrayJdbcType.HIBERNATE_SQL_TYPE) {
             return format(
-                    "unused from %s.aggregateComponentAssignmentExpression",
-                    MongoAggregateSupport.class.getSimpleName());
+                    "unused from %s.aggregateComponentAssignmentExpression for SQL type code [%d]",
+                    MongoAggregateSupport.class.getSimpleName(), aggregateColumnType);
         }
         throw new FeatureNotSupportedException(format("The SQL type code [%d] is not supported", aggregateColumnType));
     }
 
     @Override
     public boolean requiresAggregateCustomWriteExpressionRenderer(int aggregateSqlTypeCode) {
-        if (aggregateSqlTypeCode == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()) {
+        if (aggregateSqlTypeCode == MongoStructJdbcType.JDBC_TYPE.getVendorTypeNumber()
+                || aggregateSqlTypeCode == MongoArrayJdbcType.HIBERNATE_SQL_TYPE) {
             return false;
         }
         throw new FeatureNotSupportedException(format("The SQL type code [%d] is not supported", aggregateSqlTypeCode));

src/main/java/com/mongodb/hibernate/dialect/MongoDialect.java

@@ -20,7 +20,9 @@
 import static java.lang.String.format;
 
 import com.mongodb.hibernate.internal.translate.MongoTranslatorFactory;
+import com.mongodb.hibernate.internal.type.MongoArrayJdbcType;
 import com.mongodb.hibernate.internal.type.MongoStructJdbcType;
+import com.mongodb.hibernate.internal.type.MqlType;
 import com.mongodb.hibernate.internal.type.ObjectIdJavaType;
 import com.mongodb.hibernate.internal.type.ObjectIdJdbcType;
 import com.mongodb.hibernate.jdbc.MongoConnectionProvider;
@@ -31,6 +33,7 @@
 import org.hibernate.engine.jdbc.dialect.spi.DialectResolutionInfo;
 import org.hibernate.service.ServiceRegistry;
 import org.hibernate.sql.ast.SqlAstTranslatorFactory;
+import org.hibernate.type.descriptor.sql.internal.DdlTypeImpl;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -91,9 +94,24 @@ public SqlAstTranslatorFactory getSqlAstTranslatorFactory() {
     @Override
     public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
         super.contribute(typeContributions, serviceRegistry);
+        contributeObjectIdType(typeContributions);
+        typeContributions.contributeJdbcTypeConstructor(MongoArrayJdbcType.Constructor.INSTANCE);
+        typeContributions.contributeJdbcType(MongoStructJdbcType.INSTANCE);
+    }
+
+    private void contributeObjectIdType(TypeContributions typeContributions) {
         typeContributions.contributeJavaType(ObjectIdJavaType.INSTANCE);
         typeContributions.contributeJdbcType(ObjectIdJdbcType.INSTANCE);
-        typeContributions.contributeJdbcType(MongoStructJdbcType.INSTANCE);
+        var objectIdTypeCode = MqlType.OBJECT_ID.getVendorTypeNumber();
+        typeContributions
+                .getTypeConfiguration()
+                .getDdlTypeRegistry()
+                .addDescriptorIfAbsent(new DdlTypeImpl(
+                        objectIdTypeCode,
+                        format(
+                                "unused from %s.contributeObjectIdType for SQL type code [%d]",
+                                MongoDialect.class.getSimpleName(), objectIdTypeCode),
+                        this));
     }
 
     @Override
@@ -105,4 +123,9 @@ public void contribute(TypeContributions typeContributions, ServiceRegistry serv
     public AggregateSupport getAggregateSupport() {
         return MongoAggregateSupport.INSTANCE;
     }
+
+    @Override
+    public boolean supportsStandardArrays() {
+        return true;
+    }
 }

src/main/java/com/mongodb/hibernate/internal/extension/MongoAdditionalMappingContributor.java

@@ -57,6 +57,7 @@ public void contribute(
             InFlightMetadataCollector metadata,
             ResourceStreamLocator resourceStreamLocator,
             MetadataBuildingContext buildingContext) {
+        forbidEmbeddablesWithoutPersistentAttributes(metadata);
         metadata.getEntityBindings().forEach(persistentClass -> {
             forbidDynamicInsert(persistentClass);
             checkColumnNames(persistentClass);
@@ -67,7 +68,8 @@ public void contribute(
 
     private static void forbidDynamicInsert(PersistentClass persistentClass) {
         if (persistentClass.useDynamicInsert()) {
-            throw new FeatureNotSupportedException(format("%s is not supported", DynamicInsert.class.getSimpleName()));
+            throw new FeatureNotSupportedException(
+                    format("%s: %s is not supported", persistentClass, DynamicInsert.class.getSimpleName()));
         }
     }
 
@@ -100,6 +102,15 @@ private static void forbidStructIdentifier(PersistentClass persistentClass) {
         }
     }
 
+    private static void forbidEmbeddablesWithoutPersistentAttributes(InFlightMetadataCollector metadata) {
+        metadata.visitRegisteredComponents(component -> {
+            if (!component.hasAnyInsertableColumns()) {
+                throw new FeatureNotSupportedException(
+                        format("%s: must have at least one persistent attribute", component));
+            }
+        });
+    }
+
     private static void setIdentifierColumnName(PersistentClass persistentClass) {
         var identifier = persistentClass.getIdentifier();
         assertFalse(identifier.hasFormula());

src/main/java/com/mongodb/hibernate/internal/translate/AbstractMqlTranslator.java

@@ -950,6 +950,7 @@ private static boolean isComparingFieldWithValue(ComparisonPredicate comparisonP
     }
 
     private static BsonValue toBsonValue(Object value) {
+        // TODO-HIBERNATE-74 decide if `value` is nullable
         try {
             return ValueConversions.toBsonValue(value);
         } catch (SQLFeatureNotSupportedException e) {

src/main/java/com/mongodb/hibernate/internal/type/MongoArrayJdbcType.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ *
+ * 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 com.mongodb.hibernate.internal.type;
+
+import static com.mongodb.hibernate.internal.MongoAssertions.assertTrue;
+
+import java.io.Serial;
+import java.sql.JDBCType;
+import java.sql.SQLException;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.tool.schema.extract.spi.ColumnTypeInformation;
+import org.hibernate.type.SqlTypes;
+import org.hibernate.type.descriptor.WrapperOptions;
+import org.hibernate.type.descriptor.jdbc.ArrayJdbcType;
+import org.hibernate.type.descriptor.jdbc.BasicExtractor;
+import org.hibernate.type.descriptor.jdbc.JdbcType;
+import org.hibernate.type.descriptor.jdbc.JdbcTypeConstructor;
+import org.hibernate.type.spi.TypeConfiguration;
+import org.jspecify.annotations.Nullable;
+
+/** Thread-safe. */
+public final class MongoArrayJdbcType extends ArrayJdbcType {
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    public static final JDBCType JDBC_TYPE = JDBCType.ARRAY;
+    public static final int HIBERNATE_SQL_TYPE = SqlTypes.STRUCT_ARRAY;
+
+    private MongoArrayJdbcType(JdbcType elementJdbcType) {
+        super(elementJdbcType);
+    }
+
+    @Override
+    public int getJdbcTypeCode() {
+        var result = super.getJdbcTypeCode();
+        assertTrue(result == JDBC_TYPE.getVendorTypeNumber());
+        return result;
+    }
+
+    /** This method is overridden to make it accessible from our code. */
+    @Override
+    protected <X> @Nullable X getArray(
+            BasicExtractor<X> extractor, java.sql.@Nullable Array array, WrapperOptions options) throws SQLException {
+        return super.getArray(extractor, array, options);
+    }
+
+    public static final class Constructor implements JdbcTypeConstructor {
+        public static final Constructor INSTANCE = new Constructor();
+
+        private Constructor() {}
+
+        @Override
+        public JdbcType resolveType(
+                TypeConfiguration typeConfiguration,
+                Dialect dialect,
+                JdbcType elementType,
+                ColumnTypeInformation columnTypeInformation) {
+            return new MongoArrayJdbcType(elementType);
+        }
+
+        @Override
+        public int getDefaultSqlTypeCode() {
+            return JDBC_TYPE.getVendorTypeNumber();
+        }
+    }
+}