src/t_string.c

#include "redis.h"

/*-----------------------------------------------------------------------------
 * String Commands
 *----------------------------------------------------------------------------*/

static int checkStringLength(redisClient *c, long long size) {
    if (size > 512*1024*1024) {
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
        return REDIS_ERR;
    }
    return REDIS_OK;
}

void setGenericCommand(redisClient *c, int nx, robj *key, robj *val, robj *expire) {
    long seconds = 0; /* initialized to avoid an harmness warning */

    if (expire) {
        if (getLongFromObjectOrReply(c, expire, &seconds, NULL) != REDIS_OK)
            return;
        if (seconds <= 0) {
            addReplyError(c,"invalid expire time in SETEX");
            return;
        }
    }

    if (lookupKeyWrite(c->db,key) != NULL && nx) {
        addReply(c,shared.czero);
        return;
    }
    setKey(c->db,key,val);
    server.dirty++;
    if (expire) setExpire(c->db,key,time(NULL)+seconds);
    addReply(c, nx ? shared.cone : shared.ok);
}

void setCommand(redisClient *c) {
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setGenericCommand(c,0,c->argv[1],c->argv[2],NULL);
}

void setnxCommand(redisClient *c) {
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setGenericCommand(c,1,c->argv[1],c->argv[2],NULL);
}

void setexCommand(redisClient *c) {
    c->argv[3] = tryObjectEncoding(c->argv[3]);
    setGenericCommand(c,0,c->argv[1],c->argv[3],c->argv[2]);
}

int getGenericCommand(redisClient *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
        return REDIS_OK;

    if (o->type != REDIS_STRING) {
        addReply(c,shared.wrongtypeerr);
        return REDIS_ERR;
    } else {
        addReplyBulk(c,o);
        return REDIS_OK;
    }
}

void getCommand(redisClient *c) {
    getGenericCommand(c);
}

void getsetCommand(redisClient *c) {
    if (getGenericCommand(c) == REDIS_ERR) return;
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setKey(c->db,c->argv[1],c->argv[2]);
    server.dirty++;
}

static int getBitOffsetFromArgument(redisClient *c, robj *o, size_t *offset) {
    long long loffset;
    char *err = "bit offset is not an integer or out of range";

    if (getLongLongFromObjectOrReply(c,o,&loffset,err) != REDIS_OK)
        return REDIS_ERR;

    /* Limit offset to 512MB in bytes */
    if ((loffset < 0) || ((unsigned long long)loffset >> 3) >= (512*1024*1024))
    {
        addReplyError(c,err);
        return REDIS_ERR;
    }

    *offset = (size_t)loffset;
    return REDIS_OK;
}

void setbitCommand(redisClient *c) {
    robj *o;
    char *err = "bit is not an integer or out of range";
    size_t bitoffset;
    int byte, bit;
    int byteval, bitval;
    long on;

    if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset) != REDIS_OK)
        return;

    if (getLongFromObjectOrReply(c,c->argv[3],&on,err) != REDIS_OK)
        return;

    /* Bits can only be set or cleared... */
    if (on & ~1) {
        addReplyError(c,err);
        return;
    }

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o == NULL) {
        o = createObject(REDIS_STRING,sdsempty());
        dbAdd(c->db,c->argv[1],o);
    } else {
        if (checkType(c,o,REDIS_STRING)) return;

        /* Create a copy when the object is shared or encoded. */
        if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
            robj *decoded = getDecodedObject(o);
            o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
            decrRefCount(decoded);
            dbOverwrite(c->db,c->argv[1],o);
        }
    }

    /* Grow sds value to the right length if necessary */
    byte = bitoffset >> 3;
    o->ptr = sdsgrowzero(o->ptr,byte+1);

    /* Get current values */
    byteval = ((char*)o->ptr)[byte];
    bit = 7 - (bitoffset & 0x7);
    bitval = byteval & (1 << bit);

    /* Update byte with new bit value and return original value */
    byteval &= ~(1 << bit);
    byteval |= ((on & 0x1) << bit);
    ((char*)o->ptr)[byte] = byteval;
    signalModifiedKey(c->db,c->argv[1]);
    server.dirty++;
    addReply(c, bitval ? shared.cone : shared.czero);
}

void getbitCommand(redisClient *c) {
    robj *o;
    char llbuf[32];
    size_t bitoffset;
    size_t byte, bit;
    size_t bitval = 0;

    if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset) != REDIS_OK)
        return;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,REDIS_STRING)) return;

    byte = bitoffset >> 3;
    bit = 7 - (bitoffset & 0x7);
    if (o->encoding != REDIS_ENCODING_RAW) {
        if (byte < (size_t)ll2string(llbuf,sizeof(llbuf),(long)o->ptr))
            bitval = llbuf[byte] & (1 << bit);
    } else {
        if (byte < sdslen(o->ptr))
            bitval = ((char*)o->ptr)[byte] & (1 << bit);
    }

    addReply(c, bitval ? shared.cone : shared.czero);
}

void setrangeCommand(redisClient *c) {
    robj *o;
    long offset;
    sds value = c->argv[3]->ptr;

    if (getLongFromObjectOrReply(c,c->argv[2],&offset,NULL) != REDIS_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 */
        if (sdslen(value) == 0) {
            addReply(c,shared.czero);
            return;
        }

        /* Return when the resulting string exceeds allowed size */
        if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
            return;

        o = createObject(REDIS_STRING,sdsempty());
        dbAdd(c->db,c->argv[1],o);
    } else {
        size_t olen;

        /* Key exists, check type */
        if (checkType(c,o,REDIS_STRING))
            return;

        /* Return existing string length when setting nothing */
        olen = stringObjectLen(o);
        if (sdslen(value) == 0) {
            addReplyLongLong(c,olen);
            return;
        }

        /* Return when the resulting string exceeds allowed size */
        if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
            return;

        /* Create a copy when the object is shared or encoded. */
        if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
            robj *decoded = getDecodedObject(o);
            o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
            decrRefCount(decoded);
            dbOverwrite(c->db,c->argv[1],o);
        }
    }

    if (sdslen(value) > 0) {
        o->ptr = sdsgrowzero(o->ptr,offset+sdslen(value));
        memcpy((char*)o->ptr+offset,value,sdslen(value));
        signalModifiedKey(c->db,c->argv[1]);
        server.dirty++;
    }
    addReplyLongLong(c,sdslen(o->ptr));
}

void getrangeCommand(redisClient *c) {
    robj *o;
    long start, end;
    char *str, llbuf[32];
    size_t strlen;

    if (getLongFromObjectOrReply(c,c->argv[2],&start,NULL) != REDIS_OK)
        return;
    if (getLongFromObjectOrReply(c,c->argv[3],&end,NULL) != REDIS_OK)
        return;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptybulk)) == NULL ||
        checkType(c,o,REDIS_STRING)) return;

    if (o->encoding == REDIS_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) start = strlen+start;
    if (end < 0) end = strlen+end;
    if (start < 0) start = 0;
    if (end < 0) end = 0;
    if ((unsigned)end >= strlen) end = strlen-1;

    /* Precondition: end >= 0 && end < strlen, so the only condition where
     * nothing can be returned is: start > end. */
    if (start > end) {
        addReply(c,shared.emptybulk);
    } else {
        addReplyBulkCBuffer(c,(char*)str+start,end-start+1);
    }
}

void mgetCommand(redisClient *c) {
    int j;

    addReplyMultiBulkLen(c,c->argc-1);
    for (j = 1; j < c->argc; j++) {
        robj *o = lookupKeyRead(c->db,c->argv[j]);
        if (o == NULL) {
            addReply(c,shared.nullbulk);
        } else {
            if (o->type != REDIS_STRING) {
                addReply(c,shared.nullbulk);
            } else {
                addReplyBulk(c,o);
            }
        }
    }
}

void msetGenericCommand(redisClient *c, int nx) {
    int j, busykeys = 0;

    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 nothing at all if at least one already key exists. */
    if (nx) {
        for (j = 1; j < c->argc; j += 2) {
            if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
                busykeys++;
            }
        }
        if (busykeys) {
            addReply(c, shared.czero);
            return;
        }
    }

    for (j = 1; j < c->argc; j += 2) {
        c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);
        setKey(c->db,c->argv[j],c->argv[j+1]);
    }
    server.dirty += (c->argc-1)/2;
    addReply(c, nx ? shared.cone : shared.ok);
}

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

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

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

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o != NULL && checkType(c,o,REDIS_STRING)) return;
    if (getLongLongFromObjectOrReply(c,o,&value,NULL) != REDIS_OK) return;

    oldvalue = value;
    value += incr;
    if ((incr < 0 && value > oldvalue) || (incr > 0 && value < oldvalue)) {
        addReplyError(c,"increment or decrement would overflow");
        return;
    }
    new = createStringObjectFromLongLong(value);
    if (o)
        dbOverwrite(c->db,c->argv[1],new);
    else
        dbAdd(c->db,c->argv[1],new);
    signalModifiedKey(c->db,c->argv[1]);
    server.dirty++;
    addReply(c,shared.colon);
    addReply(c,new);
    addReply(c,shared.crlf);
}

void incrCommand(redisClient *c) {
    incrDecrCommand(c,1);
}

void decrCommand(redisClient *c) {
    incrDecrCommand(c,-1);
}

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

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
    incrDecrCommand(c,incr);
}

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

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
    incrDecrCommand(c,-incr);
}

void appendCommand(redisClient *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,REDIS_STRING))
            return;

        /* "append" is an argument, so always an sds */
        append = c->argv[2];
        totlen = stringObjectLen(o)+sdslen(append->ptr);
        if (checkStringLength(c,totlen) != REDIS_OK)
            return;

        /* If the object is shared or encoded, we have to make a copy */
        if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
            robj *decoded = getDecodedObject(o);
            o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
            decrRefCount(decoded);
            dbOverwrite(c->db,c->argv[1],o);
        }

        /* Append the value */
        o->ptr = sdscatlen(o->ptr,append->ptr,sdslen(append->ptr));
        totlen = sdslen(o->ptr);
    }
    signalModifiedKey(c->db,c->argv[1]);
    server.dirty++;
    addReplyLongLong(c,totlen);
}

void strlenCommand(redisClient *c) {
    robj *o;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,REDIS_STRING)) return;
    addReplyLongLong(c,stringObjectLen(o));
}
Commit	Line	Data
	1	#include "redis.h"
	2
	3	/*-----------------------------------------------------------------------------
	4	* String Commands
	5	----------------------------------------------------------------------------/
	6
	7	static int checkStringLength(redisClient *c, long long size) {
	8	if (size > 51210241024) {
	9	addReplyError(c,"string exceeds maximum allowed size (512MB)");
	10	return REDIS_ERR;
	11	}
	12	return REDIS_OK;
	13	}
	14
	15	void setGenericCommand(redisClient c, int nx, robj key, robj val, robj expire) {
	16	long seconds = 0; /* initialized to avoid an harmness warning */
	17
	18	if (expire) {
	19	if (getLongFromObjectOrReply(c, expire, &seconds, NULL) != REDIS_OK)
	20	return;
	21	if (seconds <= 0) {
	22	addReplyError(c,"invalid expire time in SETEX");
	23	return;
	24	}
	25	}
	26
	27	if (lookupKeyWrite(c->db,key) != NULL && nx) {
	28	addReply(c,shared.czero);
	29	return;
	30	}
	31	setKey(c->db,key,val);
	32	server.dirty++;
	33	if (expire) setExpire(c->db,key,time(NULL)+seconds);
	34	addReply(c, nx ? shared.cone : shared.ok);
	35	}
	36
	37	void setCommand(redisClient *c) {
	38	c->argv[2] = tryObjectEncoding(c->argv[2]);
	39	setGenericCommand(c,0,c->argv[1],c->argv[2],NULL);
	40	}
	41
	42	void setnxCommand(redisClient *c) {
	43	c->argv[2] = tryObjectEncoding(c->argv[2]);
	44	setGenericCommand(c,1,c->argv[1],c->argv[2],NULL);
	45	}
	46
	47	void setexCommand(redisClient *c) {
	48	c->argv[3] = tryObjectEncoding(c->argv[3]);
	49	setGenericCommand(c,0,c->argv[1],c->argv[3],c->argv[2]);
	50	}
	51
	52	int getGenericCommand(redisClient *c) {
	53	robj *o;
	54
	55	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
	56	return REDIS_OK;
	57
	58	if (o->type != REDIS_STRING) {
	59	addReply(c,shared.wrongtypeerr);
	60	return REDIS_ERR;
	61	} else {
	62	addReplyBulk(c,o);
	63	return REDIS_OK;
	64	}
	65	}
	66
	67	void getCommand(redisClient *c) {
	68	getGenericCommand(c);
	69	}
	70
	71	void getsetCommand(redisClient *c) {
	72	if (getGenericCommand(c) == REDIS_ERR) return;
	73	c->argv[2] = tryObjectEncoding(c->argv[2]);
	74	setKey(c->db,c->argv[1],c->argv[2]);
	75	server.dirty++;
	76	}
	77
	78	static int getBitOffsetFromArgument(redisClient c, robj o, size_t *offset) {
	79	long long loffset;
	80	char *err = "bit offset is not an integer or out of range";
	81
	82	if (getLongLongFromObjectOrReply(c,o,&loffset,err) != REDIS_OK)
	83	return REDIS_ERR;
	84
	85	/* Limit offset to 512MB in bytes */
	86	if ((loffset < 0) \|\| ((unsigned long long)loffset >> 3) >= (51210241024))
	87	{
	88	addReplyError(c,err);
	89	return REDIS_ERR;
	90	}
	91
	92	*offset = (size_t)loffset;
	93	return REDIS_OK;
	94	}
	95
	96	void setbitCommand(redisClient *c) {
	97	robj *o;
	98	char *err = "bit is not an integer or out of range";
	99	size_t bitoffset;
	100	int byte, bit;
	101	int byteval, bitval;
	102	long on;
	103
	104	if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset) != REDIS_OK)
	105	return;
	106
	107	if (getLongFromObjectOrReply(c,c->argv[3],&on,err) != REDIS_OK)
	108	return;
	109
	110	/* Bits can only be set or cleared... */
	111	if (on & ~1) {
	112	addReplyError(c,err);
	113	return;
	114	}
	115
	116	o = lookupKeyWrite(c->db,c->argv[1]);
	117	if (o == NULL) {
	118	o = createObject(REDIS_STRING,sdsempty());
	119	dbAdd(c->db,c->argv[1],o);
	120	} else {
	121	if (checkType(c,o,REDIS_STRING)) return;
	122
	123	/* Create a copy when the object is shared or encoded. */
	124	if (o->refcount != 1 \|\| o->encoding != REDIS_ENCODING_RAW) {
	125	robj *decoded = getDecodedObject(o);
	126	o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
	127	decrRefCount(decoded);
	128	dbOverwrite(c->db,c->argv[1],o);
	129	}
	130	}
	131
	132	/* Grow sds value to the right length if necessary */
	133	byte = bitoffset >> 3;
	134	o->ptr = sdsgrowzero(o->ptr,byte+1);
	135
	136	/* Get current values */
	137	byteval = ((char*)o->ptr)[byte];
	138	bit = 7 - (bitoffset & 0x7);
	139	bitval = byteval & (1 << bit);
	140
	141	/* Update byte with new bit value and return original value */
	142	byteval &= ~(1 << bit);
	143	byteval \|= ((on & 0x1) << bit);
	144	((char*)o->ptr)[byte] = byteval;
	145	signalModifiedKey(c->db,c->argv[1]);
	146	server.dirty++;
	147	addReply(c, bitval ? shared.cone : shared.czero);
	148	}
	149
	150	void getbitCommand(redisClient *c) {
	151	robj *o;
	152	char llbuf[32];
	153	size_t bitoffset;
	154	size_t byte, bit;
	155	size_t bitval = 0;
	156
	157	if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset) != REDIS_OK)
	158	return;
	159
	160	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL \|\|
	161	checkType(c,o,REDIS_STRING)) return;
	162
	163	byte = bitoffset >> 3;
	164	bit = 7 - (bitoffset & 0x7);
	165	if (o->encoding != REDIS_ENCODING_RAW) {
	166	if (byte < (size_t)ll2string(llbuf,sizeof(llbuf),(long)o->ptr))
	167	bitval = llbuf[byte] & (1 << bit);
	168	} else {
	169	if (byte < sdslen(o->ptr))
	170	bitval = ((char*)o->ptr)[byte] & (1 << bit);
	171	}
	172
	173	addReply(c, bitval ? shared.cone : shared.czero);
	174	}
	175
	176	void setrangeCommand(redisClient *c) {
	177	robj *o;
	178	long offset;
	179	sds value = c->argv[3]->ptr;
	180
	181	if (getLongFromObjectOrReply(c,c->argv[2],&offset,NULL) != REDIS_OK)
	182	return;
	183
	184	if (offset < 0) {
	185	addReplyError(c,"offset is out of range");
	186	return;
	187	}
	188
	189	o = lookupKeyWrite(c->db,c->argv[1]);
	190	if (o == NULL) {
	191	/* Return 0 when setting nothing on a non-existing string */
	192	if (sdslen(value) == 0) {
	193	addReply(c,shared.czero);
	194	return;
	195	}
	196
	197	/* Return when the resulting string exceeds allowed size */
	198	if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
	199	return;
	200
	201	o = createObject(REDIS_STRING,sdsempty());
	202	dbAdd(c->db,c->argv[1],o);
	203	} else {
	204	size_t olen;
	205
	206	/* Key exists, check type */
	207	if (checkType(c,o,REDIS_STRING))
	208	return;
	209
	210	/* Return existing string length when setting nothing */
	211	olen = stringObjectLen(o);
	212	if (sdslen(value) == 0) {
	213	addReplyLongLong(c,olen);
	214	return;
	215	}
	216
	217	/* Return when the resulting string exceeds allowed size */
	218	if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
	219	return;
	220
	221	/* Create a copy when the object is shared or encoded. */
	222	if (o->refcount != 1 \|\| o->encoding != REDIS_ENCODING_RAW) {
	223	robj *decoded = getDecodedObject(o);
	224	o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
	225	decrRefCount(decoded);
	226	dbOverwrite(c->db,c->argv[1],o);
	227	}
	228	}
	229
	230	if (sdslen(value) > 0) {
	231	o->ptr = sdsgrowzero(o->ptr,offset+sdslen(value));
	232	memcpy((char*)o->ptr+offset,value,sdslen(value));
	233	signalModifiedKey(c->db,c->argv[1]);
	234	server.dirty++;
	235	}
	236	addReplyLongLong(c,sdslen(o->ptr));
	237	}
	238
	239	void getrangeCommand(redisClient *c) {
	240	robj *o;
	241	long start, end;
	242	char *str, llbuf[32];
	243	size_t strlen;
	244
	245	if (getLongFromObjectOrReply(c,c->argv[2],&start,NULL) != REDIS_OK)
	246	return;
	247	if (getLongFromObjectOrReply(c,c->argv[3],&end,NULL) != REDIS_OK)
	248	return;
	249	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptybulk)) == NULL \|\|
	250	checkType(c,o,REDIS_STRING)) return;
	251
	252	if (o->encoding == REDIS_ENCODING_INT) {
	253	str = llbuf;
	254	strlen = ll2string(llbuf,sizeof(llbuf),(long)o->ptr);
	255	} else {
	256	str = o->ptr;
	257	strlen = sdslen(str);
	258	}
	259
	260	/* Convert negative indexes */
	261	if (start < 0) start = strlen+start;
	262	if (end < 0) end = strlen+end;
	263	if (start < 0) start = 0;
	264	if (end < 0) end = 0;
	265	if ((unsigned)end >= strlen) end = strlen-1;
	266
	267	/* Precondition: end >= 0 && end < strlen, so the only condition where
	268	* nothing can be returned is: start > end. */
	269	if (start > end) {
	270	addReply(c,shared.emptybulk);
	271	} else {
	272	addReplyBulkCBuffer(c,(char*)str+start,end-start+1);
	273	}
	274	}
	275
	276	void mgetCommand(redisClient *c) {
	277	int j;
	278
	279	addReplyMultiBulkLen(c,c->argc-1);
	280	for (j = 1; j < c->argc; j++) {
	281	robj *o = lookupKeyRead(c->db,c->argv[j]);
	282	if (o == NULL) {
	283	addReply(c,shared.nullbulk);
	284	} else {
	285	if (o->type != REDIS_STRING) {
	286	addReply(c,shared.nullbulk);
	287	} else {
	288	addReplyBulk(c,o);
	289	}
	290	}
	291	}
	292	}
	293
	294	void msetGenericCommand(redisClient *c, int nx) {
	295	int j, busykeys = 0;
	296
	297	if ((c->argc % 2) == 0) {
	298	addReplyError(c,"wrong number of arguments for MSET");
	299	return;
	300	}
	301	/* Handle the NX flag. The MSETNX semantic is to return zero and don't
	302	* set nothing at all if at least one already key exists. */
	303	if (nx) {
	304	for (j = 1; j < c->argc; j += 2) {
	305	if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
	306	busykeys++;
	307	}
	308	}
	309	if (busykeys) {
	310	addReply(c, shared.czero);
	311	return;
	312	}
	313	}
	314
	315	for (j = 1; j < c->argc; j += 2) {
	316	c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);
	317	setKey(c->db,c->argv[j],c->argv[j+1]);
	318	}
	319	server.dirty += (c->argc-1)/2;
	320	addReply(c, nx ? shared.cone : shared.ok);
	321	}
	322
	323	void msetCommand(redisClient *c) {
	324	msetGenericCommand(c,0);
	325	}
	326
	327	void msetnxCommand(redisClient *c) {
	328	msetGenericCommand(c,1);
	329	}
	330
	331	void incrDecrCommand(redisClient *c, long long incr) {
	332	long long value, oldvalue;
	333	robj o, new;
	334
	335	o = lookupKeyWrite(c->db,c->argv[1]);
	336	if (o != NULL && checkType(c,o,REDIS_STRING)) return;
	337	if (getLongLongFromObjectOrReply(c,o,&value,NULL) != REDIS_OK) return;
	338
	339	oldvalue = value;
	340	value += incr;
	341	if ((incr < 0 && value > oldvalue) \|\| (incr > 0 && value < oldvalue)) {
	342	addReplyError(c,"increment or decrement would overflow");
	343	return;
	344	}
	345	new = createStringObjectFromLongLong(value);
	346	if (o)
	347	dbOverwrite(c->db,c->argv[1],new);
	348	else
	349	dbAdd(c->db,c->argv[1],new);
	350	signalModifiedKey(c->db,c->argv[1]);
	351	server.dirty++;
	352	addReply(c,shared.colon);
	353	addReply(c,new);
	354	addReply(c,shared.crlf);
	355	}
	356
	357	void incrCommand(redisClient *c) {
	358	incrDecrCommand(c,1);
	359	}
	360
	361	void decrCommand(redisClient *c) {
	362	incrDecrCommand(c,-1);
	363	}
	364
	365	void incrbyCommand(redisClient *c) {
	366	long long incr;
	367
	368	if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
	369	incrDecrCommand(c,incr);
	370	}
	371
	372	void decrbyCommand(redisClient *c) {
	373	long long incr;
	374
	375	if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
	376	incrDecrCommand(c,-incr);
	377	}
	378
	379	void appendCommand(redisClient *c) {
	380	size_t totlen;
	381	robj o, append;
	382
	383	o = lookupKeyWrite(c->db,c->argv[1]);
	384	if (o == NULL) {
	385	/* Create the key */
	386	c->argv[2] = tryObjectEncoding(c->argv[2]);
	387	dbAdd(c->db,c->argv[1],c->argv[2]);
	388	incrRefCount(c->argv[2]);
	389	totlen = stringObjectLen(c->argv[2]);
	390	} else {
	391	/* Key exists, check type */
	392	if (checkType(c,o,REDIS_STRING))
	393	return;
	394
	395	/* "append" is an argument, so always an sds */
	396	append = c->argv[2];
	397	totlen = stringObjectLen(o)+sdslen(append->ptr);
	398	if (checkStringLength(c,totlen) != REDIS_OK)
	399	return;
	400
	401	/* If the object is shared or encoded, we have to make a copy */
	402	if (o->refcount != 1 \|\| o->encoding != REDIS_ENCODING_RAW) {
	403	robj *decoded = getDecodedObject(o);
	404	o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
	405	decrRefCount(decoded);
	406	dbOverwrite(c->db,c->argv[1],o);
	407	}
	408
	409	/* Append the value */
	410	o->ptr = sdscatlen(o->ptr,append->ptr,sdslen(append->ptr));
	411	totlen = sdslen(o->ptr);
	412	}
	413	signalModifiedKey(c->db,c->argv[1]);
	414	server.dirty++;
	415	addReplyLongLong(c,totlen);
	416	}
	417
	418	void strlenCommand(redisClient *c) {
	419	robj *o;
	420	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL \|\|
	421	checkType(c,o,REDIS_STRING)) return;
	422	addReplyLongLong(c,stringObjectLen(o));
	423	}
	424