Revert "Merge branch 'features-2621' into 'master'"

This reverts merge request !8

dap_chain_global_db.c

@@ -22,12 +22,12 @@
  along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <string.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <pthread.h>
 #include <time.h>
 #include <assert.h>
+#include <string.h>
 
 #include "uthash.h"
 
@@ -83,7 +83,7 @@ char * extract_group_prefix(const char * a_group);
  * @param a_group
  * @return
  */
-char * extract_group_prefix(const char * a_group)
+char * extract_group_prefix(const char* a_group)
 {
     char * l_group_prefix = NULL, *l_delimeter;
     size_t l_group_prefix_size;
@@ -190,17 +190,6 @@ int dap_chain_global_db_init(dap_config_t * g_config)
     return res;
 }
 
-/**
- * @brief dap_chain_global_db_flush
- * @return
- */
-int dap_chain_global_db_flush(void){
-    lock();
-    int res = dap_db_driver_flush();
-    unlock();
-    return res;
-}
-
 /**
  * @brief dap_chain_global_db_deinit
  */
@@ -351,7 +340,7 @@ bool dap_chain_global_db_set( char *a_key,  void *a_value, size_t a_value_len)
 /**
  * Delete entry from base
  */
-bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group)
+bool dap_chain_global_db_gr_del(char *a_key, char *a_group)
 {
     if(!a_key)
         return NULL;
@@ -387,7 +376,7 @@ bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group)
         return true;
     return false;
 }
-bool dap_chain_global_db_del(const char *a_key)
+bool dap_chain_global_db_del(char *a_key)
 {
     return dap_chain_global_db_gr_del(a_key, GROUP_LOCAL_GENERAL);
 }
@@ -488,7 +477,7 @@ bool dap_chain_global_db_obj_save(void* a_store_data, size_t a_objs_count)
     if(!l_res) {
         for(size_t i = 0; i < a_objs_count; i++) {
             history_group_item_t * l_history_group_item = NULL;
-            dap_store_obj_t* l_obj = a_store_data + i;
+            dap_store_obj_t* l_obj = (dap_store_obj_t*)a_store_data + i;
             char * l_group_prefix = extract_group_prefix(l_obj->group);
             if(l_group_prefix)
                 HASH_FIND_STR(s_history_group_items, l_group_prefix, l_history_group_item);
@@ -496,13 +485,13 @@ bool dap_chain_global_db_obj_save(void* a_store_data, size_t a_objs_count)
             if(l_history_group_item) {
                 if(l_history_group_item->auto_track) {
                     lock();
-                    dap_db_history_add(l_obj->type, l_obj, 1);
+                    dap_db_history_add((char)l_obj->type, l_obj, 1);
                     unlock();
                 }
                 if(l_history_group_item->callback_notify) {
                     if(l_obj) {
                         l_history_group_item->callback_notify(l_history_group_item->callback_arg,
-                                l_obj->type,
+                                (const char)l_obj->type,
                                 l_group_prefix, l_obj->group, l_obj->key,
                                 l_obj->value, l_obj->value_len);
                     } else {

dap_chain_global_db.h

@@ -25,10 +25,8 @@ typedef struct dap_global_db_obj {
 typedef void (*dap_global_db_obj_callback_notify_t) (void * a_arg, const char a_op_code, const char * a_prefix, const char * a_group,
                                                      const char * a_key, const void * a_value,
                                                      const size_t a_value_len);
-/**
- * Flush DB
- */
-int dap_chain_global_db_flush(void);
+
+
 /**
  * Clean struct dap_global_db_obj_t
  */
@@ -70,8 +68,8 @@ bool dap_chain_global_db_set( char *a_key, void *a_value, size_t a_value_len);
 /**
  * Delete entry from base
  */
-bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group);
-bool dap_chain_global_db_del(const char *a_key);
+bool dap_chain_global_db_gr_del(char *a_key, char *a_group);
+bool dap_chain_global_db_del(char *a_key);
 
 /**
  * Read the entire database into an array of size bytes

dap_chain_global_db_driver.c

@@ -43,8 +43,6 @@ static char *s_used_driver = NULL;
 
 //#define USE_WRITE_BUFFER
 
-pthread_cond_t access_resource = PTHREAD_COND_INITIALIZER;
-
 #ifdef USE_WRITE_BUFFER
 static int save_write_buf(void);
 
@@ -147,11 +145,6 @@ void dap_db_driver_deinit(void)
     }
 }
 
-int dap_db_driver_flush(void)
-{
-    return s_drv_callback.flush();
-}
-
 dap_store_obj_t* dap_store_obj_copy(dap_store_obj_t *a_store_obj, size_t a_store_count)
 {
     if(!a_store_obj || !a_store_count)
@@ -317,7 +310,7 @@ char* dap_chain_global_db_driver_hash(const uint8_t *data, size_t data_size)
     dap_hash_fast(data, data_size, &l_hash);
     size_t a_str_max = (sizeof(l_hash.raw) + 1) * 2 + 2; /* heading 0x */
     char *a_str = DAP_NEW_Z_SIZE(char, a_str_max);
-    size_t hash_len = dap_chain_hash_fast_to_str(&l_hash, a_str, a_str_max);
+    size_t hash_len = (size_t)dap_chain_hash_fast_to_str(&l_hash, a_str, a_str_max);
     if(!hash_len) {
         DAP_DELETE(a_str);
         return NULL;

dap_chain_global_db_driver.h

@@ -34,7 +34,7 @@ typedef struct dap_store_obj {
     time_t timestamp;
 	uint8_t type;
     char *group;
-	char *key;
+    char *key;
     const char *c_group;
     const char *c_key;
     uint8_t *value;
@@ -61,7 +61,6 @@ typedef struct dap_db_driver_callbacks {
     dap_db_driver_callback_t transaction_start;
     dap_db_driver_callback_t transaction_end;
     dap_db_driver_callback_t deinit;
-    dap_db_driver_callback_t flush;
 } dap_db_driver_callbacks_t;
 
 
@@ -70,7 +69,6 @@ void dap_db_driver_deinit(void);
 
 dap_store_obj_t* dap_store_obj_copy(dap_store_obj_t *a_store_obj, size_t a_store_count);
 void dap_store_obj_free(dap_store_obj_t *a_store_obj, size_t a_store_count);
-int dap_db_driver_flush(void);
 
 char* dap_chain_global_db_driver_hash(const uint8_t *data, size_t data_size);
 

dap_chain_global_db_driver_cdb.c

@@ -90,10 +90,16 @@ static void cdb_serialize_val_to_dap_store_obj(pdap_store_obj_t a_obj, const cha
     a_obj->value = DAP_NEW_SIZE(uint8_t, a_obj->value_len);
     memcpy(a_obj->value, val + offset, a_obj->value_len);
     offset += a_obj->value_len;
-    a_obj->timestamp = dap_cdb_hex_to_uint(val + offset, sizeof(time_t));
+    a_obj->timestamp = (time_t)dap_cdb_hex_to_uint(val + offset, sizeof(time_t));
 }
 
 bool dap_cdb_get_last_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     if (--((pobj_arg)arg)->q == 0) {
         cdb_serialize_val_to_dap_store_obj((pdap_store_obj_t)(((pobj_arg)arg)->o), key, val);
         return false;
@@ -102,6 +108,12 @@ bool dap_cdb_get_last_obj_iter_callback(void *arg, const char *key, int ksize, c
 }
 
 bool dap_cdb_get_some_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     pdap_store_obj_t l_obj = (pdap_store_obj_t)((pobj_arg)arg)->o;
     cdb_serialize_val_to_dap_store_obj(&l_obj[((pobj_arg)arg)->n - ((pobj_arg)arg)->q], key, val);
     if (--((pobj_arg)arg)->q == 0) {
@@ -111,6 +123,12 @@ bool dap_cdb_get_some_obj_iter_callback(void *arg, const char *key, int ksize, c
 }
 
 bool dap_cdb_get_cond_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     if (dap_cdb_hex_to_uint(val, sizeof(uint64_t)) < ((pobj_arg)arg)->id) {
         return true;
     }
@@ -172,6 +190,7 @@ pcdb_instance dap_cdb_init_group(char *a_group, int a_flags) {
         log_it(L_INFO, "Group \"%s\" truncated"             , l_cdb_i->local_group);
         l_cdb_i->id = 0;
     }
+
 FIN:
     pthread_mutex_unlock(&cdb_mutex);
     return l_cdb_i;
@@ -211,7 +230,6 @@ int dap_db_driver_cdb_init(const char *a_cdb_path, dap_db_driver_callbacks_t *a_
     a_drv_callback->read_store_obj      = dap_db_driver_cdb_read_store_obj;
     a_drv_callback->read_cond_store_obj = dap_db_driver_cdb_read_cond_store_obj;
     a_drv_callback->deinit              = dap_db_driver_cdb_deinit;
-    a_drv_callback->flush               = dap_db_driver_cdb_flush;
 
     closedir(dir);
     return CDB_SUCCESS;
@@ -226,7 +244,7 @@ pcdb_instance dap_cdb_get_db_by_group(const char *a_group) {
 }
 
 int dap_cdb_add_group(const char *a_group) {
-    char l_cdb_path[strlen(s_cdb_path) + strlen(a_group) + 2];
+    char* l_cdb_path = malloc(strlen(s_cdb_path) + strlen(a_group) + 2);
     memset(l_cdb_path, '\0', strlen(s_cdb_path) + strlen(a_group) + 2);
     strcat(l_cdb_path, s_cdb_path);
     strcat(l_cdb_path, "/");
@@ -238,6 +256,7 @@ int dap_cdb_add_group(const char *a_group) {
     mkdir(l_cdb_path, 0755);
 #endif
 
+    free(l_cdb_path);
     return 0;
 }
 
@@ -255,42 +274,6 @@ int dap_db_driver_cdb_deinit() {
     return CDB_SUCCESS;
 }
 
-int dap_db_driver_cdb_flush(void){
-    log_it(L_DEBUG, "Start flush cuttdb.");
-    //CLOSE
-    cdb_instance *cur_cdb, *tmp;
-    HASH_ITER(hh, s_cdb, cur_cdb, tmp) {
-        DAP_DELETE(cur_cdb->local_group);
-        cdb_destroy(cur_cdb->cdb);
-        HASH_DEL(s_cdb, cur_cdb);
-        DAP_DELETE(cur_cdb);
-    }
-    //SYNC
-#ifndef _WIN32
-    sync();
-#endif
-    //OPEN
-    struct dirent *d;
-    DIR *dir = opendir(s_cdb_path);
-    if (!dir) {
-        log_it(L_ERROR, "Couldn't open db directory");
-        return -1;
-    }
-    for (d = readdir(dir); d; d = readdir(dir)) {
-        if (!dap_strcmp(d->d_name, ".") || !dap_strcmp(d->d_name, "..")) {
-            continue;
-        }
-        pcdb_instance l_cdb_i = dap_cdb_init_group(d->d_name, CDB_CREAT | CDB_PAGEWARMUP);
-        if (!l_cdb_i) {
-            dap_db_driver_cdb_deinit();
-            closedir(dir);
-            return -2;
-        }
-    }
-    closedir(dir);
-    return 0;
-}
-
 dap_store_obj_t *dap_db_driver_cdb_read_last_store_obj(const char* a_group) {
     if (!a_group) {
         return NULL;
@@ -325,7 +308,7 @@ dap_store_obj_t *dap_db_driver_cdb_read_store_obj(const char *a_group, const cha
     if (a_key) {
         char *l_value;
         int l_vsize;
-        cdb_get(l_cdb, a_key, strlen(a_key), (void**)&l_value, &l_vsize);
+        cdb_get(l_cdb, a_key, (int)strlen(a_key), (void**)&l_value, &l_vsize);
         if (!l_value) {
             return NULL;
         }
@@ -441,7 +424,7 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
         dap_cdb_uint_to_hex(l_val + offset, l_time, sizeof(time_t));
         offset += sizeof(time_t);
         l_rec.val = l_val;
-        if (cdb_set2(l_cdb_i->cdb, l_rec.key, strlen(l_rec.key), l_rec.val, offset, CDB_INSERTCACHE | CDB_OVERWRITE, 0) != CDB_SUCCESS) {
+        if (cdb_set2(l_cdb_i->cdb, l_rec.key, (int)strlen(l_rec.key), l_rec.val, offset, CDB_INSERTCACHE | CDB_OVERWRITE, 0) != CDB_SUCCESS) {
             log_it(L_ERROR, "Couldn't add record with key [%s] to CDB: \"%s\"", l_rec.key, cdb_errmsg(cdb_errno(l_cdb_i->cdb)));
             ret = -1;
         }
@@ -449,7 +432,7 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
         DAP_DELETE(l_rec.val);
     } else if(a_store_obj->type == 'd') {
         if(a_store_obj->key) {
-            cdb_del(l_cdb_i->cdb, a_store_obj->key, strlen(a_store_obj->key));
+            cdb_del(l_cdb_i->cdb, a_store_obj->key, (int)strlen(a_store_obj->key));
         } else {
             cdb_destroy(l_cdb_i->cdb);
             if (!dap_cdb_init_group(a_store_obj->group, CDB_TRUNC | CDB_PAGEWARMUP)) {

dap_chain_global_db_driver_cdb.h

@@ -24,9 +24,7 @@
 
 #include "cuttdb.h"
 #include "dap_chain_global_db_driver.h"
-#ifndef _WIN32
-#include "unistd.h"
-#endif
+#define UNUSED(x) (void)(x)
 
 typedef struct _cdb_options {
     int hsize;      // Main hash table size, 1%-10% of total records, immutable
@@ -41,7 +39,6 @@ typedef struct _cdb_record {
 
 int dap_db_driver_cdb_init(const char*, dap_db_driver_callbacks_t*);
 int dap_db_driver_cdb_deinit();
-int dap_db_driver_cdb_flush(void);
 
 int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t);
 

dap_chain_global_db_driver_sqlite.c

@@ -32,7 +32,6 @@
 #define LOG_TAG "db_sqlite"
 
 static sqlite3 *s_db = NULL;
-static char *s_filename_db = NULL;
 
 // Value of one field in the table
 typedef struct _SQLITE_VALUE_
@@ -46,13 +45,14 @@ typedef struct _SQLITE_VALUE_
      #define SQLITE_BLOB     4
      #define SQLITE_NULL     5
      */
+    uint8_t reserv[3];
     union
     {
         int val_int;
         long long val_int64;
         double val_float;
-        char *val_str;
-        unsigned char *val_blob;
+        const char *val_str;
+        const unsigned char *val_blob;
     } val;
 } SQLITE_VALUE;
 
@@ -60,6 +60,7 @@ typedef struct _SQLITE_VALUE_
 typedef struct _SQLITE_ROW_VALUE_
 {
     int count; // number of columns in a row
+    int reserv;
     SQLITE_VALUE *val; // array of field values
 } SQLITE_ROW_VALUE;
 
@@ -103,8 +104,6 @@ int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks
         a_drv_callback->transaction_start = dap_db_driver_sqlite_start_transaction;
         a_drv_callback->transaction_end = dap_db_driver_sqlite_end_transaction;
         a_drv_callback->deinit = dap_db_driver_sqlite_deinit;
-        a_drv_callback->flush = dap_db_driver_sqlite_flush;
-        s_filename_db = strdup(a_filename_db);
     }
     return l_ret;
 }
@@ -119,10 +118,10 @@ int dap_db_driver_sqlite_deinit(void)
 // additional function for sqlite to convert byte to number
 static void byte_to_bin(sqlite3_context *l_context, int a_argc, sqlite3_value **a_argv)
 {
-    unsigned char *l_text;
+    const unsigned char *l_text;
     if(a_argc != 1)
         sqlite3_result_null(l_context);
-    l_text = (unsigned char *) sqlite3_value_blob(a_argv[0]);
+    l_text = (const unsigned char *) sqlite3_value_blob(a_argv[0]);
     if(l_text && l_text[0])
             {
         int l_result = (int) l_text[0];
@@ -206,30 +205,6 @@ bool dap_db_driver_sqlite_set_pragma(sqlite3 *a_db, char *a_param, char *a_mode)
     return false;
 }
 
-int dap_db_driver_sqlite_flush()
-{
-    log_it(L_DEBUG, "Start flush sqlite data base.");
-    dap_db_driver_sqlite_close(s_db);
-    char *l_error_message;
-    s_db = dap_db_driver_sqlite_open(s_filename_db, SQLITE_OPEN_READWRITE, &l_error_message);
-    if(!s_db) {
-        log_it(L_ERROR, "Can't init sqlite err=%d", l_error_message);
-        dap_db_driver_sqlite_free(l_error_message);
-        return -3;
-    }
-#ifndef _WIN32
-    sync();
-#endif
-    if(!dap_db_driver_sqlite_set_pragma(s_db, "synchronous", "NORMAL")) // 0 | OFF | 1 | NORMAL | 2 | FULL
-        log_it(L_WARNING, "Can't set new synchronous mode\n");
-    if(!dap_db_driver_sqlite_set_pragma(s_db, "journal_mode", "OFF")) // DELETE | TRUNCATE | PERSIST | MEMORY | WAL | OFF
-        log_it(L_WARNING, "Can't set new journal mode\n");
-
-    if(!dap_db_driver_sqlite_set_pragma(s_db, "page_size", "1024")) // DELETE | TRUNCATE | PERSIST | MEMORY | WAL | OFF
-        log_it(L_WARNING, "Can't set page_size\n");
-    return 0;
-}
-
 /**
  * Execute SQL query to database that does not return data
  *
@@ -358,7 +333,7 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
         l_row = (SQLITE_ROW_VALUE*) sqlite3_malloc(sizeof(SQLITE_ROW_VALUE));
         int l_count = sqlite3_column_count(l_res); // get the number of columns
         // allocate memory for all columns
-        l_row->val = (SQLITE_VALUE*) sqlite3_malloc(l_count * sizeof(SQLITE_VALUE));
+        l_row->val = (SQLITE_VALUE*) sqlite3_malloc(l_count * (int)sizeof(SQLITE_VALUE));
         if(l_row->val)
         {
             l_row->count = l_count; // number of columns
@@ -366,7 +341,7 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
                     {
                 SQLITE_VALUE *cur_val = l_row->val + l_iCol;
                 cur_val->len = sqlite3_column_bytes(l_res, l_iCol); // how many bytes will be needed
-                cur_val->type = sqlite3_column_type(l_res, l_iCol); // field type
+                cur_val->type = (signed char)sqlite3_column_type(l_res, l_iCol); // field type
                 if(cur_val->type == SQLITE_INTEGER)
                 {
                     cur_val->val.val_int64 = sqlite3_column_int64(l_res, l_iCol);
@@ -375,9 +350,9 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
                 else if(cur_val->type == SQLITE_FLOAT)
                     cur_val->val.val_float = sqlite3_column_double(l_res, l_iCol);
                 else if(cur_val->type == SQLITE_BLOB)
-                    cur_val->val.val_blob = (unsigned char*) sqlite3_column_blob(l_res, l_iCol);
+                    cur_val->val.val_blob = (const unsigned char*) sqlite3_column_blob(l_res, l_iCol);
                 else if(cur_val->type == SQLITE_TEXT)
-                    cur_val->val.val_str = (char*) sqlite3_column_text(l_res, l_iCol); //sqlite3_mprintf("%s",sqlite3_column_text(l_res,iCol));
+                    cur_val->val.val_str = (const char*) sqlite3_column_text(l_res, l_iCol); //sqlite3_mprintf("%s",sqlite3_column_text(l_res,iCol));
                 else
                     cur_val->val.val_str = NULL;
             }
@@ -415,7 +390,7 @@ static char* dap_db_driver_get_string_from_blob(uint8_t *blob, int len)
     if(!blob)
         return NULL;
     str_out = (char*) sqlite3_malloc(len * 2 + 1);
-    ret = dap_bin2hex((char*) str_out, blob, len);
+    ret = (int)dap_bin2hex(str_out, (const void*)blob, (size_t)len);
     str_out[len * 2] = 0;
     return str_out;
 
@@ -469,7 +444,7 @@ int dap_db_driver_sqlite_end_transaction(void)
 char *dap_db_driver_sqlite_make_table_name(const char *a_group_name)
 {
     char *l_group_name = dap_strdup(a_group_name);
-    ssize_t l_group_name_len = dap_strlen(l_group_name);
+    ssize_t l_group_name_len = (ssize_t)dap_strlen(l_group_name);
     const char *l_needle = ".";
     // replace '.' to '_'
     while(1){
@@ -499,7 +474,7 @@ int dap_db_driver_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
         //dap_hash_fast(a_store_obj->value, a_store_obj->value_len, &l_hash);
 
         char *l_blob_hash = "";//dap_db_driver_get_string_from_blob((uint8_t*) &l_hash, sizeof(dap_chain_hash_fast_t));
-        char *l_blob_value = dap_db_driver_get_string_from_blob(a_store_obj->value, a_store_obj->value_len);
+        char *l_blob_value = dap_db_driver_get_string_from_blob(a_store_obj->value, (int)a_store_obj->value_len);
         //add one record
         char *table_name = dap_db_driver_sqlite_make_table_name(a_store_obj->group);
         l_query = sqlite3_mprintf("insert into '%s' values(NULL, '%s', x'%s', '%lld', x'%s')",
@@ -571,7 +546,7 @@ static void fill_one_item(const char *a_group, dap_store_obj_t *a_obj, SQLITE_RO
         switch (l_iCol) {
         case 0:
             if(l_cur_val->type == SQLITE_INTEGER)
-                a_obj->id = l_cur_val->val.val_int64;
+                a_obj->id = (uint64_t)l_cur_val->val.val_int64;
             break; // id
         case 1:
             if(l_cur_val->type == SQLITE_INTEGER)
@@ -649,7 +624,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     // no limit
     int l_count_out = 0;
     if(a_count_out)
-        l_count_out = *a_count_out;
+        l_count_out = (int)*a_count_out;
     char *l_str_query;
     if(l_count_out)
         l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE id>'%lld' ORDER BY id ASC LIMIT %d",
@@ -679,8 +654,8 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
             // realloc memory
             if(l_count_out >= l_count_sized) {
                 l_count_sized += 10;
-                l_obj = DAP_REALLOC(l_obj, sizeof(dap_store_obj_t) * l_count_sized);
-                memset(l_obj + l_count_out, 0, sizeof(dap_store_obj_t) * (l_count_sized - l_count_out));
+                l_obj = DAP_REALLOC(l_obj, sizeof(dap_store_obj_t) * (uint64_t)l_count_sized);
+                memset(l_obj + l_count_out, 0, sizeof(dap_store_obj_t) * (uint64_t)(l_count_sized - l_count_out));
             }
             // fill current item
             dap_store_obj_t *l_obj_cur = l_obj + l_count_out;
@@ -693,7 +668,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     dap_db_driver_sqlite_query_free(l_res);
 
     if(a_count_out)
-        *a_count_out = l_count_out;
+        *a_count_out = (size_t)l_count_out;
     return l_obj;
 }
 
@@ -713,7 +688,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     if(!a_group)
         return NULL;
     // no limit
-    int l_count_out = 0;
+    uint64_t l_count_out = 0;
     if(a_count_out)
         l_count_out = *a_count_out;
     char *l_str_query;
@@ -743,7 +718,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     //int b = qlite3_column_count(s_db);
     SQLITE_ROW_VALUE *l_row = NULL;
     l_count_out = 0;
-    int l_count_sized = 0;
+    uint64_t l_count_sized = 0;
     do {
         l_ret = dap_db_driver_sqlite_fetch_array(l_res, &l_row);
         if(l_ret != SQLITE_ROW && l_ret != SQLITE_DONE)

dap_chain_global_db_driver_sqlite.h

@@ -24,9 +24,6 @@
 
 #include "sqlite3.h"
 #include "dap_chain_global_db_driver.h"
-#ifndef _WIN32
-#include "unistd.h"
-#endif
 
 int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks_t *a_drv_callback);
 int dap_db_driver_sqlite_deinit(void);
@@ -35,7 +32,6 @@ sqlite3* dap_db_driver_sqlite_open(const char *a_filename_utf8, int a_flags, cha
 void dap_db_driver_sqlite_close(sqlite3 *l_db);
 void dap_db_driver_sqlite_free(char *memory);
 bool dap_db_driver_sqlite_set_pragma(sqlite3 *a_db, char *a_param, char *a_mode);
-int dap_db_driver_sqlite_flush(void);
 
 
 // ** SQLite callbacks **