int redis_zset::zadd(const char* key, const char* members[],
size_t members_len[], double scores[], size_t size)
{
size_t argc = 2 + size * 2;
const char** argv = (const char**)
dbuf_->dbuf_alloc(argc * sizeof(char*));
size_t* lens = (size_t*) dbuf_->dbuf_alloc(argc * sizeof(size_t));
argv[0] = "ZADD";
lens[0] = sizeof("ZADD") - 1;
argv[1] = key;
lens[1] = strlen(key);
size_t j = 2;
char* buf;
int len;
for (size_t i = 0; i < size; i++)
{
buf = (char*) dbuf_->dbuf_alloc(BUFLEN);
len = safe_snprintf(buf, BUFLEN, "%.8f", scores[i]);
argv[j] = buf;
lens[j] = len;
j++;
argv[j] = members[i];
lens[j] = members_len[i];
j++;
}
hash_slot(key);
build_request(argc, argv, lens);
return get_number();
}
bool redis_string::incoper(const char* cmd, const char* key, long long int* n,
long long int* result)
{
size_t argc = 2;
const char* argv[3];
size_t lens[3];
argv[0] = cmd;
lens[0] = strlen(cmd);
argv[1] = key;
lens[1] = strlen(key);
char buf[INT64_LEN];
if (n != NULL)
{
(void) acl_i64toa(*n, buf, sizeof(buf));
argv[2] = buf;
lens[2] = strlen(buf);
argc++;
}
hash_slot(key);
build_request(argc, argv, lens);
bool success;
if (result != NULL)
*result = get_number64(&success);
else
(void) get_number64(&success);
return success;
}
int redis_list::rpush(const char* key, const char* values[],
const size_t lens[], size_t argc)
{
hash_slot(key);
build("RPUSH", key, values, lens, argc);
return get_number();
}
int redis_string::bitcount(const char* key, size_t len, int start, int end)
{
const char* argv[4];
size_t lens[4];
argv[0] = "BITCOUNT";
lens[0] = sizeof("BITCOUNT") - 1;
argv[1] = key;
lens[1] = len;
char buf4start[INT_LEN];
(void) safe_snprintf(buf4start, sizeof(buf4start), "%d", start);
argv[2] = buf4start;
lens[2] = strlen(buf4start);
char buf4end[INT_LEN];
(void) safe_snprintf(buf4end, sizeof(buf4end), "%d", end);
argv[3] = buf4end;
lens[3] = strlen(buf4end);
hash_slot(key, len);
build_request(4, argv, lens);
return get_number();
}
bool redis_string::incrbyfloat(const char* key, double inc,
double* result /* = NULL */)
{
const char* argv[3];
size_t lens[3];
argv[0] = "INCRBYFLOAT";
lens[0] = sizeof("INCRBYFLOAT") - 1;
argv[1] = key;
lens[1] = strlen(key);
char buf[FLOAT_LEN];
(void) safe_snprintf(buf, sizeof(buf), "%f", inc);
argv[2] = buf;
lens[2] = strlen(buf);
hash_slot(key);
build_request(3, argv, lens);
if (get_string(buf, sizeof(buf)) == false)
return false;
if (result != NULL)
*result = atof(buf);
return true;
}
bool redis_string::getrange(const char* key, size_t key_len,
int start, int end, string& buf)
{
const char* argv[4];
size_t lens[4];
argv[0] = "GETRANGE";
lens[0] = sizeof("GETRANGE") - 1;
argv[1] = key;
lens[1] = key_len;
char start_buf[INT_LEN], end_buf[INT_LEN];
(void) safe_snprintf(start_buf, sizeof(start_buf), "%d", start);
argv[2] = start_buf;
lens[2] = strlen(start_buf);
(void) safe_snprintf(end_buf, sizeof(end_buf), "%d", end);
argv[3] = end_buf;
lens[3] = strlen(end_buf);
hash_slot(key, key_len);
build_request(4, argv, lens);
return get_string(buf) >= 0 ? true : false;
}
bool redis_string::getbit(const char* key, size_t len,
unsigned offset, int& bit)
{
const char* argv[3];
size_t lens[3];
argv[0] = "GETBIT";
lens[0] = sizeof("GETBIT") - 1;
argv[1] = key;
lens[1] = len;
char buf4off[INT_LEN];
(void) safe_snprintf(buf4off, sizeof(buf4off), "%d", offset);
argv[2] = buf4off;
lens[2] = strlen(buf4off);
hash_slot(key, len);
build_request(3, argv, lens);
int ret = get_number();
if (ret < 0)
return false;
bit = ret == 0 ? 0 : 1;
return true;
}
int redis_zset::zremrangebyrank(const char* key, int start, int stop)
{
const char* argv[4];
size_t lens[4];
argv[0] = "ZREMRANGEBYRANK";
lens[0] = sizeof("ZREMRANGEBYRANK") - 1;
argv[1] = key;
lens[1] = strlen(key);
char start_s[INTLEN], stop_s[INTLEN];
safe_snprintf(start_s, sizeof(start_s), "%d", start);
safe_snprintf(stop_s, sizeof(stop_s), "%d", stop);
argv[2] = start_s;
lens[2] = strlen(start_s);
argv[3] = stop_s;
lens[3] = strlen(stop_s);
hash_slot(key);
build_request(4, argv, lens);
return get_number();
}
bool redis_zset::zscore(const char* key, const char* member, size_t len,
double& result)
{
const char* argv[3];
size_t lens[3];
argv[0] = "ZSCORE";
lens[0] = sizeof("ZSCORE") - 1;
argv[1] = key;
lens[1] = strlen(key);
argv[2] = member;
lens[2] = len;
hash_slot(key);
build_request(3, argv, lens);
char buf[BUFLEN];
int ret = get_string(buf, sizeof(buf));
if (ret <= 0)
return false;
result = atof(buf);
return true;
}
int redis_zset::zadd(const char* key,
const std::vector<std::pair<string, double> >&members)
{
size_t argc = 2 + members.size() * 2;
const char** argv = (const char**)
dbuf_->dbuf_alloc(argc * sizeof(char*));
size_t* lens = (size_t*) dbuf_->dbuf_alloc(argc * sizeof(size_t));
argv[0] = "ZADD";
lens[0] = sizeof("ZADD") - 1;
argv[1] = key;
lens[1] = strlen(key);
char* buf;
size_t i = 2;
std::vector<std::pair<string, double> >::const_iterator cit;
for (cit = members.begin(); cit != members.end(); ++cit)
{
buf = (char*) dbuf_->dbuf_alloc(BUFLEN);
safe_snprintf(buf, BUFLEN, "%.8f", (*cit).second);
argv[i] = buf;
lens[i] = strlen(buf);
i++;
argv[i] = (*cit).first.c_str();
lens[i] = (*cit).first.length();
i++;
}
hash_slot(key);
build_request(argc, argv, lens);
return get_number();
}
int redis_zset::zrem(const char* key, const char* members[],
const size_t lens[], size_t argc)
{
hash_slot(key);
build("ZREM", key, members, lens, argc);
return get_number();
}
int redis_zset::zrange_get(const char* cmd, const char* key, int start,
int stop, std::vector<string>* result)
{
const char* argv[4];
size_t lens[4];
argv[0] = cmd;
lens[0] = strlen(cmd);
argv[1] = key;
lens[1] = strlen(key);
char start_s[INTLEN], stop_s[INTLEN];
safe_snprintf(start_s, sizeof(start_s), "%d", start);
safe_snprintf(stop_s, sizeof(stop_s), "%d", stop);
argv[2] = start_s;
lens[2] = strlen(start_s);
argv[3] = stop_s;
lens[3] = strlen(stop_s);
hash_slot(key);
build_request(4, argv, lens);
return get_strings(result);
}
bool redis_zset::zincrby(const char* key, double inc,
const char* member, size_t len, double* result /* = NULL */)
{
const char* argv[4];
size_t lens[4];
argv[0] = "ZINCRBY";
lens[0] = sizeof("ZINCRBY") - 1;
argv[1] = key;
lens[1] = strlen(key);
char score[BUFLEN];
safe_snprintf(score, sizeof(score), "%.8f", inc);
argv[2] = score;
lens[2] = strlen(score);
argv[3] = member;
lens[3] = len;
hash_slot(key);
build_request(4, argv, lens);
int ret = get_string(score, sizeof(score));
if (ret <= 0)
return false;
if (result)
*result = atof(score);
return true;
}
int redis_zset::zcount(const char* key, double min, double max)
{
const char* argv[4];
size_t lens[4];
argv[0] = "ZCOUNT";
lens[0] = sizeof("ZCOUNT") - 1;
argv[1] = key;
lens[1] = strlen(key);
char min_buf[BUFLEN], max_buf[BUFLEN];
safe_snprintf(min_buf, sizeof(min_buf), "%.8f", min);
safe_snprintf(max_buf, sizeof(max_buf), "%.8f", max);
argv[2] = min_buf;
lens[2] = strlen(min_buf);
argv[3] = max_buf;
lens[3] = strlen(max_buf);
hash_slot(key);
build_request(4, argv, lens);
return get_number();
}
int redis_key::del_keys(const char* keys[], const size_t lens[], size_t argc)
{
if (argc == 1)
hash_slot(keys[0], lens[0]);
build("DEL", NULL, keys, lens, argc);
return get_number();
}
bool redis_hash::hmget(const char* key, const char* names[],
const size_t lens[], size_t argc, std::vector<string>* result /* = NULL */)
{
hash_slot(key);
build("HMGET", key, names, lens, argc);
return get_strings(result) >= 0 ? true : false;
}
int redis_zset::zrangebylex(const char* key, const char* min, const char* max,
std::vector<string>* out, const int* offset /* = NULL */,
const int* count /* = NULL */)
{
const char* argv[7];
size_t lens[7];
size_t argc = 4;
argv[0] = "ZRANGEBYLEX";
lens[0] = sizeof("ZRANGEBYLEX") - 1;
argv[1] = key;
lens[1] = strlen(key);
argv[2] = min;
lens[2] = strlen(min);
argv[3] = max;
lens[3] = strlen(max);
if (offset != NULL && count != NULL)
{
argv[4] = min;
lens[4] = strlen(min);
argc++;
argv[5] = max;
lens[5] = strlen(max);
argc++;
}
hash_slot(key);
build_request(argc, argv, lens);
return get_strings(out);
}
bool redis_hash::hmget(const char* key, const std::vector<const char*>& names,
std::vector<string>* result /* = NULL */)
{
hash_slot(key);
build("HMGET", key, names);
return get_strings(result) >= 0 ? true : false;
}
int redis_hash::hdel(const char* key, const char* names[],
const size_t names_len[], size_t argc)
{
hash_slot(key);
build("HDEL", key, names, names_len, argc);
return get_number();;
}
int redis_key::del_keys(const std::vector<string>& keys)
{
if (keys.size() == 1)
hash_slot(keys[0].c_str());
build("DEL", NULL, keys);
return get_number();
}
redis_key_t redis_key::type(const char* key)
{
const char* argv[2];
size_t lens[2];
argv[0] = "TYPE";
lens[0] = sizeof("TYPE") - 1;
argv[1] = key;
lens[1] = strlen(key);
hash_slot(key);
build_request(2, argv, lens);
const char* ptr = get_status();
if (ptr == NULL || *ptr == 0 || strcasecmp(ptr, "none") == 0)
return REDIS_KEY_NONE;
else if (strcasecmp(ptr, "string") == 0)
return REDIS_KEY_STRING;
else if (strcasecmp(ptr, "hash") == 0)
return REDIS_KEY_HASH;
else if (strcasecmp(ptr, "list") == 0)
return REDIS_KEY_LIST;
else if (strcasecmp(ptr, "set") == 0)
return REDIS_KEY_SET;
else if (strcasecmp(ptr, "zset") == 0)
return REDIS_KEY_ZSET;
else
{
logger_error("unknown type: %s, key: %s", ptr, key);
return REDIS_KEY_NONE;
}
}
bool redis_key::restore(const char* key, const char* value, size_t len,
int nttl, bool replace /* = false */)
{
const char* argv[5];
size_t lens[5];
argv[0] = "RESTORE";
lens[0] = sizeof("RESTORE") - 1;
argv[1] = key;
lens[1] = strlen(key);
char ttl_s[INT_LEN];
safe_snprintf(ttl_s, sizeof(ttl_s), "%d", nttl);
argv[2] = ttl_s;
lens[2] = strlen(ttl_s);
argv[3] = value;
lens[3] = len;
size_t argc = 4;
if (replace)
{
argv[4] = "REPLACE";
lens[4] = sizeof("REPLACE") - 1;
argc++;
}
hash_slot(key);
build_request(argc, argv, lens);
return check_status();
}
int redis_hash::hlen(const char* key)
{
const char* keys[1];
keys[0] = key;
hash_slot(key);
build("HLEN", NULL, keys, 1);
return get_number();
}
bool redis_hash::hkeys(const char* key, std::vector<string>& names)
{
const char* keys[1];
keys[0] = key;
hash_slot(key);
build("HKEYS", NULL, keys, 1);
return get_strings(names) < 0 ? false : true;
}
bool redis_hash::hgetall(const char* key, std::map<string, string>& result)
{
const char* keys[1];
keys[0] = key;
hash_slot(key);
build("HGETALL", NULL, keys, 1);
return get_strings(result) < 0 ? false : true;
}
bool redis_hash::hgetall(const char* key, std::vector<const char*>& names,
std::vector<const char*>& values)
{
const char* keys[1];
keys[0] = key;
hash_slot(key);
build("HGETALL", NULL, keys, 1);
return get_strings(names, values) < 0 ? false : true;
}
bool redis_hash::hexists(const char* key, const char* name, size_t name_len)
{
const char* names[1];
names[0] = name;
size_t names_len[1];
names_len[0] = name_len;
hash_slot(key);
build("HEXISTS", key, names, names_len, 1);
return get_number() < 0 ? false : true;
}
int redis_list::llen(const char* key)
{
const char* argv[2];
size_t lens[2];
argv[0] = "LLEN";
lens[0] = sizeof("LLEN") - 1;
argv[1] = key;
lens[1] = strlen(key);
hash_slot(key);
build_request(2, argv, lens);
return get_number();
}
int redis_key::del_one(const char* key, size_t len)
{
const char* argv[2];
size_t lens[2];
argv[0] = "DEL";
lens[0] = sizeof("DEL") - 1;
argv[1] = key;
lens[1] = len;
hash_slot(key);
build_request(2, argv, lens);
return get_number();
}
int redis_key::persist(const char* key)
{
const char* argv[2];
size_t lens[2];
argv[0] = "PERSIST";
lens[0] = sizeof("PERSIST") - 1;
argv[1] = key;
lens[1] = strlen(key);
hash_slot(key);
build_request(2, argv, lens);
return get_number();
}
