标签：redis6.0 return string -- db argv && OBJ NULL

/*-----------------------------------------------------------------------------
 * String Commands  字符串命令
 *----------------------------------------------------------------------------*/
检查字符长度，超过512MB 判定错误
static int checkStringLength(client *c, long long size) {
    if (size > 512*1024*1024) {
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
        return C_ERR;
    }
    return C_OK;
}
*********************************************************************************************************************
/* The setGenericCommand() function implements the SET operation with different
 * options and variants. This function is called in order to implement the
 * following commands: SET, SETEX, PSETEX, SETNX.
setGenericCommand这个函数 用不同的选项和变量实现了SET命令。
这个函数被调用用来实现以下的命令： SET, SETEX, PSETEX, SETNX.
 * 'flags' changes the behavior of the command (NX or XX, see below).
变量flags改变了命令的表现(NX  或者 XX, 看下面的介绍)
 * 'expire' represents an expire to set in form of a Redis object as passed
 * by the user. It is interpreted according to the specified 'unit'.
变量expire 表示一个由用户传入的redis对象的过期设置 。这个过期设置的解释需要根据特定的单位(unit 有秒和毫秒的差别)
 * 'ok_reply' and 'abort_reply' is what the function will reply to the client
 * if the operation is performed, or when it is not because of NX or
 * XX flags.
ok_reply和abort_reply 是函数执行之后回复客户端的消息，或者是因为标志NX或XX标志没有执行的回复
 * If ok_reply is NULL "+OK" is used. 如果ok_reply是空的，那么+OK被使用
 * If abort_reply is NULL, "$-1" is used. */ 如果abort_reply是空的，那么$-1被使用

#define OBJ_SET_NO_FLAGS 0  
#define OBJ_SET_NX (1<<0)          /* Set if key not exists. */  设置如果键不存在
#define OBJ_SET_XX (1<<1)          /* Set if key exists. */  设置如果键存在
#define OBJ_SET_EX (1<<2)          /* Set if time in seconds is given */ 按秒设置时间如果有传入
#define OBJ_SET_PX (1<<3)          /* Set if time in ms in given */ 按毫秒设置时间如果有传入
#define OBJ_SET_KEEPTTL (1<<4)     /* Set and keep the ttl */ 设置和保存TTL

//robj结构体的定义
typedef struct redisObject {
    unsigned type:4;  类型  
    unsigned encoding:4;  编码方式
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */  淘汰策略
    int refcount;  引用计数
    void *ptr; 指向对象
} robj;

void setGenericCommand(client *c, int flags, robj *key, robj *val, robj *expire, int unit, robj *ok_reply, robj *abort_reply) {
    long long milliseconds = 0; /* initialized to avoid any harmness warning */ 初始化避免各种不必要的警告

    if (expire) {  如果设置了超时标志
        if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != C_OK)  获取redis对象的超时设置时间
            return;
        if (milliseconds <= 0) {  设置的超时时间小于等于0，是无效的过期时间
            addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
            return;
        }
        if (unit == UNIT_SECONDS) milliseconds *= 1000;  如果单位是秒，那么需要乘以1000
    }

    if ((flags & OBJ_SET_NX && lookupKeyWrite(c->db,key) != NULL) ||  如果设置了键不存在的标志但实际库中键存在
        (flags & OBJ_SET_XX && lookupKeyWrite(c->db,key) == NULL))  如果设置了键存在的标志但是实际库中键不存在
    { 这两种情况下都不需要实际实行命令，返回丢弃信息即可
        addReply(c, abort_reply ? abort_reply : shared.null[c->resp]);
        return;
    }
    genericSetKey(c,c->db,key,val,flags & OBJ_SET_KEEPTTL,1);  设置库中键对应的值
    server.dirty++; 修改次数
    if (expire) setExpire(c,c->db,key,mstime()+milliseconds);  如果设置超时，那么就需要将对应键的值设置时间
    notifyKeyspaceEvent(NOTIFY_STRING,"set",key,c->db->id);  对订阅了事件set的客户端进行通知
    if (expire) notifyKeyspaceEvent(NOTIFY_GENERIC,
        "expire",key,c->db->id);  设置了超期标志，通知订阅客户端事件expire
    addReply(c, ok_reply ? ok_reply : shared.ok); 回复执行命令成功
}
*********************************************************************************************************************
/* SET key value [NX] [XX] [KEEPTTL] [EX <seconds>] [PX <milliseconds>] */
命令的格式如上 set 键  值 后面都时可选的项  NX 不存在 XX存在 KEEPTTL保留设置前指定的过期时间 EX单位按秒 PX单位按毫秒
void setCommand(client *c) {
    int j;
    robj *expire = NULL;
    int unit = UNIT_SECONDS;
    int flags = OBJ_SET_NO_FLAGS;

    for (j = 3; j < c->argc; j++) {  前面至少有三个值 SET  KEY  VALUE
        char *a = c->argv[j]->ptr;
        robj *next = (j == c->argc-1) ? NULL : c->argv[j+1];  是不是最后一个参数，不是的话next就指向下个参数

        if ((a[0] == 'n' || a[0] == 'N') &&
            (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
            !(flags & OBJ_SET_XX))
        {
            flags |= OBJ_SET_NX;  设置不存在标志
        } else if ((a[0] == 'x' || a[0] == 'X') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_NX))
        {
            flags |= OBJ_SET_XX;  设置存在标志
        } else if (!strcasecmp(c->argv[j]->ptr,"KEEPTTL") &&  如果参数为KEEPTTL(不区分大小写)
                   !(flags & OBJ_SET_EX) && !(flags & OBJ_SET_PX)) 并且参数没有设置时间单位
        {
            flags |= OBJ_SET_KEEPTTL; 设置保存设置前的超期时间值
        } else if ((a[0] == 'e' || a[0] == 'E') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_KEEPTTL) &&
                   !(flags & OBJ_SET_PX) && next)  存在下一个参数
        {
            flags |= OBJ_SET_EX;
            unit = UNIT_SECONDS;按秒为单位计算
            expire = next; 下个值就是超时的值
            j++;下一个参数
        } else if ((a[0] == 'p' || a[0] == 'P') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_KEEPTTL) &&
                   !(flags & OBJ_SET_EX) && next)
        {
            flags |= OBJ_SET_PX;
            unit = UNIT_MILLISECONDS; 按毫秒为单位
            expire = next;
            j++;
        } else {
            addReply(c,shared.syntaxerr);  其它情况，返回格式错误
            return;
        }
    }

    c->argv[2] = tryObjectEncoding(c->argv[2]); 对传入值的字符串进行优化编码，节约内存空间
    setGenericCommand(c,flags,c->argv[1],c->argv[2],expire,unit,NULL,NULL);  设置具体的值
}
*********************************************************************************************************************
设置不存在键的值
void setnxCommand(client *c) {  
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setGenericCommand(c,OBJ_SET_NX,c->argv[1],c->argv[2],NULL,0,shared.cone,shared.czero);
}
按妙设置超时
void setexCommand(client *c) {
    c->argv[3] = tryObjectEncoding(c->argv[3]);
    setGenericCommand(c,OBJ_SET_NO_FLAGS,c->argv[1],c->argv[3],c->argv[2],UNIT_SECONDS,NULL,NULL);
}
按毫秒设置超时
void psetexCommand(client *c) {
    c->argv[3] = tryObjectEncoding(c->argv[3]);
    setGenericCommand(c,OBJ_SET_NO_FLAGS,c->argv[1],c->argv[3],c->argv[2],UNIT_MILLISECONDS,NULL,NULL);
}
*********************************************************************************************************************
获取库中的键值
int getGenericCommand(client *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.null[c->resp])) == NULL) 不存在返回OK
        return C_OK;

    if (o->type != OBJ_STRING) { 存在但是类型不是字符串
        addReply(c,shared.wrongtypeerr); 返回错误的类型
        return C_ERR;
    } else {
        addReplyBulk(c,o); 按照特定分块数据格式返回
        return C_OK;
    }
}
*********************************************************************************************************************
void getCommand(client *c) {
    getGenericCommand(c);
}
*********************************************************************************************************************
void getsetCommand(client *c) {
    if (getGenericCommand(c) == C_ERR) return;  从库中获取值
    c->argv[2] = tryObjectEncoding(c->argv[2]); 尝试对字符串编码从而节省空间
    setKey(c,c->db,c->argv[1],c->argv[2]); 设置键对应的值
    notifyKeyspaceEvent(NOTIFY_STRING,"set",c->argv[1],c->db->id); 通知订阅客户端set事件
    server.dirty++; 自从上次保存库之后键改变的数量加1
}
*********************************************************************************************************************
void setrangeCommand(client *c) {
    robj *o;
    long offset;
    sds value = c->argv[3]->ptr;

    if (getLongFromObjectOrReply(c,c->argv[2],&offset,NULL) != C_OK)  
        return;

    if (offset < 0) {
        addReplyError(c,"offset is out of range");
        return;
    }

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o == NULL) {  键不在数据库中
        /* Return 0 when setting nothing on a non-existing string */  返回0如果在不存在的字符串上设置空串
        if (sdslen(value) == 0) {
            addReply(c,shared.czero);
            return;
        }

        /* Return when the resulting string exceeds allowed size */ 当结果字符串长度超过最大的允许长度时直接返回
        if (checkStringLength(c,offset+sdslen(value)) != C_OK)
            return;

        o = createObject(OBJ_STRING,sdsnewlen(NULL, offset+sdslen(value))); 创建新的值对象
        dbAdd(c->db,c->argv[1],o); 添加到对应的数据库中
    } else {
        size_t olen;

        /* Key exists, check type */
        if (checkType(c,o,OBJ_STRING))  不是字符串类型，直接返回
            return;

        /* Return existing string length when setting nothing */
        olen = stringObjectLen(o);  当什么也不设置时，返回存在的字符串长度
        if (sdslen(value) == 0) {   新值的长度为0，返回原值的长度
            addReplyLongLong(c,olen);
            return;
        }

        /* Return when the resulting string exceeds allowed size */  当结果字符串超过了允许的长度，直接返回
        if (checkStringLength(c,offset+sdslen(value)) != C_OK)
            return;

        /* Create a copy when the object is shared or encoded. */  创建一份拷贝，如果这个对象是共享或者编码的
        o = dbUnshareStringValue(c->db,c->argv[1],o);
    }

    if (sdslen(value) > 0) {  如果新值长度大于0
        o->ptr = sdsgrowzero(o->ptr,offset+sdslen(value)); 缩减不必要的长度
        memcpy((char*)o->ptr+offset,value,sdslen(value)); 拼接字符串
        signalModifiedKey(c,c->db,c->argv[1]);通知键被修改的信息
        notifyKeyspaceEvent(NOTIFY_STRING,
            "setrange",c->argv[1],c->db->id);  通知事件setrange
        server.dirty++; 上次库保存之后变动的键加1
    }
    addReplyLongLong(c,sdslen(o->ptr));回复客户端
}
*********************************************************************************************************************
获取一个键对应值的区间段，
比如设置 
set ccy  "this is a test"  
getrange ccy 1 3  
结果为  his

void getrangeCommand(client *c) {
    robj *o;
    long long start, end;  传入的开始和结尾
    char *str, llbuf[32];
    size_t strlen;

    if (getLongLongFromObjectOrReply(c,c->argv[2],&start,NULL) != C_OK) 获取开始位置的值
        return;
    if (getLongLongFromObjectOrReply(c,c->argv[3],&end,NULL) != C_OK)  获取最后一个参数，即结束位置的值
        return;
        通过传入的参数键获取对应的值 或者 检查值是否为字符串
        当值为空或者不是字符串的时候，就返回，表示没有区间可以获得
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptybulk)) == NULL ||
        checkType(c,o,OBJ_STRING)) return;   

    if (o->encoding == OBJ_ENCODING_INT) {
        str = llbuf;
        strlen = ll2string(llbuf,sizeof(llbuf),(long)o->ptr); 将数字装换为字符串
    } else {  字符串编码，直接使用
        str = o->ptr;  
        strlen = sdslen(str);
    }

    /* Convert negative indexes */  转化负索引的情况，就是反向索引
    if (start < 0 && end < 0 && start > end) {  
    如果开始位置和结束位置都时负的，但是开始位置在结束位置后面，那么结果也是为空
        addReply(c,shared.emptybulk);
        return;
    }
    if (start < 0) start = strlen+start; 根据负索引的位置重新确定开始位置
    if (end < 0) end = strlen+end;  结束位置
    if (start < 0) start = 0; 如果还是小于0，那么从0开始
    if (end < 0) end = 0;
    if ((unsigned long long)end >= strlen) end = strlen-1;  如果超出长度，那么定位到最后一个字符

    /* Precondition: end >= 0 && end < strlen, so the only condition where
     * nothing can be returned is: start > end. */
     前提条件：end>=0&&end<strlen，因此在这种情况下，不能返回任何内容的唯一条件是：start>end
    if (start > end || strlen == 0) {
        addReply(c,shared.emptybulk);
    } else {
        addReplyBulkCBuffer(c,(char*)str+start,end-start+1); 否则就返回正常的区间段
    }
}
*********************************************************************************************************************
void mgetCommand(client *c) {
    int j;

    addReplyArrayLen(c,c->argc-1);  确定回复的个数
    for (j = 1; j < c->argc; j++) {
        robj *o = lookupKeyRead(c->db,c->argv[j]);  对每个键进行查找，
        if (o == NULL) {  不存在就返回空
            addReplyNull(c);
        } else {
            if (o->type != OBJ_STRING) {
                addReplyNull(c);
            } else {
                addReplyBulk(c,o); 存在而且类型是字符串就返回值
            }
        }
    }
}
*********************************************************************************************************************
void msetGenericCommand(client *c, int nx) {
    int j;

    if ((c->argc % 2) == 0) {
        addReplyError(c,"wrong number of arguments for MSET");
        return;
    }

    /* Handle the NX flag. The MSETNX semantic is to return zero and don't
     * set anything if at least one key alerady exists. */  
     当标志为NX时，只要有一个键存在，命令MSETNX就不设置其它所有的值，返回0
    if (nx) {  当nx标志存在时，检查所有的键是否存在数据库中
        for (j = 1; j < c->argc; j += 2) {
            if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
                addReply(c, shared.czero);
                return;
            }
        }
    }

    for (j = 1; j < c->argc; j += 2) {
        c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);  尝试编码缩小储存空间
        setKey(c,c->db,c->argv[j],c->argv[j+1]); 设置键的新值
        notifyKeyspaceEvent(NOTIFY_STRING,"set",c->argv[j],c->db->id);
    }
    server.dirty += (c->argc-1)/2;  自从上次数据保存之后变动的键值数目
    addReply(c, nx ? shared.cone : shared.ok);
}
*********************************************************************************************************************

void msetCommand(client *c) {
    msetGenericCommand(c,0);
}

void msetnxCommand(client *c) {
    msetGenericCommand(c,1);
}

void incrDecrCommand(client *c, long long incr) {
    long long value, oldvalue;
    robj *o, *new;

    o = lookupKeyWrite(c->db,c->argv[1]);  在库中查找输入的键
    if (o != NULL && checkType(c,o,OBJ_STRING)) return; 如果非空并且不是字符串，那么直接返回。不能做加这个操作
    if (getLongLongFromObjectOrReply(c,o,&value,NULL) != C_OK) return; 将字符串转化为数字，失败的情况就返回

    oldvalue = value; 获取的旧值进行保存
    if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
        (incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
        addReplyError(c,"increment or decrement would overflow");  超出可以表示的范围，返回失败
        return;
    }
    value += incr;  可以表示的情况下，就进行计算

    if (o && o->refcount == 1 && o->encoding == OBJ_ENCODING_INT &&
        (value < 0 || value >= OBJ_SHARED_INTEGERS) &&
        value >= LONG_MIN && value <= LONG_MAX)
    { 非共享对象，不是小数值，没有超过范围，编码是整型 那么可以直接使用
        new = o;
        o->ptr = (void*)((long)value);
    } else { 否则需要创建一个新的对象
        new = createStringObjectFromLongLongForValue(value);  创建新的一个值
        if (o) {
            dbOverwrite(c->db,c->argv[1],new);  存在就修改
        } else {
            dbAdd(c->db,c->argv[1],new); 不存在就新增
        }
    }
    signalModifiedKey(c,c->db,c->argv[1]); 给客户端发送键被修改的消息
    notifyKeyspaceEvent(NOTIFY_STRING,"incrby",c->argv[1],c->db->id); 对订阅了消息的客户端发送事件
    server.dirty++; 变化过的键加1
    addReply(c,shared.colon);  冒号
    addReply(c,new);  内容
    addReply(c,shared.crlf);  回车换行
}
*********************************************************************************************************************

void incrCommand(client *c) {
    incrDecrCommand(c,1); 加数为1
}

void decrCommand(client *c) {
    incrDecrCommand(c,-1);  同加法，只是加数为负数，-1
}

void incrbyCommand(client *c) {
    long long incr;

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != C_OK) return;
    incrDecrCommand(c,incr);  加数自定义
}

void decrbyCommand(client *c) {
    long long incr;

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != C_OK) return;
    incrDecrCommand(c,-incr); 减数自定义
}
*********************************************************************************************************************
加一个浮点数
void incrbyfloatCommand(client *c) {
    long double incr, value;
    robj *o, *new, *aux1, *aux2;

    o = lookupKeyWrite(c->db,c->argv[1]); 数据库查找键对应的值
    if (o != NULL && checkType(c,o,OBJ_STRING)) return;
    if (getLongDoubleFromObjectOrReply(c,o,&value,NULL) != C_OK ||  本身的值，即键对应的数据库中的值
        getLongDoubleFromObjectOrReply(c,c->argv[2],&incr,NULL) != C_OK)  传入的参数值
        return;

    value += incr;
    if (isnan(value) || isinf(value)) {
        addReplyError(c,"increment would produce NaN or Infinity");
        return;
    }
    new = createStringObjectFromLongDouble(value,1);
    if (o)
        dbOverwrite(c->db,c->argv[1],new);  非空，覆盖
    else
        dbAdd(c->db,c->argv[1],new); 空，新增
    signalModifiedKey(c,c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_STRING,"incrbyfloat",c->argv[1],c->db->id);
    server.dirty++;
    addReplyBulk(c,new);

    /* Always replicate INCRBYFLOAT as a SET command with the final value
     * in order to make sure that differences in float precision or formatting
     * will not create differences in replicas or after an AOF restart. */
     始终将命令INCRBYFLOAT赋值成为具有最终set值的命令。
     这是为了确保不同的操作中(复制或者在AOF重启之后)浮点数精度和格式保持一致。
    aux1 = createStringObject("SET",3);
    rewriteClientCommandArgument(c,0,aux1);
    decrRefCount(aux1);
    rewriteClientCommandArgument(c,2,new);
    aux2 = createStringObject("KEEPTTL",7);
    rewriteClientCommandArgument(c,3,aux2);
    decrRefCount(aux2);
}
*********************************************************************************************************************
在已有的键对应的值后面添加新的字符串或者不存在键的情况下，将字符串作为值建立新键
void appendCommand(client *c) {
    size_t totlen;
    robj *o, *append;

    o = lookupKeyWrite(c->db,c->argv[1]);  查询可写的键
    if (o == NULL) {  不存在
        /* Create the key */  新建键
        c->argv[2] = tryObjectEncoding(c->argv[2]); 看看是否可以压缩字符串编码
        dbAdd(c->db,c->argv[1],c->argv[2]); 增加键
        incrRefCount(c->argv[2]);  增加引用计数
        totlen = stringObjectLen(c->argv[2]); 获取长度
    } else {
        /* Key exists, check type */ 如果存在键值，则查询键值类型
        if (checkType(c,o,OBJ_STRING))
            return;

        /* "append" is an argument, so always an sds */  append是一个参数，总是一个sds字符串类型
        append = c->argv[2];
        totlen = stringObjectLen(o)+sdslen(append->ptr); 原字符串长度+ 需要添加的字符串长度
        if (checkStringLength(c,totlen) != C_OK) 是否超过最大允许值
            return;

        /* Append the value */ 
        o = dbUnshareStringValue(c->db,c->argv[1],o);  获取不共享的对象，可用于修改
        o->ptr = sdscatlen(o->ptr,append->ptr,sdslen(append->ptr)); 根据长度拼接字符串
        totlen = sdslen(o->ptr); 新字符串长度
    }

    signalModifiedKey(c,c->db,c->argv[1]);  通知修改过的key信息给客户端
    notifyKeyspaceEvent(NOTIFY_STRING,"append",c->argv[1],c->db->id); 对订阅了事件的客户端发送信息键相关信息
    server.dirty++; 被修改的键加1
    addReplyLongLong(c,totlen); 回复客户端总长度
}
*********************************************************************************************************************
返回键对应值的长度
void strlenCommand(client *c) {
    robj *o;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_STRING)) return;
    addReplyLongLong(c,stringObjectLen(o));  返回键对应值的长度
}
*********************************************************************************************************************

标签：redis6.0,return,string,--,db,argv,&&,OBJ,NULL
来源： https://www.cnblogs.com/cquccy/p/14962728.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。