Ass back support for ucp and sqlite

Author: radovanradic

jdbc-ucp/src/main/java/io/micronaut/configuration/jdbc/ucp/DatasourceFactory.java

@@ -85,7 +85,7 @@ public PoolDataSource dataSource(DatasourceConfiguration datasourceConfiguration
         PoolDataSource ds = datasourceConfiguration.getPoolDataSource();
         dataSources.put(datasourceConfiguration.getName(), ds);
 
-        return ds;
+        return UcpSqliteProxyFactory.wrap(ds, datasourceConfiguration.getDriverClassName(), datasourceConfiguration.getUrl());
     }
 
     /**

jdbc-ucp/src/main/java/io/micronaut/configuration/jdbc/ucp/UcpSqliteProxyFactory.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2017-2026 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.configuration.jdbc.ucp;
+
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.jdbc.DelegatingDataSource;
+import io.micronaut.jdbc.JdbcSqliteSupport;
+import oracle.ucp.jdbc.PoolDataSource;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+/**
+ * Creates SQLite-aware proxies for UCP datasources while preserving the {@link PoolDataSource} type.
+ *
+ * @since 7.0.0
+ */
+@Internal
+final class UcpSqliteProxyFactory {
+
+    private UcpSqliteProxyFactory() {
+    }
+
+    static PoolDataSource wrap(PoolDataSource dataSource, String driverClassName, String jdbcUrl) {
+        if (!JdbcSqliteSupport.isSqlite(driverClassName, jdbcUrl) || dataSource instanceof DelegatingDataSource) {
+            return dataSource;
+        }
+        return (PoolDataSource) Proxy.newProxyInstance(
+                dataSource.getClass().getClassLoader(),
+                new Class<?>[]{PoolDataSource.class, DelegatingDataSource.class},
+                new PoolDataSourceInvocationHandler(dataSource)
+        );
+    }
+
+    private static final class PoolDataSourceInvocationHandler implements InvocationHandler {
+
+        private final PoolDataSource target;
+
+        private PoolDataSourceInvocationHandler(PoolDataSource target) {
+            this.target = target;
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            String methodName = method.getName();
+            if ("getTargetDataSource".equals(methodName) && (args == null || args.length == 0)) {
+                return target;
+            }
+            if ("getConnection".equals(methodName)) {
+                return wrapConnection(method, args);
+            }
+            if ("unwrap".equals(methodName) && args != null && args.length == 1 && args[0] instanceof Class<?> unwrapType) {
+                if (unwrapType.isInstance(proxy)) {
+                    return proxy;
+                }
+                if (unwrapType.isInstance(target)) {
+                    return target;
+                }
+                return target.unwrap(unwrapType);
+            }
+            if ("isWrapperFor".equals(methodName) && args != null && args.length == 1 && args[0] instanceof Class<?> unwrapType) {
+                return unwrapType.isInstance(proxy) || unwrapType.isInstance(target) || target.isWrapperFor(unwrapType);
+            }
+            if ("equals".equals(methodName) && args != null && args.length == 1) {
+                return proxy == args[0];
+            }
+            if ("hashCode".equals(methodName) && (args == null || args.length == 0)) {
+                return System.identityHashCode(proxy);
+            }
+            if ("toString".equals(methodName) && (args == null || args.length == 0)) {
+                return target.toString();
+            }
+            try {
+                return method.invoke(target, args);
+            } catch (InvocationTargetException e) {
+                throw e.getCause();
+            }
+        }
+
+        private Connection wrapConnection(Method method, Object[] args) throws Throwable {
+            try {
+                return JdbcSqliteSupport.wrapSqliteConnection((Connection) method.invoke(target, args));
+            } catch (InvocationTargetException e) {
+                throw e.getCause();
+            } catch (SQLException e) {
+                throw e;
+            }
+        }
+    }
+}

jdbc-ucp/src/test/groovy/io/micronaut/configuration/jdbc/ucp/UcpSqliteProxyFactorySpec.groovy

@@ -0,0 +1,49 @@
+package io.micronaut.configuration.jdbc.ucp
+
+import io.micronaut.jdbc.DataSourceResolver
+import io.micronaut.jdbc.SQLiteAwareDataSourceResolver
+import oracle.ucp.jdbc.PoolDataSource
+import spock.lang.Specification
+
+import java.sql.Connection
+import java.sql.SQLException
+
+class UcpSqliteProxyFactorySpec extends Specification {
+
+    private static final String SQLITE_READ_ONLY_MESSAGE = "Cannot change read-only flag after establishing a connection. Use SQLiteConfig#setReadOnly and SQLiteConfig.createConnection()."
+
+    void "sqlite proxy preserves pool data source type and unwraps target"() {
+        given:
+        Connection connection = Mock() {
+            isReadOnly() >> false
+            setReadOnly(true) >> { throw new SQLException(SQLITE_READ_ONLY_MESSAGE) }
+        }
+        PoolDataSource target = Mock() {
+            getConnection() >> connection
+        }
+        DataSourceResolver resolver = new SQLiteAwareDataSourceResolver()
+
+        when:
+        PoolDataSource proxied = UcpSqliteProxyFactory.wrap(target, "org.sqlite.JDBC", "jdbc:sqlite:file:test")
+
+        then:
+        proxied instanceof PoolDataSource
+        resolver.resolve(proxied).is(target)
+
+        when:
+        Connection wrapped = proxied.getConnection()
+        wrapped.setReadOnly(true)
+
+        then:
+        noExceptionThrown()
+        wrapped.isReadOnly()
+    }
+
+    void "non sqlite pool data source is unchanged"() {
+        given:
+        PoolDataSource target = Mock()
+
+        expect:
+        UcpSqliteProxyFactory.wrap(target, "org.h2.Driver", "jdbc:h2:mem:test").is(target)
+    }
+}

jdbc/src/main/java/io/micronaut/jdbc/DelegatingDataSource.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017-2026 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.jdbc;
+
+import io.micronaut.core.annotation.Internal;
+
+import javax.sql.DataSource;
+
+/**
+ * Internal contract for datasource wrappers that can expose their underlying target datasource.
+ *
+ * @since 7.0.0
+ */
+@Internal
+public interface DelegatingDataSource extends DataSource {
+
+    /**
+     * @return The underlying target datasource
+     */
+    DataSource getTargetDataSource();
+}

jdbc/src/main/java/io/micronaut/jdbc/JdbcSqliteSupport.java

@@ -105,15 +105,16 @@ public static Connection wrapSqliteConnection(Connection connection) throws SQLE
         );
     }
 
-    static final class SQLiteAwareDataSource implements DataSource {
+    static final class SQLiteAwareDataSource implements DelegatingDataSource {
 
         private final DataSource targetDataSource;
 
         private SQLiteAwareDataSource(DataSource targetDataSource) {
             this.targetDataSource = targetDataSource;
         }
 
-        DataSource getTargetDataSource() {
+        @Override
+        public DataSource getTargetDataSource() {
             return targetDataSource;
         }
 

jdbc/src/main/java/io/micronaut/jdbc/SQLiteAwareDataSourceResolver.java

@@ -31,8 +31,8 @@ public final class SQLiteAwareDataSourceResolver implements DataSourceResolver {
 
     @Override
     public DataSource resolve(DataSource dataSource) {
-        if (dataSource instanceof JdbcSqliteSupport.SQLiteAwareDataSource sqliteAwareDataSource) {
-            return sqliteAwareDataSource.getTargetDataSource();
+        if (dataSource instanceof DelegatingDataSource delegatingDataSource) {
+            return delegatingDataSource.getTargetDataSource();
         }
         return dataSource;
     }

settings.gradle

@@ -69,6 +69,7 @@ include 'tests:jooq-tests:jooq-r2dbc-postgres'
 include 'tests:vertx-pg-client-native'
 
 include 'tests:jdbc-ucp-tests:jdbc-ucp-oracle'
+include 'tests:jdbc-ucp-tests:jdbc-ucp-sqlite'
 include 'tests:jdbc-dbcp-tests:jdbc-dbcp-postgres'
 include 'tests:jdbc-hikari-tests:jdbc-hikari-h2'
 include 'tests:jdbc-hikari-tests:jdbc-hikari-sqlite'

tests/jdbc-ucp-tests/jdbc-ucp-sqlite/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+    id 'io.micronaut.build.internal.test-application'
+}
+
+dependencies {
+    implementation projects.micronautJdbcUcp
+    implementation projects.micronautTests.micronautCommonSync
+
+    runtimeOnly libs.managed.sqlite.jdbc
+
+    testRuntimeOnly(mnLogging.logback.classic)
+    testImplementation projects.micronautTests.micronautCommonTests
+    testImplementation(mnData.micronaut.data.tx.jdbc)
+}
+
+micronaut {
+    testResources {
+        enabled = false
+    }
+}

tests/jdbc-ucp-tests/jdbc-ucp-sqlite/src/main/java/example/jdbc/ucp/sqlite/Owner.java

@@ -0,0 +1,52 @@
+package example.jdbc.ucp.sqlite;
+
+import example.domain.IOwner;
+import io.micronaut.core.annotation.Creator;
+import io.micronaut.serde.annotation.Serdeable;
+
+@Serdeable
+public class Owner implements IOwner {
+
+    private Long id;
+    private String name;
+    private int age;
+
+    Owner() {
+    }
+
+    @Creator
+    public Owner(Long id, String name, int age) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+    }
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public int getAge() {
+        return age;
+    }
+
+    @Override
+    public void setAge(int age) {
+        this.age = age;
+    }
+}