int mdb_tool_entry_close(
BackendDB *be )
{
if ( mdb_tool_info ) {
slapd_shutdown = 1;
ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
/* There might still be some threads starting */
while ( mdb_tool_index_tcount > 0 ) {
ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
&mdb_tool_index_mutex );
}
mdb_tool_index_tcount = mdb_tool_threads - 1;
ldap_pvt_thread_cond_broadcast( &mdb_tool_index_cond_work );
/* Make sure all threads are stopped */
while ( mdb_tool_index_tcount > 0 ) {
ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
&mdb_tool_index_mutex );
}
ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
mdb_tool_info = NULL;
slapd_shutdown = 0;
ch_free( mdb_tool_index_rec );
mdb_tool_index_tcount = mdb_tool_threads - 1;
}
if( idcursor ) {
mdb_cursor_close( idcursor );
idcursor = NULL;
}
if( cursor ) {
mdb_cursor_close( cursor );
cursor = NULL;
}
if( txn ) {
MDB_TOOL_IDL_FLUSH( be, txn );
if ( mdb_txn_commit( txn ))
return -1;
txn = NULL;
}
if( nholes ) {
unsigned i;
fprintf( stderr, "Error, entries missing!\n");
for (i=0; i<nholes; i++) {
fprintf(stderr, " entry %ld: %s\n",
holes[i].id, holes[i].dn.bv_val);
}
nholes = 0;
return -1;
}
return 0;
}
int db_dbi_open(MDB_txn *const txn, DB_schema *const schema, unsigned int opts, DB_column const *const cols, count_t const ncols, strarg_t const name, MDB_dbi *const dbi) {
int rc;
uint64_t const dbname_id = db_string_id(txn, schema, name);
if(!dbname_id) return -1;
DB_VAL(dbinfo_val, 2);
db_bind(dbinfo_val, 0);
db_bind(dbinfo_val, dbname_id);
DB_VAL(info_val, 1);
db_bind(info_val, 0xff & opts);
mdb_put(txn, schema->schema, dbinfo_val, info_val, MDB_NOOVERWRITE);
// TODO: Check opts
MDB_cursor *cur = NULL;
mdb_cursor_open(txn, schema->schema, &cur);
DB_VAL(dbcols_val, 2);
db_bind(dbcols_val, 1);
db_bind(dbcols_val, dbname_id);
MDB_val col_val;
mdb_cursor_get(cur, &dbcols_val, &col_val, MDB_GET);
for(; MDB_SUCCESS == rc; rc = mdb_cursor_get(cur, &dbcols_val, &col_val, MDB_NEXT_DUP)) {
uint64_t const col = db_column(col_val, 0);
uint64_t const type = db_column(col_val, 1);
strarg_t const colname = db_column_text(txn, schema, col_val, 2);
if(col >= ncols) break; // Extra columns are not an error.
if(type != cols[i].type || 0 != strcmp(colname, cols[i].name)) {
mdb_cursor_close(cur); cur = NULL;
return -1;
}
}
mdb_cursor_close(cur); cur = NULL;
for(index_t i = 0; i < ncols; ++i) {
uint64_t const colname_id = db_string_id(txn, schema, cols[i].name);
if(!colname_id) return -1;
DB_VAL(col_val, 3);
db_bind(col_val, i);
db_bind(col_val, cols[i].type);
db_bind(col_val, colname_id);
rc = mdb_put(txn, schema->schema, dbcols_val, col_val, MDB_NODUPDATA);
if(MDB_SUCCESS != rc && MDB_KEYEXIST != rc) return -1;
}
mdb_dbi_open(txn, name, MDB_CREATE | opts, dbi);
return 0;
}
static void *perform(void *arg)
{
db_thread *thr = (db_thread*)arg;
int i,rc;
mdbinf* mdb = &thr->mdb;
srand((u32)pthread_self());
open_txn(mdb, MDB_RDONLY);
thr->resFrames = alloca((SQLITE_DEFAULT_PAGE_SIZE/thr->maxvalsize + 1)*sizeof(MDB_val));
for (i = 0; i < 1000*100; i++)
{
int j = rand() % NCONS;
if (i % 1000 == 0)
printf("r %lld %d\n",(i64)pthread_self(),i);
if (pthread_mutex_trylock(&g_cons[j].wal.mtx) != 0)
continue;
g_tsd_conn = &g_cons[j];
rc = sqlite3_exec(g_cons[j].db,"SELECT max(id) FROM tab;",NULL,NULL,NULL);
if (rc != SQLITE_OK)
{
printf("Error select");
break;
}
pthread_mutex_unlock(&g_cons[j].wal.mtx);
mdb_txn_reset(thr->mdb.txn);
rc = mdb_txn_renew(thr->mdb.txn);
if (rc != MDB_SUCCESS)
break;
rc = mdb_cursor_renew(mdb->txn, mdb->cursorLog);
if (rc != MDB_SUCCESS)
break;
rc = mdb_cursor_renew(mdb->txn, mdb->cursorPages);
if (rc != MDB_SUCCESS)
break;
rc = mdb_cursor_renew(mdb->txn, mdb->cursorInfo);
if (rc != MDB_SUCCESS)
break;
}
mdb_cursor_close(mdb->cursorLog);
mdb_cursor_close(mdb->cursorPages);
mdb_cursor_close(mdb->cursorInfo);
mdb_txn_abort(mdb->txn);
return NULL;
}
int
mdb_dn2entry(
Operation *op,
MDB_txn *tid,
MDB_cursor *m2,
struct berval *dn,
Entry **e,
ID *nsubs,
int matched )
{
struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
int rc, rc2;
ID id = NOID;
struct berval mbv, nmbv;
MDB_cursor *mc;
Debug(LDAP_DEBUG_TRACE, "mdb_dn2entry(\"%s\")\n",
dn->bv_val ? dn->bv_val : "", 0, 0 );
*e = NULL;
rc = mdb_dn2id( op, tid, m2, dn, &id, nsubs, &mbv, &nmbv );
if ( rc ) {
if ( matched ) {
rc2 = mdb_cursor_open( tid, mdb->mi_id2entry, &mc );
if ( rc2 == MDB_SUCCESS ) {
rc2 = mdb_id2entry( op, mc, id, e );
mdb_cursor_close( mc );
}
}
} else {
rc = mdb_cursor_open( tid, mdb->mi_id2entry, &mc );
if ( rc == MDB_SUCCESS ) {
rc = mdb_id2entry( op, mc, id, e );
mdb_cursor_close(mc);
}
}
if ( *e ) {
(*e)->e_name = mbv;
if ( rc == MDB_SUCCESS )
ber_dupbv_x( &(*e)->e_nname, dn, op->o_tmpmemctx );
else
ber_dupbv_x( &(*e)->e_nname, &nmbv, op->o_tmpmemctx );
} else {
op->o_tmpfree( mbv.bv_val, op->o_tmpmemctx );
}
return rc;
}
bool LmdbDataset<K, V, KCoder, VCoder>::last_key(K* key) {
DLOG(INFO) << "LMDB: Last key";
int retval;
MDB_txn* iter_txn;
retval = mdb_txn_begin(env_, NULL, MDB_RDONLY, &iter_txn);
CHECK_EQ(MDB_SUCCESS, retval) << "mdb_txn_begin failed "
<< mdb_strerror(retval);
MDB_cursor* cursor;
retval = mdb_cursor_open(iter_txn, dbi_, &cursor);
CHECK_EQ(retval, MDB_SUCCESS) << mdb_strerror(retval);
MDB_val mdbkey;
MDB_val mdbval;
retval = mdb_cursor_get(cursor, &mdbkey, &mdbval, MDB_LAST);
CHECK_EQ(retval, MDB_SUCCESS) << mdb_strerror(retval);
mdb_cursor_close(cursor);
mdb_txn_abort(iter_txn);
if (!KCoder::deserialize(reinterpret_cast<char*>(mdbkey.mv_data),
mdbkey.mv_size, key)) {
LOG(ERROR) << "failed to deserialize key";
return false;
}
return true;
}
common::Error LmdbRaw::keys(const std::string &key_start, const std::string &key_end, uint64_t limit,
std::vector<std::string> *ret) {
MDB_cursor *cursor;
MDB_txn *txn = NULL;
int rc = mdb_txn_begin(lmdb_->env, NULL, MDB_RDONLY, &txn);
if (rc == LMDB_OK) {
rc = mdb_cursor_open(txn, lmdb_->dbir, &cursor);
}
if (rc != LMDB_OK) {
mdb_txn_abort(txn);
char buff[1024] = {0};
common::SNPrintf(buff, sizeof(buff), "Keys function error: %s", mdb_strerror(rc));
return common::make_error_value(buff, common::ErrorValue::E_ERROR);
}
MDB_val key;
MDB_val data;
while ((mdb_cursor_get(cursor, &key, &data, MDB_NEXT) == LMDB_OK) && limit > ret->size()) {
std::string skey((const char*)key.mv_data, key.mv_size);
if (key_start < skey && key_end > skey) {
ret->push_back(skey);
}
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
return common::Error();
}
common::Error LmdbRaw::dbsize(size_t* size) {
if (!size) {
return common::make_error_value("Invalid input argument", common::ErrorValue::E_ERROR);
}
MDB_cursor *cursor;
MDB_txn *txn = NULL;
int rc = mdb_txn_begin(lmdb_->env, NULL, MDB_RDONLY, &txn);
if (rc == LMDB_OK) {
rc = mdb_cursor_open(txn, lmdb_->dbir, &cursor);
}
if (rc != LMDB_OK) {
mdb_txn_abort(txn);
char buff[1024] = {0};
common::SNPrintf(buff, sizeof(buff), "dbsize function error: %s", mdb_strerror(rc));
return common::make_error_value(buff, common::ErrorValue::E_ERROR);
}
MDB_val key;
MDB_val data;
size_t sz = 0;
while (mdb_cursor_get(cursor, &key, &data, MDB_NEXT) == LMDB_OK) {
sz++;
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
*size = sz;
return common::Error();
}
int
mdb_dn2id_children(
Operation *op,
MDB_txn *txn,
Entry *e )
{
struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
MDB_dbi dbi = mdb->mi_dn2id;
MDB_val key, data;
MDB_cursor *cursor;
int rc;
ID id;
key.mv_size = sizeof(ID);
key.mv_data = &id;
id = e->e_id;
rc = mdb_cursor_open( txn, dbi, &cursor );
if ( rc ) return rc;
rc = mdb_cursor_get( cursor, &key, &data, MDB_SET );
if ( rc == 0 ) {
size_t dkids;
rc = mdb_cursor_count( cursor, &dkids );
if ( rc == 0 ) {
if ( dkids < 2 ) rc = MDB_NOTFOUND;
}
}
mdb_cursor_close( cursor );
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);
}
int addOrUpdateIntIndexedProperty(GLMDB_env *glmdb_env, MDB_txn *mdbTxn, MDB_cursor * vertexCursor, long long elementId, int propertyKeyId,
int propertyValue, unsigned char vertex) {
int rc;
MDB_cursor *intIndexCursor;
if (vertex) {
rc = mdb_cursor_open(mdbTxn, glmdb_env->vertexIntIndexDb, &intIndexCursor);
} else {
rc = mdb_cursor_open(mdbTxn, glmdb_env->edgeIntIndexDb, &intIndexCursor);
}
if (rc != 0) {
goto failIndexedVertex;
}
rc = deleteEntryFromIntIndex(glmdb_env, mdbTxn, vertexCursor, intIndexCursor, (long long) elementId, (int) propertyKeyId);
if (rc != 0 && rc != MDB_NOTFOUND) {
goto failIndexedVertex;
}
rc = setVertexPropertyInt(vertexCursor, (long) elementId, (int) propertyKeyId, &propertyValue);
if (rc != 0) {
goto failIndexedVertex;
}
rc = setIntIndex(intIndexCursor, elementId, propertyKeyId, propertyValue);
failIndexedVertex: mdb_cursor_close(intIndexCursor);
return rc;
}
void
hashidx_stream_delete(HashIdxStream *st) {
MDB_txn *txn = mdb_cursor_txn(st->cur);
mdb_cursor_close(st->cur);
txn_manager_abort(st->db->txn_manager, txn);
free(st);
}
VOID
VmDirMDBIndexIteratorFree(
PVDIR_BACKEND_INDEX_ITERATOR pIterator
)
{
PVDIR_MDB_INDEX_ITERATOR pMdbIterator = NULL;
if (pIterator)
{
pMdbIterator = (PVDIR_MDB_INDEX_ITERATOR)pIterator->pIterator;
if (pMdbIterator)
{
if (pMdbIterator->pCursor)
{
mdb_cursor_close(pMdbIterator->pCursor);
}
if (pMdbIterator->pTxn)
{
if (pMdbIterator->bAbort)
{
mdb_txn_abort(pMdbIterator->pTxn);
}
else
{
mdb_txn_commit(pMdbIterator->pTxn);
}
}
VMDIR_SAFE_FREE_MEMORY(pMdbIterator->pszVal);
VMDIR_SAFE_FREE_MEMORY(pMdbIterator);
}
VMDIR_SAFE_FREE_MEMORY(pIterator);
}
}
bool B_ACCURATE_LMDB::send_base_file_list(JCR *jcr)
{
int result;
int32_t LinkFIc;
FF_PKT *ff_pkt;
MDB_cursor *cursor;
MDB_val key, data;
bool retval = false;
accurate_payload *payload;
int stream = STREAM_UNIX_ATTRIBUTES;
if (!jcr->accurate || jcr->getJobLevel() != L_FULL) {
return true;
}
/*
* Commit any pending write transactions.
*/
if (m_db_rw_txn) {
result = mdb_txn_commit(m_db_rw_txn);
if (result != 0) {
Jmsg1(jcr, M_FATAL, 0, _("Unable close write transaction: %s\n"), mdb_strerror(result));
goto bail_out;
}
m_db_rw_txn = NULL;
}
ff_pkt = init_find_files();
ff_pkt->type = FT_BASE;
result = mdb_cursor_open(m_db_ro_txn, m_db_dbi, &cursor);
if (result == 0) {
while ((result = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
payload = (accurate_payload *)data.mv_data;
if (bit_is_set(payload->filenr, m_seen_bitmap)) {
Dmsg1(dbglvl, "base file fname=%s\n", key.mv_data);
decode_stat(payload->lstat, &ff_pkt->statp, sizeof(struct stat), &LinkFIc); /* decode catalog stat */
ff_pkt->fname = (char *)key.mv_data;
encode_and_send_attributes(jcr, ff_pkt, stream);
}
}
mdb_cursor_close(cursor);
} else {
Jmsg1(jcr, M_FATAL, 0, _("Unable create cursor: %s\n"), mdb_strerror(result));
}
mdb_txn_reset(m_db_ro_txn);
result = mdb_txn_renew(m_db_ro_txn);
if (result != 0) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to renew read transaction: %s\n"), mdb_strerror(result));
goto bail_out;
}
retval = true;
bail_out:
term_find_files(ff_pkt);
return retval;
}
void
page_db_link_stream_delete(PageDBLinkStream *es) {
if (es) {
if (es->cur) {
txn_manager_abort(es->db->txn_manager, mdb_cursor_txn(es->cur));
mdb_cursor_close(es->cur);
}
free(es->to);
free(es);
}
}
int mdb_ad_read( struct mdb_info *mdb, MDB_txn *txn )
{
int i, rc;
MDB_cursor *mc;
MDB_val key, data;
struct berval bdata;
const char *text;
AttributeDescription *ad;
rc = mdb_cursor_open( txn, mdb->mi_ad2id, &mc );
if ( rc ) {
Debug( LDAP_DEBUG_ANY,
"mdb_ad_read: cursor_open failed %s(%d)\n",
mdb_strerror(rc), rc, 0);
return rc;
}
/* our array is 1-based, an index of 0 means no data */
i = mdb->mi_numads+1;
key.mv_size = sizeof(int);
key.mv_data = &i;
rc = mdb_cursor_get( mc, &key, &data, MDB_SET );
while ( rc == MDB_SUCCESS ) {
bdata.bv_len = data.mv_size;
bdata.bv_val = data.mv_data;
ad = NULL;
rc = slap_bv2ad( &bdata, &ad, &text );
if ( rc ) {
rc = slap_bv2undef_ad( &bdata, &mdb->mi_ads[i], &text, 0 );
} else {
if ( ad->ad_index >= MDB_MAXADS ) {
Debug( LDAP_DEBUG_ANY,
"mdb_adb_read: too many AttributeDescriptions in use\n",
0, 0, 0 );
return LDAP_OTHER;
}
mdb->mi_adxs[ad->ad_index] = i;
mdb->mi_ads[i] = ad;
}
i++;
rc = mdb_cursor_get( mc, &key, &data, MDB_NEXT );
}
mdb->mi_numads = i-1;
done:
if ( rc == MDB_NOTFOUND )
rc = 0;
mdb_cursor_close( mc );
return rc;
}
int64 LMDBFileIndex::get_prefer_client( const SIndexKey& key )
{
begin_txn(MDB_RDONLY);
MDB_cursor* cursor;
mdb_cursor_open(txn, dbi, &cursor);
SIndexKey orig_key = key;
MDB_val mdb_tkey;
mdb_tkey.mv_data=const_cast<void*>(static_cast<const void*>(&key));
mdb_tkey.mv_size=sizeof(SIndexKey);
MDB_val mdb_tvalue;
int rc=mdb_cursor_get(cursor,&mdb_tkey, &mdb_tvalue, MDB_SET_RANGE);
int64 ret = 0;
int retry_prev=2;
while(rc==0 && retry_prev>0 && !_has_error)
{
SIndexKey* curr_key = reinterpret_cast<SIndexKey*>(mdb_tkey.mv_data);
if(rc==MDB_NOTFOUND)
{
retry_prev=0;
}
else if(rc)
{
Server->Log("LMDB: Failed to read ("+(std::string)mdb_strerror(rc)+")", LL_ERROR);
_has_error=true;
}
else if( curr_key->isEqualWithoutClientid(orig_key))
{
CRData data((const char*)mdb_tvalue.mv_data, mdb_tvalue.mv_size);
data.getVarInt(&ret);
retry_prev=0;
}
else
{
rc=mdb_cursor_get(cursor, &mdb_tkey, &mdb_tvalue, MDB_PREV);
--retry_prev;
}
}
mdb_cursor_close(cursor);
abort_transaction();
return ret;
}
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;
}
static void slmdb_cursor_close(SLMDB *slmdb)
{
MDB_txn *txn;
/*
* Close the cursor and its read transaction. We can restore it later
* from the saved key information.
*/
txn = mdb_cursor_txn(slmdb->cursor);
mdb_cursor_close(slmdb->cursor);
slmdb->cursor = 0;
mdb_txn_abort(txn);
}
static inline void _cursor_cancel(cursor_t cursor){
cursor_t next = cursor->next;
if(next)
next->prev = cursor->prev;
// we always have a prev
cursor->prev->next = next;
mdb_cursor_close(cursor->cursor);
cursor->cursor = NULL;
// mark as cancelled
cursor->prev = NULL;
}
int traverseIntIndexDb(GLMDB_env * glmdb_env, MDB_txn *txn, MDB_dbi dbi) {
int rc = 0;
MDB_cursor *cursor;
MDB_val key, data;
rc = mdb_cursor_open(txn, dbi, &cursor);
if (rc != 0) {
goto fail;
}
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
printIntIndexDbRecord(key, data);
}
fail: mdb_cursor_close(cursor);
return rc;
}
std::map<int, int64> LMDBFileIndex::get_all_clients( const SIndexKey& key )
{
begin_txn(MDB_RDONLY);
MDB_cursor* cursor;
mdb_cursor_open(txn, dbi, &cursor);
SIndexKey orig_key = key;
MDB_val mdb_tkey;
mdb_tkey.mv_data=const_cast<void*>(static_cast<const void*>(&key));
mdb_tkey.mv_size=sizeof(SIndexKey);
MDB_val mdb_tvalue;
int rc=mdb_cursor_get(cursor,&mdb_tkey, &mdb_tvalue, MDB_SET_RANGE);
std::map<int, int64> ret;
SIndexKey* curr_key = reinterpret_cast<SIndexKey*>(mdb_tkey.mv_data);
while(rc==0 &&
orig_key.isEqualWithoutClientid(*curr_key))
{
CRData data((const char*)mdb_tvalue.mv_data, mdb_tvalue.mv_size);
int64 entryid;
data.getVarInt(&entryid);
ret[curr_key->getClientid()] = entryid;
rc=mdb_cursor_get(cursor, &mdb_tkey, &mdb_tvalue, MDB_NEXT);
curr_key = reinterpret_cast<SIndexKey*>(mdb_tkey.mv_data);
}
if(rc && rc!=MDB_NOTFOUND)
{
Server->Log("LMDB: Failed to read ("+(std::string)mdb_strerror(rc)+")", LL_ERROR);
_has_error=true;
}
mdb_cursor_close(cursor);
abort_transaction();
return ret;
}
/** Put a document into the database at this key
* If the "Prefers: ETag" header is set, we perform a CAS operation */
static int __put(h2o_req_t *req, kstr_t* key)
{
char* sv_etag = __remove_stored_etag(key);
h2o_iovec_t cli_etag = __get_if_match_header_value(req, key);
if (0 < cli_etag.len &&
!__should_etag_conditional_put_succeed(req, key, sv_etag, &cli_etag))
{
if (sv_etag)
free(sv_etag);
return h2oh_respond_with_error(req, 412, "BAD ETAG");
}
if (sv_etag)
free(sv_etag);
batch_item_t item = {
.flags = 0,
.key.mv_data = key->s,
.key.mv_size = key->len,
.val.mv_data = req->entity.base,
.val.mv_size = req->entity.len,
};
int e = bmon_offer(&sv->batch, &item);
if (0 != e)
return h2oh_respond_with_error(req, 400, batcher_error);
return h2oh_respond_with_success(req, 200);
}
typedef struct
{
h2o_generator_t super;
h2o_req_t *req;
MDB_txn *txn;
MDB_cursor* curs;
kstr_t* key;
} get_keys_generator_t;
static void __get_keys_close(h2o_generator_t *_self, h2o_req_t *req)
{
get_keys_generator_t *gen = (void*)_self;
mdb_cursor_close(gen->curs);
int e = mdb_txn_commit(gen->txn);
if (0 != e)
mdb_fatal(e);
}
StreamState
page_db_link_stream_reset(void *st) {
PageDBLinkStream *es = st;
// if no cursor, try to create one
if (es->cur) {
txn_manager_abort(es->db->txn_manager, mdb_cursor_txn(es->cur));
mdb_cursor_close(es->cur);
es->cur = 0;
}
if (page_db_link_stream_open_cursor(es) != 0) {
return stream_state_error;
}
return es->state;
}
DataLayer<Dtype>::~DataLayer<Dtype>() {
this->JoinPrefetchThread();
// clean up the database resources
switch (this->layer_param_.data_param().backend()) {
case DataParameter_DB_LEVELDB:
break; // do nothing
case DataParameter_DB_LMDB:
mdb_cursor_close(mdb_cursor_);
mdb_close(mdb_env_, mdb_dbi_);
mdb_txn_abort(mdb_txn_);
mdb_env_close(mdb_env_);
break;
default:
LOG(FATAL) << "Unknown database backend";
}
}
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;
}
static int
lmdb_storage_trim(void* handle, iid_t iid)
{
struct lmdb_storage* s = handle;
int result;
iid_t min = 0;
MDB_cursor* cursor = NULL;
MDB_val key, data;
if (iid == 0)
return 0;
lmdb_storage_put_trim_instance(handle, iid);
if ((result = mdb_cursor_open(s->txn, s->dbi, &cursor)) != 0) {
paxos_log_error("Could not create cursor. %s", mdb_strerror(result));
goto cleanup_exit;
}
key.mv_data = &min;
key.mv_size = sizeof(iid_t);
do {
if ((result = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
assert(key.mv_size = sizeof(iid_t));
min = *(iid_t*)key.mv_data;
} else {
goto cleanup_exit;
}
if (min != 0 && min <= iid) {
if (mdb_cursor_del(cursor, 0) != 0) {
paxos_log_error("mdb_cursor_del failed. %s",
mdb_strerror(result));
goto cleanup_exit;
}
}
} while (min <= iid);
cleanup_exit:
if (cursor) {
mdb_cursor_close(cursor);
}
return 0;
}
static int put(struct dbengine *db, const char *key, size_t keylen,
const char *data, size_t datalen, struct txn **tidptr, int mflags)
{
MDB_val mkey, mval;
struct txn *tid;
int r, mr;
mkey.mv_data = (void*) key;
mkey.mv_size = keylen;
mval.mv_data = (void*) data;
mval.mv_size = datalen;
/* Invalidate cursor */
if (db->mcur) {
mdb_cursor_close(db->mcur);
db->mcur = NULL;
}
/* Open or reuse transaction */
r = getorset_txn(db, tidptr, &tid, 0);
if (r) goto fail;
mr = mdb_put(tid->mtxn, tid->dbi, &mkey, &mval, mflags);
if (mr) {
/* Return the appropriate error code for existing key overwrites */
syslog(LOG_ERR, "cryusdb_lmdb(%s): %s", db->fname, mdb_strerror(mr));
r = (mr == MDB_KEYEXIST && (mflags & MDB_NOOVERWRITE)) ? \
CYRUSDB_EXISTS : CYRUSDB_INTERNAL;
goto fail;
}
/* Commit or export the transaction */
if (!tidptr) {
r = commit_txn(db, tid);
if (r) goto fail;
} else {
*tidptr = tid;
}
return CYRUSDB_OK;
fail:
if (tid && (!tidptr || !*tidptr)) abort_txn(db, tid);
return r;
}
static int
mdb_tool_idl_flush_db( MDB_txn *txn, AttrInfo *ai )
{
MDB_cursor *mc;
Avlnode *root;
int rc;
mdb_cursor_open( txn, ai->ai_dbi, &mc );
root = tavl_end( ai->ai_root, TAVL_DIR_LEFT );
do {
rc = mdb_tool_idl_flush_one( mc, ai, root->avl_data );
if ( rc != -1 )
rc = 0;
} while ((root = tavl_next(root, TAVL_DIR_RIGHT)));
mdb_cursor_close( mc );
return rc;
}
int counter_gen_stats(void *tdata) {
counter_t *lc = (counter_t *)tdata;
MDB_val key, data;
MDB_val stat_key, stat_data;
MDB_txn *txn = NULL;
MDB_cursor *cursor = NULL;
mdb_txn_begin(lc->env, NULL, 0, &txn);
mdb_cursor_open(txn, *lc->dbi, &cursor);
int rc = 0;
char *tmp_str = NULL;
uint64_t last_counter = 0;
uint64_t reqs_per_sec = 0;
int size = 0;
while((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
if((*(char *)key.mv_data) == '_') {
continue;
}
size = asprintf(&tmp_str, "_%s_last", (char *)key.mv_data);
stat_key.mv_size = size;
stat_key.mv_data = tmp_str;
last_counter = 0;
if(mdb_get(txn, *lc->dbi, &stat_key, &stat_data) == MDB_SUCCESS) {
last_counter = *(uint64_t *)stat_data.mv_data;
}
// runs every STATS_SECS secs
reqs_per_sec = (*(uint64_t *)data.mv_data - last_counter) / STATS_SECS;
stat_data.mv_size = sizeof(uint64_t);
stat_data.mv_data = data.mv_data;
mdb_put(txn, *lc->dbi, &stat_key, &data, 0);
free(tmp_str);
size = asprintf(&tmp_str, "_%s_rps", (char *)key.mv_data);
stat_key.mv_size = size;
stat_key.mv_data = tmp_str;
stat_data.mv_size = sizeof(uint64_t);
stat_data.mv_data = &reqs_per_sec;
mdb_put(txn, *lc->dbi, &stat_key, &stat_data, 0);
free(tmp_str);
}
mdb_cursor_close(cursor);
mdb_txn_commit(txn);
return 0;
}
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;
}