src/t_string.c

#include "redis.h"

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

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

    if (expire) {
        if (getLongFromObjectOrReply(c, expire, &seconds, NULL) != REDIS_OK)
            return;
        if (seconds <= 0) {
            addReplySds(c,sdsnew("-ERR invalid expire time in SETEX\r\n"));
            return;
        }
    }

    retval = dbAdd(c->db,key,val);
    if (retval == REDIS_ERR) {
        if (!nx) {
            dbReplace(c->db,key,val);
            incrRefCount(val);
        } else {
            addReply(c,shared.czero);
            return;
        }
    } else {
        incrRefCount(val);
    }
    touchWatchedKey(c->db,key);
    server.dirty++;
    removeExpire(c->db,key);
    if (expire) setExpire(c->db,key,time(NULL)+seconds);
    addReply(c, nx ? shared.cone : shared.ok);
}

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

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

void setexCommand(redisClient *c) {
    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;
    dbReplace(c->db,c->argv[1],c->argv[2]);
    incrRefCount(c->argv[2]);
    touchWatchedKey(c->db,c->argv[1]);
    server.dirty++;
    removeExpire(c->db,c->argv[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) {
        addReplySds(c,sdsnew("-ERR wrong number of arguments for MSET\r\n"));
        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]);
        dbReplace(c->db,c->argv[j],c->argv[j+1]);
        incrRefCount(c->argv[j+1]);
        removeExpire(c->db,c->argv[j]);
        touchWatchedKey(c->db,c->argv[j]);
    }
    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;
    robj *o;

    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;

    value += incr;
    o = createStringObjectFromLongLong(value);
    dbReplace(c->db,c->argv[1],o);
    touchWatchedKey(c->db,c->argv[1]);
    server.dirty++;
    addReply(c,shared.colon);
    addReply(c,o);
    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) {
    int retval;
    size_t totlen;
    robj *o;

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o == NULL) {
        /* Create the key */
        retval = dbAdd(c->db,c->argv[1],c->argv[2]);
        incrRefCount(c->argv[2]);
        totlen = stringObjectLen(c->argv[2]);
    } else {
        if (o->type != REDIS_STRING) {
            addReply(c,shared.wrongtypeerr);
            return;
        }
        /* If the object is specially encoded or shared 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);
            dbReplace(c->db,c->argv[1],o);
        }
        /* APPEND! */
        if (c->argv[2]->encoding == REDIS_ENCODING_RAW) {
            o->ptr = sdscatlen(o->ptr,
                c->argv[2]->ptr, sdslen(c->argv[2]->ptr));
        } else {
            o->ptr = sdscatprintf(o->ptr, "%ld",
                (unsigned long) c->argv[2]->ptr);
        }
        totlen = sdslen(o->ptr);
    }
    touchWatchedKey(c->db,c->argv[1]);
    server.dirty++;
    addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",(unsigned long)totlen));
}

void substrCommand(redisClient *c) {
    robj *o;
    long start = atoi(c->argv[2]->ptr);
    long end = atoi(c->argv[3]->ptr);
    size_t rangelen, strlen;
    sds range;

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

    o = getDecodedObject(o);
    strlen = sdslen(o->ptr);

    /* 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;

    /* indexes sanity checks */
    if (start > end || (size_t)start >= strlen) {
        /* Out of range start or start > end result in null reply */
        addReply(c,shared.nullbulk);
        decrRefCount(o);
        return;
    }
    if ((size_t)end >= strlen) end = strlen-1;
    rangelen = (end-start)+1;

    /* Return the result */
    addReplySds(c,sdscatprintf(sdsempty(),"$%zu\r\n",rangelen));
    range = sdsnewlen((char*)o->ptr+start,rangelen);
    addReplySds(c,range);
    addReply(c,shared.crlf);
    decrRefCount(o);
}

void strlenCommand(redisClient *c) {
    robj *o;

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

    o = getDecodedObject(o);
    addReplyLongLong(c,sdslen(o->ptr));
    decrRefCount(o);
}
Commit	Line	Data
	1	#include "redis.h"
	2
	3	/*-----------------------------------------------------------------------------
	4	* String Commands
	5	----------------------------------------------------------------------------/
	6
	7	void setGenericCommand(redisClient c, int nx, robj key, robj val, robj expire) {
	8	int retval;
	9	long seconds = 0; /* initialized to avoid an harmness warning */
	10
	11	if (expire) {
	12	if (getLongFromObjectOrReply(c, expire, &seconds, NULL) != REDIS_OK)
	13	return;
	14	if (seconds <= 0) {
	15	addReplySds(c,sdsnew("-ERR invalid expire time in SETEX\r\n"));
	16	return;
	17	}
	18	}
	19
	20	retval = dbAdd(c->db,key,val);
	21	if (retval == REDIS_ERR) {
	22	if (!nx) {
	23	dbReplace(c->db,key,val);
	24	incrRefCount(val);
	25	} else {
	26	addReply(c,shared.czero);
	27	return;
	28	}
	29	} else {
	30	incrRefCount(val);
	31	}
	32	touchWatchedKey(c->db,key);
	33	server.dirty++;
	34	removeExpire(c->db,key);
	35	if (expire) setExpire(c->db,key,time(NULL)+seconds);
	36	addReply(c, nx ? shared.cone : shared.ok);
	37	}
	38
	39	void setCommand(redisClient *c) {
	40	setGenericCommand(c,0,c->argv[1],c->argv[2],NULL);
	41	}
	42
	43	void setnxCommand(redisClient *c) {
	44	setGenericCommand(c,1,c->argv[1],c->argv[2],NULL);
	45	}
	46
	47	void setexCommand(redisClient *c) {
	48	setGenericCommand(c,0,c->argv[1],c->argv[3],c->argv[2]);
	49	}
	50
	51	int getGenericCommand(redisClient *c) {
	52	robj *o;
	53
	54	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
	55	return REDIS_OK;
	56
	57	if (o->type != REDIS_STRING) {
	58	addReply(c,shared.wrongtypeerr);
	59	return REDIS_ERR;
	60	} else {
	61	addReplyBulk(c,o);
	62	return REDIS_OK;
	63	}
	64	}
	65
	66	void getCommand(redisClient *c) {
	67	getGenericCommand(c);
	68	}
	69
	70	void getsetCommand(redisClient *c) {
	71	if (getGenericCommand(c) == REDIS_ERR) return;
	72	dbReplace(c->db,c->argv[1],c->argv[2]);
	73	incrRefCount(c->argv[2]);
	74	touchWatchedKey(c->db,c->argv[1]);
	75	server.dirty++;
	76	removeExpire(c->db,c->argv[1]);
	77	}
	78
	79	void mgetCommand(redisClient *c) {
	80	int j;
	81
	82	addReplyMultiBulkLen(c,c->argc-1);
	83	for (j = 1; j < c->argc; j++) {
	84	robj *o = lookupKeyRead(c->db,c->argv[j]);
	85	if (o == NULL) {
	86	addReply(c,shared.nullbulk);
	87	} else {
	88	if (o->type != REDIS_STRING) {
	89	addReply(c,shared.nullbulk);
	90	} else {
	91	addReplyBulk(c,o);
	92	}
	93	}
	94	}
	95	}
	96
	97	void msetGenericCommand(redisClient *c, int nx) {
	98	int j, busykeys = 0;
	99
	100	if ((c->argc % 2) == 0) {
	101	addReplySds(c,sdsnew("-ERR wrong number of arguments for MSET\r\n"));
	102	return;
	103	}
	104	/* Handle the NX flag. The MSETNX semantic is to return zero and don't
	105	* set nothing at all if at least one already key exists. */
	106	if (nx) {
	107	for (j = 1; j < c->argc; j += 2) {
	108	if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
	109	busykeys++;
	110	}
	111	}
	112	}
	113	if (busykeys) {
	114	addReply(c, shared.czero);
	115	return;
	116	}
	117
	118	for (j = 1; j < c->argc; j += 2) {
	119	c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);
	120	dbReplace(c->db,c->argv[j],c->argv[j+1]);
	121	incrRefCount(c->argv[j+1]);
	122	removeExpire(c->db,c->argv[j]);
	123	touchWatchedKey(c->db,c->argv[j]);
	124	}
	125	server.dirty += (c->argc-1)/2;
	126	addReply(c, nx ? shared.cone : shared.ok);
	127	}
	128
	129	void msetCommand(redisClient *c) {
	130	msetGenericCommand(c,0);
	131	}
	132
	133	void msetnxCommand(redisClient *c) {
	134	msetGenericCommand(c,1);
	135	}
	136
	137	void incrDecrCommand(redisClient *c, long long incr) {
	138	long long value;
	139	robj *o;
	140
	141	o = lookupKeyWrite(c->db,c->argv[1]);
	142	if (o != NULL && checkType(c,o,REDIS_STRING)) return;
	143	if (getLongLongFromObjectOrReply(c,o,&value,NULL) != REDIS_OK) return;
	144
	145	value += incr;
	146	o = createStringObjectFromLongLong(value);
	147	dbReplace(c->db,c->argv[1],o);
	148	touchWatchedKey(c->db,c->argv[1]);
	149	server.dirty++;
	150	addReply(c,shared.colon);
	151	addReply(c,o);
	152	addReply(c,shared.crlf);
	153	}
	154
	155	void incrCommand(redisClient *c) {
	156	incrDecrCommand(c,1);
	157	}
	158
	159	void decrCommand(redisClient *c) {
	160	incrDecrCommand(c,-1);
	161	}
	162
	163	void incrbyCommand(redisClient *c) {
	164	long long incr;
	165
	166	if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
	167	incrDecrCommand(c,incr);
	168	}
	169
	170	void decrbyCommand(redisClient *c) {
	171	long long incr;
	172
	173	if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
	174	incrDecrCommand(c,-incr);
	175	}
	176
	177	void appendCommand(redisClient *c) {
	178	int retval;
	179	size_t totlen;
	180	robj *o;
	181
	182	o = lookupKeyWrite(c->db,c->argv[1]);
	183	if (o == NULL) {
	184	/* Create the key */
	185	retval = dbAdd(c->db,c->argv[1],c->argv[2]);
	186	incrRefCount(c->argv[2]);
	187	totlen = stringObjectLen(c->argv[2]);
	188	} else {
	189	if (o->type != REDIS_STRING) {
	190	addReply(c,shared.wrongtypeerr);
	191	return;
	192	}
	193	/* If the object is specially encoded or shared we have to make
	194	* a copy */
	195	if (o->refcount != 1 \|\| o->encoding != REDIS_ENCODING_RAW) {
	196	robj *decoded = getDecodedObject(o);
	197
	198	o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
	199	decrRefCount(decoded);
	200	dbReplace(c->db,c->argv[1],o);
	201	}
	202	/* APPEND! */
	203	if (c->argv[2]->encoding == REDIS_ENCODING_RAW) {
	204	o->ptr = sdscatlen(o->ptr,
	205	c->argv[2]->ptr, sdslen(c->argv[2]->ptr));
	206	} else {
	207	o->ptr = sdscatprintf(o->ptr, "%ld",
	208	(unsigned long) c->argv[2]->ptr);
	209	}
	210	totlen = sdslen(o->ptr);
	211	}
	212	touchWatchedKey(c->db,c->argv[1]);
	213	server.dirty++;
	214	addReplySds(c,sdscatprintf(sdsempty(),":%lu\r\n",(unsigned long)totlen));
	215	}
	216
	217	void substrCommand(redisClient *c) {
	218	robj *o;
	219	long start = atoi(c->argv[2]->ptr);
	220	long end = atoi(c->argv[3]->ptr);
	221	size_t rangelen, strlen;
	222	sds range;
	223
	224	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL \|\|
	225	checkType(c,o,REDIS_STRING)) return;
	226
	227	o = getDecodedObject(o);
	228	strlen = sdslen(o->ptr);
	229
	230	/* convert negative indexes */
	231	if (start < 0) start = strlen+start;
	232	if (end < 0) end = strlen+end;
	233	if (start < 0) start = 0;
	234	if (end < 0) end = 0;
	235
	236	/* indexes sanity checks */
	237	if (start > end \|\| (size_t)start >= strlen) {
	238	/* Out of range start or start > end result in null reply */
	239	addReply(c,shared.nullbulk);
	240	decrRefCount(o);
	241	return;
	242	}
	243	if ((size_t)end >= strlen) end = strlen-1;
	244	rangelen = (end-start)+1;
	245
	246	/* Return the result */
	247	addReplySds(c,sdscatprintf(sdsempty(),"$%zu\r\n",rangelen));
	248	range = sdsnewlen((char*)o->ptr+start,rangelen);
	249	addReplySds(c,range);
	250	addReply(c,shared.crlf);
	251	decrRefCount(o);
	252	}
	253
	254	void strlenCommand(redisClient *c) {
	255	robj *o;
	256
	257	if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL \|\|
	258	checkType(c,o,REDIS_STRING)) return;
	259
	260	o = getDecodedObject(o);
	261	addReplyLongLong(c,sdslen(o->ptr));
	262	decrRefCount(o);
	263	}