c1eea9e6a2
This commit introduces two new command and two options for an existing command
GETEX <key> [PERSIST][EX seconds][PX milliseconds] [EXAT seconds-timestamp]
[PXAT milliseconds-timestamp]
The getexCommand() function implements extended options and variants of the GET
command. Unlike GET command this command is not read-only. Only one of the options
can be used at a given time.
1. PERSIST removes any TTL associated with the key.
2. EX Set expiry TTL in seconds.
3. PX Set expiry TTL in milliseconds.
4. EXAT Same like EX instead of specifying the number of seconds representing the
TTL (time to live), it takes an absolute Unix timestamp
5. PXAT Same like PX instead of specifying the number of milliseconds representing the
TTL (time to live), it takes an absolute Unix timestamp
Command would return either the bulk string, error or nil.
GETDEL <key>
Would delete the key after getting.
SET key value [NX] [XX] [KEEPTTL] [GET] [EX <seconds>] [PX <milliseconds>]
[EXAT <seconds-timestamp>][PXAT <milliseconds-timestamp>]
Two new options added here are EXAT and PXAT
Key implementation notes
- `SET` with `PX/EX/EXAT/PXAT` is always translated to `PXAT` in `AOF`. When relative time is
specified (`PX/EX`), replication will always use `PX`.
- `setexCommand` and `psetexCommand` would no longer need translation in `feedAppendOnlyFile`
as they are modified to invoke `setGenericCommand ` with appropriate flags which will take care of
correct AOF translation.
- `GETEX` without any optional argument behaves like `GET`.
- `GETEX` command is never propagated, It is either propagated as `PEXPIRE[AT], or PERSIST`.
- `GETDEL` command is propagated as `DEL`
- Combined the validation for `SET` and `GETEX` arguments.
- Test cases to validate AOF/Replication propagation
936 lines
33 KiB
C
936 lines
33 KiB
C
/*
|
|
* Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Redis nor the names of its contributors may be used
|
|
* to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "server.h"
|
|
#include <math.h> /* isnan(), isinf() */
|
|
|
|
/* Forward declarations */
|
|
int getGenericCommand(client *c);
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* String Commands
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
static int checkStringLength(client *c, long long size) {
|
|
if (!(c->flags & CLIENT_MASTER) && size > server.proto_max_bulk_len) {
|
|
addReplyError(c,"string exceeds maximum allowed size (proto-max-bulk-len)");
|
|
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, GETSET.
|
|
*
|
|
* 'flags' changes the behavior of the command (NX, XX or GET, see below).
|
|
*
|
|
* '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'.
|
|
*
|
|
* '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.
|
|
*
|
|
* If ok_reply is NULL "+OK" is used.
|
|
* If abort_reply is NULL, "$-1" is used. */
|
|
|
|
#define OBJ_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_EX (1<<2) /* Set if time in seconds is given */
|
|
#define OBJ_PX (1<<3) /* Set if time in ms in given */
|
|
#define OBJ_KEEPTTL (1<<4) /* Set and keep the ttl */
|
|
#define OBJ_SET_GET (1<<5) /* Set if want to get key before set */
|
|
#define OBJ_EXAT (1<<6) /* Set if timestamp in second is given */
|
|
#define OBJ_PXAT (1<<7) /* Set if timestamp in ms is given */
|
|
#define OBJ_PERSIST (1<<8) /* Set if we need to remove the ttl */
|
|
|
|
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)
|
|
return;
|
|
if (milliseconds <= 0) {
|
|
addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
|
|
return;
|
|
}
|
|
if (unit == UNIT_SECONDS) milliseconds *= 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;
|
|
}
|
|
|
|
if (flags & OBJ_SET_GET) {
|
|
if (getGenericCommand(c) == C_ERR) return;
|
|
}
|
|
|
|
genericSetKey(c,c->db,key, val,flags & OBJ_KEEPTTL,1);
|
|
server.dirty++;
|
|
notifyKeyspaceEvent(NOTIFY_STRING,"set",key,c->db->id);
|
|
if (expire) {
|
|
robj *exp = shared.pxat;
|
|
|
|
if ((flags & OBJ_PX) || (flags & OBJ_EX)) {
|
|
setExpire(c,c->db,key,milliseconds + mstime());
|
|
exp = shared.px;
|
|
} else {
|
|
setExpire(c,c->db,key,milliseconds);
|
|
}
|
|
notifyKeyspaceEvent(NOTIFY_GENERIC,"expire",key,c->db->id);
|
|
|
|
/* Propagate as SET Key Value PXAT millisecond-timestamp if there is EXAT/PXAT or
|
|
* propagate as SET Key Value PX millisecond if there is EX/PX flag.
|
|
*
|
|
* Additionally when we propagate the SET with PX (relative millisecond) we translate
|
|
* it again to SET with PXAT for the AOF.
|
|
*
|
|
* Additional care is required while modifying the argument order. AOF relies on the
|
|
* exp argument being at index 3. (see feedAppendOnlyFile)
|
|
* */
|
|
robj *millisecondObj = createStringObjectFromLongLong(milliseconds);
|
|
rewriteClientCommandVector(c,5,shared.set,key,val,exp,millisecondObj);
|
|
decrRefCount(millisecondObj);
|
|
}
|
|
if (!(flags & OBJ_SET_GET)) {
|
|
addReply(c, ok_reply ? ok_reply : shared.ok);
|
|
}
|
|
|
|
/* Propagate without the GET argument (Isn't needed if we had expire since in that case we completely re-written the command argv) */
|
|
if ((flags & OBJ_SET_GET) && !expire) {
|
|
int argc = 0;
|
|
int j;
|
|
robj **argv = zmalloc((c->argc-1)*sizeof(robj*));
|
|
for (j=0; j < c->argc; j++) {
|
|
char *a = c->argv[j]->ptr;
|
|
/* Skip GET which may be repeated multiple times. */
|
|
if (j >= 3 &&
|
|
(a[0] == 'g' || a[0] == 'G') &&
|
|
(a[1] == 'e' || a[1] == 'E') &&
|
|
(a[2] == 't' || a[2] == 'T') && a[3] == '\0')
|
|
continue;
|
|
argv[argc++] = c->argv[j];
|
|
incrRefCount(c->argv[j]);
|
|
}
|
|
replaceClientCommandVector(c, argc, argv);
|
|
}
|
|
}
|
|
|
|
#define COMMAND_GET 0
|
|
#define COMMAND_SET 1
|
|
/*
|
|
* The parseExtendedStringArgumentsOrReply() function performs the common validation for extended
|
|
* string arguments used in SET and GET command.
|
|
*
|
|
* Get specific commands - PERSIST/DEL
|
|
* Set specific commands - XX/NX/GET
|
|
* Common commands - EX/EXAT/PX/PXAT/KEEPTTL
|
|
*
|
|
* Function takes pointers to client, flags, unit, pointer to pointer of expire obj if needed
|
|
* to be determined and command_type which can be COMMAND_GET or COMMAND_SET.
|
|
*
|
|
* If there are any syntax violations C_ERR is returned else C_OK is returned.
|
|
*
|
|
* Input flags are updated upon parsing the arguments. Unit and expire are updated if there are any
|
|
* EX/EXAT/PX/PXAT arguments. Unit is updated to millisecond if PX/PXAT is set.
|
|
*/
|
|
int parseExtendedStringArgumentsOrReply(client *c, int *flags, int *unit, robj **expire, int command_type) {
|
|
|
|
int j = command_type == COMMAND_GET ? 2 : 3;
|
|
for (; j < c->argc; j++) {
|
|
char *opt = c->argv[j]->ptr;
|
|
robj *next = (j == c->argc-1) ? NULL : c->argv[j+1];
|
|
|
|
if ((opt[0] == 'n' || opt[0] == 'N') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') && opt[2] == '\0' &&
|
|
!(*flags & OBJ_SET_XX) && !(*flags & OBJ_SET_GET) && (command_type == COMMAND_SET))
|
|
{
|
|
*flags |= OBJ_SET_NX;
|
|
} else if ((opt[0] == 'x' || opt[0] == 'X') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') && opt[2] == '\0' &&
|
|
!(*flags & OBJ_SET_NX) && (command_type == COMMAND_SET))
|
|
{
|
|
*flags |= OBJ_SET_XX;
|
|
} else if ((opt[0] == 'g' || opt[0] == 'G') &&
|
|
(opt[1] == 'e' || opt[1] == 'E') &&
|
|
(opt[2] == 't' || opt[2] == 'T') && opt[3] == '\0' &&
|
|
!(*flags & OBJ_SET_NX) && (command_type == COMMAND_SET))
|
|
{
|
|
*flags |= OBJ_SET_GET;
|
|
} else if (!strcasecmp(opt, "KEEPTTL") && !(*flags & OBJ_PERSIST) &&
|
|
!(*flags & OBJ_EX) && !(*flags & OBJ_EXAT) &&
|
|
!(*flags & OBJ_PX) && !(*flags & OBJ_PXAT) && (command_type == COMMAND_SET))
|
|
{
|
|
*flags |= OBJ_KEEPTTL;
|
|
} else if (!strcasecmp(opt,"PERSIST") && (command_type == COMMAND_GET) &&
|
|
!(*flags & OBJ_EX) && !(*flags & OBJ_EXAT) &&
|
|
!(*flags & OBJ_PX) && !(*flags & OBJ_PXAT) &&
|
|
!(*flags & OBJ_KEEPTTL))
|
|
{
|
|
*flags |= OBJ_PERSIST;
|
|
} else if ((opt[0] == 'e' || opt[0] == 'E') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') && opt[2] == '\0' &&
|
|
!(*flags & OBJ_KEEPTTL) && !(*flags & OBJ_PERSIST) &&
|
|
!(*flags & OBJ_EXAT) && !(*flags & OBJ_PX) &&
|
|
!(*flags & OBJ_PXAT) && next)
|
|
{
|
|
*flags |= OBJ_EX;
|
|
*expire = next;
|
|
j++;
|
|
} else if ((opt[0] == 'p' || opt[0] == 'P') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') && opt[2] == '\0' &&
|
|
!(*flags & OBJ_KEEPTTL) && !(*flags & OBJ_PERSIST) &&
|
|
!(*flags & OBJ_EX) && !(*flags & OBJ_EXAT) &&
|
|
!(*flags & OBJ_PXAT) && next)
|
|
{
|
|
*flags |= OBJ_PX;
|
|
*unit = UNIT_MILLISECONDS;
|
|
*expire = next;
|
|
j++;
|
|
} else if ((opt[0] == 'e' || opt[0] == 'E') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') &&
|
|
(opt[2] == 'a' || opt[2] == 'A') &&
|
|
(opt[3] == 't' || opt[3] == 'T') && opt[4] == '\0' &&
|
|
!(*flags & OBJ_KEEPTTL) && !(*flags & OBJ_PERSIST) &&
|
|
!(*flags & OBJ_EX) && !(*flags & OBJ_PX) &&
|
|
!(*flags & OBJ_PXAT) && next)
|
|
{
|
|
*flags |= OBJ_EXAT;
|
|
*expire = next;
|
|
j++;
|
|
} else if ((opt[0] == 'p' || opt[0] == 'P') &&
|
|
(opt[1] == 'x' || opt[1] == 'X') &&
|
|
(opt[2] == 'a' || opt[2] == 'A') &&
|
|
(opt[3] == 't' || opt[3] == 'T') && opt[4] == '\0' &&
|
|
!(*flags & OBJ_KEEPTTL) && !(*flags & OBJ_PERSIST) &&
|
|
!(*flags & OBJ_EX) && !(*flags & OBJ_EXAT) &&
|
|
!(*flags & OBJ_PX) && next)
|
|
{
|
|
*flags |= OBJ_PXAT;
|
|
*unit = UNIT_MILLISECONDS;
|
|
*expire = next;
|
|
j++;
|
|
} else {
|
|
addReplyErrorObject(c,shared.syntaxerr);
|
|
return C_ERR;
|
|
}
|
|
}
|
|
return C_OK;
|
|
}
|
|
|
|
/* SET key value [NX] [XX] [KEEPTTL] [GET] [EX <seconds>] [PX <milliseconds>]
|
|
* [EXAT <seconds-timestamp>][PXAT <milliseconds-timestamp>] */
|
|
void setCommand(client *c) {
|
|
robj *expire = NULL;
|
|
int unit = UNIT_SECONDS;
|
|
int flags = OBJ_NO_FLAGS;
|
|
|
|
if (parseExtendedStringArgumentsOrReply(c,&flags,&unit,&expire,COMMAND_SET) != C_OK) {
|
|
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_EX,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_PX,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)
|
|
return C_OK;
|
|
|
|
if (checkType(c,o,OBJ_STRING)) {
|
|
return C_ERR;
|
|
}
|
|
|
|
addReplyBulk(c,o);
|
|
return C_OK;
|
|
}
|
|
|
|
void getCommand(client *c) {
|
|
getGenericCommand(c);
|
|
}
|
|
|
|
/*
|
|
* GETEX <key> [PERSIST][EX seconds][PX milliseconds][EXAT seconds-timestamp][PXAT milliseconds-timestamp]
|
|
*
|
|
* The getexCommand() function implements extended options and variants of the GET command. Unlike GET
|
|
* command this command is not read-only.
|
|
*
|
|
* The default behavior when no options are specified is same as GET and does not alter any TTL.
|
|
*
|
|
* Only one of the below options can be used at a given time.
|
|
*
|
|
* 1. PERSIST removes any TTL associated with the key.
|
|
* 2. EX Set expiry TTL in seconds.
|
|
* 3. PX Set expiry TTL in milliseconds.
|
|
* 4. EXAT Same like EX instead of specifying the number of seconds representing the TTL
|
|
* (time to live), it takes an absolute Unix timestamp
|
|
* 5. PXAT Same like PX instead of specifying the number of milliseconds representing the TTL
|
|
* (time to live), it takes an absolute Unix timestamp
|
|
*
|
|
* Command would either return the bulk string, error or nil.
|
|
*/
|
|
void getexCommand(client *c) {
|
|
robj *expire = NULL;
|
|
int unit = UNIT_SECONDS;
|
|
int flags = OBJ_NO_FLAGS;
|
|
|
|
if (parseExtendedStringArgumentsOrReply(c,&flags,&unit,&expire,COMMAND_GET) != C_OK) {
|
|
return;
|
|
}
|
|
|
|
robj *o;
|
|
|
|
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.null[c->resp])) == NULL)
|
|
return;
|
|
|
|
if (checkType(c,o,OBJ_STRING)) {
|
|
return;
|
|
}
|
|
|
|
long long milliseconds = 0;
|
|
|
|
/* Validate the expiration time value first */
|
|
if (expire) {
|
|
if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != C_OK)
|
|
return;
|
|
if (milliseconds <= 0) {
|
|
addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
|
|
return;
|
|
}
|
|
if (unit == UNIT_SECONDS) milliseconds *= 1000;
|
|
}
|
|
|
|
/* We need to do this before we expire the key or delete it */
|
|
addReplyBulk(c,o);
|
|
|
|
/* This command is never propagated as is. It is either propagated as PEXPIRE[AT],DEL,UNLINK or PERSIST.
|
|
* This why it doesn't need special handling in feedAppendOnlyFile to convert relative expire time to absolute one. */
|
|
if (((flags & OBJ_PXAT) || (flags & OBJ_EXAT)) && checkAlreadyExpired(milliseconds)) {
|
|
/* When PXAT/EXAT absolute timestamp is specified, there can be a chance that timestamp
|
|
* has already elapsed so delete the key in that case. */
|
|
int deleted = server.lazyfree_lazy_expire ? dbAsyncDelete(c->db, c->argv[1]) :
|
|
dbSyncDelete(c->db, c->argv[1]);
|
|
serverAssert(deleted);
|
|
robj *aux = server.lazyfree_lazy_expire ? shared.unlink : shared.del;
|
|
rewriteClientCommandVector(c,2,aux,c->argv[1]);
|
|
signalModifiedKey(c, c->db, c->argv[1]);
|
|
notifyKeyspaceEvent(NOTIFY_GENERIC, "del", c->argv[1], c->db->id);
|
|
server.dirty++;
|
|
} else if (expire) {
|
|
robj *exp = shared.pexpireat;
|
|
if ((flags & OBJ_PX) || (flags & OBJ_EX)) {
|
|
setExpire(c,c->db,c->argv[1],milliseconds + mstime());
|
|
exp = shared.pexpire;
|
|
} else {
|
|
setExpire(c,c->db,c->argv[1],milliseconds);
|
|
}
|
|
|
|
robj* millisecondObj = createStringObjectFromLongLong(milliseconds);
|
|
rewriteClientCommandVector(c,3,exp,c->argv[1],millisecondObj);
|
|
decrRefCount(millisecondObj);
|
|
signalModifiedKey(c, c->db, c->argv[1]);
|
|
notifyKeyspaceEvent(NOTIFY_GENERIC,"expire",c->argv[1],c->db->id);
|
|
server.dirty++;
|
|
} else if (flags & OBJ_PERSIST) {
|
|
if (removeExpire(c->db, c->argv[1])) {
|
|
signalModifiedKey(c, c->db, c->argv[1]);
|
|
rewriteClientCommandVector(c, 2, shared.persist, c->argv[1]);
|
|
notifyKeyspaceEvent(NOTIFY_GENERIC,"persist",c->argv[1],c->db->id);
|
|
server.dirty++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void getdelCommand(client *c) {
|
|
if (getGenericCommand(c) == C_ERR) return;
|
|
int deleted = server.lazyfree_lazy_user_del ? dbAsyncDelete(c->db, c->argv[1]) :
|
|
dbSyncDelete(c->db, c->argv[1]);
|
|
if (deleted) {
|
|
/* Propagate as DEL/UNLINK command */
|
|
robj *aux = server.lazyfree_lazy_user_del ? shared.unlink : shared.del;
|
|
rewriteClientCommandVector(c,2,aux,c->argv[1]);
|
|
signalModifiedKey(c, c->db, c->argv[1]);
|
|
notifyKeyspaceEvent(NOTIFY_GENERIC, "del", c->argv[1], c->db->id);
|
|
server.dirty++;
|
|
}
|
|
}
|
|
|
|
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);
|
|
server.dirty++;
|
|
|
|
/* Propagate as SET command */
|
|
rewriteClientCommandArgument(c,0,shared.set);
|
|
}
|
|
|
|
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 */
|
|
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) {
|
|
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) {
|
|
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);
|
|
server.dirty++;
|
|
}
|
|
addReplyLongLong(c,sdslen(o->ptr));
|
|
}
|
|
|
|
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;
|
|
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. */
|
|
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 already exists. */
|
|
if (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 (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++;
|
|
addReply(c,shared.colon);
|
|
addReply(c,new);
|
|
addReply(c,shared.crlf);
|
|
}
|
|
|
|
void incrCommand(client *c) {
|
|
incrDecrCommand(c,1);
|
|
}
|
|
|
|
void decrCommand(client *c) {
|
|
incrDecrCommand(c,-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, *aux;
|
|
|
|
o = lookupKeyWrite(c->db,c->argv[1]);
|
|
if (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. */
|
|
rewriteClientCommandArgument(c,0,shared.set);
|
|
rewriteClientCommandArgument(c,2,new);
|
|
aux = createStringObject("KEEPTTL",7);
|
|
rewriteClientCommandArgument(c,3,aux);
|
|
decrRefCount(aux);
|
|
}
|
|
|
|
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 = 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]);
|
|
notifyKeyspaceEvent(NOTIFY_STRING,"append",c->argv[1],c->db->id);
|
|
server.dirty++;
|
|
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));
|
|
}
|
|
|
|
|
|
/* STRALGO -- Implement complex algorithms on strings.
|
|
*
|
|
* STRALGO <algorithm> ... arguments ... */
|
|
void stralgoLCS(client *c); /* This implements the LCS algorithm. */
|
|
void stralgoCommand(client *c) {
|
|
/* Select the algorithm. */
|
|
if (!strcasecmp(c->argv[1]->ptr,"lcs")) {
|
|
stralgoLCS(c);
|
|
} else {
|
|
addReplyErrorObject(c,shared.syntaxerr);
|
|
}
|
|
}
|
|
|
|
/* STRALGO <algo> [IDX] [MINMATCHLEN <len>] [WITHMATCHLEN]
|
|
* STRINGS <string> <string> | KEYS <keya> <keyb>
|
|
*/
|
|
void stralgoLCS(client *c) {
|
|
uint32_t i, j;
|
|
long long minmatchlen = 0;
|
|
sds a = NULL, b = NULL;
|
|
int getlen = 0, getidx = 0, withmatchlen = 0;
|
|
robj *obja = NULL, *objb = NULL;
|
|
|
|
for (j = 2; j < (uint32_t)c->argc; j++) {
|
|
char *opt = c->argv[j]->ptr;
|
|
int moreargs = (c->argc-1) - j;
|
|
|
|
if (!strcasecmp(opt,"IDX")) {
|
|
getidx = 1;
|
|
} else if (!strcasecmp(opt,"LEN")) {
|
|
getlen = 1;
|
|
} else if (!strcasecmp(opt,"WITHMATCHLEN")) {
|
|
withmatchlen = 1;
|
|
} else if (!strcasecmp(opt,"MINMATCHLEN") && moreargs) {
|
|
if (getLongLongFromObjectOrReply(c,c->argv[j+1],&minmatchlen,NULL)
|
|
!= C_OK) goto cleanup;
|
|
if (minmatchlen < 0) minmatchlen = 0;
|
|
j++;
|
|
} else if (!strcasecmp(opt,"STRINGS") && moreargs > 1) {
|
|
if (a != NULL) {
|
|
addReplyError(c,"Either use STRINGS or KEYS");
|
|
goto cleanup;
|
|
}
|
|
a = c->argv[j+1]->ptr;
|
|
b = c->argv[j+2]->ptr;
|
|
j += 2;
|
|
} else if (!strcasecmp(opt,"KEYS") && moreargs > 1) {
|
|
if (a != NULL) {
|
|
addReplyError(c,"Either use STRINGS or KEYS");
|
|
goto cleanup;
|
|
}
|
|
obja = lookupKeyRead(c->db,c->argv[j+1]);
|
|
objb = lookupKeyRead(c->db,c->argv[j+2]);
|
|
if ((obja && obja->type != OBJ_STRING) ||
|
|
(objb && objb->type != OBJ_STRING))
|
|
{
|
|
addReplyError(c,
|
|
"The specified keys must contain string values");
|
|
/* Don't cleanup the objects, we need to do that
|
|
* only after callign getDecodedObject(). */
|
|
obja = NULL;
|
|
objb = NULL;
|
|
goto cleanup;
|
|
}
|
|
obja = obja ? getDecodedObject(obja) : createStringObject("",0);
|
|
objb = objb ? getDecodedObject(objb) : createStringObject("",0);
|
|
a = obja->ptr;
|
|
b = objb->ptr;
|
|
j += 2;
|
|
} else {
|
|
addReplyErrorObject(c,shared.syntaxerr);
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
/* Complain if the user passed ambiguous parameters. */
|
|
if (a == NULL) {
|
|
addReplyError(c,"Please specify two strings: "
|
|
"STRINGS or KEYS options are mandatory");
|
|
goto cleanup;
|
|
} else if (getlen && getidx) {
|
|
addReplyError(c,
|
|
"If you want both the length and indexes, please "
|
|
"just use IDX.");
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compute the LCS using the vanilla dynamic programming technique of
|
|
* building a table of LCS(x,y) substrings. */
|
|
uint32_t alen = sdslen(a);
|
|
uint32_t blen = sdslen(b);
|
|
|
|
/* Setup an uint32_t array to store at LCS[i,j] the length of the
|
|
* LCS A0..i-1, B0..j-1. Note that we have a linear array here, so
|
|
* we index it as LCS[j+(blen+1)*j] */
|
|
uint32_t *lcs = zmalloc((alen+1)*(blen+1)*sizeof(uint32_t));
|
|
#define LCS(A,B) lcs[(B)+((A)*(blen+1))]
|
|
|
|
/* Start building the LCS table. */
|
|
for (uint32_t i = 0; i <= alen; i++) {
|
|
for (uint32_t j = 0; j <= blen; j++) {
|
|
if (i == 0 || j == 0) {
|
|
/* If one substring has length of zero, the
|
|
* LCS length is zero. */
|
|
LCS(i,j) = 0;
|
|
} else if (a[i-1] == b[j-1]) {
|
|
/* The len LCS (and the LCS itself) of two
|
|
* sequences with the same final character, is the
|
|
* LCS of the two sequences without the last char
|
|
* plus that last char. */
|
|
LCS(i,j) = LCS(i-1,j-1)+1;
|
|
} else {
|
|
/* If the last character is different, take the longest
|
|
* between the LCS of the first string and the second
|
|
* minus the last char, and the reverse. */
|
|
uint32_t lcs1 = LCS(i-1,j);
|
|
uint32_t lcs2 = LCS(i,j-1);
|
|
LCS(i,j) = lcs1 > lcs2 ? lcs1 : lcs2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Store the actual LCS string in "result" if needed. We create
|
|
* it backward, but the length is already known, we store it into idx. */
|
|
uint32_t idx = LCS(alen,blen);
|
|
sds result = NULL; /* Resulting LCS string. */
|
|
void *arraylenptr = NULL; /* Deffered length of the array for IDX. */
|
|
uint32_t arange_start = alen, /* alen signals that values are not set. */
|
|
arange_end = 0,
|
|
brange_start = 0,
|
|
brange_end = 0;
|
|
|
|
/* Do we need to compute the actual LCS string? Allocate it in that case. */
|
|
int computelcs = getidx || !getlen;
|
|
if (computelcs) result = sdsnewlen(SDS_NOINIT,idx);
|
|
|
|
/* Start with a deferred array if we have to emit the ranges. */
|
|
uint32_t arraylen = 0; /* Number of ranges emitted in the array. */
|
|
if (getidx) {
|
|
addReplyMapLen(c,2);
|
|
addReplyBulkCString(c,"matches");
|
|
arraylenptr = addReplyDeferredLen(c);
|
|
}
|
|
|
|
i = alen, j = blen;
|
|
while (computelcs && i > 0 && j > 0) {
|
|
int emit_range = 0;
|
|
if (a[i-1] == b[j-1]) {
|
|
/* If there is a match, store the character and reduce
|
|
* the indexes to look for a new match. */
|
|
result[idx-1] = a[i-1];
|
|
|
|
/* Track the current range. */
|
|
if (arange_start == alen) {
|
|
arange_start = i-1;
|
|
arange_end = i-1;
|
|
brange_start = j-1;
|
|
brange_end = j-1;
|
|
} else {
|
|
/* Let's see if we can extend the range backward since
|
|
* it is contiguous. */
|
|
if (arange_start == i && brange_start == j) {
|
|
arange_start--;
|
|
brange_start--;
|
|
} else {
|
|
emit_range = 1;
|
|
}
|
|
}
|
|
/* Emit the range if we matched with the first byte of
|
|
* one of the two strings. We'll exit the loop ASAP. */
|
|
if (arange_start == 0 || brange_start == 0) emit_range = 1;
|
|
idx--; i--; j--;
|
|
} else {
|
|
/* Otherwise reduce i and j depending on the largest
|
|
* LCS between, to understand what direction we need to go. */
|
|
uint32_t lcs1 = LCS(i-1,j);
|
|
uint32_t lcs2 = LCS(i,j-1);
|
|
if (lcs1 > lcs2)
|
|
i--;
|
|
else
|
|
j--;
|
|
if (arange_start != alen) emit_range = 1;
|
|
}
|
|
|
|
/* Emit the current range if needed. */
|
|
uint32_t match_len = arange_end - arange_start + 1;
|
|
if (emit_range) {
|
|
if (minmatchlen == 0 || match_len >= minmatchlen) {
|
|
if (arraylenptr) {
|
|
addReplyArrayLen(c,2+withmatchlen);
|
|
addReplyArrayLen(c,2);
|
|
addReplyLongLong(c,arange_start);
|
|
addReplyLongLong(c,arange_end);
|
|
addReplyArrayLen(c,2);
|
|
addReplyLongLong(c,brange_start);
|
|
addReplyLongLong(c,brange_end);
|
|
if (withmatchlen) addReplyLongLong(c,match_len);
|
|
arraylen++;
|
|
}
|
|
}
|
|
arange_start = alen; /* Restart at the next match. */
|
|
}
|
|
}
|
|
|
|
/* Signal modified key, increment dirty, ... */
|
|
|
|
/* Reply depending on the given options. */
|
|
if (arraylenptr) {
|
|
addReplyBulkCString(c,"len");
|
|
addReplyLongLong(c,LCS(alen,blen));
|
|
setDeferredArrayLen(c,arraylenptr,arraylen);
|
|
} else if (getlen) {
|
|
addReplyLongLong(c,LCS(alen,blen));
|
|
} else {
|
|
addReplyBulkSds(c,result);
|
|
result = NULL;
|
|
}
|
|
|
|
/* Cleanup. */
|
|
sdsfree(result);
|
|
zfree(lcs);
|
|
|
|
cleanup:
|
|
if (obja) decrRefCount(obja);
|
|
if (objb) decrRefCount(objb);
|
|
return;
|
|
}
|
|
|