Added new database_internal_table_exists function to make sure to check for system tables in the public schema (PG only)

Author: marcobambini

src/cloudsync.c

@@ -1470,7 +1470,7 @@ int merge_insert (cloudsync_context *data, cloudsync_table_context *table, const
 // MARK: - Private -
 
 bool cloudsync_config_exists (cloudsync_context *data) {
-    return database_table_exists(data, CLOUDSYNC_SITEID_NAME) == true;
+    return database_internal_table_exists(data, CLOUDSYNC_SITEID_NAME) == true;
 }
 
 cloudsync_context *cloudsync_context_create (void *db) {
@@ -1518,7 +1518,7 @@ const char *cloudsync_context_init (cloudsync_context *data) {
     // The data->site_id value could exists while settings tables don't exists if the
     // cloudsync_context_init was previously called in init transaction that was rolled back
     // because of an error during the init process.
-    if (data->site_id[0] == 0 || !database_table_exists(data, CLOUDSYNC_SITEID_NAME)) {
+    if (data->site_id[0] == 0 || !database_internal_table_exists(data, CLOUDSYNC_SITEID_NAME)) {
         if (dbutils_settings_init(data) != DBRES_OK) return NULL;
         if (cloudsync_add_dbvms(data) != DBRES_OK) return NULL;
         if (cloudsync_load_siteid(data) != DBRES_OK) return NULL;
@@ -2595,7 +2595,7 @@ int cloudsync_cleanup (cloudsync_context *data, const char *table_name) {
         cloudsync_reset_siteid(data);
         dbutils_settings_cleanup(data);
     } else {
-        if (database_table_exists(data, CLOUDSYNC_TABLE_SETTINGS_NAME) == true) {
+        if (database_internal_table_exists(data, CLOUDSYNC_TABLE_SETTINGS_NAME) == true) {
             cloudsync_update_schema_hash(data);
         }
     }

src/database.h

@@ -67,6 +67,7 @@ int  database_select_blob (cloudsync_context *data, const char *sql, char **valu
 int  database_select_blob_2int (cloudsync_context *data, const char *sql, char **value, int64_t *value_len, int64_t *value2, int64_t *value3);
 int  database_write (cloudsync_context *data, const char *sql, const char **values, DBTYPE types[], int lens[], int count);
 bool database_table_exists (cloudsync_context *data, const char *table_name);
+bool database_internal_table_exists (cloudsync_context *data, const char *name);
 bool database_trigger_exists (cloudsync_context *data, const char *table_name);
 int  database_create_metatable (cloudsync_context *data, const char *table_name);
 int  database_create_triggers (cloudsync_context *data, const char *table_name, table_algo algo);

src/dbutils.c

@@ -394,7 +394,7 @@ int dbutils_settings_init (cloudsync_context *data) {
 
     // check if cloudsync_settings table exists
     int rc = DBRES_OK;
-    bool settings_exists = database_table_exists(data, CLOUDSYNC_SETTINGS_NAME);
+    bool settings_exists = database_internal_table_exists(data, CLOUDSYNC_SETTINGS_NAME);
     if (settings_exists == false) {
         DEBUG_SETTINGS("cloudsync_settings does not exist (creating a new one)");
 
@@ -414,7 +414,7 @@ int dbutils_settings_init (cloudsync_context *data) {
         if (rc != DBRES_OK) return rc;
     }
 
-    if (database_table_exists(data, CLOUDSYNC_SITEID_NAME) == false) {
+    if (database_internal_table_exists(data, CLOUDSYNC_SITEID_NAME) == false) {
         DEBUG_SETTINGS("cloudsync_site_id does not exist (creating a new one)");
 
         // create table and fill-in initial data
@@ -436,15 +436,15 @@ int dbutils_settings_init (cloudsync_context *data) {
     }
 
     // check if cloudsync_table_settings table exists
-    if (database_table_exists(data, CLOUDSYNC_TABLE_SETTINGS_NAME) == false) {
+    if (database_internal_table_exists(data, CLOUDSYNC_TABLE_SETTINGS_NAME) == false) {
         DEBUG_SETTINGS("cloudsync_table_settings does not exist (creating a new one)");
 
         rc = database_exec(data, SQL_CREATE_TABLE_SETTINGS_TABLE);
         if (rc != DBRES_OK) return rc;
     }
 
     // check if cloudsync_settings table exists
-    bool schema_versions_exists = database_table_exists(data, CLOUDSYNC_SCHEMA_VERSIONS_NAME);
+    bool schema_versions_exists = database_internal_table_exists(data, CLOUDSYNC_SCHEMA_VERSIONS_NAME);
     if (schema_versions_exists == false) {
         DEBUG_SETTINGS("cloudsync_schema_versions does not exist (creating a new one)");
 

src/postgresql/cloudsync_postgresql.c

@@ -1520,7 +1520,7 @@ Datum pg_cloudsync_set_schema (PG_FUNCTION_ARGS) {
     // Only persist if settings table exists (it may not exist before cloudsync_init).
     int spi_rc = SPI_connect();
     if (spi_rc == SPI_OK_CONNECT) {
-        if (database_table_exists(data, "cloudsync_settings")) {
+        if (database_internal_table_exists(data, CLOUDSYNC_SETTINGS_NAME)) {
             dbutils_settings_set_key_value(data, "schema", schema);
         }
         SPI_finish();

src/postgresql/database_postgresql.c

@@ -233,40 +233,6 @@ char *database_build_base_ref(const char *schema, const char *table_name) {
 
 // MARK: - HELPER FUNCTIONS -
 
-// TODO: is this really necessary? We now control the SQL statements and so we can use the Postgres style when needed
-// Convert SQLite-style ? placeholders to PostgreSQL-style $1, $2, etc.
-/*
-static char* convert_placeholders(const char *sql) {
-    if (!sql) {
-        return NULL;
-    }
-
-    // Count placeholders
-    int count = 0;
-    for (const char *p = sql; *p; p++) {
-        if (*p == '?') count++;
-    }
-
-    // Allocate new string (worst case: $999 for each ? = 4 chars vs 1)
-    size_t newlen = strlen(sql) + (count * 3) + 1;
-    char *newsql = cloudsync_memory_alloc(newlen);
-
-    // Convert
-    char *dst = newsql;
-    int param_num = 1;
-    for (const char *src = sql; *src; src++) {
-        if (*src == '?') {
-            dst += sprintf(dst, "$%d", param_num++);
-        } else {
-            *dst++ = *src;
-        }
-    }
-    *dst = '\0';
-
-    return newsql;
-}
- */
-
 // Map SPI result codes to DBRES
 static int map_spi_result (int rc) {
     switch (rc) {
@@ -521,15 +487,19 @@ int database_select3_values (cloudsync_context *data, const char *sql, char **va
     return rc;
 }
 
-bool database_system_exists (cloudsync_context *data, const char *name, const char *type) {
+static bool database_system_exists (cloudsync_context *data, const char *name, const char *type, bool force_public) {
       if (!name || !type) return false;
       cloudsync_reset_error(data);
 
       bool exists = false;
       const char *query;
 
       if (strcmp(type, "table") == 0) {
-          query = "SELECT 1 FROM pg_tables WHERE schemaname = COALESCE(cloudsync_schema(), current_schema()) AND tablename = $1";
+          if (force_public) {
+              query = "SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = $1";
+          } else {
+              query = "SELECT 1 FROM pg_tables WHERE schemaname = COALESCE(cloudsync_schema(), current_schema()) AND tablename = $1";
+          }
       } else if (strcmp(type, "trigger") == 0) {
           query = "SELECT 1 FROM pg_trigger WHERE tgname = $1";
       } else {
@@ -833,11 +803,15 @@ bool database_in_transaction (cloudsync_context *data) {
 }
 
 bool database_table_exists (cloudsync_context *data, const char *name) {
-    return database_system_exists(data, name, "table");
+    return database_system_exists(data, name, "table", false);
+}
+
+bool database_internal_table_exists (cloudsync_context *data, const char *name) {
+    return database_system_exists(data, name, "table", true);
 }
 
 bool database_trigger_exists (cloudsync_context *data, const char *name) {
-    return database_system_exists(data, name, "trigger");
+    return database_system_exists(data, name, "trigger", false);
 }
 
 // MARK: - SCHEMA INFO -

src/sqlite/database_sqlite.c

@@ -396,6 +396,10 @@ bool database_table_exists (cloudsync_context *data, const char *name) {
     return database_system_exists(data, name, "table");
 }
 
+bool database_internal_table_exists (cloudsync_context *data, const char *name) {
+    return database_table_exists(data, name);
+}
+
 bool database_trigger_exists (cloudsync_context *data, const char *name) {
     return database_system_exists(data, name, "trigger");
 }