MojErr MojDbLevelDatabase::get(MojDbLevelItem& key, MojDbStorageTxn* txn, bool forUpdate,
MojDbLevelItem& valOut, bool& foundOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(m_db);
MojAssert( !txn || dynamic_cast<MojDbLevelAbstractTxn *> (txn) );
foundOut = false;
std::string str;
MojDbLevelAbstractTxn * leveldb_txn = static_cast<MojDbLevelAbstractTxn *> (txn);
leveldb::Status s;
if (leveldb_txn)
s = leveldb_txn->tableTxn(impl()).Get(*key.impl(), str);
else
s = m_db->Get(MojDbLevelEngine::getReadOptions(), *key.impl(), &str);
//MojLdbErrCheck(s, _T("db->get"));
if(s.IsNotFound() == false)
{
foundOut = true;
valOut.fromBytes(reinterpret_cast<const MojByte*>(str.data()), str.size());
}
return MojErrNone;
}
MojErr MojDbLevelIndex::del(const MojDbKey& key, MojDbStorageTxn* txn)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(txn);
MojAssert(isOpen());
MojDbLevelItem keyItem;
keyItem.fromBytesNoCopy(key.data(), key.size());
bool found = false;
MojErr err = m_db->del(keyItem, found, txn);
#ifdef MOJ_DEBUG
char s[1024];
size_t size1 = keyItem.size();
MojErr err2 = MojByteArrayToHex(keyItem.data(), size1, s);
MojErrCheck(err2);
if (size1 > 16) // if the object-id is in key
strncat(s, (char *)(keyItem.data()) + (size1 - 17), 16);
LOG_DEBUG("[db_ldb] ldbindexdel: %s; keylen: %zu, key: %s ; err = %d\n", m_db->m_name.data(), size1, s, err);
if (!found)
LOG_WARNING(MSGID_LEVEL_DB_WARNING, 1,
PMLOGKS("index", s),
"ldbindexdel_warn: not found: %s \n", s);
#endif
MojErrCheck(err);
if (!found) {
//MojErrThrow(MojErrDbInconsistentIndex); // fix this to work around to deal with out of sync indexes
MojErrThrow(MojErrInternalIndexOnDel);
}
return MojErrNone;
}
MojErr MojDbLevelDatabase::del(const MojObject& id, MojDbStorageTxn* txn, bool& foundOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojDbLevelItem idItem;
MojErr err = idItem.fromObject(id);
MojErrCheck(err);
err = del(idItem, foundOut, txn);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbLevelDatabase::put(const MojObject& id, MojBuffer& val, MojDbStorageTxn* txn, bool updateIdQuota)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojDbLevelItem idItem;
MojErr err = idItem.fromObject(id);
MojErrCheck(err);
MojDbLevelItem valItem;
err = valItem.fromBuffer(val);
MojErrCheck(err);
err = put(idItem, valItem, txn, updateIdQuota);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbLevelDatabase::get(const MojObject& id, MojDbStorageTxn* txn, bool forUpdate, MojRefCountedPtr<MojDbStorageItem>& itemOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
// stop here
itemOut.reset();
MojDbLevelItem idItem;
MojErr err = idItem.fromObject(id);
MojErrCheck(err);
MojRefCountedPtr<MojDbLevelItem> valItem(new MojDbLevelItem);
MojAllocCheck(valItem.get());
bool found = false;
err = get(idItem, txn, forUpdate, *valItem, found);
MojErrCheck(err);
if (found) {
valItem->id(id);
itemOut = valItem;
}
return MojErrNone;
}
MojErr MojDbLevelQuery::getById(const MojObject& id, MojDbStorageItem*& itemOut, bool& foundOut)
{
itemOut = NULL;
foundOut = false;
MojDbLevelItem* item = NULL;
MojErr err = MojErrNone;
if (m_db) {
// retrun val from primary db
MojDbLevelItem primaryKey;
err = primaryKey.fromObject(id);
MojErrCheck(err);
err = m_db->get(primaryKey, m_txn, false, m_primaryVal, foundOut);
MojErrCheck(err);
if (!foundOut) {
char s[1024];
int size = primaryKey.size();
(void) MojByteArrayToHex(primaryKey.data(), size, s);
MojLogInfo(MojDbLevelEngine::s_log, _T("bdbq_byId_warnindex: KeySize: %d; %s ;id: %s \n"),
size, s, primaryKey.data()+1);
//MojErrThrow(MojErrDbInconsistentIndex);
MojErrThrow(MojErrInternalIndexOnFind);
}
item = &m_primaryVal;
} else {
// return val from cursor
item = &m_val;
}
item->id(id);
// check for exclusions
bool exclude = false;
err = checkExclude(item, exclude);
MojErrCheck(err);
if (!exclude) {
itemOut = item;
}
return MojErrNone;
}
MojErr MojDbLevelDatabase::del(MojDbLevelItem& key, bool& foundOut, MojDbStorageTxn* txn)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(m_db);
MojAssert( !txn || dynamic_cast<MojDbLevelAbstractTxn *> (txn) );
foundOut = false;
MojErr err = txn->offsetQuota(-(MojInt64) key.size());
MojErrCheck(err);
MojDbLevelAbstractTxn * leveldb_txn = static_cast<MojDbLevelAbstractTxn *> (txn);
leveldb::Status st;
if(leveldb_txn)
{
leveldb_txn->tableTxn(impl()).Delete(*key.impl());
}
else
st = m_db->Delete(MojDbLevelEngine::getWriteOptions(), *key.impl());
#if defined(MOJ_DEBUG)
char str_buf[1024]; // big enough for any key
size_t size = key.size();
MojErr err2 = MojByteArrayToHex(key.data(), size, str_buf);
MojErrCheck(err2);
if (size > 16) // if the object-id is in key
strncat(str_buf, (char *)(key.data()) + (size - 17), 16);
LOG_DEBUG("[db_ldb] ldbdel: %s; keylen: %zu, key= %s; err = %d \n", this->m_name.data(), size, str_buf, !st.ok());
#endif
if (st.IsNotFound() == false) {
MojLdbErrCheck(st, _T("db->del"));
foundOut = true;
}
postUpdate(txn, key.size());
return MojErrNone;
}
MojErr MojDbLevelIndex::insert(const MojDbKey& key, MojDbStorageTxn* txn)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(txn);
MojDbLevelItem keyItem;
keyItem.fromBytesNoCopy(key.data(), key.size());
MojDbLevelItem valItem; // empty item? not clear why do we need to insert it
MojErr err = m_db->put(keyItem, valItem, txn, true);
#ifdef MOJ_DEBUG
char s[1024];
size_t size1 = keyItem.size();
size_t size2 = valItem.size();
MojErr err2 = MojByteArrayToHex(keyItem.data(), size1, s);
MojErrCheck(err2);
if (size1 > 16) // if the object-id is in key
strncat(s, (char *)(keyItem.data()) + (size1 - 17), 16);
LOG_DEBUG("[db_ldb] ldbindexinsert: %s; keylen: %zu, key: %s ; vallen = %zu; err = %d\n",
m_db->m_name.data(), size1, s, size2, err);
#endif
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbLevelDatabase::put(MojDbLevelItem& key, MojDbLevelItem& val, MojDbStorageTxn* txn, bool updateIdQuota)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(m_db );
MojAssert( !txn || dynamic_cast<MojDbLevelAbstractTxn *> (txn) );
MojErr err;
if (txn)
{
MojInt64 quotaOffset = val.size();
if (updateIdQuota)
quotaOffset += key.size();
err = txn->offsetQuota(quotaOffset);
MojErrCheck(err);
}
MojDbLevelAbstractTxn * leveldb_txn = static_cast<MojDbLevelAbstractTxn *> (txn);
leveldb::Status s;
if(leveldb_txn)
{
leveldb_txn->tableTxn(impl()).Put(*key.impl(), *val.impl());
}
else
s = m_db->Put(MojDbLevelEngine::getWriteOptions(), *key.impl(), *val.impl());
#if defined(MOJ_DEBUG)
char str_buf[1024];
size_t size1 = key.size();
size_t size2 = val.size();
MojErr err2 = MojByteArrayToHex(key.data(), size1, str_buf);
MojErrCheck(err2);
if (size1 > 16) // if the object-id is in key
strncat(str_buf, (char *)(key.data()) + (size1 - 17), 16);
LOG_DEBUG("[db_ldb] ldb put: %s; keylen: %zu, key: %s ; vallen = %zu; err = %d\n",
this->m_name.data(), size1, str_buf, size2, err);
#endif
if(leveldb_txn)
;//MojLdbErrCheck(batch->status(), _T("db->put"));
else
MojLdbErrCheck(s, _T("db->put"));
postUpdate(txn, key.size() + val.size());
return MojErrNone;
}
