add const to select()

libblockchain/BlockChainImp.cpp

@@ -893,8 +893,9 @@ void BlockChainImp::writeTotalTransactionCount(
             auto currentCount = lexical_cast<int64_t>(entry->getField(SYS_VALUE));
             currentCount += block.transactions().size();
 
-            entry->setField(SYS_VALUE, lexical_cast<std::string>(currentCount));
-            tb->update(SYS_KEY_TOTAL_TRANSACTION_COUNT, entry, tb->newCondition());
+            auto updateEntry = tb->newEntry();
+            updateEntry->setField(SYS_VALUE, lexical_cast<std::string>(currentCount));
+            tb->update(SYS_KEY_TOTAL_TRANSACTION_COUNT, updateEntry, tb->newCondition());
         }
         else
         {

libprecompiled/CRUDPrecompiled.cpp

@@ -65,7 +65,7 @@ bytes CRUDPrecompiled::call(ExecutiveContext::Ptr context, bytesConstRef param,
         {
             auto entries = table->select(key, table->newCondition());
             auto entriesPrecompiled = std::make_shared<EntriesPrecompiled>();
-            entriesPrecompiled->setEntries(entries);
+            //entriesPrecompiled->setEntries(entries);
             auto newAddress = context->registerPrecompiled(entriesPrecompiled);
             out = abi.abiIn("", newAddress);
         }

libprecompiled/extension/DagTransferPrecompiled.cpp

@@ -325,12 +325,12 @@ void DagTransferPrecompiled::userSaveCall(dev::blockverifier::ExecutiveContext::
                 break;
             }
 
-            entry = table->newEntry();
-            entry->setField(DAG_TRANSFER_FIELD_NAME, user);
-            entry->setField(DAG_TRANSFER_FIELD_BALANCE, new_balance.str());
+            auto updateEntry = table->newEntry();
+            updateEntry->setField(DAG_TRANSFER_FIELD_NAME, user);
+            updateEntry->setField(DAG_TRANSFER_FIELD_BALANCE, new_balance.str());
 
             auto count = table->update(
-                user, entry, table->newCondition(), std::make_shared<AccessOptions>(origin));
+                user, updateEntry, table->newCondition(), std::make_shared<AccessOptions>(origin));
             if (count == CODE_NO_AUTHORIZED)
             {  // permission denied
                 strErrorMsg = "permission denied";
@@ -582,4 +582,4 @@ void DagTransferPrecompiled::userTransferCall(
     } while (0);
 
     out = abi.abiIn("", ret);
-}
+}

libstorage/Common.h

@@ -31,6 +31,7 @@ namespace storage
 
 /// \brief Sign of the DB key is valid or not
 const char* const ID_FIELD = "_id_";
+const char* const NUM_FIELD = "_num_";
 const char* const STATUS = "_status_";
 const char* const SYS_TABLES = "_sys_tables_";
 const char* const SYS_CONSENSUS = "_sys_consensus_";

libstorage/EntriesPrecompiled.cpp

@@ -58,7 +58,7 @@ bytes dev::blockverifier::EntriesPrecompiled::call(
         u256 num;
         abi.abiOut(data, num);
 
-        auto entry = m_entries->get(num.convert_to<size_t>());
+        Entry::Ptr entry = m_entries->get(num.convert_to<size_t>());
         EntryPrecompiled::Ptr entryPrecompiled = std::make_shared<EntryPrecompiled>();
         entryPrecompiled->setEntry(entry);
         Address address = context->registerPrecompiled(entryPrecompiled);

libstorage/EntriesPrecompiled.h

@@ -51,10 +51,20 @@ class EntriesPrecompiled : public Precompiled
         ExecutiveContext::Ptr context, bytesConstRef param, Address const& origin = Address());
 
     void setEntries(dev::storage::Entries::Ptr entries) { m_entries = entries; }
+    void setEntries(dev::storage::Entries::ConstPtr entries) { m_entriesConst = entries; }
     dev::storage::Entries::Ptr getEntries() { return m_entries; }
+    dev::storage::Entries::ConstPtr getEntries() const {
+    	if(m_entriesConst) {
+    		return m_entries;
+    	}
+    	else {
+    		return m_entries;
+    	}
+    }
 
 private:
     dev::storage::Entries::Ptr m_entries;
+    dev::storage::Entries::ConstPtr m_entriesConst;
 };
 
 }  // namespace blockverifier

libstorage/EntryPrecompiled.h

@@ -21,6 +21,7 @@
 #pragma once
 
 #include "libblockverifier/Precompiled.h"
+#include "Table.h"
 
 namespace dev
 {
@@ -62,11 +63,11 @@ class EntryPrecompiled : public Precompiled
     virtual bytes call(
         std::shared_ptr<ExecutiveContext>, bytesConstRef param, Address const& origin = Address());
 
-    void setEntry(std::shared_ptr<dev::storage::Entry> entry) { m_entry = entry; }
-    std::shared_ptr<dev::storage::Entry> getEntry() { return m_entry; }
+    void setEntry(dev::storage::Entry::Ptr entry) { m_entry = entry; }
+    dev::storage::Entry::Ptr getEntry() const { return m_entry; };
 
 private:
-    std::shared_ptr<dev::storage::Entry> m_entry;
+    dev::storage::Entry::Ptr m_entry;
 };
 
 }  // namespace blockverifier

libstorage/MemoryTable.h

@@ -54,7 +54,7 @@ class MemoryTable : public Table
 
     virtual ~MemoryTable(){};
 
-    virtual typename Entries::Ptr select(const std::string& key, Condition::Ptr condition) override
+    virtual typename Entries::ConstPtr select(const std::string& key, Condition::Ptr condition) override
     {
         try
         {

libstorage/MemoryTable2.cpp

@@ -39,7 +39,11 @@ using namespace dev::precompiled;
 
 MemoryTable2::MemoryTable2() : m_newEntries(std::make_shared<EntriesType>()) {}
 
-Entries::Ptr MemoryTable2::select(const std::string& key, Condition::Ptr condition)
+Entries::ConstPtr MemoryTable2::select(const std::string& key, Condition::Ptr condition) {
+	return selectNoLock(key, condition);
+}
+
+Entries::Ptr MemoryTable2::selectNoLock(const std::string& key, Condition::Ptr condition)
 {
     try
     {
@@ -104,12 +108,12 @@ int MemoryTable2::update(
 
         checkField(entry);
 
-        auto entries = select(key, condition);
+        auto entries = selectNoLock(key, condition);
         std::vector<Change::Record> records;
 
         for (size_t i = 0; i < entries->size(); ++i)
         {
-            auto updateEntry = entries->get(i);
+            Entry::Ptr updateEntry = entries->get(i);
 
             // if id not equals to zero and not in the m_dirty, must be new dirty entry
             if (updateEntry->getID() != 0 && m_dirty.find(updateEntry->getID()) == m_dirty.end())
@@ -194,12 +198,12 @@ int MemoryTable2::remove(
             return storage::CODE_NO_AUTHORIZED;
         }
 
-        auto entries = select(key, condition);
+        auto entries = selectNoLock(key, condition);
 
         std::vector<Change::Record> records;
         for (size_t i = 0; i < entries->size(); ++i)
         {
-            auto removeEntry = entries->get(i);
+            Entry::Ptr removeEntry = entries->get(i);
 
             removeEntry->setStatus(1);
 

libstorage/MemoryTable2.h

@@ -30,6 +30,7 @@
 #include <tbb/concurrent_unordered_map.h>
 #include <boost/exception/diagnostic_information.hpp>
 #include <boost/lexical_cast.hpp>
+#include <libdevcore/FixedHash.h>
 #include <type_traits>
 
 namespace dev
@@ -47,7 +48,7 @@ class MemoryTable2 : public Table
 
     virtual ~MemoryTable2(){};
 
-    virtual Entries::Ptr select(const std::string& key, Condition::Ptr condition) override;
+    virtual Entries::ConstPtr select(const std::string& key, Condition::Ptr condition) override;
 
     virtual int update(const std::string& key, Entry::Ptr entry, Condition::Ptr condition,
         AccessOptions::Ptr options = std::make_shared<AccessOptions>()) override;
@@ -108,6 +109,8 @@ class MemoryTable2 : public Table
     virtual void rollback(const Change& _change) override;
 
 private:
+    Entries::Ptr selectNoLock(const std::string& key, Condition::Ptr condition);
+
     using EntriesType = ConcurrentEntries;
     using EntriesPtr = EntriesType::Ptr;
     EntriesPtr m_newEntries;

libstorage/RangeCachedStorage.cpp

@@ -82,15 +82,48 @@ Entries::Ptr CachePage::process(Condition::Ptr condition) {
 	return out;
 }
 
+std::list<Entry::Ptr>* CachePage::entries() {
+	return &m_entries;
+}
+
+void CachePage::mergeFrom(CachePage::Ptr cachePage, bool move) {
+	for(auto entryIt = m_entries.begin(); entryIt != m_entries.end(); ++entryIt) {
+		auto entry = cachePage->getByID((*entryIt)->getID());
+		if(entry && entry->num() > (*entryIt)->num()) {
+			*entryIt = entry;
+
+			if(move) {
+				cachePage->removeByID(entry->getID());
+			}
+		}
+	}
+}
+
+TableInfo::Ptr TableCache::tableInfo() {
+	return m_tableInfo;
+}
+
+std::vector<CachePage::Ptr>* TableCache::cachePages() {
+	return &m_cachePages;
+}
+
+CachePage::Ptr TableCache::tempPage() {
+	return m_tempPage;
+}
+
 Entries::Ptr RangeCachedStorage::select(h256 hash, int num, const std::string& table,
         const std::string& key, Condition::Ptr condition) {
 	auto it = m_caches.find(table);
 	if(it != m_caches.end()) {
-		for(auto cacheIt: it->second->cachePages) {
+		for(auto cacheIt: *(it->second->cachePages())) {
 			if(cacheIt->condition()->graterThan(condition)) {
 				return cacheIt->process(condition);
 			}
 		}
+
+		if(it->second->tempPage()->condition()->graterThan(condition)) {
+			return it->second->tempPage()->process(condition);
+		}
 	}
 
 	if(m_backend) {
@@ -105,12 +138,23 @@ Entries::Ptr RangeCachedStorage::select(h256 hash, int num, const std::string& t
 		cachePage->setCondition(condition);
 		cachePage->import(out);
 
-		for(auto pageIt = tableIt->second->cachePages.begin(); pageIt != tableIt->second->cachePages.end(); ++pageIt) {
+		for(auto pageIt = tableIt->second->cachePages()->begin(); pageIt != tableIt->second->cachePages()->end(); ++pageIt) {
 			if(condition->graterThan((*pageIt)->condition())) {
-				pageIt = tableIt->second->cachePages.erase(pageIt);
+				pageIt = tableIt->second->cachePages()->erase(pageIt);
+				continue;
 			}
+
+			if(condition->related((*pageIt)->condition())) {
+				//related to page, merge related entry
+				cachePage->mergeFrom(*pageIt);
+			}
+		}
+
+		if(condition->related(tableIt->second->tempPage()->condition())) {
+			cachePage->mergeFrom(tableIt->second->tempPage(), true);
 		}
-		tableIt->second->cachePages.push_back(cachePage);
+
+		tableIt->second->cachePages()->push_back(cachePage);
 		return out;
 	}
 
@@ -119,6 +163,10 @@ Entries::Ptr RangeCachedStorage::select(h256 hash, int num, const std::string& t
 
 size_t RangeCachedStorage::commit(h256 hash, int64_t num, const std::vector<TableData::Ptr>& datas,
         h256 const& blockHash) {
+	(void)hash;
+	(void)num;
+	(void)blockHash;
+
 	for(auto it: datas) {
 		auto tableIt = m_caches.find(it->tableName);
 		if(tableIt == m_caches.end()) {
@@ -127,9 +175,10 @@ size_t RangeCachedStorage::commit(h256 hash, int64_t num, const std::vector<Tabl
 
 		for(size_t i=0;i<it->entries->size();++i) {
 			auto entry = it->entries->get(i);
-			for(auto pageIt: tableIt->second->cachePages) {
+			for(auto pageIt: *(tableIt->second->cachePages())) {
 				if(pageIt->condition()->process(entry)) {
-					pageIt->entries->addEntry(entry);
+					pageIt->addEntry(entry);
+					break;
 				}
 			}
 		}

libstorage/RangeCachedStorage.h

@@ -45,9 +45,13 @@ class CachePage: std::enable_shared_from_this<CachePage> {
 	virtual int64_t num();
 	virtual Entries::Ptr process(Condition::Ptr condition);
 
+	virtual std::list<Entry::Ptr>* entries();
+	virtual void mergeFrom(CachePage::Ptr cachePage, bool move = false);
+
 private:
 	std::list<Entry::Ptr> m_entries;
 	std::map<int64_t, std::list<Entry::Ptr>::iterator > m_ID2Entry;
+	//std::map<std::string, std::list<Entry::Ptr>::iterator >
 
 	Condition::Ptr m_condition;
 	int64_t m_num = 0;
@@ -56,10 +60,15 @@ class CachePage: std::enable_shared_from_this<CachePage> {
 class TableCache {
 public:
 	typedef std::shared_ptr<TableCache> Ptr;
+	virtual ~TableCache() {};
+
+	virtual TableInfo::Ptr tableInfo();
+	virtual std::vector<CachePage::Ptr>* cachePages();
+	virtual CachePage::Ptr tempPage();
 
-	TableInfo::Ptr tableInfo;
-	std::vector<CachePage::Ptr> cachePages;
-	CachePage::Ptr m_unindexPage;
+	TableInfo::Ptr m_tableInfo;
+	std::vector<CachePage::Ptr> m_cachePages;
+	CachePage::Ptr m_tempPage;
 };
 
 class RangeCachedStorage : public Storage