Add SQLITE Dialect

data-connection/build.gradle

@@ -16,5 +16,6 @@ dependencies {
     implementation mn.micronaut.core.reactive
 
     testImplementation(mnTest.micronaut.test.junit5)
+    testImplementation(mnTest.junit.jupiter.params)
     compileOnly(mn.kotlinx.coroutines.reactor)
 }

data-connection/src/main/java/io/micronaut/data/connection/ConnectionCapabilities.java

@@ -20,11 +20,23 @@
 import io.micronaut.core.order.Ordered;
 
 import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Supplier;
 
 /**
- * Defines the capabilities of a {@link Connection}.
+ * Defines the capabilities of a database connection.
+ * <p>
+ * The primary API is {@link #supports(Capability, Supplier)}, which accepts a supplier of
+ * the database product name so that capability detection works for both JDBC
+ * ({@link Connection}) and R2DBC ({@code io.r2dbc.spi.Connection}) connections.
+ * Convenience overloads such as {@link #supports(Capability, Connection)} delegate to the
+ * supplier-based method.
+ * <p>
+ * When the database product name cannot be determined (e.g., the supplier throws or returns
+ * an unrecognised value), implementations should default to returning {@code true} (capability
+ * is supported) so that the calling code can fall back to its own default behaviour safely.
  * <p>
  * You can provide your own implementation via Java SPI by registering
  * {@code io.micronaut.data.connection.ConnectionCapabilities} in
@@ -59,14 +71,41 @@ enum Capability {
      */
     ConnectionCapabilities INSTANCE = loadInstance();
 
+    /**
+     * Determines whether the database supports the requested capability.
+     * <p>
+     * Implementations receive a {@link Supplier} rather than a direct connection object so
+     * that this method works uniformly with JDBC ({@link Connection}) and R2DBC
+     * ({@code io.r2dbc.spi.Connection}) connections. The supplier is called lazily; if
+     * determining the product name is expensive, implementations may cache the result.
+     * <p>
+     * If the supplier throws or returns an unrecognised product name, implementations should
+     * return {@code true} (capability supported) so that callers can fall back gracefully to
+     * their own default behaviour.
+     *
+     * @param capability The capability to evaluate
+     * @param databaseProductNameSupplier supplier of the database product name; may throw
+     *        {@link RuntimeException} if the metadata cannot be retrieved
+     * @return {@code true} if the connection supports the capability; {@code false} otherwise
+     */
+    boolean supports(Capability capability, Supplier<String> databaseProductNameSupplier);
+
     /**
      * Determines whether the given JDBC connection supports the requested capability.
      *
      * @param capability The capability to evaluate
      * @param connection The JDBC connection
      * @return {@code true} if the connection supports the capability; {@code false} otherwise
      */
-    boolean supports(Capability capability, Connection connection);
+    default boolean supports(Capability capability, Connection connection) {
+        return supports(capability, () -> {
+            try {
+                return connection.getMetaData().getDatabaseProductName();
+            } catch (SQLException e) {
+                return "Unknown";
+            }
+        });
+    }
 
     private static ConnectionCapabilities loadInstance() {
         List<ConnectionCapabilities> providers = new ArrayList<>();

data-connection/src/main/java/io/micronaut/data/connection/DefaultConnectionCapabilities.java

@@ -16,7 +16,7 @@
 package io.micronaut.data.connection;
 
 import io.micronaut.core.annotation.Internal;
-import java.sql.Connection;
+import java.util.function.Supplier;
 
 /**
  * Internal fallback {@link ConnectionCapabilities} implementation that assumes all capabilities are supported.
@@ -25,9 +25,8 @@
  */
 @Internal
 final class DefaultConnectionCapabilities implements ConnectionCapabilities {
-
     @Override
-    public boolean supports(ConnectionCapabilities.Capability capability, Connection connection) {
+    public boolean supports(ConnectionCapabilities.Capability capability, Supplier<String> databaseProductNameSupplier) {
         return true;
     }
 }

data-connection/src/test/java/example/CustomConnectionCapabilities.java

@@ -1,13 +1,12 @@
 package example;
 
 import io.micronaut.data.connection.ConnectionCapabilities;
-
-import java.sql.Connection;
+import java.util.function.Supplier;
 
 public class CustomConnectionCapabilities implements ConnectionCapabilities {
 
     @Override
-    public boolean supports(ConnectionCapabilities.Capability capability, Connection connection) {
+    public boolean supports(ConnectionCapabilities.Capability capability, Supplier<String> databaseProductNameSupplier) {
         return true;
     }
 }

data-connection/src/test/java/io/micronaut/data/connection/DefaultConnectionCapabilitiesTest.java

@@ -0,0 +1,62 @@
+package io.micronaut.data.connection;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledInNativeImage;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DefaultConnectionCapabilitiesTest {
+
+    private final DefaultConnectionCapabilities capabilities = new DefaultConnectionCapabilities();
+
+    @DisabledInNativeImage
+    @ParameterizedTest
+    @ValueSource(strings = {
+        "MySQL",
+        "MariaDB",
+        "PostgreSQL",
+        "H2",
+        "SQLite",
+        "Oracle",
+        "Microsoft SQL Server"
+    })
+    void supportsReadOnlyForDifferentDatabaseProducts(String databaseProductName) {
+        assertTrue(capabilities.supports(ConnectionCapabilities.Capability.READ_ONLY, connection(databaseProductName)));
+    }
+
+    private Connection connection(String databaseProductName) {
+        DatabaseMetaData metaData = (DatabaseMetaData) Proxy.newProxyInstance(
+            DatabaseMetaData.class.getClassLoader(),
+            new Class<?>[]{DatabaseMetaData.class},
+            (proxy, method, args) -> switch (method.getName()) {
+                case "getDatabaseProductName" -> databaseProductName;
+                case "unwrap" -> null;
+                case "isWrapperFor" -> false;
+                default -> throw new UnsupportedOperationException(method.getName());
+            }
+        );
+        return connection(metaData);
+    }
+
+    private Connection connection(DatabaseMetaData metaData) {
+        return (Connection) Proxy.newProxyInstance(
+            Connection.class.getClassLoader(),
+            new Class<?>[]{Connection.class},
+            (proxy, method, args) -> switch (method.getName()) {
+                case "getMetaData" -> metaData;
+                case "unwrap" -> null;
+                case "isWrapperFor" -> false;
+                default -> throw new UnsupportedOperationException(method.getName());
+            }
+        );
+    }
+}

data-model/build.gradle

@@ -24,4 +24,5 @@ dependencies {
     testImplementation mn.micronaut.inject.java.test
     testImplementation mnSerde.micronaut.serde.jackson
     testImplementation mn.micronaut.jackson.databind
+    testImplementation(mnTest.micronaut.test.junit5)
 }

data-model/src/main/java/io/micronaut/data/model/query/builder/sql/Dialect.java

@@ -60,15 +60,19 @@ public enum Dialect {
     /**
      * Postgres 9.5 or later.
      */
-    POSTGRES(true, false, ALL_TYPES, false, true, true, true),
+    POSTGRES(true, false, ALL_TYPES, false, true, true, true, true),
     /**
      * SQL server 2012 or above.
      */
-    SQL_SERVER(false, false, ALL_TYPES),
+    SQL_SERVER(false, false, ALL_TYPES, false, false, false, false, true),
     /**
      * Oracle 12c or above.
      */
-    ORACLE(true, true, ALL_TYPES, true, true, true, true),
+    ORACLE(true, true, ALL_TYPES, true, true, true, true, true),
+    /**
+     * SQLite
+     */
+    SQLITE(false, false, ALL_TYPES, false, true, true, true, false),
     /**
      * Ansi compliant SQL.
      */
@@ -84,6 +88,8 @@ public enum Dialect {
     private final boolean supportsUpdateReturning;
     private final boolean supportsInsertReturning;
     private final boolean supportsDeleteReturning;
+    private final boolean supportsReadOnly;
+
 
     /**
      * Allows customization of batch support.
@@ -93,7 +99,7 @@ public enum Dialect {
      * @param joinTypesSupported EnumSet of supported join types.
      */
     Dialect(boolean supportsBatch, boolean stringUUID, EnumSet<Join.Type> joinTypesSupported) {
-        this(supportsBatch, stringUUID, joinTypesSupported, false, false, false, false);
+        this(supportsBatch, stringUUID, joinTypesSupported, false, false, false, false, true);
     }
 
     /**
@@ -106,6 +112,7 @@ public enum Dialect {
      * @param supportsUpdateReturning Whether the dialect supports UPDATE ... RETURNING clause.
      * @param supportsInsertReturning Whether the dialect supports INSERT ... RETURNING clause.
      * @param supportsDeleteReturning Whether the dialect supports DELETE ... RETURNING clause.
+     * @param supportsReadOnly Whether the dialect supports invoking {@link java.sql.Connection#setReadOnly(boolean)}
      * @since 4.2.0
      */
     Dialect(boolean supportsBatch,
@@ -114,14 +121,16 @@ public enum Dialect {
             boolean supportsJsonEntity,
             boolean supportsUpdateReturning,
             boolean supportsInsertReturning,
-            boolean supportsDeleteReturning) {
+            boolean supportsDeleteReturning,
+            boolean supportsReadOnly) {
         this.supportsBatch = supportsBatch;
         this.stringUUID = stringUUID;
         this.joinTypesSupported = joinTypesSupported;
         this.supportsJsonEntity = supportsJsonEntity;
         this.supportsUpdateReturning = supportsUpdateReturning;
         this.supportsInsertReturning = supportsInsertReturning;
         this.supportsDeleteReturning = supportsDeleteReturning;
+        this.supportsReadOnly = supportsReadOnly;
     }
 
     /**
@@ -210,4 +219,14 @@ public boolean supportsInsertReturning() {
     public boolean supportsDeleteReturning() {
         return supportsDeleteReturning;
     }
+
+    /**
+     * Whether the dialect supports read only. e.g. invoking {@link java.sql.Connection#setReadOnly(boolean)}.
+     *
+     * @return true if it does support
+     * @since 5.0.0
+     */
+    public boolean supportsReadOnly() {
+        return supportsReadOnly;
+    }
 }

data-model/src/main/java/io/micronaut/data/model/query/builder/sql/SqlQueryBuilder.java

@@ -1229,9 +1229,13 @@ public String[] getPropertyPath() {
                 });
             }
 
-            builder = INSERT_INTO + getTableName(entity) +
-                " (" + String.join(",", columns) + CLOSE_BRACKET + " " +
-                "VALUES (" + String.join(String.valueOf(COMMA), values) + CLOSE_BRACKET;
+            if (columns.isEmpty()) {
+                builder = INSERT_INTO + getTableName(entity) + " DEFAULT VALUES";
+            } else {
+                builder = INSERT_INTO + getTableName(entity) +
+                    " (" + String.join(",", columns) + CLOSE_BRACKET + " " +
+                    "VALUES (" + String.join(String.valueOf(COMMA), values) + CLOSE_BRACKET;
+            }
 
             if (definition.returning()) {
                 if (dialect == Dialect.ORACLE) {

data-model/src/main/java/io/micronaut/data/model/schema/sql/SqlColumnMapping.java

@@ -250,6 +250,11 @@ public  String getSqlType(Dialect dialect) {
             case LONG -> {
                 if (dialect == Dialect.ORACLE) {
                     yield "NUMBER(19)";
+
+                    // In SQLite, INTEGER PRIMARY KEY has special behavior (rowid, auto-generation).
+                } else if (dialect == Dialect.SQLITE && isAutoGenerated()) {
+                    yield "INTEGER";
+
                 } else {
                     yield "BIGINT";
                 }