db_iter_t *
db_iter_seek(db_t *db, const char *key, size_t klen) {
db_iter_t *it;
leveldb_readoptions_t *opts;
it = malloc(sizeof(db_iter_t));
memset(it, 0, sizeof(db_iter_t));
it->base_key_len = klen;
it->base_key = malloc(klen);
memcpy(it->base_key, key, klen);
opts = leveldb_readoptions_create();
/* don't fill cache in iterations */
leveldb_readoptions_set_fill_cache(opts, 0);
it->it = leveldb_create_iterator(db->db, opts);
leveldb_iter_seek(it->it, it->base_key, it->base_key_len);
it->first = 1;
return it;
}
int xleveldb_nextkey(struct db_conn *db,
const unsigned char *key, size_t ksize,
unsigned char *nextkey, size_t *nksize)
{
int rv;
const char *db_nextkey;
size_t db_nksize = 0;
leveldb_readoptions_t *options = leveldb_readoptions_create();
leveldb_iterator_t *it = leveldb_create_iterator(db->conn, options);
leveldb_iter_seek(it, (const char *) key, ksize);
if (! leveldb_iter_valid(it)) {
rv = 0;
goto exit;
}
leveldb_iter_next(it);
if (! leveldb_iter_valid(it)) {
rv = 0;
goto exit;
}
db_nextkey = leveldb_iter_key(it, &db_nksize);
if (db_nextkey == NULL || db_nksize > *nksize) {
rv = 0;
goto exit;
}
*nksize = db_nksize;
memcpy(nextkey, db_nextkey, db_nksize);
rv = 1;
exit:
leveldb_iter_destroy(it);
leveldb_readoptions_destroy(options);
return rv;
}
int ldb_cursor_seek(LDB_cursor *const cursor, DB_val *const key, DB_val *const val, int const dir) {
if(!cursor) return DB_EINVAL;
if(!key) return DB_EINVAL;
DB_val const orig = *key;
leveldb_iter_seek(cursor->iter, key->data, key->size);
cursor->valid = !!leveldb_iter_valid(cursor->iter);
int rc = ldb_cursor_current(cursor, key, val);
if(dir > 0) return rc;
if(dir < 0) {
if(DB_SUCCESS != rc) {
leveldb_iter_seek_to_last(cursor->iter);
} else if(0 != cursor->cmp(key, &orig)) {
leveldb_iter_prev(cursor->iter);
} else return rc;
cursor->valid = !!leveldb_iter_valid(cursor->iter);
return ldb_cursor_current(cursor, key, val);
}
if(DB_SUCCESS != rc) return rc;
if(0 == cursor->cmp(key, &orig)) return rc;
cursor->valid = 0;
return DB_NOTFOUND;
}
static struct stat_cache_iterator *stat_cache_iter_init(stat_cache_t *cache, const char *path_prefix) {
struct stat_cache_iterator *iter = NULL;
iter = malloc(sizeof(struct stat_cache_iterator));
iter->key_prefix = path2key(path_prefix, true); // Handles allocating the duplicate.
iter->key_prefix_len = strlen(iter->key_prefix) + 1;
//log_print(LOG_DEBUG, "creating leveldb iterator for prefix %s", iter->key_prefix);
iter->ldb_options = leveldb_readoptions_create();
iter->ldb_iter = leveldb_create_iterator(cache, iter->ldb_options);
//log_print(LOG_DEBUG, "checking iterator validity");
//if (!leveldb_iter_valid(iter->ldb_iter)) {
// log_print(LOG_ERR, "Initial LevelDB iterator is not valid.");
// return NULL;
//}
//log_print(LOG_DEBUG, "seeking");
leveldb_iter_seek(iter->ldb_iter, iter->key_prefix, iter->key_prefix_len);
return iter;
}
int main(int argc, char** argv) {
leveldb_t* db;
leveldb_comparator_t* cmp;
leveldb_cache_t* cache;
leveldb_env_t* env;
leveldb_options_t* options;
leveldb_readoptions_t* roptions;
leveldb_writeoptions_t* woptions;
char* err = NULL;
int run = -1;
CheckCondition(leveldb_major_version() >= 1);
CheckCondition(leveldb_minor_version() >= 1);
snprintf(dbname, sizeof(dbname),
"%s/leveldb_c_test-%di/meta/0",
GetTempDir(),
((int) geteuid()));
StartPhase("create_objects");
cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
env = leveldb_create_default_env();
cache = leveldb_cache_create_lru(100000);
options = leveldb_options_create();
leveldb_options_set_comparator(options, cmp);
leveldb_options_set_error_if_exists(options, 1);
leveldb_options_set_cache(options, cache);
leveldb_options_set_env(options, env);
leveldb_options_set_info_log(options, NULL);
leveldb_options_set_write_buffer_size(options, 100000);
leveldb_options_set_paranoid_checks(options, 1);
leveldb_options_set_max_open_files(options, 10);
leveldb_options_set_block_size(options, 1024);
leveldb_options_set_block_restart_interval(options, 8);
leveldb_options_set_compression(options, leveldb_no_compression);
roptions = leveldb_readoptions_create();
leveldb_readoptions_set_verify_checksums(roptions, 1);
leveldb_readoptions_set_fill_cache(roptions, 0);
woptions = leveldb_writeoptions_create();
leveldb_writeoptions_set_sync(woptions, 1);
StartPhase("destroy");
leveldb_destroy_db(options, dbname, &err);
Free(&err);
StartPhase("open");
db = leveldb_open(options, dbname, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", NULL);
StartPhase("put");
leveldb_put(db, woptions, "foo", 3, "hello", 5, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", "hello");
StartPhase("compactall");
leveldb_compact_range(db, NULL, 0, NULL, 0);
CheckGet(db, roptions, "foo", "hello");
StartPhase("compactrange");
leveldb_compact_range(db, "a", 1, "z", 1);
CheckGet(db, roptions, "foo", "hello");
StartPhase("writebatch");
{
leveldb_writebatch_t* wb = leveldb_writebatch_create();
leveldb_writebatch_put(wb, "foo", 3, "a", 1);
leveldb_writebatch_clear(wb);
leveldb_writebatch_put(wb, "bar", 3, "b", 1);
leveldb_writebatch_put(wb, "box", 3, "c", 1);
leveldb_writebatch_delete(wb, "bar", 3);
leveldb_write(db, woptions, wb, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", "hello");
CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c");
int pos = 0;
leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
CheckCondition(pos == 3);
leveldb_writebatch_destroy(wb);
}
StartPhase("iter");
{
leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions);
CheckCondition(!leveldb_iter_valid(iter));
leveldb_iter_seek_to_first(iter);
CheckCondition(leveldb_iter_valid(iter));
CheckIter(iter, "box", "c");
leveldb_iter_next(iter);
CheckIter(iter, "foo", "hello");
leveldb_iter_prev(iter);
CheckIter(iter, "box", "c");
leveldb_iter_prev(iter);
CheckCondition(!leveldb_iter_valid(iter));
leveldb_iter_seek_to_last(iter);
CheckIter(iter, "foo", "hello");
leveldb_iter_seek(iter, "b", 1);
CheckIter(iter, "box", "c");
leveldb_iter_get_error(iter, &err);
CheckNoError(err);
leveldb_iter_destroy(iter);
}
StartPhase("approximate_sizes");
{
int i;
int n = 20000;
char keybuf[100];
char valbuf[100];
uint64_t sizes[2];
const char* start[2] = { "a", "k00000000000000010000" };
size_t start_len[2] = { 1, 21 };
const char* limit[2] = { "k00000000000000010000", "z" };
size_t limit_len[2] = { 21, 1 };
leveldb_writeoptions_set_sync(woptions, 0);
for (i = 0; i < n; i++) {
snprintf(keybuf, sizeof(keybuf), "k%020d", i);
snprintf(valbuf, sizeof(valbuf), "v%020d", i);
leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf),
&err);
CheckNoError(err);
}
leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes);
CheckCondition(sizes[0] > 0);
CheckCondition(sizes[1] > 0);
}
StartPhase("property");
{
char* prop = leveldb_property_value(db, "nosuchprop");
/* CheckCondition(prop == NULL);*/
prop = leveldb_property_value(db, "leveldb.stats");
CheckCondition(prop != NULL);
Free(&prop);
}
StartPhase("snapshot");
{
const leveldb_snapshot_t* snap;
snap = leveldb_create_snapshot(db);
leveldb_delete(db, woptions, "foo", 3, &err);
CheckNoError(err);
leveldb_readoptions_set_snapshot(roptions, snap);
CheckGet(db, roptions, "foo", "hello");
leveldb_readoptions_set_snapshot(roptions, NULL);
CheckGet(db, roptions, "foo", NULL);
leveldb_release_snapshot(db, snap);
}
StartPhase("repair");
{
leveldb_close(db);
leveldb_options_set_error_if_exists(options, 0);
leveldb_repair_db(options, dbname, &err);
CheckNoError(err);
db = leveldb_open(options, dbname, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", NULL);
CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c");
leveldb_options_set_error_if_exists(options, 1);
}
StartPhase("filter");
for (run = 0; run < 2; run++) {
// First run uses custom filter, second run uses bloom filter
CheckNoError(err);
leveldb_filterpolicy_t* policy;
if (run == 0) {
policy = leveldb_filterpolicy_create(
NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName);
} else {
policy = leveldb_filterpolicy_create_bloom(10);
}
// Create new database
leveldb_close(db);
leveldb_destroy_db(options, dbname, &err);
leveldb_options_set_filter_policy(options, policy);
db = leveldb_open(options, dbname, &err);
CheckNoError(err);
leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err);
CheckNoError(err);
leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err);
CheckNoError(err);
leveldb_compact_range(db, NULL, 0, NULL, 0);
fake_filter_result = 1;
CheckGet(db, roptions, "foo", "foovalue");
CheckGet(db, roptions, "bar", "barvalue");
if (phase == 0) {
// Must not find value when custom filter returns false
fake_filter_result = 0;
CheckGet(db, roptions, "foo", NULL);
CheckGet(db, roptions, "bar", NULL);
fake_filter_result = 1;
CheckGet(db, roptions, "foo", "foovalue");
CheckGet(db, roptions, "bar", "barvalue");
}
leveldb_options_set_filter_policy(options, NULL);
leveldb_filterpolicy_destroy(policy);
}
StartPhase("cleanup");
leveldb_close(db);
leveldb_options_destroy(options);
leveldb_readoptions_destroy(roptions);
leveldb_writeoptions_destroy(woptions);
leveldb_cache_destroy(cache);
leveldb_comparator_destroy(cmp);
leveldb_env_destroy(env);
fprintf(stderr, "PASS\n");
return 0;
}
char *ldb_keys(struct _leveldb_stuff *ldbs, const char *ptn, size_t ptn_len, int *size)
{
char *err = NULL;
char *result = NULL;
char *p_dst = NULL;
char *p_key = NULL;
size_t klen = 0;
int index = 0;
int i, j, z = 0;
struct kv_list list = { 0 };
struct some_kv *p_new, *p_old, *p_tmp = NULL;
leveldb_iterator_t* iter = leveldb_create_iterator(ldbs->db, ldbs->roptions);
leveldb_iterator_t* iter_save = iter;
if (!!leveldb_iter_valid(iter)) {/* first use it is invalid */
fprintf(stderr, "%s:%d: this iter is valid already!\n", __FILE__, __LINE__);
*size = -1;
return NULL ;
}
leveldb_iter_seek(iter, ptn, ptn_len);
p_old = p_new = &list.head;
while (leveldb_iter_valid(iter)) {
/* parse kv */
p_key = (char *) leveldb_iter_key(iter, &klen);
log_debug("%p iter key = %s, klen = %ld\n", p_key, p_key, klen);
leveldb_iter_get_error(iter, &err);
if (err) {
goto FAIL_ITER_PARSE;
}
if (!prefix_match_len(ptn, ptn_len, p_key, klen)) {
break;
}
/* save parse */
list.count++;/* kv counts */
list.klens += klen;
list.knubs += get_number_len(klen);
index = list.count % SOME_KV_NODES_COUNT;
if ((list.count / SOME_KV_NODES_COUNT >= 1) && (index == 1)) {
/* new store */
p_new = malloc(sizeof(struct some_kv));
if (p_new == NULL ) {
/* free store */
index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT );
p_tmp = &list.head;
for (i = 0, z = list.count - 1; (i < index) && (p_tmp != NULL ); i++ ) {
for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) {
free(p_tmp->nodes[j].key);
}
p_old = p_tmp;
p_tmp = p_tmp->next;
if (p_old != &list.head) {
free(p_old);
}
}
goto FAIL_MEMORY;
}
memset(p_new, 0, sizeof(struct some_kv));
p_old->next = p_new;
p_new->prev = p_old;
p_old = p_new;
}
/*
* fix bug: index is error if list.count = n * SOME_KV_NODES_COUNT(1024),
* SOME_KV_NODES_COUNT = 1024, n > 0.
*/
if (index == 0) {
index = SOME_KV_NODES_COUNT;
}
/* save key */
p_new->nodes[index - 1].klen = klen;
p_new->nodes[index - 1].key = malloc(GET_NEED_COUNT( klen, G_PAGE_SIZE ) * G_PAGE_SIZE);
memcpy(p_new->nodes[index - 1].key, p_key, klen);
/* find next */
leveldb_iter_next(iter);
}
/* create result */
if (list.count > 0) {
/* has members */
/* *2\r\n$5\r\nmykey\r\n$5\r\nmyval\r\n */
*size = strlen("*\r\n") + get_number_len(list.count) + strlen("$\r\n\r\n") * (list.count)
+ list.knubs + list.klens;
index = GET_NEED_COUNT( *size, G_PAGE_SIZE ) * G_PAGE_SIZE;
result = (char *) malloc(index);
if (result == NULL ) goto FAIL_MEMORY;
memset(result, 0, index);
log_debug("----->>>ALL SIZE IS %d, BUFF %p : LEN IS %d\n", *size, result, index);
/* split piece */
index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT );
p_tmp = &list.head;
sprintf(result, "*%d\r\n", list.count);
p_dst = result + strlen(result);
for (i = 0, z = list.count; (i < index) && (p_tmp != NULL ); i++ ) {
for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) {
p_dst = set_bulk(p_dst, p_tmp->nodes[j].key, p_tmp->nodes[j].klen);
free(p_tmp->nodes[j].key);
}
p_old = p_tmp;
p_tmp = p_tmp->next;
if (p_old != &list.head) {
free(p_old);
}
}
} else {
/* no members */
*size = 0;
}
leveldb_iter_destroy(iter_save);
return result;
FAIL_ITER_PARSE: fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, (err));
leveldb_free(err);
err = NULL;
leveldb_iter_destroy(iter);
*size = -1;
return NULL ;
FAIL_MEMORY: fprintf(stderr, "%s:%d: FAILED MALLOC !\n", __FILE__, __LINE__);
leveldb_iter_destroy(iter);
*size = -1;
return NULL ;
}
int main(int argc, char** argv) {
leveldb_t* db;
leveldb_comparator_t* cmp;
leveldb_cache_t* cache;
leveldb_env_t* env;
leveldb_options_t* options;
leveldb_readoptions_t* roptions;
leveldb_writeoptions_t* woptions;
char* err = NULL;
#if defined(LEVELDB_PLATFORM_WINDOWS)
snprintf(dbname, sizeof(dbname), "tmp\\leveldb_c_test");
#else
snprintf(dbname, sizeof(dbname), "/tmp/leveldb_c_test-%d",
((int) geteuid()));
#endif
StartPhase("create_objects");
cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
env = leveldb_create_default_env();
cache = leveldb_cache_create_lru(100000);
options = leveldb_options_create();
leveldb_options_set_comparator(options, cmp);
leveldb_options_set_error_if_exists(options, 1);
leveldb_options_set_cache(options, cache);
leveldb_options_set_env(options, env);
leveldb_options_set_info_log(options, NULL);
leveldb_options_set_write_buffer_size(options, 100000);
leveldb_options_set_paranoid_checks(options, 1);
leveldb_options_set_max_open_files(options, 10);
leveldb_options_set_block_size(options, 1024);
leveldb_options_set_block_restart_interval(options, 8);
leveldb_options_set_compression(options, leveldb_no_compression);
roptions = leveldb_readoptions_create();
leveldb_readoptions_set_verify_checksums(roptions, 1);
leveldb_readoptions_set_fill_cache(roptions, 0);
woptions = leveldb_writeoptions_create();
leveldb_writeoptions_set_sync(woptions, 1);
StartPhase("destroy");
leveldb_destroy_db(options, dbname, &err);
leveldb_free(&err);
StartPhase("open_error");
db = leveldb_open(options, dbname, &err);
CheckCondition(err != NULL);
leveldb_free(&err);
StartPhase("open");
leveldb_options_set_create_if_missing(options, 1);
db = leveldb_open(options, dbname, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", NULL);
StartPhase("put");
leveldb_put(db, woptions, "foo", 3, "hello", 5, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", "hello");
StartPhase("writebatch");
{
int pos = 0;
leveldb_writebatch_t* wb = leveldb_writebatch_create();
leveldb_writebatch_put(wb, "foo", 3, "a", 1);
leveldb_writebatch_clear(wb);
leveldb_writebatch_put(wb, "bar", 3, "b", 1);
leveldb_writebatch_put(wb, "box", 3, "c", 1);
leveldb_writebatch_delete(wb, "bar", 3);
leveldb_write(db, woptions, wb, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", "hello");
CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c");
leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
CheckCondition(pos == 3);
leveldb_writebatch_destroy(wb);
}
StartPhase("iter");
{
leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions);
CheckCondition(!leveldb_iter_valid(iter));
leveldb_iter_seek_to_first(iter);
CheckCondition(leveldb_iter_valid(iter));
CheckIter(iter, "box", "c");
leveldb_iter_next(iter);
CheckIter(iter, "foo", "hello");
leveldb_iter_prev(iter);
CheckIter(iter, "box", "c");
leveldb_iter_prev(iter);
CheckCondition(!leveldb_iter_valid(iter));
leveldb_iter_seek_to_last(iter);
CheckIter(iter, "foo", "hello");
leveldb_iter_seek(iter, "b", 1);
CheckIter(iter, "box", "c");
leveldb_iter_get_error(iter, &err);
CheckNoError(err);
leveldb_iter_destroy(iter);
}
StartPhase("approximate_sizes");
{
int i;
int n = 20000;
char keybuf[100];
char valbuf[100];
uint64_t sizes[2];
const char* start[2] = { "a", "k00000000000000010000" };
size_t start_len[2] = { 1, 21 };
const char* limit[2] = { "k00000000000000010000", "z" };
size_t limit_len[2] = { 21, 1 };
leveldb_writeoptions_set_sync(woptions, 0);
for (i = 0; i < n; i++) {
snprintf(keybuf, sizeof(keybuf), "k%020d", i);
snprintf(valbuf, sizeof(valbuf), "v%020d", i);
leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf),
&err);
CheckNoError(err);
}
leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes);
CheckCondition(sizes[0] > 0);
CheckCondition(sizes[1] > 0);
}
StartPhase("property");
{
char* prop = leveldb_property_value(db, "nosuchprop");
CheckCondition(prop == NULL);
prop = leveldb_property_value(db, "leveldb.stats");
CheckCondition(prop != NULL);
leveldb_free(&prop);
}
StartPhase("snapshot");
{
const leveldb_snapshot_t* snap;
snap = leveldb_create_snapshot(db);
leveldb_delete(db, woptions, "foo", 3, &err);
CheckNoError(err);
leveldb_readoptions_set_snapshot(roptions, snap);
CheckGet(db, roptions, "foo", "hello");
leveldb_readoptions_set_snapshot(roptions, NULL);
CheckGet(db, roptions, "foo", NULL);
leveldb_release_snapshot(db, snap);
}
StartPhase("repair");
{
leveldb_close(db);
leveldb_options_set_create_if_missing(options, 0);
leveldb_options_set_error_if_exists(options, 0);
leveldb_repair_db(options, dbname, &err);
CheckNoError(err);
db = leveldb_open(options, dbname, &err);
CheckNoError(err);
CheckGet(db, roptions, "foo", NULL);
CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c");
}
StartPhase("cleanup");
leveldb_close(db);
leveldb_options_destroy(options);
leveldb_readoptions_destroy(roptions);
leveldb_writeoptions_destroy(woptions);
leveldb_cache_destroy(cache);
leveldb_comparator_destroy(cmp);
leveldb_env_destroy(env);
fprintf(stderr, "PASS\n");
return 0;
}
void db_iterator_seek(db_iterator_t *it, const char *key, size_t klen) {
leveldb_iter_seek(it, key, klen);
}
// get the corresponding pidkey from traced execution
// some graph algorithm is needed here
// @input current pidkey
// @return pidkey from netdb
// TODO
char* getMappedPid(char* pidkey) {
// TODO: need a cache for this operation as well
char key[KEYLEN], *p;
const char *read;
size_t read_len;
ull_t childid;
int n=0, i;
ull_t idlist[100]; // enough?
p = pidkey;
while (p != NULL) {
sprintf(key, "prv.pid.%s.childid", p);
vbp(3, "%s\n", key);
db_read_ull(currdb, key, &childid);
idlist[n++] = childid;
sprintf(key, "prv.pid.%s.parent", p);
if (p != pidkey && p != NULL) free(p);
p = db_readc(currdb, key);
}
vbp(2, "%s -> [%d] [", pidkey, n);
if (CDE_verbose_mode >= 2) {
for (i=0; i<n; i++) {
fprintf(stderr, "%llu, ", idlist[i]);
}
fprintf(stderr, "]\n");
}
if (PIDKEY != NULL) {
p = strdup(PIDKEY);
n -= 2;
} else {
p = db_readc(netdb, "meta.root");
sprintf(key, "prv.pid.%s.exec.", p);
//~ sprintf(key, "prv.pid.%s.actualexec.", p);
free(p);
leveldb_iterator_t *it = leveldb_create_iterator(netdb->db, netdb->roptions);
leveldb_iter_seek(it, key, strlen(key));
read = leveldb_iter_value(it, &read_len);
p = malloc(read_len + 1);
memcpy(p, read, read_len);
p[read_len] = '\0';
n-=2; // skip the first root -> child that I just did
}
while (n>0) {
sprintf(key, "prv.pid.%s.child.%llu", p, idlist[n-1]);
n--;
free(p);
p = db_readc(netdb, key);
vbp(3, "%s\n", key);
}
vbp(2, "return %s\n", p);
return p;
//~ char *value;
//~ const char *read;
//~ size_t read_len;
//~
//~ sprintf(key, "prv.pid.%s.parent.", netdb_root);
//~ leveldb_iterator_t *it = leveldb_create_iterator(netdb->db, netdb->roptions);
//~ leveldb_iter_seek(it, key, strlen(key));
//~
//~ read = leveldb_iter_value(it, &read_len);
//~ value = malloc(read_len + 1);
//~ memcpy(value, read, read_len);
//~ value[read_len] = '\0';
//~ return value;
}
int mdhim_leveldb_get_prev(void *dbh, void **key, int *key_len,
void **data, int32_t *data_len,
struct mdhim_store_opts_t *mstore_opts) {
leveldb_readoptions_t *options;
leveldb_t *db = (leveldb_t *) dbh;
int ret = MDHIM_SUCCESS;
leveldb_iterator_t *iter;
const char *res;
int len = 0;
void *old_key;
int old_key_len;
struct timeval start, end;
//Init the data to return
*data = NULL;
*data_len = 0;
gettimeofday(&start, NULL);
//Create the options and iterator
options = (leveldb_readoptions_t *) mstore_opts->db_ptr3;
old_key = *key;
old_key_len = *key_len;
*key = NULL;
*key_len = 0;
iter = leveldb_create_iterator(db, options);
//If the user didn't supply a key, then seek to the last
if (!old_key || old_key_len == 0) {
leveldb_iter_seek_to_last(iter);
} else {
leveldb_iter_seek(iter, old_key, old_key_len);
if (!leveldb_iter_valid(iter)) {
mlog(MDHIM_SERVER_DBG2, "Could not get a valid iterator in leveldb");
goto error;
}
leveldb_iter_prev(iter);
}
if (!leveldb_iter_valid(iter)) {
goto error;
}
res = leveldb_iter_value(iter, (size_t *) &len);
if (res) {
*data = malloc(len);
memcpy(*data, res, len);
*data_len = len;
} else {
*data = NULL;
*data_len = 0;
}
res = leveldb_iter_key(iter, (size_t *) key_len);
if (res) {
*key = malloc(*key_len);
memcpy(*key, res, *key_len);
} else {
*key = NULL;
*key_len = 0;
}
if (!*data) {
goto error;
}
//Destroy iterator
leveldb_iter_destroy(iter);
gettimeofday(&end, NULL);
mlog(MDHIM_SERVER_DBG, "Took: %d seconds to get the prev record",
(int) (end.tv_sec - start.tv_sec));
return ret;
error:
//Destroy iterator
leveldb_iter_destroy(iter);
*key = NULL;
*key_len = 0;
*data = NULL;
*data_len = 0;
return MDHIM_DB_ERROR;
}