modules/chain/dap_chain.c

@@ -214,7 +214,7 @@ dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain
     dap_chain_atom_ptr_t l_ret = NULL;
     dap_chain_cell_t *l_cell, *l_iter_tmp;
     HASH_ITER(hh, a_chain->cells, l_cell, l_iter_tmp) {
-        dap_chain_atom_iter_t * l_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
+        dap_chain_atom_iter_t * l_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, 0);
         l_ret = a_chain->callback_atom_find_by_hash(l_iter, a_atom_hash, a_atom_size);
         a_chain->callback_atom_iter_delete(l_iter);
         if (l_ret)
@@ -576,7 +576,7 @@ void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_not
 bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_hash_fast_t *a_atom_hash, dap_chain_cell_id_t a_cel_id)
 {
     bool l_ret = false;
-    dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_cel_id);
+    dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_cel_id, 0);
     dap_chain_atom_ptr_t * l_lasts_atom;
     size_t l_lasts_atom_count=0;
     size_t* l_lasts_atom_size =NULL;

modules/chain/dap_chain_cell.c

@@ -297,7 +297,7 @@ int dap_chain_cell_file_append( dap_chain_cell_t * a_cell, const void* a_atom, s
     // if no atom provided in arguments, we flush all the atoms in given chain
     size_t l_atom_size = a_atom_size ? a_atom_size : 0;
     size_t l_total_wrote_bytes = 0, l_count = 0;
-    dap_chain_atom_iter_t *l_atom_iter = a_atom ? NULL : a_cell->chain->callback_atom_iter_create(a_cell->chain, a_cell->id);
+    dap_chain_atom_iter_t *l_atom_iter = a_atom ? NULL : a_cell->chain->callback_atom_iter_create(a_cell->chain, a_cell->id, 0);
     if (!a_atom) {
         fseek(a_cell->file_storage, sizeof(dap_chain_cell_file_header_t), SEEK_SET);
     }

modules/chain/include/dap_chain.h

@@ -48,6 +48,8 @@ typedef struct dap_chain_atom_iter{
     dap_chain_atom_ptr_t cur;
     dap_chain_hash_fast_t *cur_hash;
     dap_chain_cell_id_t cell_id;
+    bool with_treshold;
+    bool found_in_treshold;
     size_t cur_size;
     void * cur_item;
     void * _inheritor;
@@ -72,7 +74,7 @@ typedef dap_chain_atom_ptr_t (*dap_chain_callback_atom_form_treshold_t)(dap_chai
 typedef dap_chain_atom_verify_res_t (*dap_chain_callback_atom_verify_t)(dap_chain_t *, dap_chain_atom_ptr_t , size_t);
 typedef size_t (*dap_chain_callback_atom_get_hdr_size_t)(void);
 
-typedef dap_chain_atom_iter_t* (*dap_chain_callback_atom_iter_create_t)(dap_chain_t *, dap_chain_cell_id_t);
+typedef dap_chain_atom_iter_t* (*dap_chain_callback_atom_iter_create_t)(dap_chain_t *, dap_chain_cell_id_t, bool);
 typedef dap_chain_atom_iter_t* (*dap_chain_callback_atom_iter_create_from_t)(dap_chain_t * ,dap_chain_atom_ptr_t, size_t);
 typedef dap_chain_atom_ptr_t (*dap_chain_callback_atom_iter_get_first_t)(dap_chain_atom_iter_t * , size_t*);
 typedef dap_chain_datum_t** (*dap_chain_callback_atom_get_datum_t)(dap_chain_atom_ptr_t, size_t, size_t * );

modules/channel/chain/dap_stream_ch_chain.c

@@ -292,7 +292,7 @@ static bool s_sync_out_chains_proc_callback(dap_proc_thread_t *a_thread, void *a
     dap_chain_t * l_chain = dap_chain_find_by_id(l_sync_request->request_hdr.net_id, l_sync_request->request_hdr.chain_id);
     assert(l_chain);
     //pthread_rwlock_rdlock(&l_chain->atoms_rwlock);
-    l_sync_request->chain.request_atom_iter = l_chain->callback_atom_iter_create(l_chain, l_sync_request->request_hdr.cell_id);
+    l_sync_request->chain.request_atom_iter = l_chain->callback_atom_iter_create(l_chain, l_sync_request->request_hdr.cell_id, 1);
     size_t l_first_size = 0;
     dap_chain_atom_ptr_t l_iter = l_chain->callback_atom_iter_get_first(l_sync_request->chain.request_atom_iter, &l_first_size);
     if (l_iter && l_first_size) {
@@ -1105,7 +1105,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
                 if(s_debug_more)
                     log_it(L_INFO, "Out: UPDATE_CHAINS_START pkt: net %s chain %s cell 0x%016"DAP_UINT64_FORMAT_X, l_chain->name,
                                         l_chain->net_name, l_chain_pkt->hdr.cell_id.uint64);
-                l_ch_chain->request_atom_iter = l_chain->callback_atom_iter_create(l_chain, l_chain_pkt->hdr.cell_id);
+                l_ch_chain->request_atom_iter = l_chain->callback_atom_iter_create(l_chain, l_chain_pkt->hdr.cell_id, 1);
                 l_chain->callback_atom_iter_get_first(l_ch_chain->request_atom_iter, NULL);
                 memcpy(&l_ch_chain->request_hdr, &l_chain_pkt->hdr, sizeof(dap_stream_ch_chain_pkt_hdr_t));
                 dap_stream_ch_chain_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_UPDATE_CHAINS_START,

modules/consensus/none/dap_chain_cs_none.c

@@ -71,7 +71,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
 static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_ptr_t, size_t); //    Verify new event in gdb
 static size_t s_chain_callback_atom_get_static_hdr_size(void); //    Get gdb event header size
 
-static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id);
+static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold);
 static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t * a_chain,
         dap_chain_atom_ptr_t a, size_t a_atom_size);
 
@@ -418,11 +418,12 @@ static size_t s_chain_callback_atom_get_static_hdr_size()
  * @param a_chain dap_chain_t a_chain
  * @return dap_chain_atom_iter_t* 
  */
-static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id)
+static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
 {
     dap_chain_atom_iter_t * l_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     l_iter->chain = a_chain;
     l_iter->cell_id = a_cell_id;
+    l_iter->with_treshold = a_with_treshold;
     return l_iter;
 }
 

modules/global-db/dap_chain_global_db_driver_pgsql.c

@@ -77,6 +77,7 @@ static void s_pgsql_free_connection(PGconn *a_conn)
     for (int i = 0; i < DAP_PGSQL_POOL_COUNT; i++) {
         if (s_conn_pool[i].conn == a_conn) {
             s_conn_pool[i].busy = 0;
+			break;
         }
     }
     pthread_rwlock_unlock(&s_db_rwlock);

modules/global-db/dap_chain_global_db_driver_sqlite.c

@@ -41,8 +41,15 @@
 
 #define LOG_TAG "db_sqlite"
 
-static sqlite3 *s_db = NULL;
+struct dap_sqlite_conn_pool_item {
+	sqlite3 *conn;
+	int busy;
+};
+
+//static sqlite3 *s_db = NULL;
+static sqlite3 *s_trans = NULL;
 static char *s_filename_db = NULL;
+static struct dap_sqlite_conn_pool_item s_conn_pool[DAP_SQLITE_POOL_COUNT];
 static pthread_rwlock_t s_db_rwlock = PTHREAD_RWLOCK_INITIALIZER;
 // Value of one field in the table
 typedef struct _SQLITE_VALUE_
@@ -77,6 +84,41 @@ typedef struct _SQLITE_ROW_VALUE_
 
 static int dap_db_driver_sqlite_exec(sqlite3 *l_db, const char *l_query, char **l_error_message);
 
+static sqlite3 *s_sqlite_get_connection(void)
+{
+	if (pthread_rwlock_wrlock(&s_db_rwlock) == EDEADLK) {
+		return NULL;
+	}
+
+	sqlite3 *l_ret = NULL;
+	for (int i = 0; i < DAP_SQLITE_POOL_COUNT; i++) {
+		if (!s_conn_pool[i].busy) {
+			l_ret = s_conn_pool[i].conn;
+			s_conn_pool[i].busy = 1;
+			break;
+		}
+	}
+
+	pthread_rwlock_unlock(&s_db_rwlock);
+	return l_ret;
+}
+
+static void s_sqlite_free_connection(sqlite3 *a_conn)
+{
+	if (pthread_rwlock_wrlock(&s_db_rwlock) == EDEADLK) {
+		return;
+	}
+
+	for (int i = 0; i < DAP_SQLITE_POOL_COUNT; i++) {
+		if (s_conn_pool[i].conn == a_conn) {
+			s_conn_pool[i].busy = 0;
+			break;
+		}
+	}
+
+	pthread_rwlock_unlock(&s_db_rwlock);
+}
+
 /**
  * @brief Initializes a SQLite database.
  * @note no thread safe
@@ -112,13 +154,18 @@ int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks
     DAP_DEL_Z(l_filename_dir);
     // Open Sqlite file, create if nessesary
     char *l_error_message = NULL;
-    s_db = dap_db_driver_sqlite_open(a_filename_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, &l_error_message);
-    if(!s_db) {
-        log_it(L_ERROR, "Can't init sqlite err: \"%s\"", l_error_message);
-        dap_db_driver_sqlite_free(l_error_message);
-        l_ret = -3;
-    }
-    else {
+	for (int i = 0; i < DAP_SQLITE_POOL_COUNT; i++) {
+		s_conn_pool[i].conn = dap_db_driver_sqlite_open(a_filename_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, &l_error_message);
+		if (!s_conn_pool[i].conn) {
+        	log_it(L_ERROR, "Can't init sqlite err: \"%s\"", l_error_message);
+        	dap_db_driver_sqlite_free(l_error_message);
+        	l_ret = -3;
+			for(int ii = i - 1; ii >= 0; ii--) {
+        		dap_db_driver_sqlite_close(s_conn_pool[ii].conn);
+			}
+			goto end;
+		}
+		sqlite3 *s_db = s_conn_pool[i].conn;
         if(!dap_db_driver_sqlite_set_pragma(s_db, "synchronous", "NORMAL")) // 0 | OFF | 1 | NORMAL | 2 | FULL
             printf("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
@@ -126,6 +173,9 @@ int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks
 
         if(!dap_db_driver_sqlite_set_pragma(s_db, "page_size", "1024")) // DELETE | TRUNCATE | PERSIST | MEMORY | WAL | OFF
             printf("can't set page_size\n");
+		s_conn_pool[i].busy = 0;
+	}
+
         //      *PRAGMA page_size = bytes; // page size DB; it is reasonable to make it equal to the size of the disk cluster 4096
         //     *PRAGMA cache_size = -kibibytes; // by default it is equal to 2000 pages of database
 //
@@ -141,7 +191,7 @@ int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks
         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);
-    }
+end:
         return l_ret;
 }
 
@@ -153,13 +203,14 @@ int dap_db_driver_sqlite_init(const char *a_filename_db, dap_db_driver_callbacks
 int dap_db_driver_sqlite_deinit(void)
 {
         pthread_rwlock_wrlock(&s_db_rwlock);
-        if(!s_db){
-            pthread_rwlock_unlock(&s_db_rwlock);
-            return -666;
-        }
-        dap_db_driver_sqlite_close(s_db);
+		for (int i = 0; i < DAP_SQLITE_POOL_COUNT; i++) {
+			if (s_conn_pool[i].conn) {
+        		dap_db_driver_sqlite_close(s_conn_pool[i].conn);
+				s_conn_pool[i].busy = 0;
+			}
+		}
         pthread_rwlock_unlock(&s_db_rwlock);
-        s_db = NULL;
+        //s_db = NULL;
         return sqlite3_shutdown();
 }
 
@@ -191,14 +242,14 @@ sqlite3* dap_db_driver_sqlite_open(const char *a_filename_utf8, int a_flags, cha
 {
     sqlite3 *l_db = NULL;
 
-    int l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_FULLMUTEX, NULL);
+    int l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_NOMUTEX, NULL);
     // if unable to open the database file
     if(l_rc == SQLITE_CANTOPEN) {
         log_it(L_WARNING,"No database on path %s, creating one from scratch", a_filename_utf8);
         if(l_db)
             sqlite3_close(l_db);
         // try to create database
-        l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_FULLMUTEX| SQLITE_OPEN_CREATE, NULL);
+        l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_NOMUTEX| SQLITE_OPEN_CREATE, NULL);
     }
 
     if(l_rc != SQLITE_OK) {
@@ -269,6 +320,7 @@ bool dap_db_driver_sqlite_set_pragma(sqlite3 *a_db, char *a_param, char *a_mode)
 int dap_db_driver_sqlite_flush()
 {
     log_it(L_DEBUG, "Start flush sqlite data base.");
+	sqlite3 *s_db = s_sqlite_get_connection();
     pthread_rwlock_wrlock(&s_db_rwlock);
     if(!s_db){
         pthread_rwlock_unlock(&s_db_rwlock);
@@ -331,6 +383,7 @@ static int dap_db_driver_sqlite_exec(sqlite3 *l_db, const char *l_query, char **
  */
 static int dap_db_driver_sqlite_create_group_table(const char *a_table_name)
 {
+	sqlite3 *s_db = s_sqlite_get_connection();
     char *l_error_message = NULL;
     if(!s_db || !a_table_name)
         return -1;
@@ -343,6 +396,7 @@ static int dap_db_driver_sqlite_create_group_table(const char *a_table_name)
         log_it(L_ERROR, "Creatу_table : %s\n", l_error_message);
         dap_db_driver_sqlite_free(l_error_message);
         DAP_DELETE(l_query);
+		s_sqlite_free_connection(s_db);
         return -1;
     }
     DAP_DELETE(l_query);
@@ -353,9 +407,11 @@ static int dap_db_driver_sqlite_create_group_table(const char *a_table_name)
         log_it(L_ERROR, "Create unique index : %s\n", l_error_message);
         dap_db_driver_sqlite_free(l_error_message);
         DAP_DELETE(l_query);
+		s_sqlite_free_connection(s_db);
         return -1;
     }
     DAP_DELETE(l_query);
+	s_sqlite_free_connection(s_db);
     return 0;
 }
 
@@ -512,13 +568,14 @@ int dap_db_driver_sqlite_vacuum(sqlite3 *l_db)
  */
 int dap_db_driver_sqlite_start_transaction(void)
 {
+	s_trans = s_sqlite_get_connection();
     pthread_rwlock_wrlock(&s_db_rwlock);
-    if(!s_db){
+    if(!s_trans){
         pthread_rwlock_unlock(&s_db_rwlock);
         return -666;
     }
 
-    if(SQLITE_OK == dap_db_driver_sqlite_exec(s_db, "BEGIN", NULL)){
+    if(SQLITE_OK == dap_db_driver_sqlite_exec(s_trans, "BEGIN", NULL)){
         pthread_rwlock_unlock(&s_db_rwlock);
         return 0;
     }else{
@@ -535,11 +592,11 @@ int dap_db_driver_sqlite_start_transaction(void)
 int dap_db_driver_sqlite_end_transaction(void)
 {
     pthread_rwlock_wrlock(&s_db_rwlock);
-    if(!s_db){
+    if(!s_trans){
         pthread_rwlock_unlock(&s_db_rwlock);
         return -666;
     }
-    if(SQLITE_OK == dap_db_driver_sqlite_exec(s_db, "COMMIT", NULL)){
+    if(SQLITE_OK == dap_db_driver_sqlite_exec(s_trans, "COMMIT", NULL)){
         pthread_rwlock_unlock(&s_db_rwlock);
         return 0;
     }else{
@@ -630,6 +687,7 @@ int dap_db_driver_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
         return -1;
     }
     // execute request
+	sqlite3 *s_db = s_sqlite_get_connection();
     pthread_rwlock_wrlock(&s_db_rwlock);
     if(!s_db){
         pthread_rwlock_unlock(&s_db_rwlock);
@@ -669,6 +727,7 @@ int dap_db_driver_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
         dap_db_driver_sqlite_free(l_error_message);
         l_ret = -1;
     }
+	s_sqlite_free_connection(s_db);
     if (a_store_obj->key)
         DAP_DELETE(a_store_obj->key);
     dap_db_driver_sqlite_free(l_query);
@@ -731,6 +790,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_last_store_obj(const char *a_group)
         return NULL;
     char * l_table_name = dap_db_driver_sqlite_make_table_name(a_group);
     char *l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' ORDER BY id DESC LIMIT 1", l_table_name);
+	sqlite3 *s_db = s_sqlite_get_connection();
     pthread_rwlock_wrlock(&s_db_rwlock);
     if(!s_db){
         pthread_rwlock_unlock(&s_db_rwlock);
@@ -744,6 +804,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_last_store_obj(const char *a_group)
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "read last l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
         dap_db_driver_sqlite_free(l_error_message);
+		s_sqlite_free_connection(s_db);
         return NULL;
     }
 
@@ -760,6 +821,8 @@ dap_store_obj_t* dap_db_driver_sqlite_read_last_store_obj(const char *a_group)
     dap_db_driver_sqlite_row_free(l_row);
     dap_db_driver_sqlite_query_free(l_res);
 
+	s_sqlite_free_connection(s_db);
+
     return l_obj;
 }
 
@@ -792,6 +855,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     else
         l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE id>='%lld' ORDER BY id ASC",
                 l_table_name, a_id);
+	sqlite3 *s_db = s_sqlite_get_connection();
     pthread_rwlock_wrlock(&s_db_rwlock);
     if(!s_db){
         pthread_rwlock_unlock(&s_db_rwlock);
@@ -806,6 +870,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "read l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
         dap_db_driver_sqlite_free(l_error_message);
+		s_sqlite_free_connection(s_db);
         return NULL;
     }
 
@@ -835,9 +900,11 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     } while(l_row);
 
     dap_db_driver_sqlite_query_free(l_res);
+	s_sqlite_free_connection(s_db);
 
     if(a_count_out)
         *a_count_out = (size_t)l_count_out;
+
     return l_obj;
 }
 
@@ -851,6 +918,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
  */
 dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const char *a_key, size_t *a_count_out)
 {
+	sqlite3 *s_db = s_sqlite_get_connection();
     if(!a_group || !s_db)
         return NULL;
     dap_store_obj_t *l_obj = NULL;
@@ -884,6 +952,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     DAP_DEL_Z(l_table_name);
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "read l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
+		s_sqlite_free_connection(s_db);
         return NULL;
     }
 
@@ -913,6 +982,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     } while(l_row);
 
     dap_db_driver_sqlite_query_free(l_res);
+	s_sqlite_free_connection(s_db);
 
     if(a_count_out)
         *a_count_out = l_count_out;
@@ -927,6 +997,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
  */
 dap_list_t* dap_db_driver_sqlite_get_groups_by_mask(const char *a_group_mask)
 {
+	sqlite3 *s_db = s_sqlite_get_connection();
     if(!a_group_mask || !s_db)
         return NULL;
     sqlite3_stmt *l_res;
@@ -937,6 +1008,7 @@ dap_list_t* dap_db_driver_sqlite_get_groups_by_mask(const char *a_group_mask)
     pthread_rwlock_unlock(&s_db_rwlock);
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "Get tables l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
+		s_sqlite_free_connection(s_db);
         return NULL;
     }
     char * l_mask = dap_db_driver_sqlite_make_table_name(a_group_mask);
@@ -948,6 +1020,9 @@ dap_list_t* dap_db_driver_sqlite_get_groups_by_mask(const char *a_group_mask)
         dap_db_driver_sqlite_row_free(l_row);
     }
     dap_db_driver_sqlite_query_free(l_res);
+
+	s_sqlite_free_connection(s_db);
+
     return l_ret_list;
 }
 
@@ -960,6 +1035,7 @@ dap_list_t* dap_db_driver_sqlite_get_groups_by_mask(const char *a_group_mask)
  */
 size_t dap_db_driver_sqlite_read_count_store(const char *a_group, uint64_t a_id)
 {
+	sqlite3 *s_db = s_sqlite_get_connection();
     sqlite3_stmt *l_res;
     if(!a_group || ! s_db)
         return 0;
@@ -974,6 +1050,7 @@ size_t dap_db_driver_sqlite_read_count_store(const char *a_group, uint64_t a_id)
 
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "Count l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
+		s_sqlite_free_connection(s_db);
         return 0;
     }
     size_t l_ret_val = 0;
@@ -983,6 +1060,9 @@ size_t dap_db_driver_sqlite_read_count_store(const char *a_group, uint64_t a_id)
         dap_db_driver_sqlite_row_free(l_row);
     }
     dap_db_driver_sqlite_query_free(l_res);
+
+	s_sqlite_free_connection(s_db);
+
     return l_ret_val;
 }
 
@@ -995,6 +1075,7 @@ size_t dap_db_driver_sqlite_read_count_store(const char *a_group, uint64_t a_id)
  */
 bool dap_db_driver_sqlite_is_obj(const char *a_group, const char *a_key)
 {
+	sqlite3 *s_db = s_sqlite_get_connection();
     sqlite3_stmt *l_res;
     if(!a_group || ! s_db)
         return false;
@@ -1009,6 +1090,7 @@ bool dap_db_driver_sqlite_is_obj(const char *a_group, const char *a_key)
 
     if(l_ret != SQLITE_OK) {
         //log_it(L_ERROR, "Exists l_ret=%d, %s\n", sqlite3_errcode(s_db), sqlite3_errmsg(s_db));
+		s_sqlite_free_connection(s_db);
         return false;
     }
     bool l_ret_val = false;
@@ -1018,5 +1100,8 @@ bool dap_db_driver_sqlite_is_obj(const char *a_group, const char *a_key)
         dap_db_driver_sqlite_row_free(l_row);
     }
     dap_db_driver_sqlite_query_free(l_res);
+
+	s_sqlite_free_connection(s_db);
+
     return l_ret_val;
 }

modules/global-db/include/dap_chain_global_db_driver_sqlite.h

@@ -27,6 +27,8 @@
 #include <sqlite3.h>
 #include "dap_chain_global_db_driver.h"
 
+#define DAP_SQLITE_POOL_COUNT                   16
+
 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);
 

modules/net/dap_chain_node_cli_cmd.c

@@ -4535,7 +4535,7 @@ static int s_check_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str_
     size_t l_size = 0;
 
     HASH_ITER(hh, l_chain->cells, l_cell, l_cell_tmp) {
-        l_iter = l_cell->chain->callback_atom_iter_create(l_cell->chain, l_cell->id);
+        l_iter = l_cell->chain->callback_atom_iter_create(l_cell->chain, l_cell->id, 0);
         dap_chain_datum_t *l_datum = l_cell->chain->callback_atom_find_by_hash(l_iter, &l_hash_tmp, &l_size);
         if (l_datum) {
             dap_hash_fast_t l_hash;

modules/net/dap_chain_node_cli_cmd_tx.c

@@ -420,7 +420,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
     dap_chain_cell_t *l_cell = a_chain->cells;
     do {
         // load transactions
-        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
+        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, 0);
         size_t l_atom_size = 0;
         dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
 
@@ -687,7 +687,7 @@ char* dap_db_history_addr(dap_chain_addr_t * a_addr, dap_chain_t * a_chain, cons
 
     dap_tx_data_t *l_tx_data_hash = NULL;
     // load transactions
-    dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_chain->cells->id);
+    dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_chain->cells->id, 0);
     size_t l_atom_size=0;
     dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
     if (!l_atom) {
@@ -841,7 +841,7 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
     size_t l_atom_size = 0;
     dap_chain_cell_t *l_cell = a_chain->cells;
     do {
-        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
+        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, 0);
         if(!a_chain->callback_atom_get_datums) {
             log_it(L_DEBUG, "Not defined callback_atom_get_datums for chain \"%s\"", a_chain->name);
             return NULL ;
@@ -968,7 +968,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
     do {
         // load transactions
         size_t l_atom_size = 0;
-        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
+        dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, 0);
         dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
         size_t l_datum_num = 0, l_token_num = 0, l_emission_num = 0, l_tx_num = 0;
         size_t l_datum_num_global = a_total_datums ? *a_total_datums : 0;

modules/type/blocks/dap_chain_cs_blocks.c

@@ -105,7 +105,7 @@ static dap_chain_atom_verify_res_t s_callback_atom_verify(dap_chain_t * a_chain,
 //    Get block header size
 static size_t s_callback_atom_get_static_hdr_size(void);
 
-static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id);
+static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold);
 static dap_chain_atom_iter_t* s_callback_atom_iter_create_from(dap_chain_t *  ,
                                                                      dap_chain_atom_ptr_t , size_t);
 
@@ -898,11 +898,12 @@ static size_t s_callback_atom_get_static_hdr_size(void)
  * @param a_chain
  * @return
  */
-static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id)
+static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
 {
     dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     l_atom_iter->chain = a_chain;
     l_atom_iter->cell_id = a_cell_id;
+    l_atom_iter->with_treshold = a_with_treshold;
     l_atom_iter->_inheritor = DAP_NEW_Z(dap_chain_cs_blocks_iter_t);
     ITER_PVT(l_atom_iter)->blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
 
@@ -921,7 +922,7 @@ static dap_chain_atom_iter_t* s_callback_atom_iter_create_from(dap_chain_t * a_c
     if (a_atom && a_atom_size){
         dap_chain_hash_fast_t l_atom_hash;
         dap_hash_fast(a_atom, a_atom_size, &l_atom_hash);
-        dap_chain_atom_iter_t * l_atom_iter = s_callback_atom_iter_create(a_chain, a_chain->cells->id);
+        dap_chain_atom_iter_t * l_atom_iter = s_callback_atom_iter_create(a_chain, a_chain->cells->id, 0);
         if (l_atom_iter){
             dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
             l_atom_iter->cur_item = ITER_PVT(l_atom_iter)->cache = dap_chain_block_cs_cache_get_by_hash(l_blocks, &l_atom_hash);

modules/type/dag/dap_chain_cs_dag.c

@@ -89,7 +89,7 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_add_from_treshold(dap_chain_t
 static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_ptr_t , size_t);                   //    Verify new event in dag
 static size_t s_chain_callback_atom_get_static_hdr_size(void);                               //    Get dag event header size
 
-static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id);
+static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold);
 static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t *  ,
                                                                      dap_chain_atom_ptr_t , size_t);
 
@@ -988,11 +988,12 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
  * @param a_chain
  * @return
  */
-static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id)
+static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, bool a_with_treshold)
 {
     dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     l_atom_iter->chain = a_chain;
     l_atom_iter->cell_id = a_cell_id;
+    l_atom_iter->with_treshold = a_with_treshold;
     pthread_rwlock_rdlock(&a_chain->atoms_rwlock);
 #ifdef WIN32
     log_it(L_DEBUG, "! Create caller id %lu", GetThreadId(GetCurrentThread()));
@@ -1040,12 +1041,25 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_first(dap_chain_atom_
     assert(l_dag_pvt);
     a_atom_iter->cur_item = NULL;
     dap_chain_cs_dag_event_item_t *l_item_tmp, *l_item_cur;
+    int found = 0;
     HASH_ITER(hh, l_dag_pvt->events, l_item_cur, l_item_tmp) {
         if (l_item_cur->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64) {
             a_atom_iter->cur_item = l_item_cur;
+            found = 1;
+            a_atom_iter->found_in_treshold = 0;
             break;
         }
     }
+    if (!found && a_atom_iter->with_treshold) {
+	    HASH_ITER(hh, l_dag_pvt->events_treshold, l_item_cur, l_item_tmp) {
+		    if (l_item_cur->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64) {
+			    a_atom_iter->cur_item = l_item_cur;
+                a_atom_iter->found_in_treshold = 1;
+			    break;
+		    }
+	    }
+    }
+
     if ( a_atom_iter->cur_item ){
         a_atom_iter->cur = ((dap_chain_cs_dag_event_item_t*) a_atom_iter->cur_item)->event;
         a_atom_iter->cur_size = ((dap_chain_cs_dag_event_item_t*) a_atom_iter->cur_item)->event_size;
@@ -1195,11 +1209,29 @@ static dap_chain_datum_tx_t* s_chain_callback_atom_iter_find_by_tx_hash(dap_chai
 static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_next( dap_chain_atom_iter_t * a_atom_iter,size_t * a_atom_size )
 {
     dap_chain_cs_dag_event_item_t * l_event_item = (dap_chain_cs_dag_event_item_t*) a_atom_iter->cur_item;
+
     while (l_event_item) {
         l_event_item = (dap_chain_cs_dag_event_item_t *)l_event_item->hh.next;
         if (l_event_item && l_event_item->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64)
             break;
     }
+
+    if(!l_event_item && !a_atom_iter->found_in_treshold) {
+        dap_chain_cs_dag_t *l_dag = DAP_CHAIN_CS_DAG(a_atom_iter->chain);
+        assert(l_dag);
+        dap_chain_cs_dag_pvt_t *l_dag_pvt = PVT(l_dag);
+        assert(l_dag_pvt);
+        l_event_item = l_dag_pvt->events_treshold;
+        while (l_event_item) {
+            if (l_event_item && l_event_item->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64) {
+                a_atom_iter->found_in_treshold = 1;
+                break;
+            }
+            l_event_item = (dap_chain_cs_dag_event_item_t *)l_event_item->hh.next;
+        }
+    }
+
+
     // if l_event_item=NULL then items are over
     a_atom_iter->cur_item = l_event_item;
     a_atom_iter->cur = l_event_item ? l_event_item->event : NULL;