]>
git.saurik.com Git - redis.git/blob - src/db.c
5 void SlotToKeyAdd(robj
*key
);
6 void SlotToKeyDel(robj
*key
);
8 /*-----------------------------------------------------------------------------
10 *----------------------------------------------------------------------------*/
12 /* Important notes on lookup and disk store.
14 * When disk store is enabled on lookup we can have different cases.
16 * a) The key is in memory:
17 * - If the key is not in IO_SAVEINPROG state we can access it.
18 * As if it's just IO_SAVE this means we have the key in the IO queue
19 * but can't be accessed by the IO thread (it requires to be
20 * translated into an IO Job by the cache cron function.)
21 * - If the key is in IO_SAVEINPROG we can't touch the key and have
22 * to blocking wait completion of operations.
23 * b) The key is not in memory:
24 * - If it's marked as non existing on disk as well (negative cache)
25 * we don't need to perform the disk access.
26 * - if the key MAY EXIST, but is not in memory, and it is marked as IO_SAVE
27 * then the key can only be a deleted one. As IO_SAVE keys are never
28 * evicted (dirty state), so the only possibility is that key was deleted.
29 * - if the key MAY EXIST we need to blocking load it.
30 * We check that the key is not in IO_SAVEINPROG state before accessing
31 * the disk object. If it is in this state, we wait.
34 robj
*lookupKey(redisDb
*db
, robj
*key
) {
35 dictEntry
*de
= dictFind(db
->dict
,key
->ptr
);
37 robj
*val
= dictGetEntryVal(de
);
39 /* Update the access time for the aging algorithm.
40 * Don't do it if we have a saving child, as this will trigger
41 * a copy on write madness. */
42 if (server
.bgsavechildpid
== -1 && server
.bgrewritechildpid
== -1)
43 val
->lru
= server
.lruclock
;
44 server
.stat_keyspace_hits
++;
47 server
.stat_keyspace_misses
++;
52 robj
*lookupKeyRead(redisDb
*db
, robj
*key
) {
53 expireIfNeeded(db
,key
);
54 return lookupKey(db
,key
);
57 robj
*lookupKeyWrite(redisDb
*db
, robj
*key
) {
58 expireIfNeeded(db
,key
);
59 return lookupKey(db
,key
);
62 robj
*lookupKeyReadOrReply(redisClient
*c
, robj
*key
, robj
*reply
) {
63 robj
*o
= lookupKeyRead(c
->db
, key
);
64 if (!o
) addReply(c
,reply
);
68 robj
*lookupKeyWriteOrReply(redisClient
*c
, robj
*key
, robj
*reply
) {
69 robj
*o
= lookupKeyWrite(c
->db
, key
);
70 if (!o
) addReply(c
,reply
);
74 /* Add the key to the DB. It's up to the caller to increment the reference
75 * counte of the value if needed.
77 * The program is aborted if the key already exists. */
78 void dbAdd(redisDb
*db
, robj
*key
, robj
*val
) {
79 sds copy
= sdsdup(key
->ptr
);
80 int retval
= dictAdd(db
->dict
, copy
, val
);
82 redisAssertWithInfo(NULL
,key
,retval
== REDIS_OK
);
83 if (server
.cluster_enabled
) SlotToKeyAdd(key
);
86 /* Overwrite an existing key with a new value. Incrementing the reference
87 * count of the new value is up to the caller.
88 * This function does not modify the expire time of the existing key.
90 * The program is aborted if the key was not already present. */
91 void dbOverwrite(redisDb
*db
, robj
*key
, robj
*val
) {
92 struct dictEntry
*de
= dictFind(db
->dict
,key
->ptr
);
94 redisAssertWithInfo(NULL
,key
,de
!= NULL
);
95 dictReplace(db
->dict
, key
->ptr
, val
);
98 /* High level Set operation. This function can be used in order to set
99 * a key, whatever it was existing or not, to a new object.
101 * 1) The ref count of the value object is incremented.
102 * 2) clients WATCHing for the destination key notified.
103 * 3) The expire time of the key is reset (the key is made persistent). */
104 void setKey(redisDb
*db
, robj
*key
, robj
*val
) {
105 if (lookupKeyWrite(db
,key
) == NULL
) {
108 dbOverwrite(db
,key
,val
);
111 removeExpire(db
,key
);
112 touchWatchedKey(db
,key
);
115 int dbExists(redisDb
*db
, robj
*key
) {
116 return dictFind(db
->dict
,key
->ptr
) != NULL
;
119 /* Return a random key, in form of a Redis object.
120 * If there are no keys, NULL is returned.
122 * The function makes sure to return keys not already expired. */
123 robj
*dbRandomKey(redisDb
*db
) {
124 struct dictEntry
*de
;
130 de
= dictGetRandomKey(db
->dict
);
131 if (de
== NULL
) return NULL
;
133 key
= dictGetEntryKey(de
);
134 keyobj
= createStringObject(key
,sdslen(key
));
135 if (dictFind(db
->expires
,key
)) {
136 if (expireIfNeeded(db
,keyobj
)) {
137 decrRefCount(keyobj
);
138 continue; /* search for another key. This expired. */
145 /* Delete a key, value, and associated expiration entry if any, from the DB */
146 int dbDelete(redisDb
*db
, robj
*key
) {
147 /* Deleting an entry from the expires dict will not free the sds of
148 * the key, because it is shared with the main dictionary. */
149 if (dictSize(db
->expires
) > 0) dictDelete(db
->expires
,key
->ptr
);
150 if (dictDelete(db
->dict
,key
->ptr
) == DICT_OK
) {
151 if (server
.cluster_enabled
) SlotToKeyDel(key
);
158 /* Empty the whole database.
159 * If diskstore is enabled this function will just flush the in-memory cache. */
160 long long emptyDb() {
162 long long removed
= 0;
164 for (j
= 0; j
< server
.dbnum
; j
++) {
165 removed
+= dictSize(server
.db
[j
].dict
);
166 dictEmpty(server
.db
[j
].dict
);
167 dictEmpty(server
.db
[j
].expires
);
172 int selectDb(redisClient
*c
, int id
) {
173 if (id
< 0 || id
>= server
.dbnum
)
175 c
->db
= &server
.db
[id
];
179 /*-----------------------------------------------------------------------------
180 * Hooks for key space changes.
182 * Every time a key in the database is modified the function
183 * signalModifiedKey() is called.
185 * Every time a DB is flushed the function signalFlushDb() is called.
186 *----------------------------------------------------------------------------*/
188 void signalModifiedKey(redisDb
*db
, robj
*key
) {
189 touchWatchedKey(db
,key
);
192 void signalFlushedDb(int dbid
) {
193 touchWatchedKeysOnFlush(dbid
);
196 /*-----------------------------------------------------------------------------
197 * Type agnostic commands operating on the key space
198 *----------------------------------------------------------------------------*/
200 void flushdbCommand(redisClient
*c
) {
201 server
.dirty
+= dictSize(c
->db
->dict
);
202 signalFlushedDb(c
->db
->id
);
203 dictEmpty(c
->db
->dict
);
204 dictEmpty(c
->db
->expires
);
205 addReply(c
,shared
.ok
);
208 void flushallCommand(redisClient
*c
) {
210 server
.dirty
+= emptyDb();
211 addReply(c
,shared
.ok
);
212 if (server
.bgsavechildpid
!= -1) {
213 kill(server
.bgsavechildpid
,SIGKILL
);
214 rdbRemoveTempFile(server
.bgsavechildpid
);
216 rdbSave(server
.dbfilename
);
220 void delCommand(redisClient
*c
) {
223 for (j
= 1; j
< c
->argc
; j
++) {
224 if (dbDelete(c
->db
,c
->argv
[j
])) {
225 signalModifiedKey(c
->db
,c
->argv
[j
]);
230 addReplyLongLong(c
,deleted
);
233 void existsCommand(redisClient
*c
) {
234 expireIfNeeded(c
->db
,c
->argv
[1]);
235 if (dbExists(c
->db
,c
->argv
[1])) {
236 addReply(c
, shared
.cone
);
238 addReply(c
, shared
.czero
);
242 void selectCommand(redisClient
*c
) {
243 int id
= atoi(c
->argv
[1]->ptr
);
245 if (server
.cluster_enabled
&& id
!= 0) {
246 addReplyError(c
,"SELECT is not allowed in cluster mode");
249 if (selectDb(c
,id
) == REDIS_ERR
) {
250 addReplyError(c
,"invalid DB index");
252 addReply(c
,shared
.ok
);
256 void randomkeyCommand(redisClient
*c
) {
259 if ((key
= dbRandomKey(c
->db
)) == NULL
) {
260 addReply(c
,shared
.nullbulk
);
268 void keysCommand(redisClient
*c
) {
271 sds pattern
= c
->argv
[1]->ptr
;
272 int plen
= sdslen(pattern
), allkeys
;
273 unsigned long numkeys
= 0;
274 void *replylen
= addDeferredMultiBulkLength(c
);
276 di
= dictGetIterator(c
->db
->dict
);
277 allkeys
= (pattern
[0] == '*' && pattern
[1] == '\0');
278 while((de
= dictNext(di
)) != NULL
) {
279 sds key
= dictGetEntryKey(de
);
282 if (allkeys
|| stringmatchlen(pattern
,plen
,key
,sdslen(key
),0)) {
283 keyobj
= createStringObject(key
,sdslen(key
));
284 if (expireIfNeeded(c
->db
,keyobj
) == 0) {
285 addReplyBulk(c
,keyobj
);
288 decrRefCount(keyobj
);
291 dictReleaseIterator(di
);
292 setDeferredMultiBulkLength(c
,replylen
,numkeys
);
295 void dbsizeCommand(redisClient
*c
) {
296 addReplyLongLong(c
,dictSize(c
->db
->dict
));
299 void lastsaveCommand(redisClient
*c
) {
300 addReplyLongLong(c
,server
.lastsave
);
303 void typeCommand(redisClient
*c
) {
307 o
= lookupKeyRead(c
->db
,c
->argv
[1]);
312 case REDIS_STRING
: type
= "string"; break;
313 case REDIS_LIST
: type
= "list"; break;
314 case REDIS_SET
: type
= "set"; break;
315 case REDIS_ZSET
: type
= "zset"; break;
316 case REDIS_HASH
: type
= "hash"; break;
317 default: type
= "unknown"; break;
320 addReplyStatus(c
,type
);
323 void shutdownCommand(redisClient
*c
) {
324 if (prepareForShutdown() == REDIS_OK
)
326 addReplyError(c
,"Errors trying to SHUTDOWN. Check logs.");
329 void renameGenericCommand(redisClient
*c
, int nx
) {
332 /* To use the same key as src and dst is probably an error */
333 if (sdscmp(c
->argv
[1]->ptr
,c
->argv
[2]->ptr
) == 0) {
334 addReply(c
,shared
.sameobjecterr
);
338 if ((o
= lookupKeyWriteOrReply(c
,c
->argv
[1],shared
.nokeyerr
)) == NULL
)
342 if (lookupKeyWrite(c
->db
,c
->argv
[2]) != NULL
) {
345 addReply(c
,shared
.czero
);
348 dbOverwrite(c
->db
,c
->argv
[2],o
);
350 dbAdd(c
->db
,c
->argv
[2],o
);
352 dbDelete(c
->db
,c
->argv
[1]);
353 signalModifiedKey(c
->db
,c
->argv
[1]);
354 signalModifiedKey(c
->db
,c
->argv
[2]);
356 addReply(c
,nx
? shared
.cone
: shared
.ok
);
359 void renameCommand(redisClient
*c
) {
360 renameGenericCommand(c
,0);
363 void renamenxCommand(redisClient
*c
) {
364 renameGenericCommand(c
,1);
367 void moveCommand(redisClient
*c
) {
372 if (server
.cluster_enabled
) {
373 addReplyError(c
,"MOVE is not allowed in cluster mode");
377 /* Obtain source and target DB pointers */
380 if (selectDb(c
,atoi(c
->argv
[2]->ptr
)) == REDIS_ERR
) {
381 addReply(c
,shared
.outofrangeerr
);
385 selectDb(c
,srcid
); /* Back to the source DB */
387 /* If the user is moving using as target the same
388 * DB as the source DB it is probably an error. */
390 addReply(c
,shared
.sameobjecterr
);
394 /* Check if the element exists and get a reference */
395 o
= lookupKeyWrite(c
->db
,c
->argv
[1]);
397 addReply(c
,shared
.czero
);
401 /* Return zero if the key already exists in the target DB */
402 if (lookupKeyWrite(dst
,c
->argv
[1]) != NULL
) {
403 addReply(c
,shared
.czero
);
406 dbAdd(dst
,c
->argv
[1],o
);
409 /* OK! key moved, free the entry in the source DB */
410 dbDelete(src
,c
->argv
[1]);
412 addReply(c
,shared
.cone
);
415 /*-----------------------------------------------------------------------------
417 *----------------------------------------------------------------------------*/
419 int removeExpire(redisDb
*db
, robj
*key
) {
420 /* An expire may only be removed if there is a corresponding entry in the
421 * main dict. Otherwise, the key will never be freed. */
422 redisAssertWithInfo(NULL
,key
,dictFind(db
->dict
,key
->ptr
) != NULL
);
423 return dictDelete(db
->expires
,key
->ptr
) == DICT_OK
;
426 void setExpire(redisDb
*db
, robj
*key
, time_t when
) {
429 /* Reuse the sds from the main dict in the expire dict */
430 de
= dictFind(db
->dict
,key
->ptr
);
431 redisAssertWithInfo(NULL
,key
,de
!= NULL
);
432 dictReplace(db
->expires
,dictGetEntryKey(de
),(void*)when
);
435 /* Return the expire time of the specified key, or -1 if no expire
436 * is associated with this key (i.e. the key is non volatile) */
437 time_t getExpire(redisDb
*db
, robj
*key
) {
440 /* No expire? return ASAP */
441 if (dictSize(db
->expires
) == 0 ||
442 (de
= dictFind(db
->expires
,key
->ptr
)) == NULL
) return -1;
444 /* The entry was found in the expire dict, this means it should also
445 * be present in the main dict (safety check). */
446 redisAssertWithInfo(NULL
,key
,dictFind(db
->dict
,key
->ptr
) != NULL
);
447 return (time_t) dictGetEntryVal(de
);
450 /* Propagate expires into slaves and the AOF file.
451 * When a key expires in the master, a DEL operation for this key is sent
452 * to all the slaves and the AOF file if enabled.
454 * This way the key expiry is centralized in one place, and since both
455 * AOF and the master->slave link guarantee operation ordering, everything
456 * will be consistent even if we allow write operations against expiring
458 void propagateExpire(redisDb
*db
, robj
*key
) {
461 argv
[0] = createStringObject("DEL",3);
465 if (server
.appendonly
)
466 feedAppendOnlyFile(server
.delCommand
,db
->id
,argv
,2);
467 if (listLength(server
.slaves
))
468 replicationFeedSlaves(server
.slaves
,db
->id
,argv
,2);
470 decrRefCount(argv
[0]);
471 decrRefCount(argv
[1]);
474 int expireIfNeeded(redisDb
*db
, robj
*key
) {
475 time_t when
= getExpire(db
,key
);
477 if (when
< 0) return 0; /* No expire for this key */
479 /* Don't expire anything while loading. It will be done later. */
480 if (server
.loading
) return 0;
482 /* If we are running in the context of a slave, return ASAP:
483 * the slave key expiration is controlled by the master that will
484 * send us synthesized DEL operations for expired keys.
486 * Still we try to return the right information to the caller,
487 * that is, 0 if we think the key should be still valid, 1 if
488 * we think the key is expired at this time. */
489 if (server
.masterhost
!= NULL
) {
490 return time(NULL
) > when
;
493 /* Return when this key has not expired */
494 if (time(NULL
) <= when
) return 0;
497 server
.stat_expiredkeys
++;
498 propagateExpire(db
,key
);
499 return dbDelete(db
,key
);
502 /*-----------------------------------------------------------------------------
504 *----------------------------------------------------------------------------*/
506 void expireGenericCommand(redisClient
*c
, robj
*key
, robj
*param
, long offset
) {
510 if (getLongFromObjectOrReply(c
, param
, &seconds
, NULL
) != REDIS_OK
) return;
514 de
= dictFind(c
->db
->dict
,key
->ptr
);
516 addReply(c
,shared
.czero
);
519 /* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past
520 * should never be executed as a DEL when load the AOF or in the context
521 * of a slave instance.
523 * Instead we take the other branch of the IF statement setting an expire
524 * (possibly in the past) and wait for an explicit DEL from the master. */
525 if (seconds
<= 0 && !server
.loading
&& !server
.masterhost
) {
528 redisAssertWithInfo(c
,key
,dbDelete(c
->db
,key
));
531 /* Replicate/AOF this as an explicit DEL. */
532 aux
= createStringObject("DEL",3);
533 rewriteClientCommandVector(c
,2,aux
,key
);
535 signalModifiedKey(c
->db
,key
);
536 addReply(c
, shared
.cone
);
539 time_t when
= time(NULL
)+seconds
;
540 setExpire(c
->db
,key
,when
);
541 addReply(c
,shared
.cone
);
542 signalModifiedKey(c
->db
,key
);
548 void expireCommand(redisClient
*c
) {
549 expireGenericCommand(c
,c
->argv
[1],c
->argv
[2],0);
552 void expireatCommand(redisClient
*c
) {
553 expireGenericCommand(c
,c
->argv
[1],c
->argv
[2],time(NULL
));
556 void ttlCommand(redisClient
*c
) {
557 time_t expire
, ttl
= -1;
559 expire
= getExpire(c
->db
,c
->argv
[1]);
561 ttl
= (expire
-time(NULL
));
562 if (ttl
< 0) ttl
= -1;
564 addReplyLongLong(c
,(long long)ttl
);
567 void persistCommand(redisClient
*c
) {
570 de
= dictFind(c
->db
->dict
,c
->argv
[1]->ptr
);
572 addReply(c
,shared
.czero
);
574 if (removeExpire(c
->db
,c
->argv
[1])) {
575 addReply(c
,shared
.cone
);
578 addReply(c
,shared
.czero
);
583 /* -----------------------------------------------------------------------------
584 * API to get key arguments from commands
585 * ---------------------------------------------------------------------------*/
587 int *getKeysUsingCommandTable(struct redisCommand
*cmd
,robj
**argv
, int argc
, int *numkeys
) {
588 int j
, i
= 0, last
, *keys
;
591 if (cmd
->firstkey
== 0) {
596 if (last
< 0) last
= argc
+last
;
597 keys
= zmalloc(sizeof(int)*((last
- cmd
->firstkey
)+1));
598 for (j
= cmd
->firstkey
; j
<= last
; j
+= cmd
->keystep
) {
599 redisAssert(j
< argc
);
606 int *getKeysFromCommand(struct redisCommand
*cmd
,robj
**argv
, int argc
, int *numkeys
, int flags
) {
607 if (cmd
->getkeys_proc
) {
608 return cmd
->getkeys_proc(cmd
,argv
,argc
,numkeys
,flags
);
610 return getKeysUsingCommandTable(cmd
,argv
,argc
,numkeys
);
614 void getKeysFreeResult(int *result
) {
618 int *noPreloadGetKeys(struct redisCommand
*cmd
,robj
**argv
, int argc
, int *numkeys
, int flags
) {
619 if (flags
& REDIS_GETKEYS_PRELOAD
) {
623 return getKeysUsingCommandTable(cmd
,argv
,argc
,numkeys
);
627 int *renameGetKeys(struct redisCommand
*cmd
,robj
**argv
, int argc
, int *numkeys
, int flags
) {
628 if (flags
& REDIS_GETKEYS_PRELOAD
) {
629 int *keys
= zmalloc(sizeof(int));
634 return getKeysUsingCommandTable(cmd
,argv
,argc
,numkeys
);
638 int *zunionInterGetKeys(struct redisCommand
*cmd
,robj
**argv
, int argc
, int *numkeys
, int flags
) {
641 REDIS_NOTUSED(flags
);
643 num
= atoi(argv
[2]->ptr
);
644 /* Sanity check. Don't return any key if the command is going to
645 * reply with syntax error. */
646 if (num
> (argc
-3)) {
650 keys
= zmalloc(sizeof(int)*num
);
651 for (i
= 0; i
< num
; i
++) keys
[i
] = 3+i
;
656 /* Slot to Key API. This is used by Redis Cluster in order to obtain in
657 * a fast way a key that belongs to a specified hash slot. This is useful
658 * while rehashing the cluster. */
659 void SlotToKeyAdd(robj
*key
) {
660 unsigned int hashslot
= keyHashSlot(key
->ptr
,sdslen(key
->ptr
));
662 zslInsert(server
.cluster
.slots_to_keys
,hashslot
,key
);
666 void SlotToKeyDel(robj
*key
) {
667 unsigned int hashslot
= keyHashSlot(key
->ptr
,sdslen(key
->ptr
));
669 zslDelete(server
.cluster
.slots_to_keys
,hashslot
,key
);
672 unsigned int GetKeysInSlot(unsigned int hashslot
, robj
**keys
, unsigned int count
) {
677 range
.min
= range
.max
= hashslot
;
678 range
.minex
= range
.maxex
= 0;
680 n
= zslFirstInRange(server
.cluster
.slots_to_keys
, range
);
681 while(n
&& n
->score
== hashslot
&& count
--) {
683 n
= n
->level
[0].forward
;