feat: add MariaDB as a compatibility-tested database

MariaDB is MySQL wire-compatible and maps to DbFlavour.MYSQL.
Runs in a separate nightly compatibility-test CI job, also
triggerable via workflow_dispatch or 'run-compat-tests' label.

Author: driessamyn

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

@@ -4,6 +4,10 @@ on:
     branches: [ main ]
   pull_request:
     branches: [ main, feature/* ]
+    types: [ opened, synchronize, reopened, labeled ]
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch:
 
 permissions:
   checks: write
@@ -76,6 +80,7 @@ jobs:
   integration-test:
     name: Integration tests
     runs-on: ubuntu-latest
+    if: github.event_name == 'push' || github.event_name == 'pull_request'
     needs:
       - build
     strategy:
@@ -112,3 +117,39 @@ jobs:
           check_name: ${{ matrix.db }} Integration Tests
           files: |
             **/build/test-results/integrationTest/TEST-*.xml
+
+  compatibility-test:
+    name: Compatibility tests
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' || contains(github.event.pull_request.labels.*.name, 'run-compat-tests')
+    strategy:
+      matrix:
+        db: [ MARIADB ]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
+        with:
+          fetch-depth: 0
+      - name: Set up JDK 17
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654
+        with:
+          java-version: '17'
+          distribution: 'zulu'
+          cache: 'gradle'
+      - name: Compatibility tests
+        run: ./gradlew integrationTest -Ddb=${{ matrix.db }}
+      - name: Upload Test Report
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f
+        if: always()
+        with:
+          name: ${{ matrix.db }}-compat-test-results
+          path: '**/build/test-results/integrationTest/TEST-*.xml'
+          retention-days: 1
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action@c950f6fb443cb5af20a377fd0dfaa78838901040
+        if: always()
+        with:
+          check_name: ${{ matrix.db }} Compatibility Tests
+          files: |
+            **/build/test-results/integrationTest/TEST-*.xml

README.md

@@ -21,6 +21,7 @@ Kapper is a lightweight, Dapper-inspired ORM (Object-Relational Mapping) library
 ![Oracle](https://img.shields.io/badge/oracle-F80000.svg?style=for-the-badge&logo=oracle&logoColor=white)
 ![MSSQL](https://img.shields.io/badge/mssql-%23CC2927.svg?style=for-the-badge&logo=microsoftsqlserver&logoColor=white)
 ![DuckDB](https://img.shields.io/badge/duckdb-FFF000.svg?style=for-the-badge&logo=duckdb&logoColor=black)
+![MariaDB](https://img.shields.io/badge/mariadb-003545.svg?style=for-the-badge&logo=mariadb&logoColor=white)
 
 See [Kapper](https://driessamyn.github.io/kapper/) for more information.
 

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

@@ -12,6 +12,7 @@ import org.junit.jupiter.params.provider.Arguments.arguments
 import org.junit.jupiter.params.provider.MethodSource
 import org.testcontainers.containers.JdbcDatabaseContainer
 import org.testcontainers.containers.MSSQLServerContainer
+import org.testcontainers.containers.MariaDBContainer
 import org.testcontainers.containers.MySQLContainer
 import org.testcontainers.containers.PostgreSQLContainer
 import org.testcontainers.oracle.OracleContainer
@@ -52,6 +53,10 @@ abstract class AbstractDbTests {
                 .also { it.start() }
         }
 
+        private val mariadb by lazy {
+            MariaDBContainer("mariadb:11.7").also { it.start() }
+        }
+
         private val msSqlServer by lazy {
             MSSQLServerContainer("mcr.microsoft.com/mssql/server:2017-CU12")
                 .acceptLicense()
@@ -63,29 +68,37 @@ abstract class AbstractDbTests {
                 }
         }
 
-        private val connections = ConcurrentHashMap<DbFlavour, Connection>()
+        private val connections = ConcurrentHashMap<String, Connection>()
 
         private fun getConnection(container: JdbcDatabaseContainer<*>): Connection {
             Class.forName(container.driverClassName)
             return DriverManager.getConnection(container.jdbcUrl, container.username, container.password)
         }
 
-        val dbs =
+        // Use string keys so that MariaDB (which resolves to DbFlavour.MYSQL) can be a separate entry
+        private val selectedDb = System.getProperty("db", "").trim().uppercase()
+        private val allDbs =
             mapOf(
-                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, PG and DuckDB 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.DUCKDB
-                    "ALL" -> true
-                    else -> it.key == DbFlavour.valueOf(System.getProperty("db").uppercase())
-                }
+                "POSTGRESQL" to { getConnection(postgresql) },
+                "MYSQL" to { getConnection(mysql) },
+                "SQLITE" to { DriverManager.getConnection("jdbc:sqlite::memory:") },
+                "DUCKDB" to { DriverManager.getConnection("jdbc:duckdb:") },
+                "MSSQLSERVER" to { getConnection(msSqlServer) },
+                "ORACLE" to { getConnection(oracle) },
+                "MARIADB" to { getConnection(mariadb) },
+            )
+
+        val dbs =
+            when (selectedDb) {
+                "" -> allDbs.filterKeys { it == "SQLITE" || it == "POSTGRESQL" || it == "DUCKDB" }
+                "ALL" -> allDbs
+                else ->
+                    mapOf(
+                        selectedDb to
+                            requireNotNull(allDbs[selectedDb]) {
+                                "Unsupported db '$selectedDb'. Expected one of ${allDbs.keys.sorted().joinToString()}"
+                            },
+                    )
             }
 
         @JvmStatic
@@ -96,7 +109,7 @@ abstract class AbstractDbTests {
                 connections
                     .map {
                         println("   ${it.key}")
-                        arguments(named(it.key.toString(), it.value))
+                        arguments(named(it.key, it.value))
                     }
             println("--------------------------------")
             return connections

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

@@ -10,7 +10,8 @@ fun Connection.getDbFlavour(): DbFlavour {
     return when {
         productName.contains("postgres", ignoreCase = true) ||
             productName.contains("enterprisedb", ignoreCase = true) -> DbFlavour.POSTGRESQL
-        productName.contains("mysql", ignoreCase = true) -> DbFlavour.MYSQL
+        productName.contains("mysql", ignoreCase = true) ||
+            productName.contains("mariadb", ignoreCase = true) -> DbFlavour.MYSQL
         productName.contains("sqlite", ignoreCase = true) -> DbFlavour.SQLITE
         productName.contains("oracle", ignoreCase = true) -> DbFlavour.ORACLE
         productName.contains("sql server", ignoreCase = true) ||

core/src/test/kotlin/net/samyn/kapper/internal/DbFlavourTest.kt

@@ -33,6 +33,7 @@ class DbFlavourTest {
                 "MySQL Server",
                 "MySQL Community Server",
                 "MySQL Enterprise Server",
+                "MariaDB",
             ],
     )
     fun `when databaseProductName is mysql then getDbFlavour returns MYSQL`(value: String) {
@@ -132,7 +133,6 @@ class DbFlavourTest {
                 "IDS",
 
                 // Other common databases
-                "MariaDB",
                 "H2",
                 "HSQL Database Engine",
                 "HSQLDB",

gradle/libs.versions.toml

@@ -8,6 +8,7 @@ kotlin = "2.2.21"
 kotlinx-coroutines = "1.10.2"
 mockito = "5.20.0"
 mockk = "1.14.9"
+mariadb-driver = "3.5.3"
 mssql-server-driver = "13.2.1.jre11"
 mysql-driver = "9.6.0"
 oracle-driver = "23.26.0.0.0"
@@ -34,6 +35,7 @@ kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-t
 # mockito only to be used from Java code (API usability test)
 mockito = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
+mariadb-driver = { module = "org.mariadb.jdbc:mariadb-java-client", version.ref = "mariadb-driver" }
 mssql-server-driver = { module = "com.microsoft.sqlserver:mssql-jdbc", version.ref = "mssql-server-driver" }
 mysql-driver = { module = "com.mysql:mysql-connector-j", version.ref = "mysql-driver" }
 oracle-driver = { module = "com.oracle.database.jdbc:ojdbc11", version.ref = "oracle-driver" }
@@ -47,6 +49,7 @@ test-containers-junit = { module = "org.testcontainers:junit-jupiter", version.r
 test-containers-mssqlserver = { module = "org.testcontainers:mssqlserver", version.ref = "test-containers" }
 test-containers-mysql = { module = "org.testcontainers:mysql", version.ref = "test-containers" }
 test-containers-oracle = { module = "org.testcontainers:oracle-free", version.ref = "test-containers" }
+test-containers-mariadb = { module = "org.testcontainers:mariadb", version.ref = "test-containers" }
 test-containers-postgresql = { module = "org.testcontainers:postgresql", version.ref = "test-containers" }
 
 # Example dependencies
@@ -76,12 +79,13 @@ jmh = ["jmh-core", "jmh-generator-annprocess"]
 test = ["junit-jupiter", "mockk", "kotest-assertions-core"]
 test-containers = [
     "test-containers-junit",
+    "test-containers-mariadb",
     "test-containers-mysql",
     "test-containers-postgresql",
     "test-containers-mssqlserver",
     "test-containers-oracle"
 ]
-test-dbs = ["mysql-driver", "postgresql-driver", "sqlite-jdbc", "duckdb-jdbc", "mssql-server-driver", "oracle-driver"]
+test-dbs = ["mariadb-driver", "mysql-driver", "postgresql-driver", "sqlite-jdbc", "duckdb-jdbc", "mssql-server-driver", "oracle-driver"]
 
 # Example bundles
 hibernate = ["hibernate-core", "hibernate-validator", "glassfish-jakarta"]