char *ldb_lrangeget(struct _leveldb_stuff *ldbs, const char *pre_key,
size_t pre_klen, const char *st_time, size_t st_tlen,
const char *ed_time, size_t ed_tlen, int *size)
{
char *err = NULL;
char *result = NULL;
char *p_dst = NULL;
char *p_val = NULL;
char *p_key = NULL;
size_t klen = 0;
size_t vlen = 0;
int index = 0;
int i, j, z = 0;
struct kv_list list = { 0 };
struct some_kv *p_new, *p_old, *p_tmp = NULL;
/* piece the start_key && end_key together */
size_t st_klen = pre_klen + st_tlen;
size_t ed_klen = pre_klen + ed_tlen;
char *st_key = (char *) malloc(st_klen);
char *ed_key = (char *) malloc(ed_klen);
memcpy(st_key, pre_key, pre_klen);
memcpy(st_key + pre_klen, st_time, st_tlen);
memcpy(ed_key, pre_key, pre_klen);
memcpy(ed_key + pre_klen, ed_time, ed_tlen);
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, st_key, st_klen);
p_key = (char *) st_key;
p_old = p_new = &list.head;
if (0 <= strncmp(ed_key, p_key, ed_klen)) {
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);
p_val = (char *) leveldb_iter_value(iter, &vlen);
leveldb_iter_get_error(iter, &err);
if (err) {
goto FAIL_ITER_PARSE;
}
if (0 > strncmp(ed_key, p_key, ed_klen)) {
log_debug("--------------break------------------\n");
break;
}
/* save parse */
list.count++;/* kv counts */
list.klens += klen;
list.knubs += get_number_len(klen);
list.vlens += vlen;
list.vnubs += get_number_len(vlen);
index = list.count % SOME_KV_NODES_COUNT;
if ((list.count / SOME_KV_NODES_COUNT >= 1) && (index == 1)) {
/* new store */
p_new = (struct some_kv *) malloc(sizeof(struct some_kv));
if (p_new == NULL) {
/* free stroe */
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);
free(p_tmp->nodes[j].val);
}
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 = (char *) malloc(
GET_NEED_COUNT( klen, G_PAGE_SIZE ) * G_PAGE_SIZE);
memcpy(p_new->nodes[index - 1].key, p_key, klen);
/* save val */
p_new->nodes[index - 1].vlen = vlen;
p_new->nodes[index - 1].val = (char *) malloc(
GET_NEED_COUNT( vlen, G_PAGE_SIZE ) * G_PAGE_SIZE);
memcpy(p_new->nodes[index - 1].val, p_val, vlen);
/* find next */
leveldb_iter_next(iter);
}
}
/* free space */
free(st_key);
free(ed_key);
/* 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 * 2)
+ strlen("$\r\n\r\n") * (list.count * 2) + list.knubs
+ list.klens + list.vnubs + list.vlens;
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 * 2);
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_dst = set_bulk(p_dst, p_tmp->nodes[j].val,
p_tmp->nodes[j].vlen);
free(p_tmp->nodes[j].val);
}
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;
}
const char *db_iterator_key(db_iterator_t *it, size_t *klen) {
return leveldb_iter_key(it, klen);
}
static PyObject* RangeIterator_next(RangeIterator *iter)
{
VERBOSE("%s", "Entering RangeIterator_next...");
if (iter->_db == 0 || !leveldb_iter_valid(iter->_iterator)) {
RangeIterator_clean(iter);
return 0;
}
if (iter->_to != NULL) {
const char *tkey; /* c style key */
size_t key_len; /* key length */
if (iter->_iterator != NULL) {
tkey = leveldb_iter_key(iter->_iterator, &key_len);
} else return NULL;
int limit_len = (strlen(iter->_to) > key_len) ? key_len: strlen(iter->_to);
int c = memcmp(iter->_to, tkey, limit_len);
if (!(0 <= c)) {
VERBOSE("%s", "Invalid iterator................................");
RangeIterator_clean(iter);
return 0;
}
}
// get key and (optional) value
const char *ckey; /* c style key */
size_t key_len; /* key length */
if (iter->_iterator != NULL) {
ckey = leveldb_iter_key(iter->_iterator, &key_len);
} else return NULL;
VERBOSE("The key is %s, length is %d", ckey, key_len);
PyObject* key = PyString_FromStringAndSize(ckey, key_len);
PyObject* value = 0;
PyObject* ret = key;
if (key == 0) return 0;
const char *cvalue; /* c style value */
size_t value_len; /* value length */
if (iter->_iterator != NULL) {
cvalue = leveldb_iter_value(iter->_iterator, &value_len);
} else return NULL;
if (iter->_include_value) {
value = PyString_FromStringAndSize(cvalue, value_len);
if (value == 0) {
Py_XDECREF(key);
return 0;
}
}
// key/value pairs are returned as 2-tuples
if (value != NULL) {
ret = PyTuple_New(2);
if (ret == 0) {
Py_DECREF(key);
Py_XDECREF(value);
return 0;
}
PyTuple_SET_ITEM(ret, 0, key);
PyTuple_SET_ITEM(ret, 1, value);
}
// get next value
leveldb_iter_next(iter->_iterator);
// return k/v pair or single key
return ret;
}
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;
}
