void
Freeze::handleDbException(const DbException& dx,
Key& key, Dbt& dbKey,
Value& value, Dbt& dbValue,
const char* file, int line)
{
bool bufferSmallException =
#if (DB_VERSION_MAJOR == 4) && (DB_VERSION_MINOR == 2)
(dx.get_errno() == ENOMEM);
#else
(dx.get_errno() == DB_BUFFER_SMALL || dx.get_errno() == ENOMEM);
#endif
bool resized = false;
if(bufferSmallException)
{
if(dbKey.get_size() > dbKey.get_ulen())
{
size_t oldKeySize = key.size();
key.resize(dbKey.get_size());
initializeOutDbt(key, dbKey);
dbKey.set_size(static_cast<u_int32_t>(oldKeySize));
resized = true;
}
if(dbValue.get_size() > dbValue.get_ulen())
{
value.resize(dbValue.get_size());
initializeOutDbt(value, dbValue);
resized = true;
}
}
if(!resized)
{
handleDbException(dx, file, line);
}
}
AntiCacheBlock AntiCacheDB::readBlock(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, value);
return (block);
}
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();
}
void BtRecExample::run()
{
db_recno_t recno;
int ret;
char buf[1024];
// Acquire a cursor for the database.
dbp->cursor(NULL, &dbcp, 0);
//
// Prompt the user for a record number, then retrieve and display
// that record.
//
for (;;) {
// Get a record number.
cout << "recno #> ";
cout.flush();
if (fgets(buf, sizeof(buf), stdin) == NULL)
break;
recno = atoi(buf);
//
// Start with a fresh key each time,
// the dbp->get() routine returns
// the key and data pair, not just the key!
//
Dbt key(&recno, sizeof(recno));
Dbt data;
if ((ret = dbcp->get(&key, &data, DB_SET_RECNO)) != 0) {
dbp->err(ret, "DBcursor->get");
throw DbException(ret);
}
// Display the key and data.
show("k/d\t", &key, &data);
// Move the cursor a record forward.
if ((ret = dbcp->get(&key, &data, DB_NEXT)) != 0) {
dbp->err(ret, "DBcursor->get");
throw DbException(ret);
}
// Display the key and data.
show("next\t", &key, &data);
//
// Retrieve the record number for the following record into
// local memory.
//
data.set_data(&recno);
data.set_size(sizeof(recno));
data.set_ulen(sizeof(recno));
data.set_flags(data.get_flags() | DB_DBT_USERMEM);
if ((ret = dbcp->get(&key, &data, DB_GET_RECNO)) != 0) {
if (ret != DB_NOTFOUND && ret != DB_KEYEMPTY) {
dbp->err(ret, "DBcursor->get");
throw DbException(ret);
}
}
else {
cout << "retrieved recno: " << (u_long)recno << "\n";
}
}
dbcp->close();
dbcp = NULL;
}
// Modify or create a part based on the following information
MultiPartHeader::Add_Code MultiPartHeader::modifyPart(Db* pdb, quint16 partNo, RawHeader *rh, quint16 hostId)
{
//qDebug() << "Entering modifyPart";
Add_Code retCode = New_Part;
int ret = 0;
bool createPart = false;
Header* h = 0;
char *phead = 0;
Dbc *cursorp = 0;
Dbt key;
Dbt data;
//qDebug() << "Creating part for key " << multiPartKey;
key.set_data(&multiPartKey);
key.set_size(sizeof(quint64));
data.set_data(&partNo);
data.set_size(sizeof(quint16));
// Get a cursor
pdb->cursor(NULL, &cursorp, DB_WRITECURSOR);
//qDebug("1");
// Position the cursor to the first record in the database whose
// key matches the search key and whose data begins with the search
// data.
ret = cursorp->get(&key, &data, DB_GET_BOTH);
if (ret == 0)
{
//qDebug("2");
// update the data
h = new Header((char*)data.get_data(), (char*)key.get_data());
//qDebug("3");
if (h->isHeldByServer(hostId))
{
retCode = Duplicate_Part;
}
else
retCode = Updated_Part;
// qDebug() << "Found an update for part " << partNo << ", existing part " << h->getPartNo() << ", existing msgid " << h->getMessageId() << ", new msgid " << rh->m_mid;
// Always update the article number
h->setServerPartNum(hostId, rh->m_num);
//qDebug("4");
phead=h->data();
data.set_data(phead);
data.set_size(h->getRecordSize());
//qDebug("5");
cursorp->put(&key, &data, DB_CURRENT);
//qDebug("6");
Q_DELETE_ARRAY(phead);
}
else if (ret == DB_NOTFOUND) // create the part
{
//qDebug("7");
createPart = true;
}
else // encountered an error
{
qDebug() << "Unable to find part " << partNo << " for key " << multiPartKey << ", result = " << ret;
retCode = Error_Part;
}
// Close the cursor
if (cursorp != NULL)
cursorp->close();
if (createPart == true)
{
//qDebug("8");
quint32 partSize = rh->m_bytes.toULong();
h = new Header(multiPartKey, partNo, partSize);
//qDebug("9");
h->setMessageId(rh->m_mid);
h->setServerPartNum(hostId, rh->m_num);
//save in the parts db
phead=h->data();
data.set_data(phead);
data.set_size(h->getRecordSize());
//qDebug("10");
ret = pdb->put(0, &key, &data, 0);
if (ret)
{
qDebug() << "Unable to create part " << partNo << " for key " << multiPartKey << ", result = " << ret;
retCode = Error_Part;
}
else
retCode = New_Part;
//qDebug("11");
Q_DELETE_ARRAY(phead);
}
Q_DELETE(h);
//qDebug("12\n");
//qDebug() << "Exiting modifyPart";
return retCode;
}
int* ROSWOSSegment::lookupByIndex( char* key, int size, Dbc *iter,
u_int32_t flags, void **_ptr, void **buf )
{
size_t retklen, retdlen;
Dbt skey;
void *retkey, *retdata;
bool second_pass = false;
int answer;
memset(&skey, 0, sizeof(skey));
memset(&_bulk_data, 0, sizeof(_bulk_data));
//memset( (*buf), 0, sizeof( (*buf) ) );
//_bulk_data.set_data( _bulk_buffer );
_bulk_data.set_data( (*buf) );
_bulk_data.set_ulen( BUFFER_LENGTH );
_bulk_data.set_flags( DB_DBT_USERMEM );
skey.set_data( key );
skey.set_size( size );
//if ( _debug ) return NULL;
do
{
// if bulk buffer is done, get a new one.
//if ( _p_bulk == NULL )
if ( ((*_ptr)) == NULL )
{
//cout << " Request from iter " << iter << " key " << *(int *)key << " FLAGS? " << flags << endl;
memset( (*buf), 0, sizeof( (*buf) ) );
answer = iter->/*_sort_key_cursor->*/get( &skey, &_bulk_data,
flags | DB_MULTIPLE_KEY );
if ( answer == DB_NOTFOUND )
return NULL;
//DB_MULTIPLE_INIT(_p_bulk, _bulk_data.get_DBT());
DB_MULTIPLE_INIT((*_ptr), _bulk_data.get_DBT());
//cout << " DB_NOTFOUND " << DB_NOTFOUND << " ans " << answer << " -- Getting answers, page size " << BUFFER_LENGTH << " ITER " << iter << " PTR " << (*_ptr) <<endl;
}
//else
//cout << " ROSWOSSegment, *_ptr is not NULL, go go go" << endl;
/*if ( answer == DB_NOTFOUND )
{
//_debug = true;
// THAT really does NOT close the iterator. WHY, I have not
// a faintest idea!
//cout << " ITERATOR " << iter << " IS CLOSED " << endl;
//iter->close();
return NULL;
}*/
//if ( !_p_bulk )
if ( !((*_ptr)) )
return NULL;
// I don't understand that.
//if ( !_p_bulk && second_pass )
//cout << " PTR " << (*_ptr) << " SECOND PASS " << second_pass << endl;
if ( !((*_ptr)) && second_pass )
return NULL;
DB_MULTIPLE_KEY_NEXT((*_ptr), _bulk_data.get_DBT(), retkey, retklen, retdata, retdlen);
//DB_MULTIPLE_KEY_NEXT(_p_bulk, _bulk_data.get_DBT(), retkey, retklen, retdata, retdlen);
// cout << " ANd now, ptr is " << *_ptr << " int ptr " << ((int*)retkey) << endl;
second_pass = true;
}
//while( !_p_bulk ); // if bulk is null, get the buffer.
while( !(*_ptr) ); // if bulk is null, get the buffer.
/*if ( (*((int*)retkey)) > 10500 )
{
cout << DB_NOTFOUND << " <=> " << answer << " Ret answer " << *((int *)retkey) << " retDATA " << *((int *)retdata) << endl;
cout << " Recieved buffer " << buf << " points to buf " << (*buf) << " and ptr " << *_ptr << endl;
*/
/*if ( *((int *)retdata) == 596992 &&
10511 == *((int *)retkey) )
*(int *)retdata = 597221;
if ( *((int *)retdata) == 598272 &&
10524 == *((int *)retkey) )
*(int *)retdata = 598362;*/
//cout << " Finally returning " << ( ((int *)retdata) ) << endl << endl;
return( ((int *)retdata) );
/*
// THIS IS AN ITERATION SEQUENCE. DO NOT ERASE.
while ( _sort_key_cursor->get( &skey, &data, DB_NEXT | DB_MULTIPLE_KEY ) == 0 )
{
for (DB_MULTIPLE_INIT(p, data.get_DBT());;)
{
DB_MULTIPLE_KEY_NEXT(p, data.get_DBT(), retkey, retklen, retdata, retdlen);
if (p == NULL)
break;
//cout << " Ret klen " << *((int *)retkey) << " retdlen " << *((int *)retdata) << endl;
//printf("key: %.*s, data: %.*s\n",
//(int)retklen, (char*)retkey, (int)retdlen, (char*)retdata);
ctr2++;
}
cout << " Got SORT key " << *((int *)skey.get_data()) << endl;
cout << " Curr count " << ctr2 << endl;
}
*/
/*
Dbt dkey, data; // Dbt is a key / data pair
int ret; //,a, b;
char *result = ( char* )malloc( sizeof(int) );
memset(&dkey, 0, sizeof(dkey));
memset(&data, 0, sizeof(data));
data.set_data( &result );
data.set_size( sizeof(int) );
// BDB documentation neglects to mention that once you use your own
// buffer you MUST set this parameter or things will break horribly.
// thanks to a helpful post on a google newsgroup...
data.set_ulen( sizeof(int) );
dkey.set_data( key );
dkey.set_size( size );
try
{
int before = StopWatch::ticks();
ret = iter->get( &dkey, &data, flags );
int after = StopWatch::ticks();
db_access+=(after-before)*StopWatch::secondsPerTick();
//cout << _segNameDebug << " Got " << (after-before)*StopWatch::secondsPerTick() << " for " << db_access << endl;
}
catch(DbException& e)
{
if (DEBUG) cout << "Exception " << e.what() << endl;
// Throw exception here
exit( 1 );
}
if ( ret < 0 )
{
//cout << ret << "Nothing found for key ... " << key << endl;
return NULL;
}
//int a,b;
//memcpy( &a, key, 4 );
//memcpy( &b, data.get_data(), 4 );
//cout << "Receiving key " << b << " for given key " << a << endl;
//if ( fake_key > 599874 )
//return NULL;
//memcpy( result, &fake_key, sizeof(int) );
//fake_key++;
memcpy( result, data.get_data(), sizeof(int) );
return ( int* )result;
*/
}
vector<Identity>::const_iterator
Freeze::EvictorIteratorI::nextBatch()
{
DeactivateController::Guard
deactivateGuard(_store->evictor()->deactivateController());
_batch.clear();
if(!_more)
{
return _batch.end();
}
vector<EvictorElementPtr> evictorElements;
evictorElements.reserve(_batchSize);
Key firstKey = _key;
CommunicatorPtr communicator = _store->communicator();
try
{
for(;;)
{
_batch.clear();
evictorElements.clear();
Dbt dbKey;
initializeOutDbt(_key, dbKey);
Dbt dbValue;
dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
Dbc* dbc = 0;
try
{
//
// Move to the first record
//
u_int32_t flags = DB_NEXT;
if(_initialized)
{
//
// _key represents the next element not yet returned
// if it has been deleted, we want the one after
//
flags = DB_SET_RANGE;
//
// Will be used as input as well
//
dbKey.set_size(static_cast<u_int32_t>(firstKey.size()));
}
_store->db()->cursor(0, &dbc, 0);
bool done = false;
do
{
for(;;)
{
try
{
//
// It is critical to set key size to key capacity before the
// get, as a resize that increases the size inserts 0
//
_key.resize(_key.capacity());
_more = (dbc->get(&dbKey, &dbValue, flags) == 0);
if(_more)
{
_key.resize(dbKey.get_size());
_initialized = true;
flags = DB_NEXT;
Ice::Identity ident;
ObjectStore::unmarshal(ident, _key, communicator);
if(_batch.size() < _batchSize)
{
_batch.push_back(ident);
}
else
{
//
// Keep the last element in _key
//
done = true;
}
}
break;
}
catch(const DbDeadlockException&)
{
throw;
}
catch(const DbException& dx)
{
handleDbException(dx, _key, dbKey, __FILE__, __LINE__);
}
}
}
while(!done && _more);
Dbc* toClose = dbc;
dbc = 0;
toClose->close();
break; // for (;;)
}
catch(const DbDeadlockException&)
{
if(dbc != 0)
{
try
{
dbc->close();
}
catch(const DbDeadlockException&)
{
//
// Ignored
//
}
}
_key = firstKey;
//
// Retry
//
}
catch(...)
{
if(dbc != 0)
{
try
{
dbc->close();
}
catch(const DbDeadlockException&)
{
//
// Ignored
//
}
}
throw;
}
}
}
catch(const DbException& dx)
{
handleDbException(dx, __FILE__, __LINE__);
}
if(_batch.size() == 0)
{
return _batch.end();
}
else
{
return _batch.begin();
}
}
