forked from blue/lmdbal
274 lines
8.0 KiB
C++
274 lines
8.0 KiB
C++
// Squawk messenger.
|
|
// Copyright (C) 2019 Yury Gubich <blue@macaw.me>
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifndef LMDBDATABASE_CACHE_HPP
|
|
#define LMDBDATABASE_CACHE_HPP
|
|
|
|
#include "cache.h"
|
|
#include "exceptions.h"
|
|
|
|
template<class K, class V>
|
|
LMDBDataBase::Cache<K, V>::Cache(const std::string& p_name, DataBase* parent):
|
|
Storage<K, V>(p_name, parent),
|
|
mode(new Mode),
|
|
cache(new std::map<K, V>()),
|
|
abscent(new std::set<K>()),
|
|
sizeDifference(new uint32_t)
|
|
{
|
|
*mode = Mode::nothing;
|
|
*sizeDifference = 0;
|
|
}
|
|
|
|
template<class K, class V>
|
|
LMDBDataBase::Cache<K, V>::~Cache() {
|
|
delete sizeDifference;
|
|
delete mode;
|
|
delete cache;
|
|
delete abscent;
|
|
}
|
|
|
|
template<class K, class V>
|
|
void LMDBDataBase::Cache<K, V>::addRecord(const K& key, const V& value) {
|
|
StorageBase::ensureOpened(StorageBase::addRecordMethodName);
|
|
|
|
if (cache->count(key) > 0)
|
|
StorageBase::throwDuplicate(StorageBase::toString(key));
|
|
|
|
Storage<K, V>::addRecord(key, value);
|
|
cache->insert(std::make_pair(key, value));
|
|
|
|
if (*mode != Mode::full)
|
|
abscent->erase(key);
|
|
}
|
|
|
|
template<class K, class V>
|
|
bool LMDBDataBase::Cache<K, V>::forceRecord(const K& key, const V& value) {
|
|
StorageBase::ensureOpened(StorageBase::forceRecordMethodName);
|
|
|
|
bool added = Storage<K, V>::forceRecord(key, value);
|
|
if (*mode == Mode::full) {
|
|
(*cache)[key] = value;
|
|
} else {
|
|
if (added)
|
|
abscent->erase(key);
|
|
|
|
std::pair<typename std::map<K, V>::iterator, bool> result = cache->insert(std::make_pair(key, value));
|
|
if (!result.second)
|
|
result.first->second = value;
|
|
else if (!added) //this way database had value but cache didn't, so, need to decrease sizeDifference
|
|
handleMode();
|
|
}
|
|
|
|
return added;
|
|
}
|
|
|
|
template<class K, class V>
|
|
void LMDBDataBase::Cache<K, V>::changeRecord(const K& key, const V& value) {
|
|
StorageBase::ensureOpened(StorageBase::changeRecordMethodName);
|
|
|
|
if (*mode == Mode::full) {
|
|
typename std::map<K, V>::iterator itr = cache->find(key);
|
|
if (itr == cache->end())
|
|
StorageBase::throwNotFound(StorageBase::toString(key));
|
|
|
|
Storage<K, V>::changeRecord(key, value);
|
|
itr->second = value;
|
|
} else {
|
|
if (abscent->count(key) > 0)
|
|
StorageBase::throwNotFound(StorageBase::toString(key));
|
|
|
|
try {
|
|
Storage<K, V>::changeRecord(key, value);
|
|
typename std::pair<typename std::map<K, V>::iterator, bool> res = cache->insert(std::make_pair(key, value));
|
|
if (!res.second)
|
|
res.first->second = value;
|
|
else
|
|
handleMode();
|
|
} catch (const NotFound& error) {
|
|
abscent->insert(key);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
V LMDBDataBase::Cache<K, V>::getRecord(const K& key) const {
|
|
StorageBase::ensureOpened(StorageBase::getRecordMethodName);
|
|
|
|
typename std::map<K, V>::const_iterator itr = cache->find(key);
|
|
if (itr != cache->end())
|
|
return itr->second;
|
|
|
|
if (*mode == Mode::full || abscent->count(key) != 0)
|
|
StorageBase::throwNotFound(StorageBase::toString(key));
|
|
|
|
try {
|
|
V value = Storage<K, V>::getRecord(key);
|
|
cache->insert(std::make_pair(key, value));
|
|
handleMode();
|
|
return value;
|
|
} catch (const NotFound& error) {
|
|
if (*mode != Mode::full)
|
|
abscent->insert(key);
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
bool LMDBDataBase::Cache<K, V>::checkRecord(const K& key) const {
|
|
StorageBase::ensureOpened(StorageBase::checkRecordMethodName);
|
|
|
|
typename std::map<K, V>::const_iterator itr = cache->find(key);
|
|
if (itr != cache->end())
|
|
return true;
|
|
|
|
if (*mode == Mode::full || abscent->count(key) != 0)
|
|
return false;
|
|
|
|
try {
|
|
V value = Storage<K, V>::getRecord(key);
|
|
cache->insert(std::make_pair(key, value));
|
|
handleMode();
|
|
return true;
|
|
} catch (const NotFound& error) {
|
|
if (*mode != Mode::full)
|
|
abscent->insert(key);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
std::map<K, V> LMDBDataBase::Cache<K, V>::readAll() const {
|
|
StorageBase::ensureOpened(StorageBase::readAllMethodName);
|
|
|
|
if (*mode != Mode::full) { //there is a room for optimization
|
|
*mode = Mode::full; //I can read and deserialize only those values
|
|
*cache = Storage<K, V>::readAll(); //that are missing in the cache
|
|
abscent->clear();
|
|
*sizeDifference = 0;
|
|
}
|
|
|
|
return *cache;
|
|
}
|
|
|
|
template<class K, class V>
|
|
void LMDBDataBase::Cache<K, V>::replaceAll(const std::map<K, V>& data) {
|
|
Storage<K, V>::replaceAll(data);
|
|
*cache = data;
|
|
|
|
if (*mode != Mode::full) {
|
|
*mode = Mode::full;
|
|
abscent->clear();
|
|
*sizeDifference = 0;
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
uint32_t LMDBDataBase::Cache<K, V>::addRecords(const std::map<K, V>& data, bool overwrite) {
|
|
uint32_t newSize = Storage<K, V>::addRecords(data, overwrite);
|
|
|
|
Mode& m = *mode;
|
|
if (m == Mode::nothing)
|
|
m = Mode::size;
|
|
|
|
std::map<K, V>& c = *cache;
|
|
std::set<K>& a = *abscent;
|
|
for (const std::pair<const K, V>& pair : data) {
|
|
std::pair<typename std::map<K, V>::iterator, bool> res = c.insert(pair);
|
|
if (!res.second) {
|
|
if (overwrite)
|
|
res.first->second = pair.second;
|
|
} else if (m != Mode::full) {
|
|
a.erase(pair.first);
|
|
}
|
|
}
|
|
|
|
if (m != Mode::full) {
|
|
*sizeDifference = newSize - c.size();
|
|
if (*sizeDifference == 0) {
|
|
*mode = Mode::full;
|
|
abscent->clear();
|
|
}
|
|
}
|
|
|
|
return newSize;
|
|
}
|
|
|
|
template<class K, class V>
|
|
void LMDBDataBase::Cache<K, V>::removeRecord(const K& key) {
|
|
StorageBase::ensureOpened(StorageBase::removeRecordMethodName);
|
|
|
|
typename std::pair<typename std::set<K>::const_iterator, bool> pair = abscent->insert(key);
|
|
if (!pair.second)
|
|
StorageBase::throwNotFound(StorageBase::toString(key));
|
|
|
|
Storage<K, V>::removeRecord(key);
|
|
if (cache->erase(key) == 0) //if it was not cached and we are now in size mode then the sizeDifference would decrease
|
|
handleMode();
|
|
|
|
if (*mode != Mode::full)
|
|
abscent->insert(key);
|
|
}
|
|
|
|
template<class K, class V>
|
|
uint32_t LMDBDataBase::Cache<K, V>::count() const {
|
|
switch (*mode) {
|
|
case Mode::nothing:
|
|
{
|
|
uint32_t sz = Storage<K, V>::count();
|
|
*sizeDifference = sz - cache->size();
|
|
if (sz == 0) {
|
|
*mode = Mode::full;
|
|
abscent->clear();
|
|
} else {
|
|
*mode = Mode::size;
|
|
}
|
|
return sz;
|
|
}
|
|
case Mode::size:
|
|
return cache->size() + *sizeDifference;
|
|
case Mode::full:
|
|
return cache->size();
|
|
default:
|
|
return 0; //unreachable, no such state, just to suppress the waring
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
void LMDBDataBase::Cache<K, V>::handleMode() const {
|
|
if (*mode == Mode::size) {
|
|
--(*sizeDifference);
|
|
if (*sizeDifference == 0) {
|
|
*mode = Mode::full;
|
|
abscent->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class K, class V>
|
|
int LMDBDataBase::Cache<K, V>::drop(MDB_txn * transaction) {
|
|
int res = Storage<K, V>::drop(transaction);
|
|
cache->clear();
|
|
abscent->clear();
|
|
*mode = Mode::full;
|
|
*sizeDifference = 0;
|
|
return res;
|
|
}
|
|
|
|
#endif //LMDBDATABASE_CACHE_HPP
|