int zset_rank(ldb_context_t* context, const ldb_slice_t* name,
const ldb_slice_t* key, int reverse, uint64_t* rank){
int retval = 0;
ldb_zset_iterator_t *iterator = NULL;
if(reverse == 0){
iterator = ziterator(context, name, NULL, LDB_SCORE_MIN, LDB_SCORE_MAX, INT32_MAX, FORWARD);
}else{
iterator = ziterator(context, name, NULL, LDB_SCORE_MAX, LDB_SCORE_MIN, INT32_MAX, BACKWARD);
}
ldb_slice_t *slice_key = NULL;
uint64_t tmp = 0;
while(1){
if(!ldb_zset_iterator_valid(iterator)){
retval = LDB_OK_NOT_EXIST;
goto end;
}
int64_t score = 0;
size_t raw_klen = 0;
const char* raw_key = ldb_zset_iterator_key_raw(iterator, &raw_klen);
if(decode_zscore_key(raw_key, raw_klen, NULL, &slice_key, &score)<0){
retval = LDB_OK_NOT_EXIST;
goto end;
}
size_t raw_vlen =0;
const char* raw_val = ldb_zset_iterator_val_raw(iterator, &raw_vlen);
assert(raw_vlen >= LDB_VAL_META_SIZE);
uint8_t type = leveldb_decode_fixed8(raw_val);
if((type & LDB_VALUE_TYPE_VAL)&& !(type & LDB_VALUE_TYPE_LAT)){
printf("%s, score=%ld\n", __func__, score);
printbuf(raw_key, raw_klen);
if(compare_with_length(ldb_slice_data(key),
ldb_slice_size(key),
ldb_slice_data(slice_key),
ldb_slice_size(slice_key))==0){
ldb_slice_destroy(slice_key);
retval = LDB_OK;
break;
}
++tmp;
}
ldb_slice_destroy(slice_key);
if(ldb_zset_iterator_next(iterator)){
retval = LDB_OK_NOT_EXIST;
goto end;
}
}
*rank = tmp;
end:
ldb_zset_iterator_destroy(iterator);
return retval;
}
static int zscan(ldb_context_t* context, const ldb_slice_t* name,
const ldb_slice_t* key, int64_t start, int64_t end, int reverse, ldb_zset_iterator_t **piterator){
int64_t score = 0;
if(ldb_slice_size(key)==0 || zset_get(context, name, key, &score) != LDB_OK ){
score= start;
}
if(reverse == 0){
*piterator = ziterator(context, name, key, score, end, INT32_MAX, FORWARD);
}else{
*piterator = ziterator(context, name, key, score, end, INT32_MAX, BACKWARD);
}
return 0;
}
ZIterator* SSDB::zrrange(const Bytes &name, uint64_t offset, uint64_t limit){
if(offset + limit > limit){
limit = offset + limit;
}
ZIterator *it = ziterator(this, name, "", "", "", limit, Iterator::BACKWARD);
it->skip(offset);
return it;
}
ZIterator* SSDBImpl::zrscan(const Bytes &name, const Bytes &key,
const Bytes &score_start, const Bytes &score_end, uint64_t limit)
{
std::string score;
// if only key is specified, load its value
if(!key.empty() && score_start.empty()){
this->zget(name, key, &score);
}else{
score = score_start.String();
}
return ziterator(this, name, key, score, score_end, limit, Iterator::BACKWARD);
}
static int zrange(ldb_context_t* context, const ldb_slice_t* name,
uint64_t offset, uint64_t limit, int reverse, ldb_zset_iterator_t **piterator){
uint64_t start, end = 0;
start = LDB_SCORE_MIN;
end = LDB_SCORE_MAX;
if((offset + limit)> limit){
limit = offset + limit;
}
if(reverse == 0){
*piterator = ziterator(context, name, NULL, start, end, limit, FORWARD);
}else{
*piterator = ziterator(context, name, NULL, end, start, limit, BACKWARD);
}
int retval = 0;
if(ldb_zset_iterator_skip(*piterator, offset)<0){
retval = -1;
goto end;
}
retval = 0;
end:
return retval;
}
int64_t SSDB::zrrank(const Bytes &name, const Bytes &key) const{
ZIterator *it = ziterator(this, name, "", "", "", INT_MAX, Iterator::BACKWARD);
uint64_t ret = 0;
while(true){
if(it->next() == false){
ret = -1;
break;
}
if(key == it->key){
break;
}
ret ++;
}
delete it;
return ret;
}
ZIterator* SSDB::zrscan(const Bytes &name, const Bytes &key,
const Bytes &score_start, const Bytes &score_end, uint64_t limit) const
{
std::string score;
// if only key is specified, load its value
if(!key.empty() && score_start.empty()){
this->zget(name, key, &score);
}else{
score = score_start.String();
}
return ziterator(this, name, key, score, score_end, limit, Iterator::BACKWARD);
/*
std::string key_start, key_end;
if(score_start.empty()){
if(!key.empty()){
std::string score;
if(this->zget(name, key, &score) == 1){
key_start = encode_zscore_key(name, key, score);
}else{
key_start = encode_zscore_key(name, key, SSDB_SCORE_MAX);
}
}else{
key_start = encode_zscore_key(name, key, SSDB_SCORE_MAX);
}
}else{
key_start = encode_zscore_key(name, key, score_start);
}
if(score_end.empty()){
key_end = encode_zscore_key(name, "", SSDB_SCORE_MIN);
}else{
key_end = encode_zscore_key(name, "", score_end);
}
//dump(key_start.data(), key_start.size(), "zscan.start");
//dump(key_end.data(), key_end.size(), "zscan.end");
return new ZIterator(this->rev_iterator(key_start, key_end, limit), name);
*/
}
