fix: queries for DB2 dialect

Author: davidfrigolet

community/flamingock-auditstore-sql/src/main/java/io/flamingock/community/sql/internal/SqlAuditorDialectHelper.java

@@ -138,28 +138,33 @@ public String getCreateTableSqlString(String tableName) {
                                 ")'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -955 THEN RAISE; END IF; END;", tableName, getAutoIncrementType(), getClobType(), getBigIntType(), getClobType(), getBooleanType(), getBooleanType());
             case DB2:
                 return String.format(
-                        "CREATE TABLE %s (" +
-                                "id %s PRIMARY KEY, " +
-                                "execution_id VARCHAR(255), " +
-                                "stage_id VARCHAR(255), " +
-                                "task_id VARCHAR(255), " +
-                                "author VARCHAR(255), " +
-                                "created_at TIMESTAMP DEFAULT CURRENT TIMESTAMP, " +
-                                "state VARCHAR(255), " +
-                                "class_name VARCHAR(255), " +
-                                "method_name VARCHAR(255), " +
-                                "metadata %s, " +
-                                "execution_millis %s, " +
-                                "execution_hostname VARCHAR(255), " +
-                                "error_trace %s, " +
-                                "type VARCHAR(50), " +
-                                "tx_type VARCHAR(50), " +
-                                "target_system_id VARCHAR(255), " +
-                                "order_col VARCHAR(50), " +
-                                "recovery_strategy VARCHAR(50), " +
-                                "transaction_flag %s, " +
-                                "system_change %s" +
-                                ")", tableName, getAutoIncrementType(), getClobType(), getBigIntType(), getClobType(), getBooleanType(), getBooleanType());
+                        "BEGIN\n" +
+                                "  DECLARE CONTINUE HANDLER FOR SQLSTATE '42710' BEGIN END;\n" +
+                                "  EXECUTE IMMEDIATE 'CREATE TABLE %s (" +
+                                "id BIGINT NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1) PRIMARY KEY," +
+                                "execution_id VARCHAR(255)," +
+                                "stage_id VARCHAR(255)," +
+                                "task_id VARCHAR(255)," +
+                                "author VARCHAR(255)," +
+                                "created_at TIMESTAMP," +
+                                "state VARCHAR(32)," +
+                                "class_name VARCHAR(255)," +
+                                "method_name VARCHAR(255)," +
+                                "metadata CLOB," +
+                                "execution_millis BIGINT," +
+                                "execution_hostname VARCHAR(255)," +
+                                "error_trace CLOB," +
+                                "type VARCHAR(50)," +
+                                "tx_type VARCHAR(50)," +
+                                "target_system_id VARCHAR(255)," +
+                                "order_col VARCHAR(50)," +
+                                "recovery_strategy VARCHAR(50)," +
+                                "transaction_flag SMALLINT," +
+                                "system_change SMALLINT" +
+                                ")';\n" +
+                                "END",
+                        tableName);
+
             case SQLITE:
                 return String.format(
                         "CREATE TABLE IF NOT EXISTS %s (" +

community/flamingock-auditstore-sql/src/main/java/io/flamingock/community/sql/internal/SqlLockDialectHelper.java

@@ -78,12 +78,14 @@ public String getCreateTableSqlString(String tableName) {
                                 ")'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -955 THEN RAISE; END IF; END;", tableName);
             case DB2:
                 return String.format(
-                        "CREATE TABLE %s (" +
-                                "\"key\" VARCHAR(255) PRIMARY KEY," +
-                                "status VARCHAR(32)," +
-                                "owner VARCHAR(255)," +
-                                "expires_at TIMESTAMP" +
-                                ")", tableName);
+                        "BEGIN " +
+                                "DECLARE CONTINUE HANDLER FOR SQLSTATE '42710' BEGIN END; " +
+                                "EXECUTE IMMEDIATE 'CREATE TABLE %s (" +
+                                "lock_key VARCHAR(255) NOT NULL PRIMARY KEY, " +
+                                "status VARCHAR(32), " +
+                                "owner VARCHAR(255), " +
+                                "expires_at TIMESTAMP)'; " +
+                                "END", tableName);
             default:
                 throw new UnsupportedOperationException("Dialect not supported for CREATE TABLE: " + sqlDialect.name());
         }
@@ -93,6 +95,9 @@ public String getSelectLockSqlString(String tableName) {
         switch (sqlDialect) {
             case POSTGRESQL:
                 return String.format("SELECT \"key\", status, owner, expires_at FROM %s WHERE \"key\" = ?", tableName);
+            case DB2:
+                // Select lock_key as the first column (getLockEntry expects rs.getString(1) to be the key)
+                return String.format("SELECT lock_key, status, owner, expires_at FROM %s WHERE lock_key = ?", tableName);
             case SQLSERVER:
             case SYBASE:
                 return String.format("SELECT [key], status, owner, expires_at FROM %s WITH (UPDLOCK, ROWLOCK) WHERE [key] = ?", tableName);
@@ -145,12 +150,13 @@ public String getInsertOrUpdateLockSqlString(String tableName) {
                         "MERGE INTO %s (`key`, status, owner, expires_at) KEY (`key`) VALUES (?, ?, ?, ?)",
                         tableName);
             case DB2:
+                // Use a VALUES-derived table and a target alias for DB2 to avoid parsing issues
                 return String.format(
-                        "MERGE INTO %s USING (SELECT ? AS \"key\", ? AS status, ? AS owner, ? AS expires_at FROM SYSIBM.SYSDUMMY1) AS src " +
-                                "ON (%s.\"key\" = src.\"key\") " +
+                        "MERGE INTO %s tgt USING (VALUES (?, ?, ?, ?)) src(lock_key, status, owner, expires_at) " +
+                                "ON (tgt.lock_key = src.lock_key) " +
                                 "WHEN MATCHED THEN UPDATE SET status = src.status, owner = src.owner, expires_at = src.expires_at " +
-                                "WHEN NOT MATCHED THEN INSERT (\"key\", status, owner, expires_at) VALUES (src.\"key\", src.status, src.owner, src.expires_at)",
-                        tableName, tableName);
+                                "WHEN NOT MATCHED THEN INSERT (lock_key, status, owner, expires_at) VALUES (src.lock_key, src.status, src.owner, src.expires_at)",
+                        tableName);
             case FIREBIRD:
                 return String.format(
                         "UPDATE OR INSERT INTO %s (`key`, status, owner, expires_at) VALUES (?, ?, ?, ?) MATCHING (`key`)",
@@ -164,12 +170,41 @@ public String getDeleteLockSqlString(String tableName) {
         if (Objects.requireNonNull(sqlDialect) == SqlDialect.POSTGRESQL) {
             return String.format("DELETE FROM %s WHERE \"key\" = ?", tableName);
         }
+        if (sqlDialect == SqlDialect.DB2) {
+            return String.format("DELETE FROM %s WHERE lock_key = ?", tableName);
+        }
         return String.format("DELETE FROM %s WHERE `key` = ?", tableName);
     }
 
     public void upsertLockEntry(Connection conn, String tableName, String key, String owner, LocalDateTime expiresAt) throws SQLException {
         String sql = getInsertOrUpdateLockSqlString(tableName);
 
+        if (sqlDialect == SqlDialect.DB2) {
+            // UPDATE first
+            try (PreparedStatement update = conn.prepareStatement(
+                    "UPDATE " + tableName + " SET owner = ?, expires_at = ? WHERE lock_key = ?")) {
+                update.setString(1, owner);
+                update.setTimestamp(2, Timestamp.valueOf(expiresAt));
+                update.setString(3, key);
+                int updated = update.executeUpdate();
+                if (updated > 0) {
+                    return;
+                }
+            }
+
+            // If no row updated, try INSERT
+            try (PreparedStatement insert = conn.prepareStatement(
+                    "INSERT INTO " + tableName + " (lock_key, status, owner, expires_at) VALUES (?, ?, ?, ?)")) {
+                insert.setString(1, key);
+                // Use "LOCKED" string to avoid using a non-existing enum constant (previous "ACQUIRED" caused failures)
+                insert.setString(2, LockStatus.LOCK_HELD.name());
+                insert.setString(3, owner);
+                insert.setTimestamp(4, Timestamp.valueOf(expiresAt));
+                insert.executeUpdate();
+                return;
+            }
+        }
+
         if (getSqlDialect() == SqlDialect.SQLSERVER || getSqlDialect() == SqlDialect.SYBASE) {
             // For SQL Server/Sybase, use Statement and format SQL
             try (Statement stmt = conn.createStatement()) {
@@ -186,6 +221,7 @@ public void upsertLockEntry(Connection conn, String tableName, String key, Strin
             }
         } else {
             try (PreparedStatement ps = conn.prepareStatement(sql)) {
+                // For DB2 we use lock_key but callers pass key as first parameter - that's correct
                 ps.setString(1, key);
                 ps.setString(2, LockStatus.LOCK_HELD.name());
                 ps.setString(3, owner);

community/flamingock-auditstore-sql/src/main/java/io/flamingock/community/sql/internal/SqlLockService.java

@@ -136,7 +136,7 @@ public void releaseLock(LockKey lockKey, RunnerId owner) {
         String keyStr = lockKey.toString();
         try (Connection conn = dataSource.getConnection();
              PreparedStatement ps = conn.prepareStatement(
-                     "SELECT owner FROM " + lockRepositoryName + " WHERE `key` = ?")) {
+                     dialectHelper.getSelectLockSqlString(lockRepositoryName))) {
             ps.setString(1, keyStr);
             try (ResultSet rs = ps.executeQuery()) {
                 if (rs.next()) {

community/flamingock-auditstore-sql/src/test/java/io/flamingock/community/sql/SqlAuditStoreTest.java

@@ -210,6 +210,7 @@ private Class<?>[] getChangeClasses(String dialectName, String scenario) {
                 }
                 break;
             case "postgresql":
+            case "db2":
                 if ("happyPath".equals(scenario)) {
                     return new Class<?>[]{
                             io.flamingock.community.sql.changes.postgresql.happyPath._001__create_index.class,

community/flamingock-auditstore-sql/src/test/java/io/flamingock/community/sql/SqlAuditTestHelper.java

@@ -91,6 +91,12 @@ private static String getCreateTestTableSql(SqlDialect dialect) {
                         "name VARCHAR2(255), " +
                         "field1 VARCHAR2(255), " +
                         "field2 VARCHAR2(255))";
+            case DB2:
+                return "CREATE TABLE test_table (" +
+                        "id VARCHAR(255) PRIMARY KEY," +
+                        "name VARCHAR(255)," +
+                        "field1 VARCHAR(255)," +
+                        "field2 VARCHAR(255))";
             default:
                 throw new UnsupportedOperationException("Dialect not supported: " + dialect);
         }
@@ -128,6 +134,13 @@ private static String getCreateLockTableSql(SqlDialect dialect) {
                         "status VARCHAR2(32), " +
                         "owner VARCHAR2(255), " +
                         "expires_at TIMESTAMP)";
+            case DB2:
+                // Use lock_key in DB2 test DDL to match runtime helper and avoid reserved-key issues
+                return "CREATE TABLE flamingockLock (" +
+                        "lock_key VARCHAR(255) PRIMARY KEY, " +
+                        "status VARCHAR(32), " +
+                        "owner VARCHAR(255), " +
+                        "expires_at TIMESTAMP)";
             default:
                 throw new UnsupportedOperationException("Dialect not supported: " + dialect);
         }
@@ -170,7 +183,6 @@ private static String getIndexCheckSql(SqlDialect dialect) {
             case HSQLDB:
             default:
                 return "SELECT INDEX_NAME FROM INFORMATION_SCHEMA.INDEXES WHERE INDEX_NAME = ?";
-
         }
     }
 
@@ -183,6 +195,9 @@ public static void verifyIndexExists(TestContext context) throws SQLException {
                         ps.setString(1, "IDX_STANDALONE_INDEX");
                         ps.setString(2, "TEST_TABLE");
                         break;
+                    case DB2:
+                        ps.setString(1, "IDX_STANDALONE_INDEX");
+                        break;
                     case MYSQL:
                     case MARIADB:
                         ps.setString(1, "test_table");