mirror of
https://github.com/fluencelabs/redis
synced 2025-03-24 11:30:50 +00:00
bfc197c3b6
Unfortunately we had still the lame atoi() without any error checking in place, so "SELECT foo" would work as "SELECT 0". This was not an huge problem per se but some people expected that DB can be strings and not just numbers, and without errors you get the feeling that they can be numbers, but not the behavior. Now getLongFromObjectOrReply() is used as almost everybody else across the code, generating an error if the number is not an integer or overflows the long type. Thanks to @mipearson for reporting that on Twitter.
727 lines
21 KiB
C
727 lines
21 KiB
C
#include "redis.h"
|
|
|
|
#include <signal.h>
|
|
#include <ctype.h>
|
|
|
|
void SlotToKeyAdd(robj *key);
|
|
void SlotToKeyDel(robj *key);
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* C-level DB API
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
robj *lookupKey(redisDb *db, robj *key) {
|
|
dictEntry *de = dictFind(db->dict,key->ptr);
|
|
if (de) {
|
|
robj *val = dictGetVal(de);
|
|
|
|
/* Update the access time for the aging algorithm.
|
|
* Don't do it if we have a saving child, as this will trigger
|
|
* a copy on write madness. */
|
|
if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
|
|
val->lru = server.lruclock;
|
|
return val;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
robj *lookupKeyRead(redisDb *db, robj *key) {
|
|
robj *val;
|
|
|
|
expireIfNeeded(db,key);
|
|
val = lookupKey(db,key);
|
|
if (val == NULL)
|
|
server.stat_keyspace_misses++;
|
|
else
|
|
server.stat_keyspace_hits++;
|
|
return val;
|
|
}
|
|
|
|
robj *lookupKeyWrite(redisDb *db, robj *key) {
|
|
expireIfNeeded(db,key);
|
|
return lookupKey(db,key);
|
|
}
|
|
|
|
robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply) {
|
|
robj *o = lookupKeyRead(c->db, key);
|
|
if (!o) addReply(c,reply);
|
|
return o;
|
|
}
|
|
|
|
robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply) {
|
|
robj *o = lookupKeyWrite(c->db, key);
|
|
if (!o) addReply(c,reply);
|
|
return o;
|
|
}
|
|
|
|
/* Add the key to the DB. It's up to the caller to increment the reference
|
|
* counte of the value if needed.
|
|
*
|
|
* The program is aborted if the key already exists. */
|
|
void dbAdd(redisDb *db, robj *key, robj *val) {
|
|
sds copy = sdsdup(key->ptr);
|
|
int retval = dictAdd(db->dict, copy, val);
|
|
|
|
redisAssertWithInfo(NULL,key,retval == REDIS_OK);
|
|
if (server.cluster_enabled) SlotToKeyAdd(key);
|
|
}
|
|
|
|
/* Overwrite an existing key with a new value. Incrementing the reference
|
|
* count of the new value is up to the caller.
|
|
* This function does not modify the expire time of the existing key.
|
|
*
|
|
* The program is aborted if the key was not already present. */
|
|
void dbOverwrite(redisDb *db, robj *key, robj *val) {
|
|
struct dictEntry *de = dictFind(db->dict,key->ptr);
|
|
|
|
redisAssertWithInfo(NULL,key,de != NULL);
|
|
dictReplace(db->dict, key->ptr, val);
|
|
}
|
|
|
|
/* High level Set operation. This function can be used in order to set
|
|
* a key, whatever it was existing or not, to a new object.
|
|
*
|
|
* 1) The ref count of the value object is incremented.
|
|
* 2) clients WATCHing for the destination key notified.
|
|
* 3) The expire time of the key is reset (the key is made persistent). */
|
|
void setKey(redisDb *db, robj *key, robj *val) {
|
|
if (lookupKeyWrite(db,key) == NULL) {
|
|
dbAdd(db,key,val);
|
|
} else {
|
|
dbOverwrite(db,key,val);
|
|
}
|
|
incrRefCount(val);
|
|
removeExpire(db,key);
|
|
signalModifiedKey(db,key);
|
|
}
|
|
|
|
int dbExists(redisDb *db, robj *key) {
|
|
return dictFind(db->dict,key->ptr) != NULL;
|
|
}
|
|
|
|
/* Return a random key, in form of a Redis object.
|
|
* If there are no keys, NULL is returned.
|
|
*
|
|
* The function makes sure to return keys not already expired. */
|
|
robj *dbRandomKey(redisDb *db) {
|
|
struct dictEntry *de;
|
|
|
|
while(1) {
|
|
sds key;
|
|
robj *keyobj;
|
|
|
|
de = dictGetRandomKey(db->dict);
|
|
if (de == NULL) return NULL;
|
|
|
|
key = dictGetKey(de);
|
|
keyobj = createStringObject(key,sdslen(key));
|
|
if (dictFind(db->expires,key)) {
|
|
if (expireIfNeeded(db,keyobj)) {
|
|
decrRefCount(keyobj);
|
|
continue; /* search for another key. This expired. */
|
|
}
|
|
}
|
|
return keyobj;
|
|
}
|
|
}
|
|
|
|
/* Delete a key, value, and associated expiration entry if any, from the DB */
|
|
int dbDelete(redisDb *db, robj *key) {
|
|
/* Deleting an entry from the expires dict will not free the sds of
|
|
* the key, because it is shared with the main dictionary. */
|
|
if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);
|
|
if (dictDelete(db->dict,key->ptr) == DICT_OK) {
|
|
if (server.cluster_enabled) SlotToKeyDel(key);
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
long long emptyDb() {
|
|
int j;
|
|
long long removed = 0;
|
|
|
|
for (j = 0; j < server.dbnum; j++) {
|
|
removed += dictSize(server.db[j].dict);
|
|
dictEmpty(server.db[j].dict);
|
|
dictEmpty(server.db[j].expires);
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
int selectDb(redisClient *c, int id) {
|
|
if (id < 0 || id >= server.dbnum)
|
|
return REDIS_ERR;
|
|
c->db = &server.db[id];
|
|
return REDIS_OK;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* Hooks for key space changes.
|
|
*
|
|
* Every time a key in the database is modified the function
|
|
* signalModifiedKey() is called.
|
|
*
|
|
* Every time a DB is flushed the function signalFlushDb() is called.
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
void signalModifiedKey(redisDb *db, robj *key) {
|
|
touchWatchedKey(db,key);
|
|
}
|
|
|
|
void signalFlushedDb(int dbid) {
|
|
touchWatchedKeysOnFlush(dbid);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* Type agnostic commands operating on the key space
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
void flushdbCommand(redisClient *c) {
|
|
server.dirty += dictSize(c->db->dict);
|
|
signalFlushedDb(c->db->id);
|
|
dictEmpty(c->db->dict);
|
|
dictEmpty(c->db->expires);
|
|
addReply(c,shared.ok);
|
|
}
|
|
|
|
void flushallCommand(redisClient *c) {
|
|
signalFlushedDb(-1);
|
|
server.dirty += emptyDb();
|
|
addReply(c,shared.ok);
|
|
if (server.rdb_child_pid != -1) {
|
|
kill(server.rdb_child_pid,SIGKILL);
|
|
rdbRemoveTempFile(server.rdb_child_pid);
|
|
}
|
|
if (server.saveparamslen > 0) {
|
|
/* Normally rdbSave() will reset dirty, but we don't want this here
|
|
* as otherwise FLUSHALL will not be replicated nor put into the AOF. */
|
|
int saved_dirty = server.dirty;
|
|
rdbSave(server.rdb_filename);
|
|
server.dirty = saved_dirty;
|
|
}
|
|
server.dirty++;
|
|
}
|
|
|
|
void delCommand(redisClient *c) {
|
|
int deleted = 0, j;
|
|
|
|
for (j = 1; j < c->argc; j++) {
|
|
if (dbDelete(c->db,c->argv[j])) {
|
|
signalModifiedKey(c->db,c->argv[j]);
|
|
server.dirty++;
|
|
deleted++;
|
|
}
|
|
}
|
|
addReplyLongLong(c,deleted);
|
|
}
|
|
|
|
void existsCommand(redisClient *c) {
|
|
expireIfNeeded(c->db,c->argv[1]);
|
|
if (dbExists(c->db,c->argv[1])) {
|
|
addReply(c, shared.cone);
|
|
} else {
|
|
addReply(c, shared.czero);
|
|
}
|
|
}
|
|
|
|
void selectCommand(redisClient *c) {
|
|
long id;
|
|
|
|
if (getLongFromObjectOrReply(c, c->argv[1], &id,
|
|
"invalid DB index") != REDIS_OK)
|
|
return;
|
|
|
|
if (server.cluster_enabled && id != 0) {
|
|
addReplyError(c,"SELECT is not allowed in cluster mode");
|
|
return;
|
|
}
|
|
if (selectDb(c,id) == REDIS_ERR) {
|
|
addReplyError(c,"invalid DB index");
|
|
} else {
|
|
addReply(c,shared.ok);
|
|
}
|
|
}
|
|
|
|
void randomkeyCommand(redisClient *c) {
|
|
robj *key;
|
|
|
|
if ((key = dbRandomKey(c->db)) == NULL) {
|
|
addReply(c,shared.nullbulk);
|
|
return;
|
|
}
|
|
|
|
addReplyBulk(c,key);
|
|
decrRefCount(key);
|
|
}
|
|
|
|
void keysCommand(redisClient *c) {
|
|
dictIterator *di;
|
|
dictEntry *de;
|
|
sds pattern = c->argv[1]->ptr;
|
|
int plen = sdslen(pattern), allkeys;
|
|
unsigned long numkeys = 0;
|
|
void *replylen = addDeferredMultiBulkLength(c);
|
|
|
|
di = dictGetSafeIterator(c->db->dict);
|
|
allkeys = (pattern[0] == '*' && pattern[1] == '\0');
|
|
while((de = dictNext(di)) != NULL) {
|
|
sds key = dictGetKey(de);
|
|
robj *keyobj;
|
|
|
|
if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
|
|
keyobj = createStringObject(key,sdslen(key));
|
|
if (expireIfNeeded(c->db,keyobj) == 0) {
|
|
addReplyBulk(c,keyobj);
|
|
numkeys++;
|
|
}
|
|
decrRefCount(keyobj);
|
|
}
|
|
}
|
|
dictReleaseIterator(di);
|
|
setDeferredMultiBulkLength(c,replylen,numkeys);
|
|
}
|
|
|
|
void dbsizeCommand(redisClient *c) {
|
|
addReplyLongLong(c,dictSize(c->db->dict));
|
|
}
|
|
|
|
void lastsaveCommand(redisClient *c) {
|
|
addReplyLongLong(c,server.lastsave);
|
|
}
|
|
|
|
void typeCommand(redisClient *c) {
|
|
robj *o;
|
|
char *type;
|
|
|
|
o = lookupKeyRead(c->db,c->argv[1]);
|
|
if (o == NULL) {
|
|
type = "none";
|
|
} else {
|
|
switch(o->type) {
|
|
case REDIS_STRING: type = "string"; break;
|
|
case REDIS_LIST: type = "list"; break;
|
|
case REDIS_SET: type = "set"; break;
|
|
case REDIS_ZSET: type = "zset"; break;
|
|
case REDIS_HASH: type = "hash"; break;
|
|
default: type = "unknown"; break;
|
|
}
|
|
}
|
|
addReplyStatus(c,type);
|
|
}
|
|
|
|
void shutdownCommand(redisClient *c) {
|
|
int flags = 0;
|
|
|
|
if (c->argc > 2) {
|
|
addReply(c,shared.syntaxerr);
|
|
return;
|
|
} else if (c->argc == 2) {
|
|
if (!strcasecmp(c->argv[1]->ptr,"nosave")) {
|
|
flags |= REDIS_SHUTDOWN_NOSAVE;
|
|
} else if (!strcasecmp(c->argv[1]->ptr,"save")) {
|
|
flags |= REDIS_SHUTDOWN_SAVE;
|
|
} else {
|
|
addReply(c,shared.syntaxerr);
|
|
return;
|
|
}
|
|
}
|
|
if (prepareForShutdown(flags) == REDIS_OK) exit(0);
|
|
addReplyError(c,"Errors trying to SHUTDOWN. Check logs.");
|
|
}
|
|
|
|
void renameGenericCommand(redisClient *c, int nx) {
|
|
robj *o;
|
|
long long expire;
|
|
|
|
/* To use the same key as src and dst is probably an error */
|
|
if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
|
|
addReply(c,shared.sameobjecterr);
|
|
return;
|
|
}
|
|
|
|
if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr)) == NULL)
|
|
return;
|
|
|
|
incrRefCount(o);
|
|
expire = getExpire(c->db,c->argv[1]);
|
|
if (lookupKeyWrite(c->db,c->argv[2]) != NULL) {
|
|
if (nx) {
|
|
decrRefCount(o);
|
|
addReply(c,shared.czero);
|
|
return;
|
|
}
|
|
/* Overwrite: delete the old key before creating the new one with the same name. */
|
|
dbDelete(c->db,c->argv[2]);
|
|
}
|
|
dbAdd(c->db,c->argv[2],o);
|
|
if (expire != -1) setExpire(c->db,c->argv[2],expire);
|
|
dbDelete(c->db,c->argv[1]);
|
|
signalModifiedKey(c->db,c->argv[1]);
|
|
signalModifiedKey(c->db,c->argv[2]);
|
|
server.dirty++;
|
|
addReply(c,nx ? shared.cone : shared.ok);
|
|
}
|
|
|
|
void renameCommand(redisClient *c) {
|
|
renameGenericCommand(c,0);
|
|
}
|
|
|
|
void renamenxCommand(redisClient *c) {
|
|
renameGenericCommand(c,1);
|
|
}
|
|
|
|
void moveCommand(redisClient *c) {
|
|
robj *o;
|
|
redisDb *src, *dst;
|
|
int srcid;
|
|
|
|
if (server.cluster_enabled) {
|
|
addReplyError(c,"MOVE is not allowed in cluster mode");
|
|
return;
|
|
}
|
|
|
|
/* Obtain source and target DB pointers */
|
|
src = c->db;
|
|
srcid = c->db->id;
|
|
if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
|
|
addReply(c,shared.outofrangeerr);
|
|
return;
|
|
}
|
|
dst = c->db;
|
|
selectDb(c,srcid); /* Back to the source DB */
|
|
|
|
/* If the user is moving using as target the same
|
|
* DB as the source DB it is probably an error. */
|
|
if (src == dst) {
|
|
addReply(c,shared.sameobjecterr);
|
|
return;
|
|
}
|
|
|
|
/* Check if the element exists and get a reference */
|
|
o = lookupKeyWrite(c->db,c->argv[1]);
|
|
if (!o) {
|
|
addReply(c,shared.czero);
|
|
return;
|
|
}
|
|
|
|
/* Return zero if the key already exists in the target DB */
|
|
if (lookupKeyWrite(dst,c->argv[1]) != NULL) {
|
|
addReply(c,shared.czero);
|
|
return;
|
|
}
|
|
dbAdd(dst,c->argv[1],o);
|
|
incrRefCount(o);
|
|
|
|
/* OK! key moved, free the entry in the source DB */
|
|
dbDelete(src,c->argv[1]);
|
|
server.dirty++;
|
|
addReply(c,shared.cone);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* Expires API
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
int removeExpire(redisDb *db, robj *key) {
|
|
/* An expire may only be removed if there is a corresponding entry in the
|
|
* main dict. Otherwise, the key will never be freed. */
|
|
redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
|
|
return dictDelete(db->expires,key->ptr) == DICT_OK;
|
|
}
|
|
|
|
void setExpire(redisDb *db, robj *key, long long when) {
|
|
dictEntry *kde, *de;
|
|
|
|
/* Reuse the sds from the main dict in the expire dict */
|
|
kde = dictFind(db->dict,key->ptr);
|
|
redisAssertWithInfo(NULL,key,kde != NULL);
|
|
de = dictReplaceRaw(db->expires,dictGetKey(kde));
|
|
dictSetSignedIntegerVal(de,when);
|
|
}
|
|
|
|
/* Return the expire time of the specified key, or -1 if no expire
|
|
* is associated with this key (i.e. the key is non volatile) */
|
|
long long getExpire(redisDb *db, robj *key) {
|
|
dictEntry *de;
|
|
|
|
/* No expire? return ASAP */
|
|
if (dictSize(db->expires) == 0 ||
|
|
(de = dictFind(db->expires,key->ptr)) == NULL) return -1;
|
|
|
|
/* The entry was found in the expire dict, this means it should also
|
|
* be present in the main dict (safety check). */
|
|
redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
|
|
return dictGetSignedIntegerVal(de);
|
|
}
|
|
|
|
/* Propagate expires into slaves and the AOF file.
|
|
* When a key expires in the master, a DEL operation for this key is sent
|
|
* to all the slaves and the AOF file if enabled.
|
|
*
|
|
* This way the key expiry is centralized in one place, and since both
|
|
* AOF and the master->slave link guarantee operation ordering, everything
|
|
* will be consistent even if we allow write operations against expiring
|
|
* keys. */
|
|
void propagateExpire(redisDb *db, robj *key) {
|
|
robj *argv[2];
|
|
|
|
argv[0] = shared.del;
|
|
argv[1] = key;
|
|
incrRefCount(argv[0]);
|
|
incrRefCount(argv[1]);
|
|
|
|
if (server.aof_state != REDIS_AOF_OFF)
|
|
feedAppendOnlyFile(server.delCommand,db->id,argv,2);
|
|
if (listLength(server.slaves))
|
|
replicationFeedSlaves(server.slaves,db->id,argv,2);
|
|
|
|
decrRefCount(argv[0]);
|
|
decrRefCount(argv[1]);
|
|
}
|
|
|
|
int expireIfNeeded(redisDb *db, robj *key) {
|
|
long long when = getExpire(db,key);
|
|
|
|
if (when < 0) return 0; /* No expire for this key */
|
|
|
|
/* Don't expire anything while loading. It will be done later. */
|
|
if (server.loading) return 0;
|
|
|
|
/* If we are running in the context of a slave, return ASAP:
|
|
* the slave key expiration is controlled by the master that will
|
|
* send us synthesized DEL operations for expired keys.
|
|
*
|
|
* Still we try to return the right information to the caller,
|
|
* that is, 0 if we think the key should be still valid, 1 if
|
|
* we think the key is expired at this time. */
|
|
if (server.masterhost != NULL) {
|
|
return mstime() > when;
|
|
}
|
|
|
|
/* Return when this key has not expired */
|
|
if (mstime() <= when) return 0;
|
|
|
|
/* Delete the key */
|
|
server.stat_expiredkeys++;
|
|
propagateExpire(db,key);
|
|
return dbDelete(db,key);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
* Expires Commands
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
/* This is the generic command implementation for EXPIRE, PEXPIRE, EXPIREAT
|
|
* and PEXPIREAT. Because the commad second argument may be relative or absolute
|
|
* the "basetime" argument is used to signal what the base time is (either 0
|
|
* for *AT variants of the command, or the current time for relative expires).
|
|
*
|
|
* unit is either UNIT_SECONDS or UNIT_MILLISECONDS, and is only used for
|
|
* the argv[2] parameter. The basetime is always specified in milliesconds. */
|
|
void expireGenericCommand(redisClient *c, long long basetime, int unit) {
|
|
dictEntry *de;
|
|
robj *key = c->argv[1], *param = c->argv[2];
|
|
long long when; /* unix time in milliseconds when the key will expire. */
|
|
|
|
if (getLongLongFromObjectOrReply(c, param, &when, NULL) != REDIS_OK)
|
|
return;
|
|
|
|
if (unit == UNIT_SECONDS) when *= 1000;
|
|
when += basetime;
|
|
|
|
de = dictFind(c->db->dict,key->ptr);
|
|
if (de == NULL) {
|
|
addReply(c,shared.czero);
|
|
return;
|
|
}
|
|
/* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past
|
|
* should never be executed as a DEL when load the AOF or in the context
|
|
* of a slave instance.
|
|
*
|
|
* Instead we take the other branch of the IF statement setting an expire
|
|
* (possibly in the past) and wait for an explicit DEL from the master. */
|
|
if (when <= mstime() && !server.loading && !server.masterhost) {
|
|
robj *aux;
|
|
|
|
redisAssertWithInfo(c,key,dbDelete(c->db,key));
|
|
server.dirty++;
|
|
|
|
/* Replicate/AOF this as an explicit DEL. */
|
|
aux = createStringObject("DEL",3);
|
|
rewriteClientCommandVector(c,2,aux,key);
|
|
decrRefCount(aux);
|
|
signalModifiedKey(c->db,key);
|
|
addReply(c, shared.cone);
|
|
return;
|
|
} else {
|
|
setExpire(c->db,key,when);
|
|
addReply(c,shared.cone);
|
|
signalModifiedKey(c->db,key);
|
|
server.dirty++;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void expireCommand(redisClient *c) {
|
|
expireGenericCommand(c,mstime(),UNIT_SECONDS);
|
|
}
|
|
|
|
void expireatCommand(redisClient *c) {
|
|
expireGenericCommand(c,0,UNIT_SECONDS);
|
|
}
|
|
|
|
void pexpireCommand(redisClient *c) {
|
|
expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);
|
|
}
|
|
|
|
void pexpireatCommand(redisClient *c) {
|
|
expireGenericCommand(c,0,UNIT_MILLISECONDS);
|
|
}
|
|
|
|
void ttlGenericCommand(redisClient *c, int output_ms) {
|
|
long long expire, ttl = -1;
|
|
|
|
expire = getExpire(c->db,c->argv[1]);
|
|
if (expire != -1) {
|
|
ttl = expire-mstime();
|
|
if (ttl < 0) ttl = -1;
|
|
}
|
|
if (ttl == -1) {
|
|
addReplyLongLong(c,-1);
|
|
} else {
|
|
addReplyLongLong(c,output_ms ? ttl : ((ttl+500)/1000));
|
|
}
|
|
}
|
|
|
|
void ttlCommand(redisClient *c) {
|
|
ttlGenericCommand(c, 0);
|
|
}
|
|
|
|
void pttlCommand(redisClient *c) {
|
|
ttlGenericCommand(c, 1);
|
|
}
|
|
|
|
void persistCommand(redisClient *c) {
|
|
dictEntry *de;
|
|
|
|
de = dictFind(c->db->dict,c->argv[1]->ptr);
|
|
if (de == NULL) {
|
|
addReply(c,shared.czero);
|
|
} else {
|
|
if (removeExpire(c->db,c->argv[1])) {
|
|
addReply(c,shared.cone);
|
|
server.dirty++;
|
|
} else {
|
|
addReply(c,shared.czero);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* API to get key arguments from commands
|
|
* ---------------------------------------------------------------------------*/
|
|
|
|
int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, int *numkeys) {
|
|
int j, i = 0, last, *keys;
|
|
REDIS_NOTUSED(argv);
|
|
|
|
if (cmd->firstkey == 0) {
|
|
*numkeys = 0;
|
|
return NULL;
|
|
}
|
|
last = cmd->lastkey;
|
|
if (last < 0) last = argc+last;
|
|
keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
|
|
for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
|
|
redisAssert(j < argc);
|
|
keys[i++] = j;
|
|
}
|
|
*numkeys = i;
|
|
return keys;
|
|
}
|
|
|
|
int *getKeysFromCommand(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
|
|
if (cmd->getkeys_proc) {
|
|
return cmd->getkeys_proc(cmd,argv,argc,numkeys,flags);
|
|
} else {
|
|
return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
|
|
}
|
|
}
|
|
|
|
void getKeysFreeResult(int *result) {
|
|
zfree(result);
|
|
}
|
|
|
|
int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
|
|
if (flags & REDIS_GETKEYS_PRELOAD) {
|
|
*numkeys = 0;
|
|
return NULL;
|
|
} else {
|
|
return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
|
|
}
|
|
}
|
|
|
|
int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
|
|
if (flags & REDIS_GETKEYS_PRELOAD) {
|
|
int *keys = zmalloc(sizeof(int));
|
|
*numkeys = 1;
|
|
keys[0] = 1;
|
|
return keys;
|
|
} else {
|
|
return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
|
|
}
|
|
}
|
|
|
|
int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
|
|
int i, num, *keys;
|
|
REDIS_NOTUSED(cmd);
|
|
REDIS_NOTUSED(flags);
|
|
|
|
num = atoi(argv[2]->ptr);
|
|
/* Sanity check. Don't return any key if the command is going to
|
|
* reply with syntax error. */
|
|
if (num > (argc-3)) {
|
|
*numkeys = 0;
|
|
return NULL;
|
|
}
|
|
keys = zmalloc(sizeof(int)*num);
|
|
for (i = 0; i < num; i++) keys[i] = 3+i;
|
|
*numkeys = num;
|
|
return keys;
|
|
}
|
|
|
|
/* Slot to Key API. This is used by Redis Cluster in order to obtain in
|
|
* a fast way a key that belongs to a specified hash slot. This is useful
|
|
* while rehashing the cluster. */
|
|
void SlotToKeyAdd(robj *key) {
|
|
unsigned int hashslot = keyHashSlot(key->ptr,sdslen(key->ptr));
|
|
|
|
zslInsert(server.cluster.slots_to_keys,hashslot,key);
|
|
incrRefCount(key);
|
|
}
|
|
|
|
void SlotToKeyDel(robj *key) {
|
|
unsigned int hashslot = keyHashSlot(key->ptr,sdslen(key->ptr));
|
|
|
|
zslDelete(server.cluster.slots_to_keys,hashslot,key);
|
|
}
|
|
|
|
unsigned int GetKeysInSlot(unsigned int hashslot, robj **keys, unsigned int count) {
|
|
zskiplistNode *n;
|
|
zrangespec range;
|
|
int j = 0;
|
|
|
|
range.min = range.max = hashslot;
|
|
range.minex = range.maxex = 0;
|
|
|
|
n = zslFirstInRange(server.cluster.slots_to_keys, range);
|
|
while(n && n->score == hashslot && count--) {
|
|
keys[j++] = n->obj;
|
|
n = n->level[0].forward;
|
|
}
|
|
return j;
|
|
}
|