bool xRedisClient::sadd(const RedisDBIdx& dbi, const string& key, const VALUES& vValue, int64_t& count) {
VDATA vCmdData;
vCmdData.push_back("SADD");
vCmdData.push_back(key);
addparam(vCmdData, vValue);
return commandargv_integer(dbi, vCmdData, count);
}
bool xRedisClient::srem(const RedisDBIdx& dbi, const KEY& key, const VALUES& vmembers, int64_t& count) {
VDATA vCmdData;
vCmdData.push_back("SREM");
vCmdData.push_back(key);
addparam(vCmdData, vmembers);
return commandargv_integer(dbi, vCmdData, count);
}
bool xRedisClient::commandargv_array(const RedisDBIdx& dbi, const VDATA& vDataIn, VALUES& array){
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv( vDataIn.size() );
std::vector<size_t> argvlen( vDataIn.size() );
uint32_t j = 0;
for ( VDATA::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j ) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
for (size_t i = 0; i<reply->elements; i++) {
std::string str(reply->element[i]->str, reply->element[i]->len);
array.push_back(str);
}
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::commandargv_integer(const RedisDBIdx& dbi, const VDATA& vDataIn, int64_t& retval){
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv( vDataIn.size() );
std::vector<size_t> argvlen( vDataIn.size() );
uint32_t j = 0;
for ( VDATA::const_iterator iter = vDataIn.begin(); iter != vDataIn.end(); ++iter, ++j ) {
argv[j] = iter->c_str(), argvlen[j] = iter->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
retval = reply->integer;
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::commandargv_status(const RedisDBIdx& dbi, const VDATA& vData) {
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return bRet;
}
std::vector<const char *> argv( vData.size() );
std::vector<size_t> argvlen( vData.size() );
uint32_t j = 0;
for ( VDATA::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j ) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
// Assume good reply until further inspection
bRet = true;
if (REDIS_REPLY_STRING == reply->type) {
if (!reply->len || !reply->str || strcasecmp(reply->str, "OK") != 0) {
bRet = false;
}
}
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::zadd(const RedisDBIdx& dbi, const KEY& key, const VALUES& vValues, int64_t& count){
VDATA vCmdData;
vCmdData.push_back("ZADD");
vCmdData.push_back(key);
addparam(vCmdData, vValues);
SETDEFAULTIOTYPE(MASTER);
return commandargv_integer(dbi, vCmdData, count);
}
bool xRedisClient::hmget(const RedisDBIdx& dbi, const string& key, const KEYS& field, ArrayReply& array){
VDATA vCmdData;
vCmdData.push_back("HMGET");
vCmdData.push_back(key);
addparam(vCmdData, field);
SETDEFAULTIOTYPE(SLAVE);
return commandargv_array(dbi, vCmdData, array);
}
bool xRedisClient::hmset(const RedisDBIdx& dbi, const string& key, const VDATA& vData){
VDATA vCmdData;
vCmdData.push_back("HMSET");
vCmdData.push_back(key);
addparam(vCmdData, vData);
SETDEFAULTIOTYPE(MASTER);
return commandargv_status(dbi, vCmdData);
}
bool xRedisClient::hdel(const RedisDBIdx& dbi, const string& key, const KEYS& vfiled, int64_t& count) {
VDATA vCmdData;
vCmdData.push_back("HDEL");
vCmdData.push_back(key);
addparam(vCmdData, vfiled);
SETDEFAULTIOTYPE(MASTER);
return commandargv_integer(dbi, vCmdData, count);
}
bool xRedisClient::set(const RedisDBIdx& dbi, const string& key, const string& value) {
VDATA vCmdData;
vCmdData.push_back("SET");
vCmdData.push_back(key);
vCmdData.push_back(value);
SETDEFAULTIOTYPE(MASTER);
return commandargv_status(dbi, vCmdData);
}
bool xRedisClient::hset(const RedisDBIdx& dbi, const string& key, const string& field, const string& value, int64_t& retval){
SETDEFAULTIOTYPE(MASTER);
VDATA vCmdData;
vCmdData.push_back("HSET");
vCmdData.push_back(key);
vCmdData.push_back(field);
vCmdData.push_back(value);
return commandargv_integer(dbi, vCmdData, retval);
//return command_integer(dbi, retval, "HSET %s %s %s", key.c_str(), field.c_str(), value.c_str());
}
bool xRedisClient::setex(const RedisDBIdx& dbi, const string& key, int seconds, const string& value) {
VDATA vCmdData;
vCmdData.push_back("SETEX");
vCmdData.push_back(key);
vCmdData.push_back(toString(seconds));
vCmdData.push_back(value);
SETDEFAULTIOTYPE(MASTER);
return commandargv_bool(dbi, vCmdData);
}
bool xRedisClient::lpush(const RedisDBIdx& dbi, const string& key, const VALUES& vValue, int64_t& length) {
if (0 == key.length()) {
return false;
}
VDATA vCmdData;
vCmdData.push_back("LPUSH");
vCmdData.push_back(key);
addparam(vCmdData, vValue);
SETDEFAULTIOTYPE(MASTER);
return commandargv_integer(dbi, vCmdData, length);
}
bool xRedisClient::srem(const RedisDBIdx& dbi, const KEY& key, const VALUES& vmembers, int64_t& count) {
if (0 == key.length()) {
return false;
}
SETDEFAULTIOTYPE(MASTER);
VDATA vCmdData;
vCmdData.push_back("SREM");
vCmdData.push_back(key);
addparam(vCmdData, vmembers);
return commandargv_integer(dbi, vCmdData, count);
}
bool xRedisClient::mset(const DBIArray& vdbi, const VDATA& vData) {
DBIArray::const_iterator iter_dbi = vdbi.begin();
VDATA::const_iterator iter_data = vData.begin();
for (; iter_data != vData.end(); iter_dbi++) {
const string &key = (*iter_data++);
const string &value = (*iter_data++);
const RedisDBIdx& dbi = *iter_dbi;
SETDEFAULTIOTYPE(SLAVE);
command_status(dbi, "SET %s %s", key.c_str(), value.c_str());
}
return true;
}
bool xRedisClient::ScanFun(const char* cmd, const RedisDBIdx& dbi, const std::string *key,
int64_t &cursor, const char* pattern, uint32_t count, ArrayReply& array, xRedisContext& ctx)
{
SETDEFAULTIOTYPE(MASTER);
VDATA vCmdData;
vCmdData.push_back(cmd);
if (NULL != key) {
vCmdData.push_back(*key);
}
vCmdData.push_back(toString(cursor));
if (NULL != pattern) {
vCmdData.push_back("MATCH");
vCmdData.push_back(pattern);
}
if (0 != count) {
vCmdData.push_back("COUNT");
vCmdData.push_back(toString(count));
}
bool bRet = false;
RedisConn *pRedisConn = static_cast<RedisConn *>(ctx.conn);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv(vCmdData.size());
std::vector<size_t> argvlen(vCmdData.size());
uint32_t j = 0;
for (VDATA::const_iterator i = vCmdData.begin(); i != vCmdData.end(); ++i, ++j) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
if (0 == reply->elements){
cursor = 0;
} else {
cursor = atoi(reply->element[0]->str);
redisReply **replyData = reply->element[1]->element;
for (size_t i = 0; i < reply->element[1]->elements; i++) {
DataItem item;
item.type = replyData[i]->type;
item.str.assign(replyData[i]->str, replyData[i]->len);
array.push_back(item);
}
}
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
return bRet;
}
