/*
* Initialize ENTRYID and USN sequence.
*/
static
DWORD
MDBInitSequence(
PVDIR_MDB_DB pDB,
VDIR_DB mdbDbi
)
{
DWORD dwError = 0;
PVDIR_DB_TXN pTxn = NULL;
VDIR_DB_DBT key = {0};
VDIR_DB_DBT value = {0};
unsigned char EidBytes[sizeof( ENTRYID )] = {0};
ENTRYID initEIDValue = ENTRY_ID_SEQ_INITIAL_VALUE;
ENTRYID initUNSValue = USN_SEQ_INITIAL_VALUE;
assert(pDB);
dwError = mdb_txn_begin( pDB->mdbEnv, NULL, BE_DB_FLAGS_ZERO, &pTxn );
BAIL_ON_VMDIR_ERROR(dwError);
key.mv_data = &EidBytes[0];
MDBEntryIdToDBT(BE_MDB_ENTRYID_SEQ_KEY, &key);
dwError = mdb_get(pTxn, mdbDbi, &key, &value);
if (dwError == MDB_NOTFOUND)
{
// first time, initialize two sequence records
value.mv_data = &initEIDValue;
value.mv_size = sizeof(initEIDValue);
// set entryid sequence record
dwError = mdb_put(pTxn, mdbDbi, &key, &value, MDB_NOOVERWRITE);
BAIL_ON_VMDIR_ERROR(dwError);
MDBEntryIdToDBT(BE_MDB_USN_SEQ_KEY, &key);
value.mv_data = &initUNSValue;
value.mv_size = sizeof(initUNSValue);
// set usn sequence record
dwError = mdb_put(pTxn, mdbDbi, &key, &value, MDB_NOOVERWRITE);
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = mdb_txn_commit(pTxn);
pTxn = NULL;
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
if (pTxn)
{
mdb_txn_abort(pTxn);
}
goto cleanup;
}
int CDbxMdb::Load(bool bSkipInit)
{
if (!Remap())
return EGROKPRF_CANTREAD;
if (!bSkipInit) {
txn_ptr trnlck(m_pMdbEnv);
mdb_open(trnlck, "global", MDB_CREATE | MDB_INTEGERKEY, &m_dbGlobal);
mdb_open(trnlck, "contacts", MDB_CREATE | MDB_INTEGERKEY, &m_dbContacts);
mdb_open(trnlck, "modules", MDB_CREATE | MDB_INTEGERKEY, &m_dbModules);
mdb_open(trnlck, "events", MDB_CREATE | MDB_INTEGERKEY, &m_dbEvents);
mdb_open(trnlck, "eventsrt", MDB_CREATE | MDB_INTEGERKEY, &m_dbEventsSort);
mdb_open(trnlck, "settings", MDB_CREATE, &m_dbSettings);
DWORD keyVal = 1;
MDB_val key = { sizeof(DWORD), &keyVal }, data;
if (mdb_get(trnlck, m_dbGlobal, &key, &data) == MDB_SUCCESS) {
DBHeader *hdr = (DBHeader*)data.mv_data;
if (hdr->dwSignature != DBHEADER_SIGNATURE)
DatabaseCorruption(NULL);
memcpy(&m_header, data.mv_data, sizeof(m_header));
}
else {
m_header.dwSignature = DBHEADER_SIGNATURE;
m_header.dwVersion = 1;
data.mv_data = &m_header; data.mv_size = sizeof(m_header);
mdb_put(trnlck, m_dbGlobal, &key, &data, 0);
keyVal = 0;
DBContact dbc = { DBCONTACT_SIGNATURE, 0, 0, 0 };
data.mv_data = &dbc; data.mv_size = sizeof(dbc);
mdb_put(trnlck, m_dbContacts, &key, &data, 0);
}
trnlck.commit();
if (InitModuleNames()) return EGROKPRF_CANTREAD;
if (InitCrypt()) return EGROKPRF_CANTREAD;
// everything is ok, go on
if (!m_bReadOnly) {
// we don't need events in the service mode
if (ServiceExists(MS_DB_SETSAFETYMODE)) {
hContactDeletedEvent = CreateHookableEvent(ME_DB_CONTACT_DELETED);
hContactAddedEvent = CreateHookableEvent(ME_DB_CONTACT_ADDED);
hSettingChangeEvent = CreateHookableEvent(ME_DB_CONTACT_SETTINGCHANGED);
hEventMarkedRead = CreateHookableEvent(ME_DB_EVENT_MARKED_READ);
hEventAddedEvent = CreateHookableEvent(ME_DB_EVENT_ADDED);
hEventDeletedEvent = CreateHookableEvent(ME_DB_EVENT_DELETED);
hEventFilterAddedEvent = CreateHookableEvent(ME_DB_EVENT_FILTER_ADD);
}
}
FillContacts();
}
return ERROR_SUCCESS;
}
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;
}
void storeBatch (Batch const& batch)
{
MDB_txn* txn = nullptr;
int error = 0;
error = mdb_txn_begin (m_env, NULL, 0, &txn);
if (error == 0)
{
EncodedBlob::Pool::ScopedItem item (m_blobPool);
BOOST_FOREACH (NodeObject::Ptr const& object, batch)
{
EncodedBlob& encoded (item.getObject ());
encoded.prepare (object);
MDB_val key;
key.mv_size = m_keyBytes;
key.mv_data = mdb_cast (encoded.getKey ());
MDB_val data;
data.mv_size = encoded.getSize ();
data.mv_data = mdb_cast (encoded.getData ());
error = mdb_put (txn, m_dbi, &key, &data, 0);
if (error != 0)
{
WriteLog (lsWARNING, NodeObject) << "mdb_put failed, error=" << error;
break;
}
}
void write(const std::string& keystr, const std::string& value) {
if (use_leveldb) { // leveldb
batch->Put(keystr, value);
} else { // lmdb
mdb_data.mv_size = value.size();
mdb_data.mv_data = const_cast<char*>(&value[0]);
mdb_key.mv_size = keystr.size();
mdb_key.mv_data = const_cast<char*>(&keystr[0]);
CHECK_EQ(mdb_put(mdb_txn, mdb_dbi, &mdb_key, &mdb_data, 0), MDB_SUCCESS)
<< "mdb_put failed";
}
if (++count % 1000 == 0) {
// Commit txn
if (use_leveldb) { // leveldb
db->Write(leveldb::WriteOptions(), batch);
delete batch;
batch = new leveldb::WriteBatch();
} else { // lmdb
CHECK_EQ(mdb_txn_commit(mdb_txn), MDB_SUCCESS)
<< "mdb_txn_commit failed";
CHECK_EQ(mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn), MDB_SUCCESS)
<< "mdb_txn_begin failed";
}
LOG(ERROR) << "Processed " << count << " files.";
}
}
int LMDBEngine::Put(const Slice& key, const Slice& value)
{
LMDBContext& holder = m_ctx_local.GetValue();
MDB_txn *txn = holder.readonly_txn;
if (NULL == txn || holder.batch_write == 0)
{
MDB_val k, v;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
v.mv_data = const_cast<char*>(value.data());
v.mv_size = value.size();
mdb_txn_begin(m_env, NULL, 0, &txn);
mdb_put(txn, m_dbi, &k, &v, 0);
mdb_txn_commit(txn);
return 0;
}
PutOperation* op = new PutOperation;
op->key.assign((const char*) key.data(), key.size());
op->value.assign((const char*) value.data(), value.size());
m_write_queue.Push(op);
if (holder.batch_write == 0)
{
CheckPointOperation* ck = new CheckPointOperation(holder.cond);
m_write_queue.Push(ck);
NotifyBackgroundThread();
ck->Wait();
DELETE(ck);
return 0;
}
return 0;
}
bool LmdbDataset<K, V, KCoder, VCoder>::put(const K& key, const V& value) {
DLOG(INFO) << "LMDB: Put";
vector<char> serialized_key;
if (!KCoder::serialize(key, &serialized_key)) {
LOG(ERROR) << "failed to serialize key";
return false;
}
vector<char> serialized_value;
if (!VCoder::serialize(value, &serialized_value)) {
LOG(ERROR) << "failed to serialized value";
return false;
}
MDB_val mdbkey, mdbdata;
mdbdata.mv_size = serialized_value.size();
mdbdata.mv_data = serialized_value.data();
mdbkey.mv_size = serialized_key.size();
mdbkey.mv_data = serialized_key.data();
CHECK_NOTNULL(write_txn_);
CHECK_NE(0, dbi_);
int retval = mdb_put(write_txn_, dbi_, &mdbkey, &mdbdata, 0);
if (MDB_SUCCESS != retval) {
LOG(ERROR) << "mdb_put failed " << mdb_strerror(retval);
return false;
}
return true;
}
int mail_cache_db_put(struct mail_cache_db * cache_db,
const void * key, size_t key_len, const void * value, size_t value_len)
{
int r;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_val mdb_key;
MDB_val mdb_val;
env = cache_db->internal_database;
mdb_key.mv_size = key_len;
mdb_key.mv_data = (void *) key;
mdb_val.mv_size = value_len;
mdb_val.mv_data = (void *) value;
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_put(txn, dbi, &mdb_key, &mdb_val, 0);
if (r != 0)
goto error;
mdb_txn_commit(txn);
return 0;
error:
mdb_txn_abort(txn);
return -1;
}
common::Error LmdbRaw::put(const std::string& key, const std::string& value) {
MDB_val mkey;
mkey.mv_size = key.size();
mkey.mv_data = (void*)key.c_str();
MDB_val mval;
mval.mv_size = value.size();
mval.mv_data = (void*)value.c_str();
MDB_txn *txn = NULL;
int rc = mdb_txn_begin(lmdb_->env, NULL, 0, &txn);
if (rc == LMDB_OK) {
rc = mdb_put(txn, lmdb_->dbir, &mkey, &mval, 0);
if (rc == LMDB_OK) {
rc = mdb_txn_commit(txn);
} else {
mdb_txn_abort(txn);
}
}
if (rc != LMDB_OK) {
char buff[1024] = {0};
common::SNPrintf(buff, sizeof(buff), "put function error: %s", mdb_strerror(rc));
return common::make_error_value(buff, common::ErrorValue::E_ERROR);
}
return common::Error();
}
/**
* This function works in stages. First we clean up the given key to prevent
* any trickery by users. Then we retrieve the existing value, increment it,
* and store it back in the db.
*/
uint64_t counter_inc(counter_t *lc, const char *key) {
char clean_key[KEYSZ] = { 0 };
key_clean(clean_key, key);
clean_key[15] = '\0';
MDB_val mkey, data, update;
MDB_txn *txn = NULL;
mkey.mv_size = (KEYSZ) * sizeof(char);
mkey.mv_data = (void *)clean_key;
mdb_txn_begin(lc->env, NULL, 0, &txn);
uint64_t stored_counter = 0;
// We only care about success here, since if mdb_get fails it is because
// the key doesn't exist and we need to make it.
if(mdb_get(txn, *lc->dbi, &mkey, &data) == MDB_SUCCESS) {
stored_counter = *(uint64_t *)data.mv_data;
}
stored_counter++;
update.mv_size = sizeof(uint64_t);
update.mv_data = (void *)&stored_counter;
if(mdb_put(txn, *lc->dbi, &mkey, &update, 0) != MDB_SUCCESS) {
perror("mdb_put");
mdb_txn_abort(txn);
return 0;
}
MDB_CHECK(mdb_txn_commit(txn), MDB_SUCCESS, 0);
return stored_counter;
}
int kvdb_lmdb_put(kvdb_t *kvdb, const char *key, uint32_t klen, void *value, uint32_t vlen)
{
kvdb_lmdb_t *lmdb = (kvdb_lmdb_t*)kvdb;
kvenv_lmdb_t *kvenv_lmdb = (kvenv_lmdb_t*)kvdb->kvenv;
MDB_val m_val;
MDB_val m_key;
MDB_txn *txn;
m_val.mv_size = vlen;
m_val.mv_data = value;
m_key.mv_size = klen;
m_key.mv_data = (void*)key;
int rc = mdb_txn_begin(kvenv_lmdb->env, NULL, 0, &txn);
if( rc==0 ){
rc = mdb_put(txn, lmdb->dbi, &m_key, &m_val, 0);
if( rc==0 ){
rc = mdb_txn_commit(txn);
}else{
error_log("kvdb_lmdb_put() failure. error: %s", mdb_strerror(rc));
mdb_txn_abort(txn);
}
}
return rc;
}
int mdb_ad_get( struct mdb_info *mdb, MDB_txn *txn, AttributeDescription *ad )
{
int i, rc;
MDB_val key, val;
rc = mdb_ad_read( mdb, txn );
if (rc)
return rc;
if ( mdb->mi_adxs[ad->ad_index] )
return 0;
i = mdb->mi_numads+1;
key.mv_size = sizeof(int);
key.mv_data = &i;
val.mv_size = ad->ad_cname.bv_len;
val.mv_data = ad->ad_cname.bv_val;
rc = mdb_put( txn, mdb->mi_ad2id, &key, &val, 0 );
if ( rc == MDB_SUCCESS ) {
mdb->mi_adxs[ad->ad_index] = i;
mdb->mi_ads[i] = ad;
mdb->mi_numads++;
} else {
Debug( LDAP_DEBUG_ANY,
"mdb_ad_get: mdb_put failed %s(%d)\n",
mdb_strerror(rc), rc, 0);
}
return rc;
}
int LMDBEngine::FlushWriteBatch(BatchHolder& holder)
{
if (NULL != holder.txn)
{
StringSet::iterator it = holder.dels.begin();
while (it != holder.dels.end())
{
MDB_val k;
k.mv_data = (void*) (it->c_str());
k.mv_size = it->size();
mdb_del(holder.txn, m_dbi, &k, NULL);
it++;
}
std::map<std::string, std::string>::iterator sit =
holder.inserts.begin();
while (sit != holder.inserts.end())
{
MDB_val k, v;
k.mv_data = (void*) (sit->first.c_str());
k.mv_size = sit->first.size();
v.mv_data = (void*) (sit->second.c_str());
v.mv_size = sit->second.size();
mdb_put(holder.txn, m_dbi, &k, &v, 0);
sit++;
}
mdb_txn_commit(holder.txn);
holder.txn = NULL;
holder.Clear();
}
return 0;
}
int slmdb_put(SLMDB *slmdb, MDB_val *mdb_key,
MDB_val *mdb_value, int flags)
{
MDB_txn *txn;
int status;
/*
* Start a write transaction if there's no bulk-mode txn.
*/
if (slmdb->txn)
txn = slmdb->txn;
else if ((status = slmdb_txn_begin(slmdb, 0, &txn)) != 0)
SLMDB_API_RETURN(slmdb, status);
/*
* Do the update.
*/
if ((status = mdb_put(txn, slmdb->dbi, mdb_key, mdb_value, flags)) != 0) {
mdb_txn_abort(txn);
if (status != MDB_KEYEXIST) {
if ((status = slmdb_recover(slmdb, status)) == 0)
status = slmdb_put(slmdb, mdb_key, mdb_value, flags);
SLMDB_API_RETURN(slmdb, status);
}
}
/*
* Commit the transaction if it's not the bulk-mode txn.
*/
if (status == 0 && slmdb->txn == 0 && (status = mdb_txn_commit(txn)) != 0
&& (status = slmdb_recover(slmdb, status)) == 0)
status = slmdb_put(slmdb, mdb_key, mdb_value, flags);
SLMDB_API_RETURN(slmdb, status);
}
void LMDBTransaction::Put(const string& key, const string& value) {
MDB_val mdb_key, mdb_value;
mdb_key.mv_data = const_cast<char*>(key.data());
mdb_key.mv_size = key.size();
mdb_value.mv_data = const_cast<char*>(value.data());
mdb_value.mv_size = value.size();
MDB_CHECK(mdb_put(mdb_txn_, *mdb_dbi_, &mdb_key, &mdb_value, 0));
}
void put(const char *k)
{
keyv.mv_size = strlen(k);
keyv.mv_data = k;
valv.mv_size = 0;
valv.mv_data = "";
check(mdb_put(txn, dbi, &keyv, &valv, 0));
}
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;
}
// 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);
}
CAMLprim value caml_mdb_put(value txn,value dbi,value key,value data,value flags){
CAMLparam5(txn,dbi,key,data,flags);
MDB_val key_,data_;
key_.mv_data=String_val(key);
key_.mv_size=caml_string_length(key);
data_.mv_data=String_val(data);
data_.mv_size=caml_string_length(data);
if(mdb_put((MDB_txn*)txn,
(MDB_dbi) Int_val(dbi),
&key_,
&data_,
Int_val(flags)
)){
caml_failwith("error in mdb_put");
}
CAMLreturn0;
}
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
lmdb_storage_put(void* handle, paxos_accepted* acc)
{
struct lmdb_storage* s = handle;
int result;
MDB_val key, data;
char* buffer = paxos_accepted_to_buffer(acc);
key.mv_data = &acc->iid;
key.mv_size = sizeof(iid_t);
data.mv_data = buffer;
data.mv_size = sizeof(paxos_accepted) + acc->value.paxos_value_len;
result = mdb_put(s->txn, s->dbi, &key, &data, 0);
assert(result == 0);
free(buffer);
return 0;
}
bool Context::Write(size_t ksz, void* key,
size_t dsz, void* data){
Error(0);
if (envHandle==nullptr){
return false;
}
else if (txnHandle==nullptr){
return false;
}
else{
MDB_val kkey { ksz, key };
MDB_val ddata { dsz, data};
putReturn = mdb_put(txnHandle,dbiHandle,&kkey,&ddata,0);
if (putReturn !=0){
Error(putReturn);
return false;
}
else return true;
}
}
static int __batcher_commit(batch_monitor_t* m, batch_queue_t* bq)
{
if (0 == heap_count(bq->queue))
return 0;
MDB_txn *txn;
int e = mdb_txn_begin(sv->db_env, NULL, 0, &txn);
if (0 != e)
mdb_fatal(e);
while (0 < heap_count(bq->queue))
{
batch_item_t* item = heap_poll(bq->queue);
e = mdb_put(txn, sv->docs, &item->key, &item->val, item->flags);
switch (e)
{
case 0:
break;
case MDB_MAP_FULL:
{
mdb_txn_abort(txn);
while ((item = heap_poll(bq->queue)))
;
snprintf(batcher_error, BATCHER_ERROR_LEN, "NOT ENOUGH SPACE");
return -1;
}
case MDB_KEYEXIST:
item->flags = WOULD_OVERWRITE;
break;
default:
mdb_fatal(e);
}
}
e = mdb_txn_commit(txn);
if (0 != e)
mdb_fatal(e);
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;
}
static int
lmdb_storage_put_trim_instance(void* handle, iid_t iid)
{
struct lmdb_storage* s = handle;
iid_t k = 0;
int result;
MDB_val key, data;
key.mv_data = &k;
key.mv_size = sizeof(iid_t);
data.mv_data = &iid;
data.mv_size = sizeof(iid_t);
result = mdb_put(s->txn, s->dbi, &key, &data, 0);
if (result != 0)
paxos_log_error("%s\n", mdb_strerror(result));
assert(result == 0);
return 0;
}
int _db_put(DB *db, DB_TXN *txnid, DBT *key, DBT *data, uint32_t flags)
{
//FIXME
printf("%s\n", __FUNCTION__);
MDB_val _key;
MDB_val _data;
_key.mv_size = key->size;
_key.mv_data = key->data;
_data.mv_size = data->size;
_data.mv_data = data->data;
uint32_t _flags = 0;
if (mdb_txn_begin(db->_internal->env, NULL, 0, &db->_internal->txn) != 0) return EINVAL;
mdb_put(db->_internal->txn, db->_internal->dbi, &_key, &_data, _flags);
mdb_txn_commit(db->_internal->txn);
return 0;
}
bool DBPrivWrite(DBPriv *db, const void *key, int key_size, const void *value, int value_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc = GetWriteTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
data.mv_data = (void *)value;
data.mv_size = value_size;
rc = mdb_put(txn->txn, db->dbi, &mkey, &data, 0);
if (rc != MDB_SUCCESS)
{
Log(LOG_LEVEL_ERR, "Could not write database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return rc == MDB_SUCCESS;
}
int LMDBEngine::Put(const Slice& key, const Slice& value)
{
MDB_val k, v;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
v.mv_data = const_cast<char*>(value.data());
v.mv_size = value.size();
BatchHolder& holder = m_batch_local.GetValue();
if (!holder.EmptyRef())
{
//mdb_put(holder.txn, m_dbi, &k, &v, 0);
holder.Put(key, value);
}
else
{
MDB_txn *txn = NULL;
mdb_txn_begin(m_env, NULL, 0, &txn);
mdb_put(txn, m_dbi, &k, &v, 0);
mdb_txn_commit(txn);
}
return 0;
}
/*
* Class: jmdb_DatabaseWrapper
* Method: put
* Signature: (JI[BII[BIII)V
*/
JNIEXPORT void JNICALL Java_jmdb_DatabaseWrapper_put(JNIEnv *vm, jclass clazz,
jlong txnL, jint dbi, jbyteArray keyA, jint kofs, jint klen,
jbyteArray valueA, jint vofs, jint vlen, jint flags) {
MDB_txn *txnC = (MDB_txn*) txnL;
enum {
NONE, OOM, MDB
} result = NONE;
jint ret;
MDB_val key, value;
jbyte *keyC = (*vm)->GetPrimitiveArrayCritical(vm, keyA, NULL);
jbyte *valueC = (*vm)->GetPrimitiveArrayCritical(vm, valueA, NULL);
if (keyC == NULL || valueC == NULL) {
result = OOM;
ret = -1;
} else {
key.mv_size = klen;
key.mv_data = keyC + kofs;
value.mv_size = vlen;
value.mv_data = valueC + vofs;
ret = mdb_put(txnC, (MDB_dbi) dbi, &key, &value, (unsigned int) flags);
if (ret) {
result = MDB;
}
}
(*vm)->ReleasePrimitiveArrayCritical(vm, valueA, valueC, 0);
(*vm)->ReleasePrimitiveArrayCritical(vm, keyA, keyC, JNI_ABORT);
switch (result) {
case NONE:
return;
case OOM:
throwNew(vm, "java/lang/OutOfMemoryError", "");
return;
case MDB:
throwDatabaseException(vm, ret);
return;
}
}
int gcache_put(struct gcache *gc, char *keystr, char *payload)
{
int rc;
MDB_val key, data;
MDB_txn *txn;
if (gc == NULL)
return (1);
if (strcmp(payload, "DELETE") == 0)
return gcache_del(gc, keystr);
rc = mdb_txn_begin(gc->env, NULL, 0, &txn);
if (rc != 0) {
olog(LOG_ERR, "gcache_put: mdb_txn_begin: %s", mdb_strerror(rc));
return (-1);
}
key.mv_data = keystr;
key.mv_size = strlen(keystr);
data.mv_data = payload;
data.mv_size = strlen(payload) + 1; /* including nul-byte so we can
* later decode string directly
* from this buffer */
rc = mdb_put(txn, gc->dbi, &key, &data, 0);
if (rc != 0) {
olog(LOG_ERR, "gcache_put: mdb_put: %s", mdb_strerror(rc));
/* fall through to commit */
}
rc = mdb_txn_commit(txn);
if (rc) {
olog(LOG_ERR, "gcache_put: mdb_txn_commit: (%d) %s", rc, mdb_strerror(rc));
mdb_txn_abort(txn);
}
return (rc);
}
