Merge branch 'main' into update-build-pipeline

Author: Gioee

src/cloudsync.c

@@ -2991,6 +2991,17 @@ void cloudsync_commit_alter (sqlite3_context *context, int argc, sqlite3_value *
     }
 }
 
+// MARK: -
+
+void cloudsync_uuid (sqlite3_context *context, int argc, sqlite3_value **argv) {
+    DEBUG_FUNCTION("cloudsync_uuid");
+    
+    char value[UUID_STR_MAXLEN];
+    char *uuid = cloudsync_uuid_v7_string(value, true);
+    sqlite3_result_text(context, uuid, -1, SQLITE_TRANSIENT);
+}
+
+
 // MARK: - Main Entrypoint -
 
 APIEXPORT int sqlite3_cloudsync_init (sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
@@ -3101,6 +3112,9 @@ APIEXPORT int sqlite3_cloudsync_init (sqlite3 *db, char **pzErrMsg, const sqlite
     rc = dbutils_register_function(db, "cloudsync_commit_alter", cloudsync_commit_alter, 1, pzErrMsg, ctx, NULL);
     if (rc != SQLITE_OK) return rc;
 
+    rc = dbutils_register_function(db, "cloudsync_uuid", cloudsync_uuid, 0, pzErrMsg, ctx, NULL);
+    if (rc != SQLITE_OK) return rc;
+    
     // NETWORK LAYER
     #ifndef CLOUDSYNC_OMIT_NETWORK
     rc = cloudsync_network_register(db, pzErrMsg, ctx);

src/dbutils.c

@@ -1012,8 +1012,7 @@ int dbutils_update_schema_hash(sqlite3 *db, uint64_t *hash) {
     if (hash && *hash == h) return SQLITE_CONSTRAINT;
 
     char sql[1024];
-    //
-    snprintf(sql, sizeof(sql), "INSERT INTO %s (hash) VALUES (%lld);", CLOUDSYNC_SCHEMA_VERSIONS_NAME, h);
+    snprintf(sql, sizeof(sql), "INSERT INTO %s (hash) VALUES (%lld);", CLOUDSYNC_SCHEMA_VERSIONS_NAME, (sqlite3_int64)h);
     int rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
 
     if (hash) *hash = h;

src/network.c

@@ -334,7 +334,7 @@ int extract_query_param(const char *query, const char *key, char *output, size_t
     return -3; // Key not found
 }
 
-bool network_compute_endpoints (sqlite3_context *context, network_data *data, const char *connection_string) {
+bool network_compute_endpoints (sqlite3_context *context, network_data *data, const char *conn_string) {
     // compute endpoints
     bool result = false;
 
@@ -348,12 +348,16 @@ bool network_compute_endpoints (sqlite3_context *context, network_data *data, co
     char *check_endpoint = NULL;
     char *upload_endpoint = NULL;
 
+    char *conn_string_https = NULL;
+    
     CURLUcode rc = CURLUE_OUT_OF_MEMORY;
     CURLU *url = curl_url();
     if (!url) goto finalize;
 
+    conn_string_https = cloudsync_string_replace_prefix(conn_string, "sqlitecloud://", "https://");
+    
     // set URL: https://UUID.g5.sqlite.cloud:443/chinook.sqlite?apikey=hWDanFolRT9WDK0p54lufNrIyfgLZgtMw6tb6fbPmpo
-    rc = curl_url_set(url, CURLUPART_URL, connection_string, 0);
+    rc = curl_url_set(url, CURLUPART_URL, conn_string_https, 0);
     if (rc != CURLE_OK) goto finalize;
 
     // https (MANDATORY)
@@ -421,6 +425,7 @@ bool network_compute_endpoints (sqlite3_context *context, network_data *data, co
     if (database) curl_free(database);
     if (query) curl_free(query);
     if (url) curl_url_cleanup(url);
+    if (conn_string_https && conn_string_https != conn_string) cloudsync_memory_free(conn_string_https);
 
     return result;
 }
@@ -658,6 +663,15 @@ void cloudsync_network_check_changes (sqlite3_context *context, int argc, sqlite
     cloudsync_network_check_internal(context, argc, argv);
 }
 
+void cloudsync_network_reset_check_version (sqlite3_context *context, int argc, sqlite3_value **argv) {
+    DEBUG_FUNCTION("cloudsync_network_reset_check_version");
+    
+    sqlite3 *db = sqlite3_context_db_handle(context);
+    char *buf = "0";
+    dbutils_settings_set_key_value(db, context, CLOUDSYNC_KEY_CHECK_DBVERSION, buf);
+    dbutils_settings_set_key_value(db, context, CLOUDSYNC_KEY_CHECK_SEQ, buf);
+}
+
 // MARK: -
 
 int cloudsync_network_register (sqlite3 *db, char **pzErrMsg, void *ctx) {
@@ -681,7 +695,7 @@ int cloudsync_network_register (sqlite3 *db, char **pzErrMsg, void *ctx) {
     rc = dbutils_register_function(db, "cloudsync_network_check_changes", cloudsync_network_check_changes, 0, pzErrMsg, ctx, NULL);
     if (rc != SQLITE_OK) return rc;
 
-    rc = dbutils_register_function(db, "cloudsync_network_check_changes_sync", cloudsync_network_check_changes_sync, 2, pzErrMsg, ctx, NULL);
+    rc = dbutils_register_function(db, "cloudsync_network_reset_check_version", cloudsync_network_reset_check_version, 0, pzErrMsg, ctx, NULL);
     if (rc != SQLITE_OK) return rc;
 
     return rc;

src/utils.c

@@ -165,6 +165,29 @@ void cloudsync_rowid_decode (sqlite3_int64 rowid, sqlite3_int64 *db_version, sql
     *db_version = (sqlite3_int64)(urowid >> 30);
 }
 
+char *cloudsync_string_replace_prefix(const char *input, char *prefix, char *replacement) {
+    //const char *prefix = "sqlitecloud://";
+    //const char *replacement = "https://";
+    size_t prefix_len = strlen(prefix);
+    size_t replacement_len = strlen(replacement);
+
+    if (strncmp(input, prefix, prefix_len) == 0) {
+        // Allocate memory for new string
+        size_t input_len = strlen(input);
+        size_t new_len = input_len - prefix_len + replacement_len;
+        char *result = cloudsync_memory_alloc(new_len + 1); // +1 for null terminator
+        if (!result) return NULL;
+
+        // Copy replacement and the rest of the input string
+        strcpy(result, replacement);
+        strcpy(result + replacement_len, input + prefix_len);
+        return result;
+    }
+
+    // If no match, return the original string
+    return (char *)input;
+}
+
 uint64_t fnv1a_hash(const char *data, size_t len) {
     uint64_t hash = FNV_OFFSET_BASIS;
     for (size_t i = 0; i < len; ++i) {

src/utils.h

@@ -125,6 +125,7 @@ int cloudsync_uuid_v7 (uint8_t value[UUID_LEN]);
 int cloudsync_uuid_v7_compare (uint8_t value1[UUID_LEN], uint8_t value2[UUID_LEN]);
 char *cloudsync_uuid_v7_string (char value[UUID_STR_MAXLEN], bool dash_format);
 char *cloudsync_uuid_v7_stringify (uint8_t uuid[UUID_LEN], char value[UUID_STR_MAXLEN], bool dash_format);
+char *cloudsync_string_replace_prefix(const char *input, char *prefix, char *replacement);
 uint64_t fnv1a_hash(const char *data, size_t len);
 
 void *cloudsync_memory_zeroalloc (uint64_t size);

test/unit.c

@@ -829,6 +829,11 @@ bool do_test_functions (sqlite3 *db, bool print_results) {
     rc = sqlite3_exec(db, "SELECT cloudsync_cleanup('*');", NULL, NULL, NULL);
     if (rc != SQLITE_OK) goto abort_test_functions;
 
+    char *uuid = dbutils_text_select(db, "SELECT cloudsync_uuid();");
+    if (uuid == NULL) goto abort_test_functions;
+    if (print_results) printf("New uuid: %s\n", uuid);
+    cloudsync_memory_free(uuid);
+    
     return true;
 
 abort_test_functions:
@@ -1760,6 +1765,26 @@ bool do_test_internal_functions (void) {
     return result;
 }
 
+bool do_test_string_replace_prefix(void) {
+    char *host = "rejfwkr.sqlite.cloud";
+    char *prefix = "sqlitecloud://";
+    char *replacement = "https://";
+    
+    char string[512];
+    snprintf(string, sizeof(string), "%s%s", prefix, host);
+    char expected[512];
+    snprintf(expected, sizeof(expected), "%s%s", replacement, host);
+    
+    char *replaced = cloudsync_string_replace_prefix(string, prefix, replacement);
+    if (string == replaced || strcmp(replaced, expected) != 0) return false;
+    if (string != replaced) cloudsync_memory_free(replaced);
+    
+    replaced = cloudsync_string_replace_prefix(expected, prefix, replacement);
+    if (expected != replaced) return false;
+    
+    return true;
+}
+
 // MARK: -
 
 bool do_compare_queries (sqlite3 *db1, const char *sql1, sqlite3 *db2, const char *sql2, int col_to_skip, int col_tombstone, bool display_column) {
@@ -3081,6 +3106,9 @@ int main(int argc, const char * argv[]) {
     result += test_report("Functions Test:", do_test_functions(db, print_result));
     result += test_report("Functions Test (Int):", do_test_internal_functions());
 
+    result = do_test_string_replace_prefix();
+    printf("%-24s %s\n", "String Func Test:", (result) ? "OK" : "FAILED");
+
     // close local database
     db = close_db(db);