bool DbstlMultipleRecnoDataIterator::next(db_recno_t &recno, Dbt &data) { if (*p_ == (u_int32_t)0) { recno = 0; data.set_data(0); data.set_size(0); p_ = 0; } else { recno = *p_--; data.set_data(data_ + *p_--); data.set_size(*p_--); } return (p_ != 0); }
bool DbstlMultipleDataIterator::next(Dbt &data) { if (*p_ == (u_int32_t)-1) { data.set_data(0); data.set_size(0); p_ = 0; } else { data.set_data(data_ + *p_--); data.set_size(*p_--); if (data.get_size() == 0 && data.get_data() == data_) data.set_data(0); } return (p_ != 0); }
Bdb::ResponseCode Bdb:: remove(const std::string& key) { if (!inited_) { return Error; } Dbt dbkey; dbkey.set_data(const_cast<char*>(key.c_str())); dbkey.set_size(key.size()); int rc = 0; for (uint32_t idx = 0; idx < numRetries_; idx++) { rc = db_->del(NULL, &dbkey, 0); if (rc == 0) { return Success; } else if (rc == DB_NOTFOUND) { return KeyNotFound; } else if (rc != DB_LOCK_DEADLOCK) { fprintf(stderr, "Db::del() returned: %s", db_strerror(rc)); return Error; } } fprintf(stderr, "update failed %d times", numRetries_); return Error; }
void berkeleydb_store<Object>::get(const timestamp& time, const long lp_id, obj_ptr& ret) { boost::lock_guard<boost::mutex> guard(get_mutex_); /* generate key */ std::vector<char> key; key_lpid_to_char(time, lp_id, key); Dbt db_key(&key[0], key.size()); /* get data */ char* event_binary; Dbt data; data.set_data(event_binary); data.set_flags(DB_DBT_MALLOC); db->get(NULL, &db_key, &data, 0); /* deserialize the data */ std::string binary = std::string((char*) data.get_data(), data.get_size()); std::stringstream from_ss; from_ss << binary; boost::archive::binary_iarchive iar(from_ss); Object obj; iar >> obj; ret = boost::make_shared<Object>(obj); };
bool DbMultipleKeyDataIterator::next(Dbt &key, Dbt &data) { if (*p_ == (u_int32_t)-1) { key.set_data(0); key.set_size(0); data.set_data(0); data.set_size(0); p_ = 0; } else { key.set_data(data_ + *p_--); key.set_size(*p_--); data.set_data(data_ + *p_--); data.set_size(*p_--); } return (data.get_data() != 0); }
void LoginDB::change(string user, string pass) { openDb(); Dbc *cursorp; Dbt key(const_cast<char*> (user.data()), user.size()); Dbt data; // Get a cursor db->cursor(NULL, &cursorp, 0); // Position the cursor int ret = cursorp->get(&key, &data, DB_SET); if (ret == 0) { data.set_data(const_cast<char*>(pass.data())); data.set_size(pass.size()); cursorp->put(&key, &data, DB_CURRENT); } if (cursorp != NULL) cursorp->close(); closeDb(); }
RecordData Database::get(const RecordID& id) const { Dbt key(id.data(), id.size()); Dbt data; thread_local static std::vector<char> buffer(256); while (true) { try { data.set_flags(DB_DBT_USERMEM); data.set_data(buffer.data()); data.set_ulen(buffer.size()); const int err = dbMain_.get(/*txnid*/nullptr, &key, &data, /*flags*/0); assert (err == 0); break; } catch(DbException const& ex) { if (ex.get_errno() != DB_BUFFER_SMALL) { throw; } buffer.resize(data.get_size() * 1.5); } } return RecordData(data); }
db_iterator Database::dirs_begin() const { Dbc* pCursor = nullptr; dbDirs_.cursor(NULL, &pCursor, 0); assert(pCursor); RecordID id; Dbt key; Dbt data; key.set_flags(DB_DBT_USERMEM); key.set_data(id.data()); key.set_ulen(id.size()); const int err = pCursor->get(&key, &data, DB_FIRST); if (err) { pCursor->close(); if (err != DB_NOTFOUND) { throw DbException("Failed to obtain first directory record", err); } return dirs_end(); } return db_iterator(pCursor, make_Record(std::move(id), RecordData(data))); }
HeaderGroup* BulkHeaderGroup::getGroup(NewsGroup* ng, QString& articleIndex) { HeaderGroup *hg = 0; int ret; Dbt groupkey; Dbt groupdata; memset(&groupkey, 0, sizeof(groupkey)); memset(&groupdata, 0, sizeof(groupdata)); groupdata.set_flags(DB_DBT_MALLOC); QByteArray ba = articleIndex.toLocal8Bit(); const char *k= ba.constData(); groupkey.set_data((void*)k); groupkey.set_size(articleIndex.length()); Db* groupsDb = ng->getGroupingDb(); ret=groupsDb->get(NULL, &groupkey, &groupdata, 0); if (ret != 0) //key not found { qDebug() << "Failed to find group with key " << articleIndex; } else { qDebug() << "Found group with key " << articleIndex; hg=new HeaderGroup(articleIndex.length(), (char*)k, (char*)groupdata.get_data()); void* ptr = groupdata.get_data(); Q_FREE(ptr); } return hg; }
AntiCacheBlock AntiCacheDB::readBlockBerkeleyDB(std::string tableName, int16_t blockId) { Dbt key; key.set_data(&blockId); key.set_size(sizeof(int16_t)); Dbt value; value.set_flags(DB_DBT_MALLOC); VOLT_DEBUG("Reading evicted block with id %d", blockId); int ret_value = m_db->get(NULL, &key, &value, 0); if (ret_value != 0) { VOLT_ERROR("Invalid anti-cache blockId '%d' for table '%s'", blockId, tableName.c_str()); throw UnknownBlockAccessException(tableName, blockId); } else { // m_db->del(NULL, &key, 0); // if we have this the benchmark won't end assert(value.get_data() != NULL); } AntiCacheBlock block(blockId, static_cast<char*>(value.get_data()), value.get_size()); return (block); }
void JabberBotSession::Status(const std::string *from, MessageStanza::MessageTypes type, const std::string *id) { std::string account_id, resource; split_identifier(from, account_id, resource); char keyValue[account_id.size()+1]; account_id.copy(keyValue, std::string::npos); keyValue[account_id.size()] = '\0'; time_t last = 0; Dbt key(keyValue, account_id.size()+1); Dbt data; data.set_data(&last); data.set_ulen(sizeof(time_t)); int result = m_subscriptionDb.get(NULL, &key, &data, 0); MessageStanza message; message.Type(type); message.To(from); message.Thread(id); if (0 != result) { message.Body("You are not subscribed"); } else { message.Body("You are subscribed"); } m_session->SendMessage(message, false); }
/** * Cursor must be closed before the transaction is aborted/commited. * http://download.oracle.com/docs/cd/E17076_02/html/programmer_reference/transapp_cursor.html */ Bdb::ResponseCode Bdb:: update(const std::string& key, const std::string& value) { if (!inited_) { fprintf(stderr, "insert called on uninitialized database"); return Error; } DbTxn* txn = NULL; Dbc* cursor = NULL; Dbt dbkey, dbdata; dbkey.set_data(const_cast<char*>(key.c_str())); dbkey.set_size(key.size()); dbdata.set_data(const_cast<char*>(value.c_str())); dbdata.set_size(value.size()); Dbt currentData; currentData.set_data(NULL); currentData.set_ulen(0); currentData.set_dlen(0); currentData.set_doff(0); currentData.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL); int rc = 0; for (uint32_t idx = 0; idx < numRetries_; idx++) { env_->txn_begin(NULL, &txn, 0); (*db_).cursor(txn, &cursor, DB_READ_COMMITTED); // move the cursor to the record. rc = cursor->get(&dbkey, ¤tData, DB_SET | DB_RMW); if (rc != 0) { cursor->close(); txn->abort(); if (rc == DB_NOTFOUND) { return KeyNotFound; } else if (rc != DB_LOCK_DEADLOCK) { fprintf(stderr, "Db::get() returned: %s", db_strerror(rc)); return Error; } continue; } // update the record. rc = cursor->put(NULL, &dbdata, DB_CURRENT); cursor->close(); if (rc == 0) { txn->commit(DB_TXN_SYNC); return Success; } else { txn->abort(); if (rc != DB_LOCK_DEADLOCK) { fprintf(stderr, "Db::put() returned: %s", db_strerror(rc)); return Error; } } } fprintf(stderr, "update failed %d times", numRetries_); return Error; }
void AntiCacheDB::writeBlock(const std::string tableName, int16_t blockId, const int tupleCount, const char* data, const long size) { Dbt key; key.set_data(&blockId); key.set_size(sizeof(int16_t)); Dbt value; value.set_data(const_cast<char*>(data)); value.set_size(static_cast<int32_t>(size)); VOLT_DEBUG("Writing out a block #%d to anti-cache database [tuples=%d / size=%ld]", blockId, tupleCount, size); // TODO: Error checking m_db->put(NULL, &key, &value, 0); }
static void make_record(const std::string& uid, const std::string& id, const std::string& owner, const std::list<std::string>& meta, Dbt& key, Dbt& data) { key.set_data(NULL); key.set_size(0); data.set_data(NULL); data.set_size(0); uint32_t l = 4 + uid.length(); for(std::list<std::string>::const_iterator m = meta.begin(); m != meta.end(); ++m) { l += 4 + m->length(); }; make_key(id,owner,key); void* d = (void*)::malloc(l); if(!d) { ::free(key.get_data()); key.set_data(NULL); key.set_size(0); return; }; data.set_data(d); data.set_size(l); d = store_string(uid,d); for(std::list<std::string>::const_iterator m = meta.begin(); m != meta.end(); ++m) { d = store_string(*m,d); }; }
float CKeyValuePair::GetFloat(const std::string &key) { structKey k( Float, key.size(), key.c_str() ); Dbt v; float value; v.set_flags( DB_DBT_USERMEM ); v.set_ulen( sizeof( float ) ); v.set_size( sizeof( float ) ); v.set_data( &value ); Get( k, &v ); return value; }
double CKeyValuePair::GetDouble(const std::string &key) { structKey k( Double, key.size(), key.c_str() ); Dbt v; double value; v.set_flags( DB_DBT_USERMEM ); v.set_ulen( sizeof( double ) ); v.set_size( sizeof( double ) ); v.set_data( &value ); Get( k, &v ); return value; }
void operator<<(Dbt& dbt, const T& obj) { QByteArray ba; QDataStream ds(&ba, QIODevice::WriteOnly); // Serialize the object ds << obj; dbt.set_ulen(ba.size()); dbt.set_data(ba.data()); }
short CKeyValuePair::GetShort(const std::string &key) { structKey k( Int16, key.size(), key.c_str() ); Dbt v; short value; v.set_flags( DB_DBT_USERMEM ); v.set_ulen( sizeof( short ) ); v.set_size( sizeof( short ) ); v.set_data( &value ); Get( k, &v ); return value; }
unsigned long CKeyValuePair::GetUnsignedLong(const std::string &key) { structKey k( UInt32, key.size(), key.c_str() ); Dbt v; unsigned long value; v.set_flags( DB_DBT_USERMEM ); v.set_ulen( sizeof( unsigned long ) ); v.set_size( sizeof( unsigned long ) ); v.set_data( &value ); Get( k, &v ); return value; }
void berkeleydb_store<Object>::get_range(const timestamp& from, const timestamp& to, const long lp_id, std::vector<obj_ptr>& ret_obj) { boost::lock_guard<boost::mutex> guard(get_mutex_); if (from > to) return; /* generate key */ std::vector<char> from_char; key_lpid_to_char(from, lp_id, from_char); Dbt db_key = Dbt(&from_char[0], from_char.size()); /* prepare data */ char* binary; Dbt data; data.set_data(binary); data.set_flags(DB_DBT_MALLOC); /* seek to from */ Dbc* cursorp; db->cursor(NULL, &cursorp, 0); int ret = cursorp->get(&db_key, &data, DB_SET_RANGE); if (ret) { if (cursorp != NULL) cursorp->close(); return; } std::string get_data_binary = std::string((char*) data.get_data(), data.get_size()); std::stringstream from_ss; from_ss << get_data_binary; boost::archive::binary_iarchive iar(from_ss); Object obj; iar >> obj; ret_obj.push_back(boost::make_shared<Object>(obj)); /* get until end */ while ((ret = cursorp->get(&db_key, &data, DB_NEXT)) == 0) { timestamp tmstmp; long id; char_to_key_lpid((char*) db_key.get_data(), tmstmp, id); if (tmstmp > to || id != lp_id) break; get_data_binary = std::string((char*) data.get_data(), data.get_size()); std::stringstream ss; ss << get_data_binary; boost::archive::binary_iarchive iar(ss); Object deserialized_obj; iar >> deserialized_obj; ret_obj.push_back(boost::make_shared<Object>(deserialized_obj)); } if (cursorp != NULL) cursorp->close(); };
void DatabaseManager::addRecord(const StringPimpl &key, const StringPimpl &value) { //Set up the key Dbt dbKey; dbKey.set_data((void *)key.c_str()); dbKey.set_size((key.size() + 1) * sizeof(char)); //Set up the data to insert Dbt dbData; dbData.set_data((void *)value.c_str()); dbData.set_size((value.size() + 1) * sizeof(char)); try { m_pimpl->checkTSSInit(); int ret = m_pimpl->m_database->put(&(**m_pimpl->m_transaction), &dbKey, &dbData, 0); } catch (DbException &e) { std::cerr << "Error in addRecord: " << e.what() << e.get_errno() << std::endl; } }
string read(const char* skey){ Dbt key((void*)skey, ::strlen(skey)); //fetch char* buf = _allocHeap(); //keep as heap mem Dbt data; data.set_data(buf); data.set_ulen(MAX_LEN); data.set_flags(DB_DBT_USERMEM); if( _db->get(nullptr, &key, &data, 0) == DB_NOTFOUND){ return string("F"); }; string res(buf); delete[] buf; return res; };
void test_dbt(void) { u_int32_t size = 3; u_int32_t flags = 5; u_int32_t ulen = 7; void* data = &size; Dbt dbt; dbt.set_size(size); dbt.set_flags(flags); dbt.set_data(data); dbt.set_ulen(ulen); assert(dbt.get_size() == size); assert(dbt.get_flags() == flags); assert(dbt.get_data() == data); assert(dbt.get_ulen() == ulen); }
/* Adds a single word pertinent to a single edit */ void addWord(const std::string & word, bool is_bad) { Dbt key(const_cast<void *>(reinterpret_cast<const void *>(word.c_str())), word.size()); Dbt data; BayesDBData bdata; if(db.get(NULL, &key, &data, 0) != DB_NOTFOUND) { int s = data.get_size(); if(s != sizeof(bdata)) throw std::runtime_error("Bayesian DB returned wrong record size"); void * vdata = data.get_data(); memcpy((void *)&bdata, vdata, s); } if(is_bad) { bdata.bad_edits++; } else { bdata.good_edits++; } data.set_data((void *)&bdata); data.set_size(sizeof(bdata)); db.put(NULL, &key, &data, 0); }
// Shows a vendor record. Each vendor record is an instance of // a vendor structure. See loadVendorDB() in // example_database_load for how this structure was originally // put into the database. int show_vendor(MyDb &vendorDB, const char *vendor) { Dbt data; VENDOR my_vendor; try { // Set the search key to the vendor's name // vendor is explicitly cast to char * to stop a compiler // complaint. Dbt key((char *)vendor, (u_int32_t)strlen(vendor) + 1); // Make sure we use the memory we set aside for the VENDOR // structure rather than the memory that DB allocates. // Some systems may require structures to be aligned in memory // in a specific way, and DB may not get it right. data.set_data(&my_vendor); data.set_ulen(sizeof(VENDOR)); data.set_flags(DB_DBT_USERMEM); // Get the record vendorDB.getDb().get(NULL, &key, &data, 0); std::cout << " " << my_vendor.street << "\n" << " " << my_vendor.city << ", " << my_vendor.state << "\n" << " " << my_vendor.zipcode << "\n" << " " << my_vendor.phone_number << "\n" << " Contact: " << my_vendor.sales_rep << "\n" << " " << my_vendor.sales_rep_phone << std::endl; } catch (DbException &e) { vendorDB.getDb().err(e.get_errno(), "Error in show_vendor"); throw e; } catch (std::exception &e) { throw e; } return (0); }
int UserDatabase::del_record(unsigned long uid) { if(m_pmazeuserDB == NULL) return -1; Dbt key; init_DBT(&key,&key); int ret; key.set_data(&uid); key.set_size(sizeof(uid)); ret = m_pmazeuserDB->del(NULL, &key, 0); if (ret != 0) { debug("del record error!"<<uid); } return ret; }
bool QueueScheduler::dbDelete(QString _scheduleName) { Dbt key; QByteArray ba; const char *c_str = 0; ba = _scheduleName.toLocal8Bit(); c_str = ba.data(); key.set_data((void*)c_str); key.set_size(_scheduleName.size()); if ((schedDb->del(NULL, &key, 0)) != 0) return false; else { schedDb->sync(0); return true; } }
void berkeleydb_store<Object>::get_prev(const timestamp& time, const long lp_id, obj_ptr& ret_obj, timestamp& time_of_ret) { boost::lock_guard<boost::mutex> guard(get_mutex_); /* generate key */ std::vector<char> key; key_lpid_to_char(time, lp_id, key); Dbt db_key = Dbt(&key[0], key.size()); /* prepare data */ char* binary; Dbt data; data.set_data(binary); data.set_flags(DB_DBT_MALLOC); /* seek to key */ Dbc* cursorp; db->cursor(NULL, &cursorp, 0); int ret = cursorp->get(&db_key, &data, DB_SET_RANGE); /* seek back */ ret = cursorp->get(&db_key, &data, DB_PREV); /* get value */ std::string obj_binary = std::string((char*) data.get_data(), data.get_size()); std::stringstream ss; ss << obj_binary; boost::archive::binary_iarchive iar(ss); Object obj; iar >> obj; ret_obj = boost::make_shared<Object>(obj); /* get key */ long lp_id_; char_to_key_lpid((char*) db_key.get_data(), time_of_ret, lp_id_); if (cursorp != NULL) cursorp->close(); };
int UserDatabase::del_record(string email) { if(m_psec_mazeuserDB == NULL) return -1; int ret; Dbt key; init_DBT(&key,&key); key.set_data(const_cast<char*>(email.c_str()) ); key.set_size(email.length() + 1); ret = m_psec_mazeuserDB->del(NULL, &key, 0); if (ret != 0) { debug("Delete record Error!"<<email); } return ret; }
void MultiPartHeader::deleteAllParts(Db* pDB) { int ret = 0; Dbc *cursorp = 0; Dbt key; Dbt data; //qDebug() << "Deleting all parts for key " << multiPartKey; key.set_data(&multiPartKey); key.set_size(sizeof(quint64)); // Get a cursor pDB->cursor(NULL, &cursorp, DB_WRITECURSOR); while ((ret = cursorp->get(&key, &data, DB_SET)) == 0) cursorp->del(0); pDB->sync(0); if (cursorp != NULL) cursorp->close(); }