Merge main into test/e2e-token-auth (resolve integration.c helper conflict)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: andinux

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.1.2] - 2026-07-13
+
+### Fixed
+
+- Querying the SQLite `cloudsync_changes` virtual table (directly or via `cloudsync_payload_blob_checked()`) on a database whose `cloudsync_table_settings` rows survived while all `*_cloudsync` meta tables were lost (e.g. a dump/restore that skipped them) now raises an actionable error ("cloudsync settings reference tables whose sync metadata is missing ...") instead of a misclassified `SQLITE_NOMEM`, which servers reported as "Not enough memory to execute query".
+
 ## [1.1.1] - 2026-07-10
 
 ### Fixed

Package.swift

@@ -14,8 +14,8 @@ let package = Package(
     targets: [
         .binaryTarget(
             name: "CloudSyncBinary",
-            url: "https://github.com/sqliteai/sqlite-sync/releases/download/1.1.1/cloudsync-apple-xcframework-1.1.1.zip",
-            checksum: "cd280eec57b2dd3b7c7c4ee80cd68d12830ebfd81597141b80b8deadeced7979"
+            url: "https://github.com/sqliteai/sqlite-sync/releases/download/1.1.2/cloudsync-apple-xcframework-1.1.2.zip",
+            checksum: "60f9d5a5e08f3327773991d605c032a33d8d32e72b93cf3eef4244706e8c57da"
         ),
         .target(
             name: "CloudSync",

src/cloudsync.h

@@ -18,7 +18,7 @@
 extern "C" {
 #endif
 
-#define CLOUDSYNC_VERSION                       "1.1.1"
+#define CLOUDSYNC_VERSION                       "1.1.2"
 #define CLOUDSYNC_MAX_TABLENAME_LEN             512
 
 #define CLOUDSYNC_VALUE_NOTSET                  -1

src/sqlite/cloudsync_changes_sqlite.c

@@ -413,6 +413,21 @@ int cloudsync_changesvtab_filter (sqlite3_vtab_cursor *cursor, int idxn, const c
                 "SELECT cloudsync_init('<table_name>') to enable sync on a "
                 "table before querying cloudsync_changes.");
         }
+        // settings rows exist but no *_cloudsync tables do (e.g. a dump/restore
+        // that skipped the meta tables): still not an OOM
+        sqlite3_stmt *vm = NULL;
+        bool meta_missing = false;
+        if (sqlite3_prepare_v2(db, "SELECT 1 FROM sqlite_master WHERE type='table' AND tbl_name LIKE '%_cloudsync' LIMIT 1;", -1, &vm, NULL) == SQLITE_OK) {
+            meta_missing = (sqlite3_step(vm) != SQLITE_ROW);
+        }
+        if (vm) sqlite3_finalize(vm);
+        if (meta_missing) {
+            return vtab_set_error((sqlite3_vtab *)c->vtab,
+                "cloudsync settings reference tables whose sync metadata is "
+                "missing (no *_cloudsync tables found). Re-run "
+                "SELECT cloudsync_init('<table_name>') for each configured "
+                "table to rebuild it.");
+        }
         return SQLITE_NOMEM;
     }
 

test/integration.c

@@ -272,6 +272,34 @@ int db_send_await_converge (sqlite3 *db, int max_attempts, int delay_ms) {
     return SQLITE_ERROR;
 }
 
+// Bring a fresh receiver up to date with the tenant's accumulated history before a
+// capped-receive test: send a sentinel row from the sender, then drain (uncapped)
+// until it arrives. A fresh site's first check makes the server spool the ENTIRE
+// tenant history — which grows with every run — answering 202 while it prepares, and
+// a 202 yields rows=0/complete=1, indistinguishable from "already drained", so only
+// the sentinel's arrival proves the replay actually finished. This keeps the capped
+// attempt budgets O(this test's batch) instead of O(tenant history).
+int chunked_receiver_catch_up (sqlite3 *sender, sqlite3 *receiver, const char *sentinel_id) {
+    char sql[512];
+    snprintf(sql, sizeof(sql),
+        "INSERT INTO chunked_payload_items (id, body) VALUES ('%s', 'sentinel');", sentinel_id);
+    int rc = db_exec(sender, sql); if (rc != SQLITE_OK) return rc;
+    rc = db_send_ok(sender); if (rc != SQLITE_OK) return rc;
+
+    for (int i = 0; i < 120; i++) {
+        int matches = 0;
+        rc = db_exec(receiver, "SELECT cloudsync_network_receive_changes();");
+        if (rc != SQLITE_OK) return rc;
+        snprintf(sql, sizeof(sql),
+            "SELECT COUNT(*) FROM chunked_payload_items WHERE id='%s';", sentinel_id);
+        rc = db_select_int(receiver, sql, &matches); if (rc != SQLITE_OK) return rc;
+        if (matches == 1) return SQLITE_OK;
+        sqlite3_sleep(500);
+    }
+    printf("Error: receiver did not catch up with tenant history (sentinel %s missing).\n", sentinel_id);
+    return SQLITE_ERROR;
+}
+
 int integration_network_init_base(sqlite3 *db, const char *database_id, char *network_init, size_t network_init_len) {
     if (!database_id) {
         fprintf(stderr, "Error: integration database ID not set.\n");
@@ -1013,6 +1041,7 @@ int test_chunked_payload_capped_receive(void) {
     sqlite3 *receiver = NULL;
     char network_init[1024];
     char batch_id[UUID_STR_MAXLEN];
+    char sentinel_id[UUID_STR_MAXLEN];
     char sql[1024];
     bool found = false;
     bool observed_capped_partial = false;  // saw chunks==1 && complete=0 from a receive(1) call
@@ -1032,6 +1061,14 @@ int test_chunked_payload_capped_receive(void) {
     if (rc != SQLITE_OK) goto cleanup;
 
     cloudsync_uuid_v7_string(batch_id, true);
+    cloudsync_uuid_v7_string(sentinel_id, true);
+
+    // Replay accumulated tenant history up front so the 80x1-chunk budget below only
+    // has to fetch this test's batch (see chunked_receiver_catch_up).
+    rc = chunked_receiver_catch_up(sender, receiver, sentinel_id);
+    if (rc != SQLITE_OK) goto cleanup;
+    cleanup_remote_rows = true;
+
     rc = db_exec(sender, "SELECT cloudsync_set('payload_max_chunk_size', '262144');"); if (rc != SQLITE_OK) goto cleanup;
     snprintf(sql, sizeof(sql),
         "WITH RECURSIVE c(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM c WHERE i < %d) "
@@ -1043,7 +1080,6 @@ int test_chunked_payload_capped_receive(void) {
     rc = db_expect_min(sender, "SELECT COUNT(*) FROM cloudsync_payload_chunks();", 2); if (rc != SQLITE_OK) goto cleanup;
 
     rc = db_send_ok(sender); if (rc != SQLITE_OK) goto cleanup;
-    cleanup_remote_rows = true;
 
     for (int attempt = 0; attempt < 80; ++attempt) {
         int chunks = 0, complete = 0, matches = 0;
@@ -1098,7 +1134,7 @@ int test_chunked_payload_capped_receive(void) {
 
 cleanup:
     if (cleanup_remote_rows && sender) {
-        snprintf(sql, sizeof(sql), "DELETE FROM chunked_payload_items WHERE id LIKE '%s-%%';", batch_id);
+        snprintf(sql, sizeof(sql), "DELETE FROM chunked_payload_items WHERE id LIKE '%s-%%' OR id='%s';", batch_id, sentinel_id);
         if (db_exec(sender, sql) == SQLITE_OK) {
             db_exec(sender, "SELECT cloudsync_network_send_changes();");
         }
@@ -1116,6 +1152,7 @@ int test_chunked_payload_batched_receive(void) {
     sqlite3 *receiver = NULL;
     char network_init[1024];
     char batch_id[UUID_STR_MAXLEN];
+    char sentinel_id[UUID_STR_MAXLEN];
     char sql[1024];
     bool found = false;
     bool observed_batched_partial = false;  // saw chunks==2 && complete=0 from receive(2)
@@ -1128,6 +1165,14 @@ int test_chunked_payload_batched_receive(void) {
     if (rc != SQLITE_OK) goto cleanup;
 
     cloudsync_uuid_v7_string(batch_id, true);
+    cloudsync_uuid_v7_string(sentinel_id, true);
+
+    // Replay accumulated tenant history up front so the capped budget below only has
+    // to fetch this test's batch (see chunked_receiver_catch_up).
+    rc = chunked_receiver_catch_up(sender, receiver, sentinel_id);
+    if (rc != SQLITE_OK) goto cleanup;
+    cleanup_remote_rows = true;
+
     rc = db_exec(sender, "SELECT cloudsync_set('payload_max_chunk_size', '262144');"); if (rc != SQLITE_OK) goto cleanup;
     snprintf(sql, sizeof(sql),
         "WITH RECURSIVE c(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM c WHERE i < %d) "
@@ -1139,7 +1184,6 @@ int test_chunked_payload_batched_receive(void) {
     rc = db_expect_min(sender, "SELECT COUNT(*) FROM cloudsync_payload_chunks();", 3); if (rc != SQLITE_OK) goto cleanup;
 
     rc = db_send_ok(sender); if (rc != SQLITE_OK) goto cleanup;
-    cleanup_remote_rows = true;
 
     for (int attempt = 0; attempt < 80; ++attempt) {
         int chunks = 0, complete = 0, matches = 0;
@@ -1186,7 +1230,7 @@ int test_chunked_payload_batched_receive(void) {
 
 cleanup:
     if (cleanup_remote_rows && sender) {
-        snprintf(sql, sizeof(sql), "DELETE FROM chunked_payload_items WHERE id LIKE '%s-%%';", batch_id);
+        snprintf(sql, sizeof(sql), "DELETE FROM chunked_payload_items WHERE id LIKE '%s-%%' OR id='%s';", batch_id, sentinel_id);
         if (db_exec(sender, sql) == SQLITE_OK) {
             db_exec(sender, "SELECT cloudsync_network_send_changes();");
         }

test/unit.c

@@ -12976,6 +12976,41 @@ bool do_test_payload_chunks_uninitialized (bool print_result, bool cleanup_datab
     return result;
 }
 
+// A database whose cloudsync_table_settings rows survived while the *_cloudsync
+// meta tables were lost (e.g. a dump/restore that skipped them) must raise an
+// actionable error from cloudsync_changes, not a misclassified SQLITE_NOMEM
+// that servers report as "Not enough memory to execute query".
+bool do_test_changes_vtab_missing_meta_tables (bool print_result) {
+    sqlite3 *db = NULL;
+    sqlite3_stmt *stmt = NULL;
+    bool result = false;
+
+    db = do_create_database();
+    if (!db) goto finalize;
+
+    if (sqlite3_exec(db, "CREATE TABLE barang (id TEXT PRIMARY KEY, name TEXT);", NULL, NULL, NULL) != SQLITE_OK) goto finalize;
+    if (sqlite3_exec(db, "SELECT cloudsync_init('barang');", NULL, NULL, NULL) != SQLITE_OK) goto finalize;
+    if (sqlite3_exec(db, "INSERT INTO barang VALUES ('1','test');", NULL, NULL, NULL) != SQLITE_OK) goto finalize;
+
+    // settings rows survive, meta table does not
+    if (sqlite3_exec(db, "DROP TABLE barang_cloudsync;", NULL, NULL, NULL) != SQLITE_OK) goto finalize;
+
+    if (sqlite3_prepare_v2(db, "SELECT COUNT(*) FROM cloudsync_changes;", -1, &stmt, NULL) != SQLITE_OK) goto finalize;
+    if (sqlite3_step(stmt) != SQLITE_ERROR) goto finalize;
+    if (!strstr(sqlite3_errmsg(db), "sync metadata")) goto finalize;
+    sqlite3_finalize(stmt); stmt = NULL;
+
+    result = true;
+
+finalize:
+    if (!result && print_result) {
+        printf("do_test_changes_vtab_missing_meta_tables error: %s\n", db ? sqlite3_errmsg(db) : "no db");
+    }
+    if (stmt) sqlite3_finalize(stmt);
+    if (db) close_db(db);
+    return result;
+}
+
 bool do_test_payload_idempotency (int nclients, bool print_result, bool cleanup_databases) {
     sqlite3 *db[2] = {NULL, NULL};
     bool result = false;
@@ -13429,6 +13464,7 @@ int main (int argc, const char * argv[]) {
     result += test_report("Payload Chunks Split db_version:", do_test_payload_chunks_split_dbversion(print_result, cleanup_databases));
     result += test_report("Payload Chunks Positional Resume:", do_test_payload_chunks_positional_resume(print_result, cleanup_databases));
     result += test_report("Payload Chunks Uninitialized:", do_test_payload_chunks_uninitialized(print_result, cleanup_databases));
+    result += test_report("Changes Vtab Missing Meta Tables:", do_test_changes_vtab_missing_meta_tables(print_result));
 
     // close local database
     close_db(db);