src/t_string.c

#include "redis.h"
#include <math.h> /* isnan(), isinf() */

/*-----------------------------------------------------------------------------
 * 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, int unit) {
    long long milliseconds = 0; /* initialized to avoid an harmness warning */

    if (expire) {
        if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != REDIS_OK)
            return;
        if (milliseconds <= 0) {
            addReplyError(c,"invalid expire time in SETEX");
            return;
        }
        if (unit == UNIT_SECONDS) milliseconds *= 1000;
    }

    if (nx && lookupKeyWrite(c->db,key) != NULL) {
        addReply(c,shared.czero);
        return;
    }
    setKey(c->db,key,val);
    server.dirty++;
    if (expire) setExpire(c->db,key,mstime()+milliseconds);
    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,0);
}

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

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

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

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++;
}

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;
    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;
    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 incrbyfloatCommand(redisClient *c) {
    long double incr, value;
    robj *o, *new, *aux;

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

    value += incr;
    if (isnan(value) || isinf(value)) {
        addReplyError(c,"increment would produce NaN or Infinity");
        return;
    }
    new = createStringObjectFromLongDouble(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++;
    addReplyBulk(c,new);

    /* Always replicate INCRBYFLOAT as a SET command with the final value
     * in order to make sure that differences in float pricision or formatting
     * will not create differences in replicas or after an AOF restart. */
    aux = createStringObject("SET",3);
    rewriteClientCommandArgument(c,0,aux);
    decrRefCount(aux);
    rewriteClientCommandArgument(c,2,new);
}

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