Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
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;
}
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;
}