Updated SQL_DATA_VERSION and added a new sql_build_select_nonpk_by_pk function to database.h

Author: marcobambini

src/cloudsync.c

@@ -544,60 +544,6 @@ void table_pknames_free (char **names, int nrows) {
     cloudsync_memory_free(names);
 }
 
-char *table_build_values_sql (db_t *db, cloudsync_table_context *table) {
-    char *sql = NULL;
-    
-    /*
-    This SQL statement dynamically generates a SELECT query for a specified table.
-    It uses Common Table Expressions (CTEs) to construct the column names and
-    primary key conditions based on the table schema, which is obtained through
-    the `pragma_table_info` function.
-
-    1. `col_names` CTE:
-       - Retrieves a comma-separated list of non-primary key column names from
-         the specified table's schema.
-
-    2. `pk_where` CTE:
-       - Retrieves a condition string representing the primary key columns in the
-         format: "column1=? AND column2=? AND ...", used to create the WHERE clause
-         for selecting rows based on primary key values.
-
-    3. Final SELECT:
-       - Constructs the complete SELECT statement as a string, combining:
-         - Column names from `col_names`.
-         - The target table name.
-         - The WHERE clause conditions from `pk_where`.
-
-    The resulting query can be used to select rows from the table based on primary
-    key values, and can be executed within the application to retrieve data dynamically.
-    */
-
-    // Unfortunately in SQLite column names (or table names) cannot be bound parameters in a SELECT statement
-    // otherwise we should have used something like SELECT 'SELECT ? FROM %w WHERE rowid=?';
-    char buffer[1024];
-    char *singlequote_escaped_table_name = sql_escape_name(table->name, buffer, sizeof(buffer));
-    
-    #if !CLOUDSYNC_DISABLE_ROWIDONLY_TABLES
-    if (table->rowid_only) {
-        sql = memory_mprintf(SQL_BUILD_SELECT_NONPK_COLS_BY_ROWID, table->name, table->name);
-        goto process_process;
-    }
-    #endif
-
-    sql = cloudsync_memory_mprintf(SQL_BUILD_SELECT_NONPK_COLS_BY_PK, table->name, table->name, singlequote_escaped_table_name);
-
-#if !CLOUDSYNC_DISABLE_ROWIDONLY_TABLES
-process_process:
-#endif
-    if (!sql) return NULL;
-    
-    char *query = NULL;
-    int rc = database_select_text(db, sql, &query);
-    cloudsync_memory_free(sql);
-    
-    return (rc == DBRES_OK) ? query : NULL;
-}
-
 char *table_build_mergedelete_sql (db_t *db, cloudsync_table_context *table) {
     #if !CLOUDSYNC_DISABLE_ROWIDONLY_TABLES
     if (table->rowid_only) {
@@ -870,7 +816,7 @@ int table_add_stmts (db_t *db, cloudsync_table_context *table, int ncols) {
 
     // precompile the get column value statement
     if (ncols > 0) {
-        sql = table_build_values_sql(db, table);
+        sql = sql_build_select_nonpk_by_pk(db, table->name);
         if (!sql) {rc = DBRES_NOMEM; goto cleanup;}
         DEBUG_SQL("real_col_values_stmt: %s", sql);
 

src/database.h

@@ -78,7 +78,7 @@ int database_count_nonpk (db_t *db, const char *table_name);
 int database_count_int_pk (db_t *db, const char *table_name);
 int database_count_notnull_without_default (db_t *db, const char *table_name);
 
-int64_t database_schema_version (db_t *db);
+int64_t  database_schema_version (db_t *db);
 uint64_t database_schema_hash (db_t *db);
 bool     database_check_schema_hash (db_t *db, uint64_t hash);
 int      database_update_schema_hash (db_t *db, uint64_t *hash);
@@ -145,6 +145,7 @@ uint64_t dbmem_size (void *ptr);
 // SQL
 char *sql_build_drop_table (const char *table_name, char *buffer, int bsize, bool is_meta);
 char *sql_escape_name (const char *name, char *buffer, size_t bsize);
+char *sql_build_select_nonpk_by_pk (db_t *db, const char *table_name);
 
 // USED ONLY by SQLite Cloud to implement RLS
 typedef struct cloudsync_pk_decode_bind_context cloudsync_pk_decode_bind_context;

src/postgresql/database_postgresql.c

@@ -120,6 +120,17 @@ char *sql_escape_name (const char *name, char *buffer, size_t bsize) {
     return buffer;
 }
 
+char *sql_build_select_nonpk_by_pk (db_t *db, const char *table_name) {
+    char *sql = cloudsync_memory_mprintf(SQL_BUILD_SELECT_NONPK_COLS_BY_PK_PG, table_name);
+    if (!sql) return NULL;
+    
+    char *query = NULL;
+    int rc = database_select_text(db, sql, &query);
+    cloudsync_memory_free(sql);
+    
+    return (rc == DBRES_OK) ? query : NULL;
+}
+
 // MARK: - HELPER FUNCTIONS -
 
 // Convert SQLite-style ? placeholders to PostgreSQL-style $1, $2, etc.

src/postgresql/sql_postgresql.c

@@ -147,7 +147,7 @@ const char * const SQL_SITEID_SELECT_ROWID0 =
     "SELECT site_id FROM cloudsync_site_id WHERE id = 0;";
 
 const char * const SQL_DATA_VERSION =
-    "SELECT 1";  // TODO: PostgreSQL equivalent of sqlite "PRAGMA data_version", "SELECT txid_current();" is not equivalent
+    "SELECT SELECT txid_snapshot_xmin(txid_current_snapshot());";  // was "PRAGMA data_version"
 
 const char * const SQL_SCHEMA_VERSION =
     "SELECT 1;";  // TODO: PostgreSQL equivalent of sqlite "PRAGMA schema_version", "SELECT current_schema();" is not equivalent
@@ -165,27 +165,40 @@ const char * const SQL_BUILD_SELECT_NONPK_COLS_BY_ROWID =
     "WHERE table_name = $1 AND constraint_name LIKE '%_pkey'"
     ");";  // TODO: build full SELECT ... WHERE ctid=? analog with ordered columns like SQLite
 
-const char * const SQL_BUILD_SELECT_NONPK_COLS_BY_PK =
-    "WITH nonpk AS ("
-    "  SELECT string_agg(quote_ident(column_name), ',' ORDER BY ordinal_position) AS cols "
-    "  FROM information_schema.columns "
-    "  WHERE table_schema = current_schema() AND table_name = '%s' AND ordinal_position NOT IN ("
-    "    SELECT ordinal_position FROM information_schema.columns c "
-    "    WHERE table_schema = current_schema() AND table_name = '%s' AND column_name IN ("
-    "      SELECT column_name FROM information_schema.key_column_usage "
-    "      WHERE table_schema = current_schema() AND table_name = '%s' AND constraint_name LIKE '%%_pkey'"
-    "    )"
-    "  )"
-    "), pk_cols AS ("
-    "  SELECT column_name, row_number() OVER (ORDER BY position_in_unique_constraint) AS rn "
-    "  FROM information_schema.key_column_usage "
-    "  WHERE table_schema = current_schema() AND table_name = '%s' AND constraint_name LIKE '%%_pkey'"
-    "), pk AS ("
-    "  SELECT string_agg(quote_ident(column_name) || ' = $' || rn, ' AND ' ORDER BY rn) AS clause "
-    "  FROM pk_cols"
+const char * const SQL_BUILD_SELECT_NONPK_COLS_BY_PK_PG =
+    "WITH tbl AS ("
+    "  SELECT to_regclass(%L) AS oid"
+    "), "
+    "pk AS ("
+    "  SELECT a.attname, k.ord "
+    "  FROM pg_index x "
+    "  JOIN tbl t ON t.oid = x.indrelid "
+    "  JOIN LATERAL unnest(x.indkey) WITH ORDINALITY AS k(attnum, ord) ON true "
+    "  JOIN pg_attribute a ON a.attrelid = x.indrelid AND a.attnum = k.attnum "
+    "  WHERE x.indisprimary "
+    "  ORDER BY k.ord"
+    "), "
+    "nonpk AS ("
+    "  SELECT a.attname "
+    "  FROM pg_attribute a "
+    "  JOIN tbl t ON t.oid = a.attrelid "
+    "  WHERE a.attnum > 0 AND NOT a.attisdropped "
+    "    AND a.attnum NOT IN ("
+    "      SELECT k.attnum "
+    "      FROM pg_index x "
+    "      JOIN tbl t2 ON t2.oid = x.indrelid "
+    "      JOIN LATERAL unnest(x.indkey) AS k(attnum) ON true "
+    "      WHERE x.indisprimary"
+    "    ) "
+    "  ORDER BY a.attnum"
     ") "
-    "SELECT 'SELECT ' || COALESCE((SELECT cols FROM nonpk), '*') || ' FROM ' || quote_ident('%s') || ' WHERE ' || clause || ';' "
-    "FROM pk;";  // Generates full SELECT with ordered non-PK columns and PK WHERE clause for cloudsync_memory_mprintf
+    "SELECT "
+    "  'SELECT '"
+    "  || (SELECT string_agg(format('%%I', attname), ',') FROM nonpk)"
+    "  || ' FROM ' || (SELECT (oid::regclass)::text FROM tbl)"
+    "  || ' WHERE '"
+    "  || (SELECT string_agg(format('%%I=?', attname), ' AND ') FROM pk)"
+    "  || ';';";
 
 const char * const SQL_DELETE_ROW_BY_ROWID =
     "DELETE FROM %s WHERE ctid = $1;";  // TODO: consider using PK-based deletion; ctid is unstable

src/sqlite/database_sqlite.c

@@ -45,6 +45,60 @@ char *sql_escape_name (const char *name, char *buffer, size_t bsize) {
     return sqlite3_snprintf((int)bsize, buffer, "%q", name);
 }
 
+char *sql_build_select_nonpk_by_pk (db_t *db, const char *table_name) {
+    char *sql = NULL;
+    
+    /*
+    This SQL statement dynamically generates a SELECT query for a specified table.
+    It uses Common Table Expressions (CTEs) to construct the column names and
+    primary key conditions based on the table schema, which is obtained through
+    the `pragma_table_info` function.
+
+    1. `col_names` CTE:
+       - Retrieves a comma-separated list of non-primary key column names from
+         the specified table's schema.
+
+    2. `pk_where` CTE:
+       - Retrieves a condition string representing the primary key columns in the
+         format: "column1=? AND column2=? AND ...", used to create the WHERE clause
+         for selecting rows based on primary key values.
+
+    3. Final SELECT:
+       - Constructs the complete SELECT statement as a string, combining:
+         - Column names from `col_names`.
+         - The target table name.
+         - The WHERE clause conditions from `pk_where`.
+
+    The resulting query can be used to select rows from the table based on primary
+    key values, and can be executed within the application to retrieve data dynamically.
+    */
+
+    // Unfortunately in SQLite column names (or table names) cannot be bound parameters in a SELECT statement
+    // otherwise we should have used something like SELECT 'SELECT ? FROM %w WHERE rowid=?';
+    char buffer[1024];
+    char *singlequote_escaped_table_name = sql_escape_name(table_name, buffer, sizeof(buffer));
+    
+    #if !CLOUDSYNC_DISABLE_ROWIDONLY_TABLES
+    if (table->rowid_only) {
+        sql = memory_mprintf(SQL_BUILD_SELECT_NONPK_COLS_BY_ROWID, table->name, table->name);
+        goto process_process;
+    }
+    #endif
+
+    sql = cloudsync_memory_mprintf(SQL_BUILD_SELECT_NONPK_COLS_BY_PK, table_name, table_name, singlequote_escaped_table_name);
+
+#if !CLOUDSYNC_DISABLE_ROWIDONLY_TABLES
+process_process:
+#endif
+    if (!sql) return NULL;
+    
+    char *query = NULL;
+    int rc = database_select_text(db, sql, &query);
+    cloudsync_memory_free(sql);
+    
+    return (rc == DBRES_OK) ? query : NULL;
+}
+
 // MARK: - PRIVATE -
 
 int database_select1_value (db_t *db, const char *sql, char **ptr_value, int64_t *int_value, DBTYPE expected_type) {