feat: add DuckDB as a supported database

Add DuckDB as an embedded database alongside SQLite. Includes a
workaround for the JDBC driver's TIME type timezone offset issue
by using string serialization.

Author: driessamyn

.github/workflows/build-and-test.yml

@@ -80,7 +80,7 @@ jobs:
       - build
     strategy:
       matrix:
-        db: [ POSTGRESQL, MYSQL, SQLITE, MSSQLSERVER, ORACLE ]
+        db: [ POSTGRESQL, MYSQL, SQLITE, MSSQLSERVER, ORACLE, DUCKDB ]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
         with:

core/src/integrationTest/kotlin/net/samyn/kapper/AbstractDbTests.kt

@@ -34,6 +34,7 @@ abstract class AbstractDbTests {
     companion object {
         init {
             Class.forName("org.sqlite.JDBC")
+            Class.forName("org.duckdb.DuckDBDriver")
         }
 
         private val postgresql by lazy {
@@ -74,13 +75,14 @@ abstract class AbstractDbTests {
                 DbFlavour.POSTGRESQL to { getConnection(postgresql) },
                 DbFlavour.MYSQL to { getConnection(mysql) },
                 DbFlavour.SQLITE to { DriverManager.getConnection("jdbc:sqlite::memory:") },
+                DbFlavour.DUCKDB to { DriverManager.getConnection("jdbc:duckdb:") },
                 DbFlavour.MSSQLSERVER to { getConnection(msSqlServer) },
                 DbFlavour.ORACLE to { getConnection(oracle) },
             ).filter {
                 // by default run against SQLite and PG only
                 //  this allows parallel runs for different int tests.
                 when (System.getProperty("db", "").uppercase()) {
-                    "" -> it.key == DbFlavour.SQLITE || it.key == DbFlavour.POSTGRESQL
+                    "" -> it.key == DbFlavour.SQLITE || it.key == DbFlavour.POSTGRESQL || it.key == DbFlavour.DUCKDB
                     "ALL" -> true
                     else -> it.key == DbFlavour.valueOf(System.getProperty("db").uppercase())
                 }

core/src/integrationTest/kotlin/net/samyn/kapper/DbTypeConverter.kt

@@ -15,16 +15,19 @@ private val specialTypes =
                 DbFlavour.MYSQL to "TEXT",
                 DbFlavour.POSTGRESQL to "TEXT",
                 DbFlavour.MSSQLSERVER to "NVARCHAR(MAX)",
+                DbFlavour.DUCKDB to "VARCHAR",
             ),
         "BINARY" to
             mapOf(
                 DbFlavour.POSTGRESQL to "BYTEA",
                 DbFlavour.ORACLE to "RAW(128)",
+                DbFlavour.DUCKDB to "BLOB",
             ),
         "VARBINARY" to
             mapOf(
                 DbFlavour.POSTGRESQL to "BYTEA",
                 DbFlavour.ORACLE to "RAW(128)",
+                DbFlavour.DUCKDB to "BLOB",
             ),
         "BLOB" to
             mapOf(

core/src/main/kotlin/net/samyn/kapper/DbFlavour.kt

@@ -6,5 +6,6 @@ enum class DbFlavour {
     SQLITE,
     ORACLE,
     MSSQLSERVER,
+    DUCKDB,
     UNKNOWN,
 }

core/src/main/kotlin/net/samyn/kapper/internal/DbFlavourFunc.kt

@@ -15,6 +15,7 @@ fun Connection.getDbFlavour(): DbFlavour {
         productName.contains("oracle", ignoreCase = true) -> DbFlavour.ORACLE
         productName.contains("sql server", ignoreCase = true) ||
             productName.contains("mssql", ignoreCase = true) -> DbFlavour.MSSQLSERVER
+        productName.contains("duckdb", ignoreCase = true) -> DbFlavour.DUCKDB
         else -> DbFlavour.UNKNOWN
     }
 }

core/src/main/kotlin/net/samyn/kapper/internal/automapper/SQLTypesConverter.kt

@@ -67,7 +67,7 @@ val sqlTypesConverter =
             JDBCType.JAVA_OBJECT,
             -> resultSet.getObject(field.columnIndex)
 
-            in TIME_TYPES -> resultSet.getTime(field.columnIndex)?.toLocalTime()
+            in TIME_TYPES -> convertTime(resultSet, field.columnIndex, field.dbFlavour)
 
             in TIMESTAMP_TYPES -> convertTimestamp(resultSet, field.columnIndex, field.typeName)
 
@@ -163,6 +163,18 @@ fun ResultSet.getNullableDouble(columnIndex: Int): Double? {
     return dbValue
 }
 
+fun convertTime(
+    resultSet: ResultSet,
+    fieldIndex: Int,
+    dbFlavour: DbFlavour,
+): LocalTime? =
+    when (dbFlavour) {
+        // DuckDB's JDBC driver stores TIME in UTC; using getTime() with the default
+        // calendar applies a timezone offset. Reading as String avoids this.
+        DbFlavour.DUCKDB -> resultSet.getString(fieldIndex)?.let { LocalTime.parse(it) }
+        else -> resultSet.getTime(fieldIndex)?.toLocalTime()
+    }
+
 fun convertDecimal(
     resultSet: ResultSet,
     fieldIndex: Int,
@@ -217,7 +229,13 @@ fun PreparedStatement.setParameter(
         is Date -> setDate(index, java.sql.Date(value.time))
         is LocalDate -> setDate(index, java.sql.Date.valueOf(value))
         is LocalDateTime -> setTimestamp(index, Timestamp.from(value.atZone(java.time.ZoneOffset.systemDefault()).toInstant()))
-        is LocalTime -> setTime(index, java.sql.Time.valueOf(value))
+        is LocalTime ->
+            when (dbFlavour) {
+                // DuckDB's JDBC driver applies a timezone offset with setTime/getTime;
+                // using setString avoids the conversion and preserves the intended value.
+                DbFlavour.DUCKDB -> setString(index, value.toString())
+                else -> setTime(index, java.sql.Time.valueOf(value))
+            }
         else -> setObject(index, value)
     }
 }

gradle/libs.versions.toml

@@ -13,6 +13,7 @@ mysql-driver = "9.6.0"
 oracle-driver = "23.26.0.0.0"
 postgresql-driver = "42.7.8"
 slf4j = "2.0.17"
+duckdb = "1.2.2.0"
 sqlite = "3.51.2.0"
 test-containers = "1.21.4"
 
@@ -39,6 +40,7 @@ oracle-driver = { module = "com.oracle.database.jdbc:ojdbc11", version.ref = "or
 postgresql-driver = { module = "org.postgresql:postgresql", version.ref = "postgresql-driver" }
 slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
+duckdb-jdbc = { module = "org.duckdb:duckdb_jdbc", version.ref = "duckdb" }
 sqlite-jdbc = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" }
 test-containers = { module = "org.testcontainers:testcontainers", version.ref = "test-containers" }
 test-containers-junit = { module = "org.testcontainers:junit-jupiter", version.ref = "test-containers" }
@@ -79,7 +81,7 @@ test-containers = [
     "test-containers-mssqlserver",
     "test-containers-oracle"
 ]
-test-dbs = ["mysql-driver", "postgresql-driver", "sqlite-jdbc", "mssql-server-driver", "oracle-driver"]
+test-dbs = ["mysql-driver", "postgresql-driver", "sqlite-jdbc", "duckdb-jdbc", "mssql-server-driver", "oracle-driver"]
 
 # Example bundles
 hibernate = ["hibernate-core", "hibernate-validator", "glassfish-jakarta"]