Status ClientImpl::zset(const std::string &name, const std::string &key, int64_t score){
std::string s_score = int64_to_str(score);
const std::vector<std::string> *resp;
resp = this->request("zset", name, key, s_score);
Status s(resp);
return s;
}
int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val, char log_type){
Transaction trans(binlogs);
int64_t val;
std::string old;
int ret = this->zget(name, key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
ret = zset_one(this, name, key, *new_val, log_type);
if(ret >= 0){
if(ret > 0){
if(incr_zsize(this, name, ret) == -1){
return -1;
}
}
leveldb::Status s = binlogs->commit();
if(!s.ok()){
log_error("zset error: %s", s.ToString().c_str());
return -1;
}
}
return ret;
}
int SSDB::incr(const Bytes &key, int64_t by, std::string *new_val, char log_type){
Transaction trans(binlogs);
int64_t val;
std::string old;
int ret = this->get(key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
std::string buf = encode_kv_key(key);
binlogs->Put(buf, *new_val);
binlogs->add_log(log_type, BinlogCommand::KSET, buf);
leveldb::Status s = binlogs->commit();
if(!s.ok()){
log_error("del error: %s", s.ToString().c_str());
return -1;
}
return 1;
}
static int proc_ttl(Server *serv, Link *link, const Request &req, Response *resp){
if(req.size() != 2){
resp->push_back("client_error");
}else{
int64_t ttl = serv->expiration->get_ttl(req[1]);
resp->push_back("ok");
resp->push_back(int64_to_str(ttl));
}
return 0;
}
Status ClientImpl::zset(const std::string &name, const std::string &key, int64_t score){
std::string s_score = int64_to_str(score);
std::vector<std::string> req;
const std::vector<std::string> *resp;
req.push_back("zset");
req.push_back(name);
req.push_back(key);
req.push_back(s_score);
resp = request(req);
Status s(resp);
return s;
}
int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val) const{
int64_t val;
std::string old;
int ret = this->zget(name, key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
return this->zset(name, key, *new_val);
}
///////////////////////////////////////////
//
// Public
//
///////////////////////////////////////////
char * const Bignum::to_s() {
int pos = 0, tmp = bignum_len - 1;
if (bignum[bignum_len - bignum_used_len()] < 0) {
cache[0] = '-';
pos += 1;
}
for (int i = 0; i < bignum_len; i++) {
if (bignum[i] != 0 || i == tmp) {
pos += int64_to_str(bignum[i], cache + pos);
for (int j = i + 1; j < bignum_len; j++) {
int64_to_str(bignum[j], cache + pos);
add_zero(cache + pos);
pos += LONG_LEN;
}
break;
}
}
return cache;
}
Status ClientImpl::incr(const std::string &key, int64_t incrby, int64_t *ret){
std::string s_incrby = int64_to_str(incrby);
std::vector<std::string> req;
const std::vector<std::string> *resp;
req.push_back("incr");
req.push_back(key);
req.push_back(s_incrby);
resp = request(req);
Status s(resp);
if(s.ok()){
if(resp->size() >= 2){
*ret = str_to_int64(resp->at(1));
}else{
return Status("server_error");
}
}
return s;
}
int RedisLink::convert_req(){
if(!inited){
inited = true;
RedisCommand_raw *def = &cmds_raw[0];
while(def->redis_cmd != NULL){
RedisRequestDesc desc;
desc.strategy = def->strategy;
desc.redis_cmd = def->redis_cmd;
desc.ssdb_cmd = def->ssdb_cmd;
desc.reply_type = def->reply_type;
cmd_table[desc.redis_cmd] = desc;
def += 1;
}
}
this->req_desc = NULL;
std::map<std::string, RedisRequestDesc>::iterator it;
it = cmd_table.find(cmd);
if(it == cmd_table.end()){
recv_string.push_back(cmd);
return 0;
}
this->req_desc = &(it->second);
if(this->req_desc->strategy == STRATEGY_HKEYS
|| this->req_desc->strategy == STRATEGY_HVALS
){
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() == 2){
recv_string.push_back(recv_bytes[1].String());
recv_string.push_back("");
recv_string.push_back("");
recv_string.push_back("99999999999999");
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_SETEX){
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() == 4){
recv_string.push_back(recv_bytes[1].String());
recv_string.push_back(recv_bytes[3].String());
recv_string.push_back(recv_bytes[2].String());
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_ZADD){
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() >= 2){
recv_string.push_back(recv_bytes[1].String());
for(int i=2; i<=recv_bytes.size()-2; i+=2){
recv_string.push_back(recv_bytes[i+1].String());
recv_string.push_back(recv_bytes[i].String());
}
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_ZINCRBY){
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() == 4){
recv_string.push_back(recv_bytes[1].String());
recv_string.push_back(recv_bytes[3].String());
recv_string.push_back(recv_bytes[2].String());
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_REMRANGEBYRANK
|| this->req_desc->strategy == STRATEGY_REMRANGEBYSCORE)
{
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() >= 4){
recv_string.push_back(recv_bytes[1].String());
recv_string.push_back(recv_bytes[2].String());
recv_string.push_back(recv_bytes[3].String());
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_ZRANGE
|| this->req_desc->strategy == STRATEGY_ZREVRANGE)
{
recv_string.push_back(req_desc->ssdb_cmd);
if(recv_bytes.size() >= 4){
int64_t start = recv_bytes[2].Int64();
int64_t end = recv_bytes[3].Int64();
if((start >= 0 && end >= 0) || end == -1){
int64_t size;
if(end == -1){
size = -1;
}else{
if(this->req_desc->strategy == STRATEGY_REMRANGEBYSCORE){
size = end;
}else{
size = end - start + 1;
}
}
recv_string.push_back(recv_bytes[1].String());
recv_string.push_back(recv_bytes[2].String());
recv_string.push_back(int64_to_str(size));
}
}
if(recv_bytes.size() > 4){
std::string s = recv_bytes[4].String();
strtolower(&s);
recv_string.push_back(s);
}
return 0;
}
if(this->req_desc->strategy == STRATEGY_ZRANGEBYSCORE || this->req_desc->strategy == STRATEGY_ZREVRANGEBYSCORE){
recv_string.push_back(req_desc->ssdb_cmd);
std::string name, smin, smax, withscores, offset, count;
if(recv_bytes.size() >= 4){
name = recv_bytes[1].String();
smin = recv_bytes[2].String();
smax = recv_bytes[3].String();
bool after_limit = false;
for(int i=4; i<recv_bytes.size(); i++){
std::string s = recv_bytes[i].String();
if(after_limit){
if(offset.empty()){
offset = s;
}else{
count = s;
after_limit = false;
}
}
strtolower(&s);
if(s == "withscores"){
withscores = s;
}else if(s == "limit"){
after_limit = true;
}
}
}
if(smin.empty() || smax.empty()){
return 0;
}
recv_string.push_back(name);
recv_string.push_back("");
if(smin == "-inf" || smin == "+inf"){
recv_string.push_back("");
}else{
if(smin[0] == '('){
std::string tmp(smin.data() + 1, smin.size() - 1);
char buf[32];
if(this->req_desc->strategy == STRATEGY_ZRANGEBYSCORE){
snprintf(buf, sizeof(buf), "%d", str_to_int(tmp) + 1);
}else{
snprintf(buf, sizeof(buf), "%d", str_to_int(tmp) - 1);
}
smin = buf;
}
recv_string.push_back(smin);
}
if(smax == "-inf" || smax == "+inf"){
recv_string.push_back("");
}else{
if(smax[0] == '('){
std::string tmp(smax.data() + 1, smax.size() - 1);
char buf[32];
if(this->req_desc->strategy == STRATEGY_ZRANGEBYSCORE){
snprintf(buf, sizeof(buf), "%d", str_to_int(tmp) - 1);
}else{
snprintf(buf, sizeof(buf), "%d", str_to_int(tmp) + 1);
}
smax = buf;
}
recv_string.push_back(smax);
}
if(!offset.empty()){
recv_string.push_back(offset);
}
if(count.empty()){
recv_string.push_back("999999999999");
}else{
recv_string.push_back(count);
}
recv_string.push_back(withscores);
return 0;
}
recv_string.push_back(req_desc->ssdb_cmd);
for(int i=1; i<recv_bytes.size(); i++){
recv_string.push_back(recv_bytes[i].String());
}
return 0;
}
Status ClientImpl::zincr(const std::string &name, const std::string &key, int64_t incrby, int64_t *ret){
std::string s_incrby = int64_to_str(incrby);
const std::vector<std::string> *resp;
resp = this->request("zincr", name, key, s_incrby);
return _read_int64(resp, ret);
}
