Cleaned-up 64bit types

Author: marcobambini

src/cloudsync.c

@@ -44,8 +44,8 @@ int cloudsync_insync (cloudsync_context *data);
 int cloudsync_bumpseq (cloudsync_context *data);
 void *cloudsync_siteid (cloudsync_context *data);
 void cloudsync_reset_siteid (cloudsync_context *data);
-db_int64 cloudsync_dbversion_next (cloudsync_context *data, db_int64 merging_version);
-db_int64 cloudsync_dbversion (cloudsync_context *data);
+int64_t cloudsync_dbversion_next (cloudsync_context *data, int64_t merging_version);
+int64_t cloudsync_dbversion (cloudsync_context *data);
 void cloudsync_update_schema_hash (cloudsync_context *data);
 int cloudsync_dbversion_check_uptodate (cloudsync_context *data);
 
@@ -72,7 +72,7 @@ int cloudsync_payload_apply (cloudsync_context *data, const char *payload, int b
 // Payload context (used to encode changes)
 int    cloudsync_payload_encode_step  (cloudsync_payload_context *payload, cloudsync_context *data, int argc, dbvalue_t **argv);
 int    cloudsync_payload_encode_final (cloudsync_payload_context *payload, cloudsync_context *data);
-char  *cloudsync_payload_blob (cloudsync_payload_context *payload, db_int64 *blob_size, db_int64 *nrows);
+char  *cloudsync_payload_blob (cloudsync_payload_context *payload, int64_t *blob_size, int64_t *nrows);
 size_t cloudsync_payload_context_size (size_t *header_size);
 
 // CLOUDSYNCTABLE CONTEXT
@@ -94,12 +94,12 @@ bool table_algo_isgos (cloudsync_table_context *table);
 int table_remove (cloudsync_context *data, cloudsync_table_context *table);
 void table_free (cloudsync_table_context *table);
 
-int local_mark_insert_sentinel_meta (cloudsync_table_context *table, const char *pk, size_t pklen, db_int64 db_version, int seq);
-int local_update_sentinel (cloudsync_table_context *table, const char *pk, size_t pklen, db_int64 db_version, int seq);
-int local_mark_insert_or_update_meta (cloudsync_table_context *table, const char *pk, size_t pklen, const char *col_name, db_int64 db_version, int seq);
-int local_mark_delete_meta (cloudsync_table_context *table, const char *pk, size_t pklen, db_int64 db_version, int seq);
+int local_mark_insert_sentinel_meta (cloudsync_table_context *table, const char *pk, size_t pklen, int64_t db_version, int seq);
+int local_update_sentinel (cloudsync_table_context *table, const char *pk, size_t pklen, int64_t db_version, int seq);
+int local_mark_insert_or_update_meta (cloudsync_table_context *table, const char *pk, size_t pklen, const char *col_name, int64_t db_version, int seq);
+int local_mark_delete_meta (cloudsync_table_context *table, const char *pk, size_t pklen, int64_t db_version, int seq);
 int local_drop_meta (cloudsync_table_context *table, const char *pk, size_t pklen);
-int local_update_move_meta (cloudsync_table_context *table, const char *pk, size_t pklen, const char *pk2, size_t pklen2, db_int64 db_version);
+int local_update_move_meta (cloudsync_table_context *table, const char *pk, size_t pklen, const char *pk2, size_t pklen2, int64_t db_version);
 
 #ifdef __cplusplus
 }

src/cloudsync.h

@@ -25,16 +25,16 @@ typedef enum {
 
 
 // used by vtab.c
-int merge_insert_col (cloudsync_context *data, cloudsync_table_context *table, const char *pk, int pklen, const char *col_name, dbvalue_t *col_value, db_int64 col_version, db_int64 db_version, const char *site_id, int site_len, db_int64 seq, db_int64 *rowid);
+int merge_insert_col (cloudsync_context *data, cloudsync_table_context *table, const char *pk, int pklen, const char *col_name, dbvalue_t *col_value, int64_t col_version, int64_t db_version, const char *site_id, int site_len, int64_t seq, int64_t *rowid);
 
-int merge_insert (cloudsync_context *data, cloudsync_table_context *table, const char *insert_pk, int insert_pk_len, db_int64 insert_cl, const char *insert_name, dbvalue_t *insert_value, db_int64 insert_col_version, db_int64 insert_db_version, const char *insert_site_id, int insert_site_id_len, db_int64 insert_seq, db_int64 *rowid);
+int merge_insert (cloudsync_context *data, cloudsync_table_context *table, const char *insert_pk, int insert_pk_len, int64_t insert_cl, const char *insert_name, dbvalue_t *insert_value, int64_t insert_col_version, int64_t insert_db_version, const char *insert_site_id, int insert_site_id_len, int64_t insert_seq, int64_t *rowid);
 
 
 
 void cloudsync_sync_key (cloudsync_context *data, const char *key, const char *value);
 
 // used by network layer
-int cloudsync_payload_get (cloudsync_context *data, char **blob, int *blob_size, int *db_version, int *seq, db_int64 *new_db_version, db_int64 *new_seq);
+int cloudsync_payload_get (cloudsync_context *data, char **blob, int *blob_size, int *db_version, int *seq, int64_t *new_db_version, int64_t *new_seq);
 
 // used by core
 bool cloudsync_config_exists (db_t *db);

src/cloudsync_private.h

@@ -327,7 +327,7 @@ void dbsync_insert (sqlite3_context *context, int argc, sqlite3_value **argv) {
     }
 
     // compute the next database version for tracking changes
-    db_int64 db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
+    int64_t db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
 
     // check if a row with the same primary key already exists
     // if so, this means the row might have been previously deleted (sentinel)
@@ -374,7 +374,7 @@ void dbsync_delete (sqlite3_context *context, int argc, sqlite3_value **argv) {
     }
 
     // compute the next database version for tracking changes
-    db_int64 db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
+    int64_t db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
     int rc = SQLITE_OK;
 
     // encode the primary key values into a buffer
@@ -482,7 +482,7 @@ void dbsync_update_final (sqlite3_context *context) {
     }
 
     // compute the next database version for tracking changes
-    db_int64 db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
+    int64_t db_version = cloudsync_dbversion_next(data, CLOUDSYNC_VALUE_NOTSET);
     int rc = SQLITE_OK;
 
     // Check if the primary key(s) have changed
@@ -752,7 +752,7 @@ void dbsync_payload_encode_final (sqlite3_context *context) {
     }
 
     // result is OK so get BLOB and returns it
-    db_int64 blob_size = 0;
+    int64_t blob_size = 0;
     char *blob = cloudsync_payload_blob (payload, &blob_size, NULL);
     if (!blob) {
         sqlite3_result_null(context);

src/cloudsync_sqlite.c

@@ -13,8 +13,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 
-typedef long long int db_int64;
-typedef unsigned long long int db_uint64;
 typedef void db_t;
 typedef void dbvm_t;
 typedef void dbvalue_t;
@@ -62,10 +60,10 @@ typedef int (*database_exec_cb) (void *xdata, int argc, char **values, char **na
 
 int  database_exec (db_t *db, const char *sql);
 int  database_exec_callback (db_t *db, const char *sql, database_exec_cb, void *xdata);
-int  database_select_int (db_t *db, const char *sql, db_int64 *value);
+int  database_select_int (db_t *db, const char *sql, int64_t *value);
 int  database_select_text (db_t *db, const char *sql, char **value);
-int  database_select_blob (db_t *db, const char *sql, char **value, db_int64 *value_len);
-int  database_select_blob_2int (db_t *db, const char *sql, char **value, db_int64 *value_len, db_int64 *value2, db_int64 *value3);
+int  database_select_blob (db_t *db, const char *sql, char **value, int64_t *value_len);
+int  database_select_blob_2int (db_t *db, const char *sql, char **value, int64_t *value_len, int64_t *value2, int64_t *value3);
 int  database_write (db_t *db, const char *sql, const char **values, DBTYPE types[], int lens[], int count);
 bool database_table_exists (db_t *db, const char *table_name);
 bool database_trigger_exists (db_t *db, const char *table_name);
@@ -80,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);
 
-db_int64 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);
@@ -101,17 +99,17 @@ void databasevm_clear_bindings (dbvm_t *vm);
 const char *databasevm_sql (dbvm_t *vm);
 
 // BINDING
-int databasevm_bind_blob (dbvm_t *vm, int index, const void *value, db_uint64 size);
+int databasevm_bind_blob (dbvm_t *vm, int index, const void *value, uint64_t size);
 int databasevm_bind_double (dbvm_t *vm, int index, double value);
-int databasevm_bind_int (dbvm_t *vm, int index, db_int64 value);
+int databasevm_bind_int (dbvm_t *vm, int index, int64_t value);
 int databasevm_bind_null (dbvm_t *vm, int index);
 int databasevm_bind_text (dbvm_t *vm, int index, const char *value, int size);
 int databasevm_bind_value (dbvm_t *vm, int index, dbvalue_t *value);
 
 // VALUE
 const void *database_value_blob (dbvalue_t *value);
 double database_value_double (dbvalue_t *value);
-db_int64 database_value_int (dbvalue_t *value);
+int64_t database_value_int (dbvalue_t *value);
 const char *database_value_text (dbvalue_t *value);
 int database_value_bytes (dbvalue_t *value);
 int database_value_type (dbvalue_t *value);
@@ -121,28 +119,28 @@ void *database_value_dup (dbvalue_t *value);
 // COLUMN
 const void *database_column_blob (dbvm_t *vm, int index);
 double database_column_double (dbvm_t *vm, int index);
-db_int64 database_column_int (dbvm_t *vm, int index);
+int64_t database_column_int (dbvm_t *vm, int index);
 const char *database_column_text (dbvm_t *vm, int index);
 dbvalue_t *database_column_value (dbvm_t *vm, int index);
 int database_column_bytes (dbvm_t *vm, int index);
 int database_column_type (dbvm_t *vm, int index);
 
 // RESULT
-void database_result_blob (dbcontext_t *context, const void *value, db_uint64 size, void(*)(void*));
+void database_result_blob (dbcontext_t *context, const void *value, uint64_t size, void(*)(void*));
 void database_result_double (dbcontext_t *context, double value);
-void database_result_int (dbcontext_t *context, db_int64 value);
+void database_result_int (dbcontext_t *context, int64_t value);
 void database_result_null (dbcontext_t *context);
 void database_result_text (dbcontext_t *context, const char *value, int size, void(*)(void*));
 void database_result_value (dbcontext_t *context, dbvalue_t *value);
 
 // MEMORY
-void *dbmem_alloc (db_uint64 size);
-void *dbmem_zeroalloc (db_uint64 size);
-void *dbmem_realloc (void *ptr, db_uint64 new_size);
+void *dbmem_alloc (uint64_t size);
+void *dbmem_zeroalloc (uint64_t size);
+void *dbmem_realloc (void *ptr, uint64_t new_size);
 char *dbmem_mprintf(const char *format, ...);
 char *dbmem_vmprintf (const char *format, va_list list);
 void dbmem_free (void *ptr);
-db_uint64 dbmem_size (void *ptr);
+uint64_t dbmem_size (void *ptr);
 
 // SQL
 char *sql_build_drop_table (const char *table_name, char *buffer, int bsize, bool is_meta);

src/database.h

@@ -46,7 +46,7 @@ char *sql_escape_name (const char *name, char *buffer, size_t bsize) {
 
 // MARK: - PRIVATE -
 
-int database_select1_value (db_t *db, const char *sql, char **ptr_value, db_int64 *int_value, DBTYPE expected_type) {
+int database_select1_value (db_t *db, const char *sql, char **ptr_value, int64_t *int_value, DBTYPE expected_type) {
     // init values and sanity check expected_type
     if (ptr_value) *ptr_value = NULL;
     *int_value = 0;
@@ -69,7 +69,7 @@ int database_select1_value (db_t *db, const char *sql, char **ptr_value, db_int6
     if (type != expected_type) {rc = SQLITE_MISMATCH; goto cleanup_select;}
 
     if (expected_type == DBTYPE_INTEGER) {
-        *int_value = (db_int64)sqlite3_column_int64(vm, 0);
+        *int_value = (int64_t)sqlite3_column_int64(vm, 0);
     } else {
         const void *value = (expected_type == DBTYPE_TEXT) ? (const void *)sqlite3_column_text(vm, 0) : (const void *)sqlite3_column_blob(vm, 0);
         int len = sqlite3_column_bytes(vm, 0);
@@ -91,7 +91,7 @@ int database_select1_value (db_t *db, const char *sql, char **ptr_value, db_int6
     return rc;
 }
 
-int database_select3_values (db_t *db, const char *sql, char **value, db_int64 *len, db_int64 *value2, db_int64 *value3) {
+int database_select3_values (db_t *db, const char *sql, char **value, int64_t *len, int64_t *value2, int64_t *value3) {
     // init values and sanity check expected_type
     *value = NULL;
     *value2 = 0;
@@ -127,8 +127,8 @@ int database_select3_values (db_t *db, const char *sql, char **value, db_int64 *
     }
 
     // 2nd and 3rd columns are INTEGERS
-    *value2 = (db_int64)sqlite3_column_int64(vm, 1);
-    *value3 = (db_int64)sqlite3_column_int64(vm, 2);
+    *value2 = (int64_t)sqlite3_column_int64(vm, 1);
+    *value3 = (int64_t)sqlite3_column_int64(vm, 2);
 
     rc = SQLITE_OK;
 
@@ -208,20 +208,20 @@ int database_write (db_t *db, const char *sql, const char **bind_values, DBTYPE
     return rc;
 }
 
-int database_select_int (db_t *db, const char *sql, db_int64 *value) {
+int database_select_int (db_t *db, const char *sql, int64_t *value) {
     return database_select1_value(db, sql, NULL, value, DBTYPE_INTEGER);
 }
 
 int database_select_text (db_t *db, const char *sql, char **value) {
-    db_int64 len = 0;
+    int64_t len = 0;
     return database_select1_value(db, sql, value, &len, DBTYPE_TEXT);
 }
 
-int database_select_blob (db_t *db, const char *sql, char **value, db_int64 *len) {
+int database_select_blob (db_t *db, const char *sql, char **value, int64_t *len) {
     return database_select1_value(db, sql, value, len, DBTYPE_BLOB);
 }
 
-int database_select_blob_2int (db_t *db, const char *sql, char **value, db_int64 *len, db_int64 *value2, db_int64 *value3) {
+int database_select_blob_2int (db_t *db, const char *sql, char **value, int64_t *len, int64_t *value2, int64_t *value3) {
     return database_select3_values(db, sql, value, len, value2, value3);
 }
 
@@ -256,7 +256,7 @@ int database_count_pk (db_t *db, const char *table_name, bool not_null) {
         sql = sqlite3_snprintf(sizeof(buffer), buffer, "SELECT count(*) FROM pragma_table_info('%q') WHERE pk>0;", table_name);
     }
 
-    db_int64 count = 0;
+    int64_t count = 0;
     int rc = database_select_int(db, sql, &count);
     if (rc != DBRES_OK) return -1;
     return (int)count;
@@ -267,7 +267,7 @@ int database_count_nonpk (db_t *db, const char *table_name) {
     char *sql = NULL;
 
     sql = sqlite3_snprintf(sizeof(buffer), buffer, "SELECT count(*) FROM pragma_table_info('%q') WHERE pk=0;", table_name);
-    db_int64 count = 0;
+    int64_t count = 0;
     int rc = database_select_int(db, sql, &count);
     if (rc != DBRES_OK) return -1;
     return (int)count;
@@ -277,7 +277,7 @@ int database_count_int_pk (db_t *db, const char *table_name) {
     char buffer[1024];
     char *sql = sqlite3_snprintf(sizeof(buffer), buffer, "SELECT count(*) FROM pragma_table_info('%q') WHERE pk=1 AND \"type\" LIKE '%%INT%%';", table_name);
 
-    db_int64 count = 0;
+    int64_t count = 0;
     int rc = database_select_int(db, sql, &count);
     if (rc != DBRES_OK) return -1;
     return (int)count;
@@ -287,7 +287,7 @@ int database_count_notnull_without_default (db_t *db, const char *table_name) {
     char buffer[1024];
     char *sql = sqlite3_snprintf(sizeof(buffer), buffer, "SELECT count(*) FROM pragma_table_info('%q') WHERE pk=0 AND \"notnull\"=1 AND \"dflt_value\" IS NULL;", table_name);
 
-    db_int64 count = 0;
+    int64_t count = 0;
     int rc = database_select_int(db, sql, &count);
     if (rc != DBRES_OK) return -1;
     return (int)count;
@@ -527,14 +527,14 @@ int database_delete_triggers (db_t *db, const char *table) {
 
 // MARK: - SCHEMA -
 
-db_int64 database_schema_version (db_t *db) {
-    db_int64 value = 0;
+int64_t database_schema_version (db_t *db) {
+    int64_t value = 0;
     int rc = database_select_int(db, SQL_SCHEMA_VERSION, &value);
     return (rc == DBRES_OK) ? value : 0;
 }
 
 uint64_t database_schema_hash (db_t *db) {
-    db_int64 value = 0;
+    int64_t value = 0;
     int rc = database_select_int(db, "SELECT hash FROM cloudsync_schema_versions ORDER BY seq DESC limit 1;", &value);
     return (rc == DBRES_OK) ? (uint64_t)value : 0;
 }
@@ -549,7 +549,7 @@ bool database_check_schema_hash (db_t *db, uint64_t hash) {
     char sql[1024];
     snprintf(sql, sizeof(sql), "SELECT 1 FROM cloudsync_schema_versions WHERE hash = (%lld)", hash);
 
-    db_int64 value = 0;
+    int64_t value = 0;
     database_select_int(db, sql, &value);
     return (value == 1);
 }
@@ -679,15 +679,15 @@ int database_pk_names (db_t *db, const char *table_name, char ***names, int *cou
 
 // MARK: - BINDING -
 
-int databasevm_bind_blob (dbvm_t *vm, int index, const void *value, db_uint64 size) {
+int databasevm_bind_blob (dbvm_t *vm, int index, const void *value, uint64_t size) {
     return sqlite3_bind_blob64((sqlite3_stmt *)vm, index, value, size, SQLITE_STATIC);
 }
 
 int databasevm_bind_double (dbvm_t *vm, int index, double value) {
     return sqlite3_bind_double((sqlite3_stmt *)vm, index, value);
 }
 
-int databasevm_bind_int (dbvm_t *vm, int index, db_int64 value) {
+int databasevm_bind_int (dbvm_t *vm, int index, int64_t value) {
     return sqlite3_bind_int64((sqlite3_stmt *)vm, index, value);
 }
 
@@ -713,8 +713,8 @@ double database_value_double (dbvalue_t *value) {
     return sqlite3_value_double((sqlite3_value *)value);
 }
 
-db_int64 database_value_int (dbvalue_t *value) {
-    return (db_int64)sqlite3_value_int64((sqlite3_value *)value);
+int64_t database_value_int (dbvalue_t *value) {
+    return (int64_t)sqlite3_value_int64((sqlite3_value *)value);
 }
 
 const char *database_value_text (dbvalue_t *value) {
@@ -748,8 +748,8 @@ double database_column_double (dbvm_t *vm, int index) {
     return sqlite3_column_double((sqlite3_stmt *)vm, index);
 }
 
-db_int64 database_column_int (dbvm_t *vm, int index) {
-    return (db_int64)sqlite3_column_int64((sqlite3_stmt *)vm, index);
+int64_t database_column_int (dbvm_t *vm, int index) {
+    return (int64_t)sqlite3_column_int64((sqlite3_stmt *)vm, index);
 }
 
 const char *database_column_text (dbvm_t *vm, int index) {
@@ -790,7 +790,7 @@ int database_rollback_savepoint (db_t *db, const char *savepoint_name) {
 
 // MARK: - MEMORY -
 
-void *dbmem_alloc (db_uint64 size) {
+void *dbmem_alloc (uint64_t size) {
     return sqlite3_malloc64((sqlite3_uint64)size);
 }
 
@@ -802,7 +802,7 @@ void *dbmem_zeroalloc (uint64_t size) {
     return ptr;
 }
 
-void *dbmem_realloc (void *ptr, db_uint64 new_size) {
+void *dbmem_realloc (void *ptr, uint64_t new_size) {
     return sqlite3_realloc64(ptr, (sqlite3_uint64)new_size);
 }
 
@@ -825,8 +825,8 @@ void dbmem_free (void *ptr) {
     sqlite3_free(ptr);
 }
 
-db_uint64 dbmem_size (void *ptr) {
-    return (db_uint64)sqlite3_msize(ptr);
+uint64_t dbmem_size (void *ptr) {
+    return (uint64_t)sqlite3_msize(ptr);
 }
 
 // MARK: - Used to implement Server Side RLS -