int gcache_del(struct gcache *gc, char *keystr)
{
int rc;
MDB_val key;
MDB_txn *txn;
rc = mdb_txn_begin(gc->env, NULL, 0, &txn);
if (rc != 0) {
olog(LOG_ERR, "gcache_del: mdb_txn_begin: %s", mdb_strerror(rc));
return (rc);
}
key.mv_data = keystr;
key.mv_size = strlen(keystr);
rc = mdb_del(txn, gc->dbi, &key, NULL);
if (rc != 0 && rc != MDB_NOTFOUND) {
olog(LOG_ERR, "gcache_del: mdb_del: %s", mdb_strerror(rc));
/* fall through to commit */
}
rc = mdb_txn_commit(txn);
if (rc) {
olog(LOG_ERR, "gcache_del: mdb_txn_commit: (%d) %s", rc, mdb_strerror(rc));
mdb_txn_abort(txn);
}
return (rc);
}
void counter_dump(counter_t *lc, buffer_t *output) {
MDB_val key, data, rps_key, rps_data;
MDB_txn *txn = NULL;
MDB_cursor *cursor = NULL;
mdb_txn_begin(lc->env, NULL, MDB_RDONLY, &txn);
mdb_cursor_open(txn, *lc->dbi, &cursor);
int rc = 0;
char *tmp_str = NULL;
int size = 0;
uint64_t rps = 0;
while((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
if((*(char *)key.mv_data) == '_') {
continue;
}
size = asprintf(&tmp_str, "_%s_rps", (char *)key.mv_data);
rps_key.mv_size = size;
rps_key.mv_data = tmp_str;
if(mdb_get(txn, *lc->dbi, &rps_key, &rps_data) == MDB_SUCCESS) {
rps = *(uint64_t *)rps_data.mv_data;
}
free(tmp_str);
size = asprintf(&tmp_str, "%s: %lu - %lurps\n", (char *)key.mv_data, *(uint64_t *)data.mv_data, rps);
buffer_append(output, tmp_str, size);
free(tmp_str);
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
}
counter_t *counter_init(const char *path, uint64_t readers) {
counter_t *lc = NULL;
if((lc = calloc(1, sizeof(counter_t))) == NULL) {
perror("calloc");
return NULL;
}
// Setup and open the lmdb enviornment
MDB_CHECK(mdb_env_create(&lc->env), MDB_SUCCESS, NULL);
MDB_CHECK(mdb_env_set_maxreaders(lc->env, readers), MDB_SUCCESS, NULL);
MDB_CHECK(mdb_env_set_mapsize(lc->env, MDB_MAPSIZE), MDB_SUCCESS, NULL);
MDB_CHECK(mdb_env_open(lc->env, path, MDB_WRITEMAP | MDB_MAPASYNC | MDB_NOSUBDIR, 0664), MDB_SUCCESS, NULL);
MDB_txn *txn = NULL;
MDB_CHECK(mdb_txn_begin(lc->env, NULL, 0, &txn), MDB_SUCCESS, NULL);
if((lc->dbi = calloc(1, sizeof(MDB_dbi))) == NULL) {
perror("calloc");
return NULL;
}
MDB_CHECK(mdb_dbi_open(txn, NULL, 0, lc->dbi), MDB_SUCCESS, NULL);
mdb_txn_commit(txn);
return lc;
}
long gcache_get(struct gcache *gc, char *k, char *buf, long buflen)
{
MDB_val key, data;
MDB_txn *txn;
int rc;
long len = -1;
if (gc == NULL)
return (-1);
rc = mdb_txn_begin(gc->env, NULL, MDB_RDONLY, &txn);
if (rc) {
olog(LOG_ERR, "gcache_get: mdb_txn_begin: (%d) %s", rc, mdb_strerror(rc));
return (-1);
}
key.mv_data = k;
key.mv_size = strlen(k);
rc = mdb_get(txn, gc->dbi, &key, &data);
if (rc != 0) {
if (rc != MDB_NOTFOUND) {
printf("get: %s\n", mdb_strerror(rc));
} else {
// printf(" [%s] not found\n", k);
}
} else {
len = (data.mv_size < buflen) ? data.mv_size : buflen;
memcpy(buf, data.mv_data, len);
// printf("%s\n", (char *)data.mv_data);
}
mdb_txn_commit(txn);
return (len);
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_dbi dbi;
MDB_val key, data;
MDB_txn *txn;
MDB_cursor *cursor;
char sval[MAX_DATA_ALLOCATE_SIZE], kval[MAX_KEY_ALLOCATE_SIZE];
/* Note: Most error checking omitted for simplicity */
rc = mdb_env_create(&env);
mdb_env_set_mapsize(env, MAX_DB_SIZE);
mdb_env_set_maxdbs(env, (MDB_dbi)10);
rc = mdb_env_open(env, "./demoDB", 0, 0664);
rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_dbi_open(txn, "what", 0, &dbi);
// rc = mdb_put(txn, dbi, &key, &data, 0);
rc = mdb_txn_commit(txn);
if (rc) {
fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
goto leave;
}
fprintf(stderr, "print out old data:\n");
rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
rc = mdb_cursor_open(txn, dbi, &cursor);
key.mv_size = sizeof(kval);
key.mv_data = kval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
memset(kval, argv[1][0], sizeof(kval));
rc = mdb_cursor_get(cursor, &key, &data, MDB_SET);
fprintf(stderr, "key: %s, data: %s\n",(char *) key.mv_data,(char *) data.mv_data);
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
leave:
mdb_dbi_close(env, dbi);
mdb_env_close(env);
return 0;
}
void new_txn(void)
{
if(txn) {
fprintf(stderr, "commit\n");
check(mdb_txn_commit(txn));
}
check(mdb_txn_begin(env, NULL, 0, &txn));
}
LMDBCursor* LMDB::NewCursor() {
MDB_txn* mdb_txn;
MDB_cursor* mdb_cursor;
MDB_CHECK(mdb_txn_begin(mdb_env_, NULL, MDB_RDONLY, &mdb_txn));
MDB_CHECK(mdb_dbi_open(mdb_txn, NULL, 0, &mdb_dbi_));
MDB_CHECK(mdb_cursor_open(mdb_txn, mdb_dbi_, &mdb_cursor));
return new LMDBCursor(mdb_txn, mdb_cursor);
}
static int begin_txn(struct dbengine *db, struct txn **tidptr, int readonly)
{
struct txn *tid = xzmalloc(sizeof(struct txn));
int mflags, mr, r;
struct MDB_txn *parent = NULL;
assert(db && tidptr);
PDEBUG("cyrusdb_lmdb(%s)[begin_txn] readonly=%d tidptr=%p *tidptr=%p",
db->fname, readonly, tidptr, tidptr ? *tidptr : NULL);
/* Read-only transactions may only be master transactions and do
* not allow nested transactions. */
readonly = !db->tid ? readonly : 0;
/*
* Hacky workaround, similar to skiplist
*
* If no transaction was passed, but we're in a transaction,
* then create a nested exception within the current main
* transaction.
*
* Note that transactions are always either the main transaction,
* or a direct descendant of it. There are no deeper transaction
* levels supported (although LMDB supports them).
*/
if (db->tid) {
parent = db->tid->mtxn;
}
/* Begin a new LMDB transaction */
mr = mdb_txn_begin(db->env, parent, readonly ? MDB_RDONLY : 0, &tid->mtxn);
if (mr) goto fail;
/* Open the database */
mflags = db->flags & CYRUSDB_CREATE ? MDB_CREATE : 0;
mr = mdb_dbi_open(tid->mtxn, NULL /*name*/, mflags, &tid->dbi);
if (mr) goto fail;
if (db->flags & CYRUSDB_MBOXSORT) {
/* Set mboxsort order */
mr = mdb_set_compare(tid->mtxn, tid->dbi, mboxcmp);
if (mr) goto fail;
}
if (!db->tid) {
/* Set the master transaction */
db->tid = tid;
}
*tidptr = tid;
return CYRUSDB_OK;
fail:
r = my_mdberror(mr);
if (tid->mtxn) abort_txn(db, tid);
syslog(LOG_ERR, "cryusdb_lmdb(%s): %s", db->fname, mdb_strerror(mr));
return r;
}
static void
lmdb_storage_tx_begin(void* handle)
{
struct lmdb_storage* s = handle;
int result;
assert(s->txn == NULL);
result = mdb_txn_begin(s->env, NULL, 0, &s->txn);
assert(result == 0);
}
Status fetch (void const* key, NodeObject::Ptr* pObject)
{
pObject->reset ();
Status status (ok);
MDB_txn* txn = nullptr;
int error = 0;
error = mdb_txn_begin (m_env, NULL, MDB_RDONLY, &txn);
if (error == 0)
{
MDB_val dbkey;
MDB_val data;
dbkey.mv_size = m_keyBytes;
dbkey.mv_data = mdb_cast (key);
error = mdb_get (txn, m_dbi, &dbkey, &data);
if (error == 0)
{
DecodedBlob decoded (key, data.mv_data, data.mv_size);
if (decoded.wasOk ())
{
*pObject = decoded.createObject ();
}
else
{
status = dataCorrupt;
}
}
else if (error == MDB_NOTFOUND)
{
status = notFound;
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
mdb_txn_abort (txn);
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
return status;
}
CAMLprim value caml_mdb_txn_begin(value env,value parent_,value flags){
CAMLparam3(env,parent_,flags);
MDB_txn*parent = (parent_!=Val_int(0)) ? ((MDB_txn*)Field(parent_,0)) : NULL;
MDB_txn*txn;
if(mdb_txn_begin((MDB_env*)env,parent,Int_val(flags),&txn)){
caml_failwith("error in mdb_txn_begin");
}
CAMLreturn(txn);
}
int LMDBEngine::BeginBatchWrite()
{
BatchHolder& holder = m_batch_local.GetValue();
holder.AddRef();
if (NULL == holder.txn)
{
mdb_txn_begin(m_env, NULL, 0, &holder.txn);
}
return 0;
}
static int slmdb_txn_begin(SLMDB *slmdb, int rdonly, MDB_txn **txn)
{
int status;
if ((status = mdb_txn_begin(slmdb->env, (MDB_txn *) 0, rdonly, txn)) != 0
&& (status = slmdb_recover(slmdb, status)) == 0)
status = slmdb_txn_begin(slmdb, rdonly, txn);
return (status);
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_dbi dbi;
MDB_val key, data;
MDB_txn *txn;
MDB_cursor *cursor;
char sval[32];
rc = mdb_env_create(&env);
rc = mdb_env_open(env, "./testdb", 0, 0664);
rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_open(txn, NULL, 0, &dbi);
key.mv_size = sizeof(int);
key.mv_data = sval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
sprintf(sval, "%03x %d foo bar", 32, 3141592);
rc = mdb_put(txn, dbi, &key, &data, 0);
rc = mdb_txn_commit(txn);
if (rc) {
fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
goto leave;
}
rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
rc = mdb_cursor_open(txn, dbi, &cursor);
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
printf("key: %p %.*s, data: %p %.*s\n",
key.mv_data, (int) key.mv_size, (char *) key.mv_data,
data.mv_data, (int) data.mv_size, (char *) data.mv_data);
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
leave:
mdb_close(env, dbi);
mdb_env_close(env);
return 0;
}
/*
* Class: jmdb_DatabaseWrapper
* Method: txnBegin
* Signature: (JJI)J
*/
JNIEXPORT jlong JNICALL Java_jmdb_DatabaseWrapper_txnBegin(JNIEnv *vm,
jclass clazz, jlong envL, jlong parentL, jint flags) {
MDB_env *envC = (MDB_env*) envL;
MDB_txn *parentC = (MDB_txn *) parentL;
MDB_txn *result;
int code = mdb_txn_begin(envC, parentC, flags, &result);
if (code) {
throwDatabaseException(vm, code);
return 0;
}
return (jlong) result;
}
int mail_cache_db_get_keys(struct mail_cache_db * cache_db,
chash * keys)
{
int r;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_cursor *cursor;
MDB_val mdb_key;
MDB_val mdb_val;
env = cache_db->internal_database;
r = mdb_txn_begin(env, NULL, 0, &txn);
if (r != 0)
return -1;
r = mdb_dbi_open(txn, NULL, 0, &dbi);
if (r != 0)
goto error;
r = mdb_cursor_open(txn, dbi, &cursor);
if (r != 0)
goto error;
r = mdb_cursor_get(cursor, &mdb_key, &mdb_val, MDB_FIRST);
if (r != 0)
goto cursor_error;
while (r == 0) {
chashdatum hash_key;
chashdatum hash_data;
hash_key.data = mdb_key.mv_data;
hash_key.len = (unsigned int) mdb_key.mv_size;
hash_data.data = NULL;
hash_data.len = 0;
r = chash_set(keys, &hash_key, &hash_data, NULL);
if (r != 0)
goto cursor_error;
r = mdb_cursor_get(cursor, &mdb_key, &mdb_val, MDB_NEXT);
}
mdb_txn_commit(txn);
return 0;
cursor_error:
mdb_cursor_close(cursor);
error:
mdb_txn_abort(txn);
return -1;
}
void LMDBFileIndex::begin_txn(unsigned int flags)
{
read_transaction_lock.reset(new IScopedReadLock(mutex));
int rc = mdb_txn_begin(env, NULL, flags, &txn);
if(rc)
{
Server->Log("LMDB: Failed to open transaction handle ("+(std::string)mdb_strerror(rc)+")", LL_ERROR);
_has_error=true;
return;
}
}
int _db_open(DB *db, DB_TXN *txnid, const char *file, const char *database, DBTYPE type, uint32_t flags, int mode)
{
printf("%s\n", __FUNCTION__);
if (db == NULL) return EINVAL;
mdb_env_open(db->_internal->env, "./", /*MDB_FIXEDMAP*/0, mode);
if (txnid == NULL) {
if (mdb_txn_begin(db->_internal->env, NULL, 0, &db->_internal->txn) != 0) return EINVAL;
} else {
if (mdb_txn_begin(db->_internal->env, txnid->_internal->txn, 0, &db->_internal->txn) != 0) return EINVAL;
}
uint32_t _flags = 0;
if (flags & DB_CREATE) _flags |= MDB_CREATE;
if (mdb_dbi_open(db->_internal->txn, database, _flags, &db->_internal->dbi) !=0 ) {
mdb_txn_abort(db->_internal->txn);
return EINVAL;
}
mdb_txn_commit(db->_internal->txn);
return 0;
}
// Remove a key from database.
void database_del(MDB_env *db, MDB_val *key) {
MDB_dbi dbi;
MDB_txn *txn;
// transaction init
mdb_txn_begin(db, NULL, 0, &txn);
// open database in read-write mode
mdb_dbi_open(txn, NULL, 0, &dbi);
// delete key
mdb_del(txn, dbi, key, NULL);
// close database
mdb_dbi_close(db, dbi);
// transaction commit
mdb_txn_commit(txn);
}
// Add or update a key in database.
void database_put(MDB_env *db, MDB_val *key, MDB_val *value) {
MDB_dbi dbi;
MDB_txn *txn;
// transaction init
mdb_txn_begin(db, NULL, 0, &txn);
// open database in read-write mode
mdb_dbi_open(txn, NULL, 0, &dbi);
// put data
mdb_put(txn, dbi, key, value, 0);
// close database
mdb_dbi_close(db, dbi);
// transaction commit
mdb_txn_commit(txn);
}
// To get the current max ENTRYID
DWORD
VmDirMDBMaxEntryId(
PVDIR_BACKEND_CTX pBECtx,
ENTRYID* pEId)
{
DWORD dwError = 0;
PVDIR_DB_TXN pTxn = NULL;
MDB_val key = {0};
MDB_val value = {0};
unsigned char EIDBytes[sizeof( ENTRYID )] = {0};
assert(pBECtx && pEId);
dwError = mdb_txn_begin( gVdirMdbGlobals.mdbEnv, NULL, MDB_RDONLY, &pTxn );
BAIL_ON_VMDIR_ERROR(dwError);
key.mv_data = &EIDBytes[0];
MDBEntryIdToDBT(BE_MDB_ENTRYID_SEQ_KEY, &key);
dwError = mdb_get(pTxn, gVdirMdbGlobals.mdbSeqDBi, &key, &value);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = mdb_txn_commit(pTxn);
pTxn = NULL;
BAIL_ON_VMDIR_ERROR(dwError);
assert(value.mv_size == sizeof(ENTRYID));
*pEId = *((ENTRYID*)value.mv_data);
cleanup:
return dwError;
error:
if (pTxn)
{
mdb_txn_abort(pTxn);
}
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"VmDirMDBMaxEntryId: failed with error (%d),(%s)",
dwError, mdb_strerror(dwError) );
dwError = MDBToBackendError(dwError, 0, ERROR_BACKEND_ERROR, pBECtx, "MaxEntryId");
goto cleanup;
}
// Return a value from database.
void database_get(MDB_env *db, MDB_val *key, MDB_val *value) {
MDB_dbi dbi;
MDB_txn *txn;
// transaction init
mdb_txn_begin(db, NULL, MDB_RDONLY, &txn);
// open database in read-write mode
mdb_dbi_open(txn, NULL, 0, &dbi);
// get data
if (mdb_get(txn, dbi, key, value))
bzero(value, sizeof(*value));
// end of transaction
mdb_txn_abort(txn);
// close database
mdb_dbi_close(db, dbi);
}
int LMDBStore::open(const char *path, bool durable)
{
int rc;
rc = mdb_env_create(&env);
rc = mdb_env_set_mapsize(env, size_t(1048576000));
rc = mdb_env_set_maxdbs(env, 1024);
rc = mdb_env_open(env, path, MDB_NOSYNC | MDB_WRITEMAP, 0664);
MDB_txn *txn;
rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_open(txn, NULL, 0, &dbi);
rc = mdb_txn_commit(txn);
return HCAT_SUCCESS;
}
static int dbase_open(struct cache *cache, const char *handle)
{
long page_size = sysconf(_SC_PAGESIZE);
if (page_size <= 0) {
return KNOT_EINVAL;
}
int ret = mdb_env_create(&cache->env);
if (ret != 0) {
return ret;
}
size_t map_size = (LMDB_MAPSIZE / page_size) * page_size;
ret = mdb_env_set_mapsize(cache->env, map_size);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
ret = mdb_env_open(cache->env, handle, 0, 0644);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
MDB_txn *txn = NULL;
ret = mdb_txn_begin(cache->env, NULL, 0, &txn);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
ret = mdb_open(txn, NULL, MDB_DUPSORT, &cache->dbi);
if (ret != 0) {
mdb_txn_abort(txn);
mdb_env_close(cache->env);
return ret;
}
ret = mdb_txn_commit(txn);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
return 0;
}
int LMDBEngine::Init(const LMDBConfig& cfg, MDB_env *env,
const std::string& name)
{
m_env = env;
MDB_txn *txn;
int rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_open(txn, NULL, MDB_CREATE, &m_dbi);
if (rc != 0)
{
ERROR_LOG(
"Failed to open mdb:%s for reason:%s\n", name.c_str(), mdb_strerror(rc));
return -1;
}
mdb_set_compare(txn, m_dbi, LMDBCompareFunc);
mdb_txn_commit(txn);
return 0;
}
void LMDBEngine::Clear()
{
if (0 != m_dbi)
{
BatchHolder& holder = m_batch_local.GetValue();
MDB_txn* txn = holder.txn;
if (NULL == holder.txn)
{
mdb_txn_begin(m_env, NULL, 0, &txn);
}
mdb_drop(txn, m_dbi, 1);
if (NULL == holder.txn)
{
mdb_txn_commit(txn);
}
}
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_stat mst;
char *envname = argv[1];
char *subname = NULL;
rc = mdb_env_create(&env);
if (argc > 2) {
mdb_env_set_maxdbs(env, 4);
subname = argv[2];
}
rc = mdb_env_open(env, envname, MDB_RDONLY, 0);
if (rc) {
printf("mdb_env_open failed, error %d\n", rc);
exit(1);
}
rc = mdb_txn_begin(env, NULL, 1, &txn);
if (rc) {
printf("mdb_txn_begin failed, error %d\n", rc);
exit(1);
}
rc = mdb_open(txn, subname, 0, &dbi);
if (rc) {
printf("mdb_open failed, error %d\n", rc);
exit(1);
}
rc = mdb_stat(txn, dbi, &mst);
printf("Page size: %u\n", mst.ms_psize);
printf("Tree depth: %u\n", mst.ms_depth);
printf("Branch pages: %zu\n", mst.ms_branch_pages);
printf("Leaf pages: %zu\n", mst.ms_leaf_pages);
printf("Overflow pages: %zu\n", mst.ms_overflow_pages);
printf("Entries: %zu\n", mst.ms_entries);
mdb_close(env, dbi);
mdb_txn_abort(txn);
mdb_env_close(env);
return 0;
}
void LMDBEngine::Clear()
{
if (0 != m_dbi)
{
LMDBContext& holder = m_ctx_local.GetValue();
MDB_txn* txn = holder.readonly_txn;
if (NULL == holder.readonly_txn)
{
mdb_txn_begin(m_env, NULL, 0, &txn);
}
mdb_drop(txn, m_dbi, 1);
if (NULL == holder.readonly_txn)
{
mdb_txn_commit(txn);
}
}
}
/*
bool Context::Write(size_t ksz, void* key,
size_t dsz, void* data){
Error(0);
if (envHandle==nullptr){
return false;
}
else{
MDB_txn *txn;
int txnret = mdb_txn_begin(envHandle,nullptr,0,&txn);
if (txnret != 0) {
Error(txnret);
return false;
}
else{
MDB_dbi dbi;
int dbiret = mdb_dbi_open(txn,"Entity",MDB_CREATE,&dbi);
if (dbiret != 0){
Error(dbiret);
mdb_txn_abort(txn);
return false;
}
else{
MDB_val kkey { ksz, key };
MDB_val ddata { dsz, data};
putReturn = mdb_put(txn,dbi,&kkey,&ddata,0);
if (putReturn !=0){
Error(putReturn);
mdb_txn_abort(txn);
return false;
}
else{
int commit = mdb_txn_commit(txn);
if (commit!=0){
Error(commit);
return false;
}
else return true;
}
}
}
}
}
*/
bool Context::GetCopy(size_t ksz, void* key,
void** data){
Error(0);
if (envHandle==nullptr){
return false;
}
else{
MDB_txn *txn;
int txnret = mdb_txn_begin(envHandle,nullptr,0,&txn);
if (txnret != 0){
Error(txnret);
return false;
}
else{
MDB_dbi dbi;
int dbiret = mdb_dbi_open(txn,"Entity",0,&dbi);
if (dbiret !=0){
Error(dbiret);
mdb_txn_abort(txn);
return false;
}
else{
MDB_val kkey { ksz, key };
MDB_val ddata;
int get = mdb_get(txn,dbi,&kkey,&ddata);
if (get!=0){
Error(get);
mdb_txn_abort(txn);
return false;
}
else {
*data = new char[ddata.mv_size];
memcpy(*data, (void*)ddata.mv_data, (ddata.mv_size)*sizeof(char));
int commit = mdb_txn_commit(txn);
if (commit!=0){
Error(commit);
delete (char*)(*data);
return false;
}
else return true;
}
}
}
}
}
uint64_t counter_get(counter_t *lc, const char *key) {
MDB_dbi dbi;
MDB_val mkey, data;
MDB_txn *txn;
mdb_txn_begin(lc->env, NULL, 0, &txn);
mdb_dbi_open(txn, NULL, 0, &dbi);
mkey.mv_size = strlen(key) * sizeof(char);
mkey.mv_data = (void *)key;
// First we get our data from the db
uint64_t stored_counter = 0;
if(mdb_get(txn, dbi, &mkey, &data) == MDB_SUCCESS) {
stored_counter = *(uint64_t *)data.mv_data;
}
mdb_dbi_close(lc->env, dbi);
return stored_counter;
}
