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; }