fix: prevent infinite loop when reloading persisted block-column settings

When a database with a persisted block-column setting was reopened,
sqlite3_cloudsync_init looped forever inside dbutils_settings_table_load_callback.
The callback iterates cloudsync_table_settings via sqlite3_exec and, for each
algo=block row, called cloudsync_setup_block_column, which unconditionally
REPLACEd the same row back into the table. The rewritten row was re-fed to the
still-open cursor, triggering the callback again ad infinitum.

Add a `persist` flag to cloudsync_setup_block_column so the settings loader
can replay the in-memory setup without writing back to cloudsync_table_settings.
The SQL-function callers (cloudsync_set_column in both the SQLite and
PostgreSQL backends) keep persisting by passing true.

Add a regression test (Block Column Reload) that creates a block column with a
custom delimiter, closes the database, and reopens it — without the fix this
hangs the test process.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: andinux

src/cloudsync.c

@@ -2069,7 +2069,7 @@ int merge_insert (cloudsync_context *data, cloudsync_table_context *table, const
 
 // MARK: - Block column setup -
 
-int cloudsync_setup_block_column (cloudsync_context *data, const char *table_name, const char *col_name, const char *delimiter) {
+int cloudsync_setup_block_column (cloudsync_context *data, const char *table_name, const char *col_name, const char *delimiter, bool persist) {
     cloudsync_table_context *table = table_lookup(data, table_name);
     if (!table) return cloudsync_set_error(data, "cloudsync_setup_block_column: table not found", DBRES_ERROR);
 
@@ -2137,13 +2137,17 @@ int cloudsync_setup_block_column (cloudsync_context *data, const char *table_nam
         if (rc != DBRES_OK) return rc;
     }
 
-    // Persist settings
-    int rc = dbutils_table_settings_set_key_value(data, table_name, col_name, "algo", "block");
-    if (rc != DBRES_OK) return rc;
-
-    if (delimiter) {
-        rc = dbutils_table_settings_set_key_value(data, table_name, col_name, "delimiter", delimiter);
+    // Persist settings (skipped when called from the settings loader, since
+    // writing to cloudsync_table_settings while sqlite3_exec is iterating it
+    // re-feeds the rewritten row to the cursor and causes an infinite loop).
+    if (persist) {
+        int rc = dbutils_table_settings_set_key_value(data, table_name, col_name, "algo", "block");
         if (rc != DBRES_OK) return rc;
+
+        if (delimiter) {
+            rc = dbutils_table_settings_set_key_value(data, table_name, col_name, "delimiter", delimiter);
+            if (rc != DBRES_OK) return rc;
+        }
     }
 
     return DBRES_OK;

src/cloudsync.h

@@ -18,7 +18,7 @@
 extern "C" {
 #endif
 
-#define CLOUDSYNC_VERSION                       "1.0.11"
+#define CLOUDSYNC_VERSION                       "1.0.12"
 #define CLOUDSYNC_MAX_TABLENAME_LEN             512
 
 #define CLOUDSYNC_VALUE_NOTSET                  -1
@@ -119,7 +119,7 @@ col_algo_t table_col_algo (cloudsync_table_context *table, int index);
 const char *table_col_delimiter (cloudsync_table_context *table, int index);
 int table_col_index (cloudsync_table_context *table, const char *col_name);
 int block_materialize_column (cloudsync_context *data, cloudsync_table_context *table, const void *pk, int pklen, const char *base_col_name);
-int cloudsync_setup_block_column (cloudsync_context *data, const char *table_name, const char *col_name, const char *delimiter);
+int cloudsync_setup_block_column (cloudsync_context *data, const char *table_name, const char *col_name, const char *delimiter, bool persist);
 
 // Block column accessors (avoids accessing opaque struct from outside cloudsync.c)
 dbvm_t *table_block_value_read_stmt (cloudsync_table_context *table);

src/dbutils.c

@@ -385,7 +385,7 @@ int dbutils_settings_table_load_callback (void *xdata, int ncols, char **values,
             char dbuf[256];
             int drc = dbutils_table_settings_get_value(data, table_name, col_name, "delimiter", dbuf, sizeof(dbuf));
             const char *delim = (drc == DBRES_OK && dbuf[0]) ? dbuf : NULL;
-            cloudsync_setup_block_column(data, table_name, col_name, delim);
+            cloudsync_setup_block_column(data, table_name, col_name, delim, false);
             DEBUG_SETTINGS("load block column: %s.%s delimiter: %s", table_name, col_name, delim ? delim : "(default)");
             continue;
         }

src/postgresql/cloudsync_postgresql.c

@@ -617,7 +617,7 @@ Datum cloudsync_set_column (PG_FUNCTION_ARGS) {
     {
         // Handle block column setup: cloudsync_set_column('tbl', 'col', 'algo', 'block')
         if (key && value && strcmp(key, "algo") == 0 && strcmp(value, "block") == 0) {
-            int rc = cloudsync_setup_block_column(data, tbl, col, NULL);
+            int rc = cloudsync_setup_block_column(data, tbl, col, NULL, true);
             if (rc != DBRES_OK) {
                 ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("%s", cloudsync_errmsg(data))));
             }

src/sqlite/cloudsync_sqlite.c

@@ -150,7 +150,7 @@ void dbsync_set_column (sqlite3_context *context, int argc, sqlite3_value **argv
 
     // Handle block column setup: cloudsync_set_column('tbl', 'col', 'algo', 'block')
     if (key && value && strcmp(key, "algo") == 0 && strcmp(value, "block") == 0) {
-        int rc = cloudsync_setup_block_column(data, tbl, col, NULL);
+        int rc = cloudsync_setup_block_column(data, tbl, col, NULL, true);
         if (rc != DBRES_OK) {
             sqlite3_result_error(context, cloudsync_errmsg(data), -1);
         }

test/unit.c

@@ -9001,6 +9001,96 @@ static int64_t do_select_int(sqlite3 *db, const char *sql) {
     return val;
 }
 
+// Regression: persisted block-column settings must not cause an infinite loop
+// when the extension is reloaded. Without the fix, dbutils_settings_table_load_callback
+// (driven by sqlite3_exec over cloudsync_table_settings) would re-invoke
+// cloudsync_setup_block_column, which REPLACEd the same row mid-iteration and
+// re-fed it back into the cursor.
+bool do_test_block_column_reload(bool cleanup_databases) {
+    bool result = false;
+    char dbpath[256];
+    time_t timestamp = time(NULL);
+
+    #ifdef __ANDROID__
+    snprintf(dbpath, sizeof(dbpath), "%s/cloudsync-test-blockreload-%ld.sqlite", ".", timestamp);
+    #else
+    snprintf(dbpath, sizeof(dbpath), "%s/cloudsync-test-blockreload-%ld.sqlite", getenv("HOME"), timestamp);
+    #endif
+
+    // Phase 1: create database, table, init cloudsync, mark a column as block algo.
+    // Use a custom delimiter so both "algo" and "delimiter" rows get persisted.
+    sqlite3 *db = NULL;
+    int rc = sqlite3_open(dbpath, &db);
+    if (rc != SQLITE_OK) return false;
+    sqlite3_exec(db, "PRAGMA journal_mode=WAL;", NULL, NULL, NULL);
+    sqlite3_cloudsync_init(db, NULL, NULL);
+
+    rc = sqlite3_exec(db, "CREATE TABLE docs (id TEXT PRIMARY KEY NOT NULL, body TEXT);", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    rc = sqlite3_exec(db, "SELECT cloudsync_init('docs');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    rc = sqlite3_exec(db, "SELECT cloudsync_set_column('docs', 'body', 'algo', 'block');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    rc = sqlite3_exec(db, "SELECT cloudsync_set_column('docs', 'body', 'delimiter', '\n');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    // Insert something so the blocks table is populated.
+    rc = sqlite3_exec(db, "INSERT INTO docs (id, body) VALUES ('doc1', 'AAA\nBBB\nCCC');", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    int64_t settings_before = do_select_int(db, "SELECT count(*) FROM cloudsync_table_settings WHERE tbl_name='docs' AND col_name='body';");
+
+    sqlite3_exec(db, "SELECT cloudsync_terminate();", NULL, NULL, NULL);
+    sqlite3_close(db);
+    db = NULL;
+
+    // Phase 2: reopen — sqlite3_cloudsync_init triggers dbutils_settings_load,
+    // which iterates cloudsync_table_settings and replays the block-column setup.
+    // Without the fix this hangs (infinite REPLACE-during-iteration loop).
+    rc = sqlite3_open(dbpath, &db);
+    if (rc != SQLITE_OK) goto cleanup;
+    rc = sqlite3_cloudsync_init(db, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    // Settings table should be unchanged after reload (no duplicate rewrites).
+    int64_t settings_after = do_select_int(db, "SELECT count(*) FROM cloudsync_table_settings WHERE tbl_name='docs' AND col_name='body';");
+    if (settings_after != settings_before) {
+        printf("block_column_reload: settings count changed across reload (before=%" PRId64 ", after=%" PRId64 ")\n", settings_before, settings_after);
+        goto cleanup;
+    }
+
+    // Block column wiring must still be active after reload: an UPDATE should
+    // continue to write per-block metadata, not a single whole-column entry.
+    rc = sqlite3_exec(db, "UPDATE docs SET body='AAA\nXXX\nCCC' WHERE id='doc1';", NULL, NULL, NULL);
+    if (rc != SQLITE_OK) goto cleanup;
+
+    int64_t whole_meta = do_select_int(db, "SELECT count(*) FROM docs_cloudsync WHERE col_name='body';");
+    if (whole_meta != 0) {
+        printf("block_column_reload: expected 0 whole-column metadata entries after reload, got %" PRId64 "\n", whole_meta);
+        goto cleanup;
+    }
+
+    result = true;
+
+cleanup:
+    if (db) {
+        sqlite3_exec(db, "SELECT cloudsync_terminate();", NULL, NULL, NULL);
+        sqlite3_close(db);
+    }
+    if (cleanup_databases) {
+        file_delete_internal(dbpath);
+        char walpath[280];
+        snprintf(walpath, sizeof(walpath), "%s-wal", dbpath);
+        file_delete_internal(walpath);
+        snprintf(walpath, sizeof(walpath), "%s-shm", dbpath);
+        file_delete_internal(walpath);
+    }
+    return result;
+}
+
 static char *do_select_text(sqlite3 *db, const char *sql) {
     sqlite3_stmt *stmt = NULL;
     char *val = NULL;
@@ -12056,6 +12146,7 @@ int main (int argc, const char * argv[]) {
     result += test_report("Large Composite PK Test:", do_test_large_composite_pk(2, print_result, cleanup_databases));
     result += test_report("Schema Hash Mismatch:", do_test_schema_hash_mismatch(2, print_result, cleanup_databases));
     result += test_report("Stale Table Settings:", do_test_stale_table_settings(cleanup_databases));
+    result += test_report("Block Column Reload:", do_test_block_column_reload(cleanup_databases));
     result += test_report("CB Error Cleanup:", do_test_context_cb_error_cleanup());
 
 finalize: