/*-----------------------------------------------------------------------------
 * 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));  返回键对应值的长度
}
*********************************************************************************************************************