Support Oracle db VECTOR type

.github/workflows/gradle.yml

@@ -41,6 +41,8 @@ jobs:
           export PATH=$(echo "$PATH" | tr ':' '\n' | grep -v '/usr/lib/jvm' | paste -sd:)
       - name: "🗑 Free disk space"
         run: |
+         sudo rm -rf /usr/share/dotnet
+         sudo rm -rf /usr/local/lib/android
          sudo rm -rf "/usr/local/share/boost"
          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
          sudo apt-get clean

data-connection-jdbc/build.gradle

@@ -42,6 +42,7 @@ micronaut {
         enabled = true
         inferClasspath = false
         additionalModules.add(KnownModules.JDBC_POSTGRESQL)
+        additionalModules.add(KnownModules.JDBC_ORACLE_XE)
         clientTimeout = 300
         version = libs.versions.micronaut.testresources.get()
     }

data-connection-jdbc/src/test/resources/application.yml

@@ -11,6 +11,7 @@ test-resources:
       startup-timeout: 300s
       image-name: gvenzl/oracle-free:latest-faststart
     postgres:
+      image-name: pgvector/pgvector:pg16
       startup-timeout: 300s
 
 micronaut:

data-hibernate-reactive/build.gradle

@@ -35,7 +35,7 @@ dependencies {
     testRuntimeOnly mnSql.vertx.mysql.client
 
     // Needed for test resources
-    testResourcesService mnSql.mysql.connector.java
+    testResourcesService mnSql.mysql.connector.j
     testResourcesService mnSql.postgresql
 }
 

data-hibernate-reactive/src/test/java/io/micronaut/data/hibernate/reactive/MySqlHibernateReactiveProperties.java

@@ -12,7 +12,7 @@ default Map<String, String> getProperties() {
             "jpa.default.properties.hibernate.hbm2ddl.auto", "create-drop",
             "jpa.default.reactive", "true",
             "jpa.default.properties.hibernate.connection.db-type", "mysql",
-            "test-resources.containers.mysql.image-name", "mysql:8.4.5"
+            "test-resources.containers.mysql.image-name", "container-registry.oracle.com/mysql/community-server:latest"
         );
     }
 }

data-jdbc/build.gradle

@@ -21,12 +21,16 @@ dependencies {
     compileOnly mnRxjava2.micronaut.rxjava2
     compileOnly projects.micronautDataHibernateJpa
     compileOnly mnSql.ojdbc11
+    compileOnly mnSql.postgresql
+    compileOnly mnSql.mysql.connector.j
+    compileOnly libs.managed.pg.vector
 
     testAnnotationProcessor mn.micronaut.inject.java
     testAnnotationProcessor projects.micronautDataProcessor
     testAnnotationProcessor mnValidation.micronaut.validation.processor
 
     testImplementation projects.micronautDataTck
+    testImplementation libs.managed.pg.vector
     testImplementation projects.micronautDataProcessor
     testImplementation mnRxjava2.micronaut.rxjava2
     testImplementation mnReactor.micronaut.reactor
@@ -44,22 +48,23 @@ dependencies {
     testImplementation(mnTestResources.testcontainers.oracle.xe)
 
     testCompileOnly mn.micronaut.inject.groovy
+    testImplementation mnSql.ojdbc11
+
 
     testImplementation mnMultitenancy.micronaut.multitenancy
 
     testImplementation mn.micronaut.http.netty
     testRuntimeOnly mnSql.micronaut.jdbc.tomcat
     testRuntimeOnly mnSql.h2
     testRuntimeOnly mnSql.mariadb.java.client
-    testRuntimeOnly mnSql.ojdbc11
-    testRuntimeOnly mnSql.mysql.connector.java
+    testRuntimeOnly mnSql.mysql.connector.j
     testRuntimeOnly mnSql.postgresql
     testRuntimeOnly mnSql.mssql.jdbc
     testRuntimeOnly mn.snakeyaml
 
     testResourcesService mnSql.mariadb.java.client
     testResourcesService mnSql.ojdbc11
-    testResourcesService mnSql.mysql.connector.java
+    testResourcesService mnSql.mysql.connector.j
     testResourcesService mnSql.postgresql
     testResourcesService mnSql.mssql.jdbc
 

data-jdbc/src/main/java/io/micronaut/data/jdbc/config/SchemaGenerator.java

@@ -38,6 +38,7 @@
 import io.micronaut.data.model.query.builder.sql.SqlQueryBuilder;
 import io.micronaut.data.model.query.builder.sql.SqlSchemaUtils;
 import io.micronaut.data.model.query.builder.sql.validation.SqlTableMappingValidator;
+import io.micronaut.data.model.runtime.convert.DefinitionProvider;
 import io.micronaut.data.model.runtime.RuntimeEntityRegistry;
 import io.micronaut.data.model.schema.sql.SqlTableMapping;
 import io.micronaut.data.model.schema.sql.metadata.SqlColumnMetadata;
@@ -79,19 +80,22 @@ public class SchemaGenerator {
     private final JdbcSchemaHandler schemaHandler;
     private final Map<Dialect, SqlTableMappingValidator> dialectSqlTableMappingValidatorMap;
     private final PropertyPlaceholderResolver propertyPlaceholderResolver;
+    private final List<DefinitionProvider> definitionProviders;
 
     /**
      * Constructors a schema generator for the given configurations.
      *
-     * @param configurations                The configurations
-     * @param schemaHandler                 The schema handler
-     * @param sqlTableMappingValidators     The list of {@link SqlTableMappingValidator} instances
-     * @param environment                   The environment
+     * @param configurations              The configurations
+     * @param schemaHandler               The schema handler
+     * @param sqlTableMappingValidators   The list of {@link SqlTableMappingValidator} instances
+     * @param environment                 The environment
+     * @param definitionProviders         Providers of vendor-specific SQL definitions (columns and indexes) used during schema generation
      */
     public SchemaGenerator(List<DataJdbcConfiguration> configurations,
                            JdbcSchemaHandler schemaHandler,
                            List<SqlTableMappingValidator> sqlTableMappingValidators,
-                           Environment environment) {
+                           Environment environment,
+                           List<DefinitionProvider> definitionProviders) {
         this.configurations = configurations == null ? Collections.emptyList() : configurations;
         this.schemaHandler = schemaHandler;
         this.propertyPlaceholderResolver = environment.getPlaceholderResolver();
@@ -103,6 +107,7 @@ public SchemaGenerator(List<DataJdbcConfiguration> configurations,
             }
             dialectSqlTableMappingValidatorMap.put(dialect, sqlTableMappingValidator);
         }
+        this.definitionProviders = definitionProviders == null ? Collections.emptyList() : definitionProviders;
     }
 
     /**
@@ -178,10 +183,11 @@ public void createOrValidateSchema(BeanLocator beanLocator) {
         }
     }
 
-    private static void generate(Connection connection,
-                                 DataJdbcConfiguration configuration,
-                                 PropertyPlaceholderResolver propertyPlaceholderResolver,
-                                 PersistentEntity[] entities) throws SQLException {
+    @SuppressWarnings("java:S3776")
+    private void generate(Connection connection,
+                          DataJdbcConfiguration configuration,
+                          PropertyPlaceholderResolver propertyPlaceholderResolver,
+                          PersistentEntity[] entities) throws SQLException {
         Dialect dialect = configuration.getDialect();
         SqlQueryBuilder builder = new SqlQueryBuilder(dialect);
         if (dialect.allowBatch() && configuration.isBatchGenerate()) {
@@ -201,7 +207,7 @@ private static void generate(Connection connection,
                         }
                     }
                 case CREATE:
-                    String sql = resolveSql(propertyPlaceholderResolver, builder.buildBatchCreateTableStatement(entities));
+                    String sql = resolveSql(propertyPlaceholderResolver, builder.buildBatchCreateTableStatement(definitionProviders, entities));
                     if (DataSettings.QUERY_LOG.isDebugEnabled()) {
                         DataSettings.QUERY_LOG.debug("Creating Tables: \n{}", sql);
                     }
@@ -234,7 +240,7 @@ private static void generate(Connection connection,
                         }
                     }
                 case CREATE:
-                    String[] sql = builder.buildCreateTableStatements(entities);
+                    String[] sql = builder.buildCreateTableStatements(entities, dialect, definitionProviders);
                     for (String stmt : sql) {
                         stmt = resolveSql(propertyPlaceholderResolver, stmt);
                         if (DataSettings.QUERY_LOG.isDebugEnabled()) {
@@ -257,10 +263,10 @@ private static void generate(Connection connection,
         }
     }
 
-    private static void validate(Connection connection,
-                                 DataJdbcConfiguration configuration,
-                                 PersistentEntity[] entities,
-                                 Map<Dialect, SqlTableMappingValidator> dialectSqlTableMappingValidatorMap) throws SQLException {
+    private void validate(Connection connection,
+                          DataJdbcConfiguration configuration,
+                          PersistentEntity[] entities,
+                          Map<Dialect, SqlTableMappingValidator> dialectSqlTableMappingValidatorMap) throws SQLException {
         Dialect dialect = configuration.getDialect();
         SqlTableMappingValidator sqlTableMappingValidator = dialectSqlTableMappingValidatorMap.get(dialect);
         if (sqlTableMappingValidator == null) {
@@ -270,7 +276,7 @@ private static void validate(Connection connection,
         // that represents join and ad-hoc SqlTableMapping for the same entity based on relation mappings (to be removed/skipped)
         Map<String, SqlTableMapping> sqlTableMappingByTableName = CollectionUtils.newLinkedHashMap(entities.length);
         for (PersistentEntity entity : entities) {
-            List<SqlTableMapping> sqlTableMappings = SqlSchemaUtils.getSqlTableMappings(entity);
+            List<SqlTableMapping> sqlTableMappings = SqlSchemaUtils.getSqlTableMappings(definitionProviders, entity, dialect);
             for (SqlTableMapping sqlTableMapping : sqlTableMappings) {
                 String tableName = sqlTableMapping.name();
                 String tableNameLowerCase = tableName.toLowerCase();

data-jdbc/src/main/java/io/micronaut/data/jdbc/convert/JdbcConversionContext.java

@@ -15,7 +15,7 @@
  */
 package io.micronaut.data.jdbc.convert;
 
-import io.micronaut.core.convert.ConversionContext;
+import io.micronaut.data.model.runtime.convert.DatabaseTypeConversionContext;
 
 import java.sql.Connection;
 
@@ -25,13 +25,12 @@
  * @author Denis Stepanov
  * @since 3.1
  */
-public interface JdbcConversionContext extends ConversionContext {
+public interface JdbcConversionContext extends DatabaseTypeConversionContext {
 
     /**
      * Provides access to JDBC connection.
      *
      * @return the connection
      */
     Connection getConnection();
-
 }

data-jdbc/src/main/java/io/micronaut/data/jdbc/convert/vendor/AbstractJdbcVectorConverter.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * 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
+ *
+ * https://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 io.micronaut.data.jdbc.convert.vendor;
+
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.convert.ConversionService;
+import io.micronaut.data.model.runtime.convert.vector.VectorTypeConverter;
+import io.micronaut.data.model.vector.Vector;
+
+@Internal
+abstract class AbstractJdbcVectorConverter<T> implements VectorTypeConverter<T> {
+
+    private final ConversionService conversionService;
+
+    protected AbstractJdbcVectorConverter(ConversionService conversionService) {
+        this.conversionService = conversionService;
+    }
+
+    @Override
+    public T convert(Vector vector) {
+        if (supportedVectorTypes().stream().anyMatch(x -> vector.getClass().isAssignableFrom(x))) {
+            return conversionService.convert(vector, getPersistedType()).orElse(null);
+        }
+        throw new IllegalArgumentException(databaseType() + " does not support " + vector.getClass().getName());
+    }
+
+    @Override
+    public Vector convert(T object, Class<Vector> targetType) {
+        if (supportedVectorTypes().stream().anyMatch(targetType::isAssignableFrom)) {
+            return conversionService.convert(object, targetType).orElse(null);
+        }
+        throw new IllegalArgumentException(databaseType() + " does not support " + targetType.getName());
+    }
+}

data-jdbc/src/main/java/io/micronaut/data/jdbc/convert/vendor/MySqlJdbcVectorConverter.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * 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
+ *
+ * https://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 io.micronaut.data.jdbc.convert.vendor;
+
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.convert.ConversionService;
+import io.micronaut.data.model.runtime.convert.DatabaseType;
+import io.micronaut.data.model.runtime.convert.vector.VectorTypeConverter;
+import io.micronaut.data.model.vector.FloatVector;
+import io.micronaut.data.model.vector.Vector;
+import jakarta.inject.Singleton;
+
+import java.util.List;
+
+
+/**
+ * MySQL-specific {@link VectorTypeConverter} that maps {@link Vector} to JDBC binary (byte[]) accepted
+ * by MySQL HeatWave VECTOR (float32 little-endian, plain concatenation), and back.
+ *
+ * Persisted type: {@code byte[]} (float32 LE per element)
+ *
+ * Example: (1.0, 2.0, 3.0) -> bytes: 00 00 80 3F  00 00 00 40  00 00 40 40
+ *
+ * @author Nemanja Mikic
+ * @since 5.0.0
+ */
+@Internal
+@Requires(classes = com.mysql.cj.jdbc.Driver.class)
+@Singleton
+final class MySqlJdbcVectorConverter extends AbstractJdbcVectorConverter<byte[]> {
+
+    MySqlJdbcVectorConverter(ConversionService conversionService) {
+        super(conversionService);
+    }
+
+    @Override
+    public Class<byte[]> getPersistedType() {
+        return byte[].class;
+    }
+
+    public List<Class<? extends Vector>> supportedVectorTypes() {
+        return List.of(Vector.class, FloatVector.class);
+    }
+
+    @Override
+    public DatabaseType databaseType() {
+        return DatabaseType.MYSQL;
+    }
+}