Rename redisDb to serverDb (#156)
A task of #144. Signed-off-by: 0del <bany.y0599@gmail.com>
This commit is contained in:
parent
98892bb5c3
commit
717dfe8022
@ -2260,7 +2260,7 @@ int rewriteAppendOnlyFileRio(rio *aof) {
|
||||
|
||||
for (j = 0; j < server.dbnum; j++) {
|
||||
char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
|
||||
redisDb *db = server.db + j;
|
||||
serverDb *db = server.db + j;
|
||||
if (kvstoreSize(db->keys) == 0) continue;
|
||||
|
||||
/* SELECT the new DB */
|
||||
|
@ -453,7 +453,7 @@ static blocking_type getBlockedTypeByType(int type) {
|
||||
* made by a script or in the context of MULTI/EXEC.
|
||||
*
|
||||
* The list will be finally processed by handleClientsBlockedOnKeys() */
|
||||
static void signalKeyAsReadyLogic(redisDb *db, robj *key, int type, int deleted) {
|
||||
static void signalKeyAsReadyLogic(serverDb *db, robj *key, int type, int deleted) {
|
||||
readyList *rl;
|
||||
|
||||
/* Quick returns. */
|
||||
@ -548,11 +548,11 @@ static void releaseBlockedEntry(client *c, dictEntry *de, int remove_key) {
|
||||
dictDelete(c->bstate.keys, key);
|
||||
}
|
||||
|
||||
void signalKeyAsReady(redisDb *db, robj *key, int type) {
|
||||
void signalKeyAsReady(serverDb *db, robj *key, int type) {
|
||||
signalKeyAsReadyLogic(db, key, type, 0);
|
||||
}
|
||||
|
||||
void signalDeletedKeyAsReady(redisDb *db, robj *key, int type) {
|
||||
void signalDeletedKeyAsReady(serverDb *db, robj *key, int type) {
|
||||
signalKeyAsReadyLogic(db, key, type, 1);
|
||||
}
|
||||
|
||||
|
94
src/db.c
94
src/db.c
@ -52,9 +52,9 @@ typedef enum {
|
||||
KEY_DELETED /* The key was deleted now. */
|
||||
} keyStatus;
|
||||
|
||||
keyStatus expireIfNeeded(redisDb *db, robj *key, int flags);
|
||||
int keyIsExpired(redisDb *db, robj *key);
|
||||
static void dbSetValue(redisDb *db, robj *key, robj *val, int overwrite, dictEntry *de);
|
||||
keyStatus expireIfNeeded(serverDb *db, robj *key, int flags);
|
||||
int keyIsExpired(serverDb *db, robj *key);
|
||||
static void dbSetValue(serverDb *db, robj *key, robj *val, int overwrite, dictEntry *de);
|
||||
|
||||
/* Update LFU when an object is accessed.
|
||||
* Firstly, decrement the counter if the decrement time is reached.
|
||||
@ -92,7 +92,7 @@ void updateLFU(robj *val) {
|
||||
* Even if the key expiry is master-driven, we can correctly report a key is
|
||||
* expired on replicas even if the master is lagging expiring our key via DELs
|
||||
* in the replication link. */
|
||||
robj *lookupKey(redisDb *db, robj *key, int flags) {
|
||||
robj *lookupKey(serverDb *db, robj *key, int flags) {
|
||||
dictEntry *de = dbFind(db, key->ptr);
|
||||
robj *val = NULL;
|
||||
if (de) {
|
||||
@ -155,14 +155,14 @@ robj *lookupKey(redisDb *db, robj *key, int flags) {
|
||||
* This function is equivalent to lookupKey(). The point of using this function
|
||||
* rather than lookupKey() directly is to indicate that the purpose is to read
|
||||
* the key. */
|
||||
robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
|
||||
robj *lookupKeyReadWithFlags(serverDb *db, robj *key, int flags) {
|
||||
serverAssert(!(flags & LOOKUP_WRITE));
|
||||
return lookupKey(db, key, flags);
|
||||
}
|
||||
|
||||
/* Like lookupKeyReadWithFlags(), but does not use any flag, which is the
|
||||
* common case. */
|
||||
robj *lookupKeyRead(redisDb *db, robj *key) {
|
||||
robj *lookupKeyRead(serverDb *db, robj *key) {
|
||||
return lookupKeyReadWithFlags(db,key,LOOKUP_NONE);
|
||||
}
|
||||
|
||||
@ -172,11 +172,11 @@ robj *lookupKeyRead(redisDb *db, robj *key) {
|
||||
*
|
||||
* Returns the linked value object if the key exists or NULL if the key
|
||||
* does not exist in the specified DB. */
|
||||
robj *lookupKeyWriteWithFlags(redisDb *db, robj *key, int flags) {
|
||||
robj *lookupKeyWriteWithFlags(serverDb *db, robj *key, int flags) {
|
||||
return lookupKey(db, key, flags | LOOKUP_WRITE);
|
||||
}
|
||||
|
||||
robj *lookupKeyWrite(redisDb *db, robj *key) {
|
||||
robj *lookupKeyWrite(serverDb *db, robj *key) {
|
||||
return lookupKeyWriteWithFlags(db, key, LOOKUP_NONE);
|
||||
}
|
||||
|
||||
@ -197,7 +197,7 @@ robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply) {
|
||||
*
|
||||
* If the update_if_existing argument is false, the program is aborted
|
||||
* if the key already exists, otherwise, it can fall back to dbOverwrite. */
|
||||
static void dbAddInternal(redisDb *db, robj *key, robj *val, int update_if_existing) {
|
||||
static void dbAddInternal(serverDb *db, robj *key, robj *val, int update_if_existing) {
|
||||
dictEntry *existing;
|
||||
int slot = getKeySlot(key->ptr);
|
||||
dictEntry *de = kvstoreDictAddRaw(db->keys, slot, key->ptr, &existing);
|
||||
@ -213,7 +213,7 @@ static void dbAddInternal(redisDb *db, robj *key, robj *val, int update_if_exist
|
||||
notifyKeyspaceEvent(NOTIFY_NEW,"new",key,db->id);
|
||||
}
|
||||
|
||||
void dbAdd(redisDb *db, robj *key, robj *val) {
|
||||
void dbAdd(serverDb *db, robj *key, robj *val) {
|
||||
dbAddInternal(db, key, val, 0);
|
||||
}
|
||||
|
||||
@ -251,7 +251,7 @@ int getKeySlot(sds key) {
|
||||
* The function returns 1 if the key was added to the database, taking
|
||||
* ownership of the SDS string, otherwise 0 is returned, and is up to the
|
||||
* caller to free the SDS string. */
|
||||
int dbAddRDBLoad(redisDb *db, sds key, robj *val) {
|
||||
int dbAddRDBLoad(serverDb *db, sds key, robj *val) {
|
||||
int slot = getKeySlot(key);
|
||||
dictEntry *de = kvstoreDictAddRaw(db->keys, slot, key, NULL);
|
||||
if (de == NULL) return 0;
|
||||
@ -272,7 +272,7 @@ int dbAddRDBLoad(redisDb *db, sds key, robj *val) {
|
||||
* The dictEntry input is optional, can be used if we already have one.
|
||||
*
|
||||
* The program is aborted if the key was not already present. */
|
||||
static void dbSetValue(redisDb *db, robj *key, robj *val, int overwrite, dictEntry *de) {
|
||||
static void dbSetValue(serverDb *db, robj *key, robj *val, int overwrite, dictEntry *de) {
|
||||
int slot = getKeySlot(key->ptr);
|
||||
if (!de) de = kvstoreDictFind(db->keys, slot, key->ptr);
|
||||
serverAssertWithInfo(NULL,key,de != NULL);
|
||||
@ -304,7 +304,7 @@ static void dbSetValue(redisDb *db, robj *key, robj *val, int overwrite, dictEnt
|
||||
|
||||
/* Replace an existing key with a new value, we just replace value and don't
|
||||
* emit any events */
|
||||
void dbReplaceValue(redisDb *db, robj *key, robj *val) {
|
||||
void dbReplaceValue(serverDb *db, robj *key, robj *val) {
|
||||
dbSetValue(db, key, val, 0, NULL);
|
||||
}
|
||||
|
||||
@ -321,7 +321,7 @@ void dbReplaceValue(redisDb *db, robj *key, robj *val) {
|
||||
* All the new keys in the database should be created via this interface.
|
||||
* The client 'c' argument may be set to NULL if the operation is performed
|
||||
* in a context where there is no clear client performing the operation. */
|
||||
void setKey(client *c, redisDb *db, robj *key, robj *val, int flags) {
|
||||
void setKey(client *c, serverDb *db, robj *key, robj *val, int flags) {
|
||||
int keyfound = 0;
|
||||
|
||||
if (flags & SETKEY_ALREADY_EXIST)
|
||||
@ -347,7 +347,7 @@ void setKey(client *c, redisDb *db, robj *key, robj *val, int flags) {
|
||||
* If there are no keys, NULL is returned.
|
||||
*
|
||||
* The function makes sure to return keys not already expired. */
|
||||
robj *dbRandomKey(redisDb *db) {
|
||||
robj *dbRandomKey(serverDb *db) {
|
||||
dictEntry *de;
|
||||
int maxtries = 100;
|
||||
int allvolatile = kvstoreSize(db->keys) == kvstoreSize(db->expires);
|
||||
@ -383,7 +383,7 @@ robj *dbRandomKey(redisDb *db) {
|
||||
}
|
||||
|
||||
/* Helper for sync and async delete. */
|
||||
int dbGenericDelete(redisDb *db, robj *key, int async, int flags) {
|
||||
int dbGenericDelete(serverDb *db, robj *key, int async, int flags) {
|
||||
dictEntry **plink;
|
||||
int table;
|
||||
int slot = getKeySlot(key->ptr);
|
||||
@ -417,19 +417,19 @@ int dbGenericDelete(redisDb *db, robj *key, int async, int flags) {
|
||||
}
|
||||
|
||||
/* Delete a key, value, and associated expiration entry if any, from the DB */
|
||||
int dbSyncDelete(redisDb *db, robj *key) {
|
||||
int dbSyncDelete(serverDb *db, robj *key) {
|
||||
return dbGenericDelete(db, key, 0, DB_FLAG_KEY_DELETED);
|
||||
}
|
||||
|
||||
/* Delete a key, value, and associated expiration entry if any, from the DB. If
|
||||
* the value consists of many allocations, it may be freed asynchronously. */
|
||||
int dbAsyncDelete(redisDb *db, robj *key) {
|
||||
int dbAsyncDelete(serverDb *db, robj *key) {
|
||||
return dbGenericDelete(db, key, 1, DB_FLAG_KEY_DELETED);
|
||||
}
|
||||
|
||||
/* This is a wrapper whose behavior depends on the Redis lazy free
|
||||
* configuration. Deletes the key synchronously or asynchronously. */
|
||||
int dbDelete(redisDb *db, robj *key) {
|
||||
int dbDelete(serverDb *db, robj *key) {
|
||||
return dbGenericDelete(db, key, server.lazyfree_lazy_server_del, DB_FLAG_KEY_DELETED);
|
||||
}
|
||||
|
||||
@ -460,7 +460,7 @@ int dbDelete(redisDb *db, robj *key) {
|
||||
* At this point the caller is ready to modify the object, for example
|
||||
* using an sdscat() call to append some data, or anything else.
|
||||
*/
|
||||
robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
|
||||
robj *dbUnshareStringValue(serverDb *db, robj *key, robj *o) {
|
||||
serverAssert(o->type == OBJ_STRING);
|
||||
if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) {
|
||||
robj *decoded = getDecodedObject(o);
|
||||
@ -477,7 +477,7 @@ robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
|
||||
* The dbnum can be -1 if all the DBs should be emptied, or the specified
|
||||
* DB index if we want to empty only a single database.
|
||||
* The function returns the number of keys removed from the database(s). */
|
||||
long long emptyDbStructure(redisDb *dbarray, int dbnum, int async,
|
||||
long long emptyDbStructure(serverDb *dbarray, int dbnum, int async,
|
||||
void(callback)(dict*))
|
||||
{
|
||||
long long removed = 0;
|
||||
@ -562,14 +562,14 @@ long long emptyData(int dbnum, int flags, void(callback)(dict*)) {
|
||||
}
|
||||
|
||||
/* Initialize temporary db on replica for use during diskless replication. */
|
||||
redisDb *initTempDb(void) {
|
||||
serverDb *initTempDb(void) {
|
||||
int slot_count_bits = 0;
|
||||
int flags = KVSTORE_ALLOCATE_DICTS_ON_DEMAND;
|
||||
if (server.cluster_enabled) {
|
||||
slot_count_bits = CLUSTER_SLOT_MASK_BITS;
|
||||
flags |= KVSTORE_FREE_EMPTY_DICTS;
|
||||
}
|
||||
redisDb *tempDb = zcalloc(sizeof(redisDb)*server.dbnum);
|
||||
serverDb *tempDb = zcalloc(sizeof(serverDb)*server.dbnum);
|
||||
for (int i=0; i<server.dbnum; i++) {
|
||||
tempDb[i].id = i;
|
||||
tempDb[i].keys = kvstoreCreate(&dbDictType, slot_count_bits, flags);
|
||||
@ -580,7 +580,7 @@ redisDb *initTempDb(void) {
|
||||
}
|
||||
|
||||
/* Discard tempDb, this can be slow (similar to FLUSHALL), but it's always async. */
|
||||
void discardTempDb(redisDb *tempDb, void(callback)(dict*)) {
|
||||
void discardTempDb(serverDb *tempDb, void(callback)(dict*)) {
|
||||
int async = 1;
|
||||
|
||||
/* Release temp DBs. */
|
||||
@ -620,7 +620,7 @@ long long dbTotalServerKeyCount(void) {
|
||||
|
||||
/* Note that the 'c' argument may be NULL if the key was modified out of
|
||||
* a context of a client. */
|
||||
void signalModifiedKey(client *c, redisDb *db, robj *key) {
|
||||
void signalModifiedKey(client *c, serverDb *db, robj *key) {
|
||||
touchWatchedKey(db,key);
|
||||
trackingInvalidateKey(c,key,1);
|
||||
}
|
||||
@ -1348,7 +1348,7 @@ void renamenxCommand(client *c) {
|
||||
|
||||
void moveCommand(client *c) {
|
||||
robj *o;
|
||||
redisDb *src, *dst;
|
||||
serverDb *src, *dst;
|
||||
int srcid, dbid;
|
||||
long long expire;
|
||||
|
||||
@ -1410,7 +1410,7 @@ void moveCommand(client *c) {
|
||||
|
||||
void copyCommand(client *c) {
|
||||
robj *o;
|
||||
redisDb *src, *dst;
|
||||
serverDb *src, *dst;
|
||||
int srcid, dbid;
|
||||
long long expire;
|
||||
int j, replace = 0, delete = 0;
|
||||
@ -1514,7 +1514,7 @@ void copyCommand(client *c) {
|
||||
* one or more blocked clients for B[LR]POP or other blocking commands
|
||||
* and signal the keys as ready if they are of the right type. See the comment
|
||||
* where the function is used for more info. */
|
||||
void scanDatabaseForReadyKeys(redisDb *db) {
|
||||
void scanDatabaseForReadyKeys(serverDb *db) {
|
||||
dictEntry *de;
|
||||
dictIterator *di = dictGetSafeIterator(db->blocking_keys);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
@ -1531,7 +1531,7 @@ void scanDatabaseForReadyKeys(redisDb *db) {
|
||||
/* Since we are unblocking XREADGROUP clients in the event the
|
||||
* key was deleted/overwritten we must do the same in case the
|
||||
* database was flushed/swapped. */
|
||||
void scanDatabaseForDeletedKeys(redisDb *emptied, redisDb *replaced_with) {
|
||||
void scanDatabaseForDeletedKeys(serverDb *emptied, serverDb *replaced_with) {
|
||||
dictEntry *de;
|
||||
dictIterator *di = dictGetSafeIterator(emptied->blocking_keys);
|
||||
while((de = dictNext(di)) != NULL) {
|
||||
@ -1573,8 +1573,8 @@ int dbSwapDatabases(int id1, int id2) {
|
||||
if (id1 < 0 || id1 >= server.dbnum ||
|
||||
id2 < 0 || id2 >= server.dbnum) return C_ERR;
|
||||
if (id1 == id2) return C_OK;
|
||||
redisDb aux = server.db[id1];
|
||||
redisDb *db1 = &server.db[id1], *db2 = &server.db[id2];
|
||||
serverDb aux = server.db[id1];
|
||||
serverDb *db1 = &server.db[id1], *db2 = &server.db[id2];
|
||||
|
||||
/* Swapdb should make transaction fail if there is any
|
||||
* client watching keys */
|
||||
@ -1615,10 +1615,10 @@ int dbSwapDatabases(int id1, int id2) {
|
||||
/* Logically, this discards (flushes) the old main database, and apply the newly loaded
|
||||
* database (temp) as the main (active) database, the actual freeing of old database
|
||||
* (which will now be placed in the temp one) is done later. */
|
||||
void swapMainDbWithTempDb(redisDb *tempDb) {
|
||||
void swapMainDbWithTempDb(serverDb *tempDb) {
|
||||
for (int i=0; i<server.dbnum; i++) {
|
||||
redisDb aux = server.db[i];
|
||||
redisDb *activedb = &server.db[i], *newdb = &tempDb[i];
|
||||
serverDb aux = server.db[i];
|
||||
serverDb *activedb = &server.db[i], *newdb = &tempDb[i];
|
||||
|
||||
/* Swapping databases should make transaction fail if there is any
|
||||
* client watching keys. */
|
||||
@ -1691,7 +1691,7 @@ void swapdbCommand(client *c) {
|
||||
* Expires API
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
int removeExpire(redisDb *db, robj *key) {
|
||||
int removeExpire(serverDb *db, robj *key) {
|
||||
return kvstoreDictDelete(db->expires, getKeySlot(key->ptr), key->ptr) == DICT_OK;
|
||||
}
|
||||
|
||||
@ -1699,7 +1699,7 @@ int removeExpire(redisDb *db, robj *key) {
|
||||
* of an user calling a command 'c' is the client, otherwise 'c' is set
|
||||
* to NULL. The 'when' parameter is the absolute unix time in milliseconds
|
||||
* after which the key will no longer be considered valid. */
|
||||
void setExpire(client *c, redisDb *db, robj *key, long long when) {
|
||||
void setExpire(client *c, serverDb *db, robj *key, long long when) {
|
||||
dictEntry *kde, *de, *existing;
|
||||
|
||||
/* Reuse the sds from the main dict in the expire dict */
|
||||
@ -1720,7 +1720,7 @@ void setExpire(client *c, redisDb *db, robj *key, long long 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) {
|
||||
long long getExpire(serverDb *db, robj *key) {
|
||||
dictEntry *de;
|
||||
|
||||
if ((de = dbFindExpires(db, key->ptr)) == NULL)
|
||||
@ -1730,7 +1730,7 @@ long long getExpire(redisDb *db, robj *key) {
|
||||
}
|
||||
|
||||
/* Delete the specified expired key and propagate expire. */
|
||||
void deleteExpiredKeyAndPropagate(redisDb *db, robj *keyobj) {
|
||||
void deleteExpiredKeyAndPropagate(serverDb *db, robj *keyobj) {
|
||||
mstime_t expire_latency;
|
||||
latencyStartMonitor(expire_latency);
|
||||
dbGenericDelete(db,keyobj,server.lazyfree_lazy_expire,DB_FLAG_KEY_EXPIRED);
|
||||
@ -1761,7 +1761,7 @@ void deleteExpiredKeyAndPropagate(redisDb *db, robj *keyobj) {
|
||||
* postExecutionUnitOperations, preferably just after a
|
||||
* single deletion batch, so that DEL/UNLINK will NOT be wrapped
|
||||
* in MULTI/EXEC */
|
||||
void propagateDeletion(redisDb *db, robj *key, int lazy) {
|
||||
void propagateDeletion(serverDb *db, robj *key, int lazy) {
|
||||
robj *argv[2];
|
||||
|
||||
argv[0] = lazy ? shared.unlink : shared.del;
|
||||
@ -1781,7 +1781,7 @@ void propagateDeletion(redisDb *db, robj *key, int lazy) {
|
||||
}
|
||||
|
||||
/* Check if the key is expired. */
|
||||
int keyIsExpired(redisDb *db, robj *key) {
|
||||
int keyIsExpired(serverDb *db, robj *key) {
|
||||
/* Don't expire anything while loading. It will be done later. */
|
||||
if (server.loading) return 0;
|
||||
|
||||
@ -1827,7 +1827,7 @@ int keyIsExpired(redisDb *db, robj *key) {
|
||||
* The return value of the function is KEY_VALID if the key is still valid.
|
||||
* The function returns KEY_EXPIRED if the key is expired BUT not deleted,
|
||||
* or returns KEY_DELETED if the key is expired and deleted. */
|
||||
keyStatus expireIfNeeded(redisDb *db, robj *key, int flags) {
|
||||
keyStatus expireIfNeeded(serverDb *db, robj *key, int flags) {
|
||||
if (server.lazy_expire_disabled) return KEY_VALID;
|
||||
if (!keyIsExpired(db,key)) return KEY_VALID;
|
||||
|
||||
@ -1905,11 +1905,11 @@ static int dbExpandGeneric(kvstore *kvs, uint64_t db_size, int try_expand) {
|
||||
return ret? C_OK : C_ERR;
|
||||
}
|
||||
|
||||
int dbExpand(redisDb *db, uint64_t db_size, int try_expand) {
|
||||
int dbExpand(serverDb *db, uint64_t db_size, int try_expand) {
|
||||
return dbExpandGeneric(db->keys, db_size, try_expand);
|
||||
}
|
||||
|
||||
int dbExpandExpires(redisDb *db, uint64_t db_size, int try_expand) {
|
||||
int dbExpandExpires(serverDb *db, uint64_t db_size, int try_expand) {
|
||||
return dbExpandGeneric(db->expires, db_size, try_expand);
|
||||
}
|
||||
|
||||
@ -1917,19 +1917,19 @@ static dictEntry *dbFindGeneric(kvstore *kvs, void *key) {
|
||||
return kvstoreDictFind(kvs, getKeySlot(key), key);
|
||||
}
|
||||
|
||||
dictEntry *dbFind(redisDb *db, void *key) {
|
||||
dictEntry *dbFind(serverDb *db, void *key) {
|
||||
return dbFindGeneric(db->keys, key);
|
||||
}
|
||||
|
||||
dictEntry *dbFindExpires(redisDb *db, void *key) {
|
||||
dictEntry *dbFindExpires(serverDb *db, void *key) {
|
||||
return dbFindGeneric(db->expires, key);
|
||||
}
|
||||
|
||||
unsigned long long dbSize(redisDb *db) {
|
||||
unsigned long long dbSize(serverDb *db) {
|
||||
return kvstoreSize(db->keys);
|
||||
}
|
||||
|
||||
unsigned long long dbScan(redisDb *db, unsigned long long cursor, dictScanFunction *scan_cb, void *privdata) {
|
||||
unsigned long long dbScan(serverDb *db, unsigned long long cursor, dictScanFunction *scan_cb, void *privdata) {
|
||||
return kvstoreScan(db->keys, cursor, -1, scan_cb, NULL, privdata);
|
||||
}
|
||||
|
||||
|
@ -142,7 +142,7 @@ void mixStringObjectDigest(unsigned char *digest, robj *o) {
|
||||
* Note that this function does not reset the initial 'digest' passed, it
|
||||
* will continue mixing this object digest to anything that was already
|
||||
* present. */
|
||||
void xorObjectDigest(redisDb *db, robj *keyobj, unsigned char *digest, robj *o) {
|
||||
void xorObjectDigest(serverDb *db, robj *keyobj, unsigned char *digest, robj *o) {
|
||||
uint32_t aux = htonl(o->type);
|
||||
mixDigest(digest,&aux,sizeof(aux));
|
||||
long long expiretime = getExpire(db,keyobj);
|
||||
@ -288,7 +288,7 @@ void computeDatasetDigest(unsigned char *final) {
|
||||
memset(final,0,20); /* Start with a clean result */
|
||||
|
||||
for (j = 0; j < server.dbnum; j++) {
|
||||
redisDb *db = server.db+j;
|
||||
serverDb *db = server.db+j;
|
||||
if (kvstoreSize(db->keys) == 0)
|
||||
continue;
|
||||
kvstoreIterator *kvs_it = kvstoreIteratorInit(db->keys);
|
||||
|
20
src/defrag.c
20
src/defrag.c
@ -349,7 +349,7 @@ void activeDefragQuickListNodes(quicklist *ql) {
|
||||
/* when the value has lots of elements, we want to handle it later and not as
|
||||
* part of the main dictionary scan. this is needed in order to prevent latency
|
||||
* spikes when handling large items */
|
||||
void defragLater(redisDb *db, dictEntry *kde) {
|
||||
void defragLater(serverDb *db, dictEntry *kde) {
|
||||
sds key = sdsdup(dictGetKey(kde));
|
||||
listAddNodeTail(db->defrag_later, key);
|
||||
}
|
||||
@ -449,7 +449,7 @@ void scanLaterHash(robj *ob, unsigned long *cursor) {
|
||||
*cursor = dictScanDefrag(d, *cursor, scanCallbackCountScanned, &defragfns, NULL);
|
||||
}
|
||||
|
||||
void defragQuicklist(redisDb *db, dictEntry *kde) {
|
||||
void defragQuicklist(serverDb *db, dictEntry *kde) {
|
||||
robj *ob = dictGetVal(kde);
|
||||
quicklist *ql = ob->ptr, *newql;
|
||||
serverAssert(ob->type == OBJ_LIST && ob->encoding == OBJ_ENCODING_QUICKLIST);
|
||||
@ -461,7 +461,7 @@ void defragQuicklist(redisDb *db, dictEntry *kde) {
|
||||
activeDefragQuickListNodes(ql);
|
||||
}
|
||||
|
||||
void defragZsetSkiplist(redisDb *db, dictEntry *kde) {
|
||||
void defragZsetSkiplist(serverDb *db, dictEntry *kde) {
|
||||
robj *ob = dictGetVal(kde);
|
||||
zset *zs = (zset*)ob->ptr;
|
||||
zset *newzs;
|
||||
@ -490,7 +490,7 @@ void defragZsetSkiplist(redisDb *db, dictEntry *kde) {
|
||||
zs->dict = newdict;
|
||||
}
|
||||
|
||||
void defragHash(redisDb *db, dictEntry *kde) {
|
||||
void defragHash(serverDb *db, dictEntry *kde) {
|
||||
robj *ob = dictGetVal(kde);
|
||||
dict *d, *newd;
|
||||
serverAssert(ob->type == OBJ_HASH && ob->encoding == OBJ_ENCODING_HT);
|
||||
@ -504,7 +504,7 @@ void defragHash(redisDb *db, dictEntry *kde) {
|
||||
ob->ptr = newd;
|
||||
}
|
||||
|
||||
void defragSet(redisDb *db, dictEntry *kde) {
|
||||
void defragSet(serverDb *db, dictEntry *kde) {
|
||||
robj *ob = dictGetVal(kde);
|
||||
dict *d, *newd;
|
||||
serverAssert(ob->type == OBJ_SET && ob->encoding == OBJ_ENCODING_HT);
|
||||
@ -657,7 +657,7 @@ void* defragStreamConsumerGroup(raxIterator *ri, void *privdata) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void defragStream(redisDb *db, dictEntry *kde) {
|
||||
void defragStream(serverDb *db, dictEntry *kde) {
|
||||
robj *ob = dictGetVal(kde);
|
||||
serverAssert(ob->type == OBJ_STREAM && ob->encoding == OBJ_ENCODING_STREAM);
|
||||
stream *s = ob->ptr, *news;
|
||||
@ -681,7 +681,7 @@ void defragStream(redisDb *db, dictEntry *kde) {
|
||||
/* Defrag a module key. This is either done immediately or scheduled
|
||||
* for later. Returns then number of pointers defragged.
|
||||
*/
|
||||
void defragModule(redisDb *db, dictEntry *kde) {
|
||||
void defragModule(serverDb *db, dictEntry *kde) {
|
||||
robj *obj = dictGetVal(kde);
|
||||
serverAssert(obj->type == OBJ_MODULE);
|
||||
|
||||
@ -696,7 +696,7 @@ void defragKey(defragCtx *ctx, dictEntry *de) {
|
||||
robj *newob, *ob;
|
||||
unsigned char *newzl;
|
||||
sds newsds;
|
||||
redisDb *db = ctx->privdata;
|
||||
serverDb *db = ctx->privdata;
|
||||
int slot = ctx->slot;
|
||||
/* Try to defrag the key name. */
|
||||
newsds = activeDefragSds(keysds);
|
||||
@ -884,7 +884,7 @@ static sds defrag_later_current_key = NULL;
|
||||
static unsigned long defrag_later_cursor = 0;
|
||||
|
||||
/* returns 0 if no more work needs to be been done, and 1 if time is up and more work is needed. */
|
||||
int defragLaterStep(redisDb *db, int slot, long long endtime) {
|
||||
int defragLaterStep(serverDb *db, int slot, long long endtime) {
|
||||
unsigned int iterations = 0;
|
||||
unsigned long long prev_defragged = server.stat_active_defrag_hits;
|
||||
unsigned long long prev_scanned = server.stat_active_defrag_scanned;
|
||||
@ -993,7 +993,7 @@ void activeDefragCycle(void) {
|
||||
static int defrag_later_item_in_progress = 0;
|
||||
static int defrag_stage = 0;
|
||||
static unsigned long defrag_cursor = 0;
|
||||
static redisDb *db = NULL;
|
||||
static serverDb *db = NULL;
|
||||
static long long start_scan, start_stat;
|
||||
unsigned int iterations = 0;
|
||||
unsigned long long prev_defragged = server.stat_active_defrag_hits;
|
||||
|
@ -143,7 +143,7 @@ void evictionPoolAlloc(void) {
|
||||
* We insert keys on place in ascending order, so keys with the smaller
|
||||
* idle time are on the left, and keys with the higher idle time on the
|
||||
* right. */
|
||||
int evictionPoolPopulate(redisDb *db, kvstore *samplekvs, struct evictionPoolEntry *pool) {
|
||||
int evictionPoolPopulate(serverDb *db, kvstore *samplekvs, struct evictionPoolEntry *pool) {
|
||||
int j, k, count;
|
||||
dictEntry *samples[server.maxmemory_samples];
|
||||
|
||||
@ -579,7 +579,7 @@ int performEvictions(void) {
|
||||
static unsigned int next_db = 0;
|
||||
sds bestkey = NULL;
|
||||
int bestdbid;
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
dictEntry *de;
|
||||
|
||||
if (server.maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) ||
|
||||
|
10
src/expire.c
10
src/expire.c
@ -55,7 +55,7 @@ static double avg_ttl_factor[16] = {0.98, 0.9604, 0.941192, 0.922368, 0.903921,
|
||||
*
|
||||
* The parameter 'now' is the current time in milliseconds as is passed
|
||||
* to the function to avoid too many gettimeofday() syscalls. */
|
||||
int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
|
||||
int activeExpireCycleTryExpire(serverDb *db, dictEntry *de, long long now) {
|
||||
long long t = dictGetSignedIntegerVal(de);
|
||||
if (now > t) {
|
||||
enterExecutionUnit(1, 0);
|
||||
@ -118,7 +118,7 @@ int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
|
||||
|
||||
/* Data used by the expire dict scan callback. */
|
||||
typedef struct {
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
long long now;
|
||||
unsigned long sampled; /* num keys checked */
|
||||
unsigned long expired; /* num keys expired */
|
||||
@ -242,7 +242,7 @@ void activeExpireCycle(int type) {
|
||||
data.ttl_sum = 0;
|
||||
data.ttl_samples = 0;
|
||||
|
||||
redisDb *db = server.db+(current_db % server.dbnum);
|
||||
serverDb *db = server.db+(current_db % server.dbnum);
|
||||
data.db = db;
|
||||
|
||||
int db_done = 0; /* The scan of the current DB is done? */
|
||||
@ -429,7 +429,7 @@ void expireSlaveKeys(void) {
|
||||
int dbid = 0;
|
||||
while(dbids && dbid < server.dbnum) {
|
||||
if ((dbids & 1) != 0) {
|
||||
redisDb *db = server.db+dbid;
|
||||
serverDb *db = server.db+dbid;
|
||||
dictEntry *expire = dbFindExpires(db, keyname);
|
||||
int expired = 0;
|
||||
|
||||
@ -474,7 +474,7 @@ void expireSlaveKeys(void) {
|
||||
|
||||
/* Track keys that received an EXPIRE or similar command in the context
|
||||
* of a writable slave. */
|
||||
void rememberSlaveKeyWithExpire(redisDb *db, robj *key) {
|
||||
void rememberSlaveKeyWithExpire(serverDb *db, robj *key) {
|
||||
if (slaveKeysWithExpire == NULL) {
|
||||
static dictType dt = {
|
||||
dictSdsHash, /* hash function */
|
||||
|
@ -185,7 +185,7 @@ void freeObjAsync(robj *key, robj *obj, int dbid) {
|
||||
/* Empty a Redis DB asynchronously. What the function does actually is to
|
||||
* create a new empty set of hash tables and scheduling the old ones for
|
||||
* lazy freeing. */
|
||||
void emptyDbAsync(redisDb *db) {
|
||||
void emptyDbAsync(serverDb *db) {
|
||||
int slot_count_bits = 0;
|
||||
int flags = KVSTORE_ALLOCATE_DICTS_ON_DEMAND;
|
||||
if (server.cluster_enabled) {
|
||||
|
@ -189,7 +189,7 @@ typedef struct RedisModuleCtx RedisModuleCtx;
|
||||
/* This represents a Redis key opened with RM_OpenKey(). */
|
||||
struct RedisModuleKey {
|
||||
RedisModuleCtx *ctx;
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
robj *key; /* Key name object. */
|
||||
robj *value; /* Value object, or NULL if the key was not found. */
|
||||
void *iter; /* Iterator. */
|
||||
|
@ -274,7 +274,7 @@ void execCommand(client *c) {
|
||||
typedef struct watchedKey {
|
||||
listNode node;
|
||||
robj *key;
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
client *client;
|
||||
unsigned expired:1; /* Flag that we're watching an already expired key. */
|
||||
} watchedKey;
|
||||
@ -377,7 +377,7 @@ int isWatchedKeyExpired(client *c) {
|
||||
|
||||
/* "Touch" a key, so that if this key is being WATCHed by some client the
|
||||
* next EXEC will fail. */
|
||||
void touchWatchedKey(redisDb *db, robj *key) {
|
||||
void touchWatchedKey(serverDb *db, robj *key) {
|
||||
list *clients;
|
||||
listIter li;
|
||||
listNode *ln;
|
||||
@ -425,7 +425,7 @@ void touchWatchedKey(redisDb *db, robj *key) {
|
||||
* replaced_with: for SWAPDB, the WATCH should be invalidated if
|
||||
* the key exists in either of them, and skipped only if it
|
||||
* doesn't exist in both. */
|
||||
void touchAllWatchedKeysInDb(redisDb *emptied, redisDb *replaced_with) {
|
||||
void touchAllWatchedKeysInDb(serverDb *emptied, serverDb *replaced_with) {
|
||||
listIter li;
|
||||
listNode *ln;
|
||||
dictEntry *de;
|
||||
|
@ -1245,7 +1245,7 @@ struct serverMemOverhead *getMemoryOverheadData(void) {
|
||||
mem_total+=mh->functions_caches;
|
||||
|
||||
for (j = 0; j < server.dbnum; j++) {
|
||||
redisDb *db = server.db+j;
|
||||
serverDb *db = server.db+j;
|
||||
if (!kvstoreNumAllocatedDicts(db->keys)) continue;
|
||||
|
||||
unsigned long long keyscount = kvstoreSize(db->keys);
|
||||
|
@ -1305,7 +1305,7 @@ ssize_t rdbSaveDb(rio *rdb, int dbid, int rdbflags, long *key_counter) {
|
||||
static long long info_updated_time = 0;
|
||||
char *pname = (rdbflags & RDBFLAGS_AOF_PREAMBLE) ? "AOF rewrite" : "RDB";
|
||||
|
||||
redisDb *db = server.db + dbid;
|
||||
serverDb *db = server.db + dbid;
|
||||
unsigned long long int db_size = kvstoreSize(db->keys);
|
||||
if (db_size == 0) return 0;
|
||||
|
||||
@ -3033,7 +3033,7 @@ int rdbLoadRioWithLoadingCtx(rio *rdb, int rdbflags, rdbSaveInfo *rsi, rdbLoadin
|
||||
int type, rdbver;
|
||||
uint64_t db_size = 0, expires_size = 0;
|
||||
int should_expand_db = 0;
|
||||
redisDb *db = rdb_loading_ctx->dbarray+0;
|
||||
serverDb *db = rdb_loading_ctx->dbarray+0;
|
||||
char buf[1024];
|
||||
int error;
|
||||
long long empty_keys_skipped = 0;
|
||||
|
@ -1840,13 +1840,13 @@ static int useDisklessLoad(void) {
|
||||
/* Helper function for readSyncBulkPayload() to initialize tempDb
|
||||
* before socket-loading the new db from master. The tempDb may be populated
|
||||
* by swapMainDbWithTempDb or freed by disklessLoadDiscardTempDb later. */
|
||||
redisDb *disklessLoadInitTempDb(void) {
|
||||
serverDb *disklessLoadInitTempDb(void) {
|
||||
return initTempDb();
|
||||
}
|
||||
|
||||
/* Helper function for readSyncBulkPayload() to discard our tempDb
|
||||
* when the loading succeeded or failed. */
|
||||
void disklessLoadDiscardTempDb(redisDb *tempDb) {
|
||||
void disklessLoadDiscardTempDb(serverDb *tempDb) {
|
||||
discardTempDb(tempDb, replicationEmptyDbCallback);
|
||||
}
|
||||
|
||||
@ -1870,7 +1870,7 @@ void readSyncBulkPayload(connection *conn) {
|
||||
char buf[PROTO_IOBUF_LEN];
|
||||
ssize_t nread, readlen, nwritten;
|
||||
int use_diskless_load = useDisklessLoad();
|
||||
redisDb *diskless_load_tempDb = NULL;
|
||||
serverDb *diskless_load_tempDb = NULL;
|
||||
functionsLibCtx* temp_functions_lib_ctx = NULL;
|
||||
int empty_db_flags = server.repl_slave_lazy_flush ? EMPTYDB_ASYNC :
|
||||
EMPTYDB_NO_FLAGS;
|
||||
@ -2088,7 +2088,7 @@ void readSyncBulkPayload(connection *conn) {
|
||||
rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
|
||||
if (use_diskless_load) {
|
||||
rio rdb;
|
||||
redisDb *dbarray;
|
||||
serverDb *dbarray;
|
||||
functionsLibCtx* functions_lib_ctx;
|
||||
int asyncLoading = 0;
|
||||
|
||||
|
@ -1082,7 +1082,7 @@ void databasesCron(void) {
|
||||
if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;
|
||||
|
||||
for (j = 0; j < dbs_per_call; j++) {
|
||||
redisDb *db = &server.db[resize_db % server.dbnum];
|
||||
serverDb *db = &server.db[resize_db % server.dbnum];
|
||||
kvstoreTryResizeDicts(db->keys, CRON_DICTS_PER_DB);
|
||||
kvstoreTryResizeDicts(db->expires, CRON_DICTS_PER_DB);
|
||||
resize_db++;
|
||||
@ -1092,7 +1092,7 @@ void databasesCron(void) {
|
||||
if (server.activerehashing) {
|
||||
uint64_t elapsed_us = 0;
|
||||
for (j = 0; j < dbs_per_call; j++) {
|
||||
redisDb *db = &server.db[rehash_db % server.dbnum];
|
||||
serverDb *db = &server.db[rehash_db % server.dbnum];
|
||||
elapsed_us += kvstoreIncrementallyRehash(db->keys, INCREMENTAL_REHASHING_THRESHOLD_US - elapsed_us);
|
||||
if (elapsed_us >= INCREMENTAL_REHASHING_THRESHOLD_US)
|
||||
break;
|
||||
@ -2655,7 +2655,7 @@ void initServer(void) {
|
||||
strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
server.db = zmalloc(sizeof(redisDb)*server.dbnum);
|
||||
server.db = zmalloc(sizeof(server)*server.dbnum);
|
||||
|
||||
/* Create the Redis databases, and initialize other internal state. */
|
||||
int slot_count_bits = 0;
|
||||
|
88
src/server.h
88
src/server.h
@ -974,7 +974,7 @@ typedef struct replBufBlock {
|
||||
/* Redis database representation. There are multiple databases identified
|
||||
* by integers from 0 (the default database) up to the max configured
|
||||
* database. The database number is the 'id' field in the structure. */
|
||||
typedef struct redisDb {
|
||||
typedef struct serverDb {
|
||||
kvstore *keys; /* The keyspace for this DB */
|
||||
kvstore *expires; /* Timeout of keys with a timeout set */
|
||||
dict *blocking_keys; /* Keys with clients waiting for data (BLPOP)*/
|
||||
@ -987,7 +987,7 @@ typedef struct redisDb {
|
||||
long long avg_ttl; /* Average TTL, just for stats */
|
||||
unsigned long expires_cursor; /* Cursor of the active expire cycle. */
|
||||
list *defrag_later; /* List of key names to attempt to defrag one by one, gradually. */
|
||||
} redisDb;
|
||||
} serverDb;
|
||||
|
||||
/* forward declaration for functions ctx */
|
||||
typedef struct functionsLibCtx functionsLibCtx;
|
||||
@ -998,7 +998,7 @@ typedef struct functionsLibCtx functionsLibCtx;
|
||||
* For example: dbarray need to be set as main database on
|
||||
* successful loading and dropped on failure. */
|
||||
typedef struct rdbLoadingCtx {
|
||||
redisDb* dbarray;
|
||||
serverDb* dbarray;
|
||||
functionsLibCtx* functions_lib_ctx;
|
||||
}rdbLoadingCtx;
|
||||
|
||||
@ -1062,7 +1062,7 @@ typedef struct blockingState {
|
||||
* where we make sure to remember if a given key was already added in the
|
||||
* server.ready_keys list. */
|
||||
typedef struct readyList {
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
robj *key;
|
||||
} readyList;
|
||||
|
||||
@ -1164,7 +1164,7 @@ typedef struct client {
|
||||
uint64_t flags; /* Client flags: CLIENT_* macros. */
|
||||
connection *conn;
|
||||
int resp; /* RESP protocol version. Can be 2 or 3. */
|
||||
redisDb *db; /* Pointer to currently SELECTed DB. */
|
||||
serverDb *db; /* Pointer to currently SELECTed DB. */
|
||||
robj *name; /* As set by CLIENT SETNAME. */
|
||||
robj *lib_name; /* The client library name as set by CLIENT SETINFO. */
|
||||
robj *lib_ver; /* The client library version as set by CLIENT SETINFO. */
|
||||
@ -1558,7 +1558,7 @@ struct redisServer {
|
||||
mode_t umask; /* The umask value of the process on startup */
|
||||
int hz; /* serverCron() calls frequency in hertz */
|
||||
int in_fork_child; /* indication that this is a fork child */
|
||||
redisDb *db;
|
||||
serverDb *db;
|
||||
dict *commands; /* Command table */
|
||||
dict *orig_commands; /* Command table before command renaming. */
|
||||
aeEventLoop *el;
|
||||
@ -2745,9 +2745,9 @@ void initClientMultiState(client *c);
|
||||
void freeClientMultiState(client *c);
|
||||
void queueMultiCommand(client *c, uint64_t cmd_flags);
|
||||
size_t multiStateMemOverhead(client *c);
|
||||
void touchWatchedKey(redisDb *db, robj *key);
|
||||
void touchWatchedKey(serverDb *db, robj *key);
|
||||
int isWatchedKeyExpired(client *c);
|
||||
void touchAllWatchedKeysInDb(redisDb *emptied, redisDb *replaced_with);
|
||||
void touchAllWatchedKeysInDb(serverDb *emptied, serverDb *replaced_with);
|
||||
void discardTransaction(client *c);
|
||||
void flagTransaction(client *c);
|
||||
void execCommandAbort(client *c, sds error);
|
||||
@ -3123,12 +3123,12 @@ int getKeySlot(sds key);
|
||||
int calculateKeySlot(sds key);
|
||||
|
||||
/* kvstore wrappers */
|
||||
int dbExpand(redisDb *db, uint64_t db_size, int try_expand);
|
||||
int dbExpandExpires(redisDb *db, uint64_t db_size, int try_expand);
|
||||
dictEntry *dbFind(redisDb *db, void *key);
|
||||
dictEntry *dbFindExpires(redisDb *db, void *key);
|
||||
unsigned long long dbSize(redisDb *db);
|
||||
unsigned long long dbScan(redisDb *db, unsigned long long cursor, dictScanFunction *scan_cb, void *privdata);
|
||||
int dbExpand(serverDb *db, uint64_t db_size, int try_expand);
|
||||
int dbExpandExpires(serverDb *db, uint64_t db_size, int try_expand);
|
||||
dictEntry *dbFind(serverDb *db, void *key);
|
||||
dictEntry *dbFindExpires(serverDb *db, void *key);
|
||||
unsigned long long dbSize(serverDb *db);
|
||||
unsigned long long dbScan(serverDb *db, unsigned long long cursor, dictScanFunction *scan_cb, void *privdata);
|
||||
|
||||
/* Set data type */
|
||||
robj *setTypeCreate(sds value, size_t size_hint);
|
||||
@ -3267,19 +3267,19 @@ long long getModuleNumericConfig(ModuleConfig *module_config);
|
||||
int setModuleNumericConfig(ModuleConfig *config, long long val, const char **err);
|
||||
|
||||
/* db.c -- Keyspace access API */
|
||||
int removeExpire(redisDb *db, robj *key);
|
||||
void deleteExpiredKeyAndPropagate(redisDb *db, robj *keyobj);
|
||||
void propagateDeletion(redisDb *db, robj *key, int lazy);
|
||||
int keyIsExpired(redisDb *db, robj *key);
|
||||
long long getExpire(redisDb *db, robj *key);
|
||||
void setExpire(client *c, redisDb *db, robj *key, long long when);
|
||||
int removeExpire(serverDb *db, robj *key);
|
||||
void deleteExpiredKeyAndPropagate(serverDb *db, robj *keyobj);
|
||||
void propagateDeletion(serverDb *db, robj *key, int lazy);
|
||||
int keyIsExpired(serverDb *db, robj *key);
|
||||
long long getExpire(serverDb *db, robj *key);
|
||||
void setExpire(client *c, serverDb *db, robj *key, long long when);
|
||||
int checkAlreadyExpired(long long when);
|
||||
robj *lookupKeyRead(redisDb *db, robj *key);
|
||||
robj *lookupKeyWrite(redisDb *db, robj *key);
|
||||
robj *lookupKeyRead(serverDb *db, robj *key);
|
||||
robj *lookupKeyWrite(serverDb *db, robj *key);
|
||||
robj *lookupKeyReadOrReply(client *c, robj *key, robj *reply);
|
||||
robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply);
|
||||
robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags);
|
||||
robj *lookupKeyWriteWithFlags(redisDb *db, robj *key, int flags);
|
||||
robj *lookupKeyReadWithFlags(serverDb *db, robj *key, int flags);
|
||||
robj *lookupKeyWriteWithFlags(serverDb *db, robj *key, int flags);
|
||||
robj *objectCommandLookup(client *c, robj *key);
|
||||
robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply);
|
||||
int objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
|
||||
@ -3292,40 +3292,40 @@ int objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
|
||||
#define LOOKUP_NOEXPIRE (1<<4) /* Avoid deleting lazy expired keys. */
|
||||
#define LOOKUP_NOEFFECTS (LOOKUP_NONOTIFY | LOOKUP_NOSTATS | LOOKUP_NOTOUCH | LOOKUP_NOEXPIRE) /* Avoid any effects from fetching the key */
|
||||
|
||||
void dbAdd(redisDb *db, robj *key, robj *val);
|
||||
int dbAddRDBLoad(redisDb *db, sds key, robj *val);
|
||||
void dbReplaceValue(redisDb *db, robj *key, robj *val);
|
||||
void dbAdd(serverDb *db, robj *key, robj *val);
|
||||
int dbAddRDBLoad(serverDb *db, sds key, robj *val);
|
||||
void dbReplaceValue(serverDb *db, robj *key, robj *val);
|
||||
|
||||
#define SETKEY_KEEPTTL 1
|
||||
#define SETKEY_NO_SIGNAL 2
|
||||
#define SETKEY_ALREADY_EXIST 4
|
||||
#define SETKEY_DOESNT_EXIST 8
|
||||
#define SETKEY_ADD_OR_UPDATE 16 /* Key most likely doesn't exists */
|
||||
void setKey(client *c, redisDb *db, robj *key, robj *val, int flags);
|
||||
robj *dbRandomKey(redisDb *db);
|
||||
int dbGenericDelete(redisDb *db, robj *key, int async, int flags);
|
||||
int dbSyncDelete(redisDb *db, robj *key);
|
||||
int dbDelete(redisDb *db, robj *key);
|
||||
robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o);
|
||||
void setKey(client *c, serverDb *db, robj *key, robj *val, int flags);
|
||||
robj *dbRandomKey(serverDb *db);
|
||||
int dbGenericDelete(serverDb *db, robj *key, int async, int flags);
|
||||
int dbSyncDelete(serverDb *db, robj *key);
|
||||
int dbDelete(serverDb *db, robj *key);
|
||||
robj *dbUnshareStringValue(serverDb *db, robj *key, robj *o);
|
||||
|
||||
#define EMPTYDB_NO_FLAGS 0 /* No flags. */
|
||||
#define EMPTYDB_ASYNC (1<<0) /* Reclaim memory in another thread. */
|
||||
#define EMPTYDB_NOFUNCTIONS (1<<1) /* Indicate not to flush the functions. */
|
||||
long long emptyData(int dbnum, int flags, void(callback)(dict*));
|
||||
long long emptyDbStructure(redisDb *dbarray, int dbnum, int async, void(callback)(dict*));
|
||||
long long emptyDbStructure(serverDb *dbarray, int dbnum, int async, void(callback)(dict*));
|
||||
void flushAllDataAndResetRDB(int flags);
|
||||
long long dbTotalServerKeyCount(void);
|
||||
redisDb *initTempDb(void);
|
||||
void discardTempDb(redisDb *tempDb, void(callback)(dict*));
|
||||
serverDb *initTempDb(void);
|
||||
void discardTempDb(serverDb *tempDb, void(callback)(dict*));
|
||||
|
||||
|
||||
int selectDb(client *c, int id);
|
||||
void signalModifiedKey(client *c, redisDb *db, robj *key);
|
||||
void signalModifiedKey(client *c, serverDb *db, robj *key);
|
||||
void signalFlushedDb(int dbid, int async);
|
||||
void scanGenericCommand(client *c, robj *o, unsigned long long cursor);
|
||||
int parseScanCursorOrReply(client *c, robj *o, unsigned long long *cursor);
|
||||
int dbAsyncDelete(redisDb *db, robj *key);
|
||||
void emptyDbAsync(redisDb *db);
|
||||
int dbAsyncDelete(serverDb *db, robj *key);
|
||||
void emptyDbAsync(serverDb *db);
|
||||
size_t lazyfreeGetPendingObjectsCount(void);
|
||||
size_t lazyfreeGetFreedObjectsCount(void);
|
||||
void lazyfreeResetStats(void);
|
||||
@ -3423,15 +3423,15 @@ void replyToBlockedClientTimedOut(client *c);
|
||||
int getTimeoutFromObjectOrReply(client *c, robj *object, mstime_t *timeout, int unit);
|
||||
void disconnectAllBlockedClients(void);
|
||||
void handleClientsBlockedOnKeys(void);
|
||||
void signalKeyAsReady(redisDb *db, robj *key, int type);
|
||||
void signalKeyAsReady(serverDb *db, robj *key, int type);
|
||||
void blockForKeys(client *c, int btype, robj **keys, int numkeys, mstime_t timeout, int unblock_on_nokey);
|
||||
void blockClientShutdown(client *c);
|
||||
void blockPostponeClient(client *c);
|
||||
void blockForReplication(client *c, mstime_t timeout, long long offset, long numreplicas);
|
||||
void blockForAofFsync(client *c, mstime_t timeout, long long offset, int numlocal, long numreplicas);
|
||||
void signalDeletedKeyAsReady(redisDb *db, robj *key, int type);
|
||||
void signalDeletedKeyAsReady(serverDb *db, robj *key, int type);
|
||||
void updateStatsOnUnblock(client *c, long blocked_us, long reply_us, int had_errors);
|
||||
void scanDatabaseForDeletedKeys(redisDb *emptied, redisDb *replaced_with);
|
||||
void scanDatabaseForDeletedKeys(serverDb *emptied, serverDb *replaced_with);
|
||||
void totalNumberOfStatefulKeys(unsigned long *blocking_keys, unsigned long *blocking_keys_on_nokey, unsigned long *watched_keys);
|
||||
void blockedBeforeSleep(void);
|
||||
|
||||
@ -3444,7 +3444,7 @@ int clientsCronHandleTimeout(client *c, mstime_t now_ms);
|
||||
/* expire.c -- Handling of expired keys */
|
||||
void activeExpireCycle(int type);
|
||||
void expireSlaveKeys(void);
|
||||
void rememberSlaveKeyWithExpire(redisDb *db, robj *key);
|
||||
void rememberSlaveKeyWithExpire(serverDb *db, robj *key);
|
||||
void flushSlaveKeysWithExpireList(void);
|
||||
size_t getSlaveKeyWithExpireCount(void);
|
||||
|
||||
@ -3771,7 +3771,7 @@ void debugDelay(int usec);
|
||||
void killIOThreads(void);
|
||||
void killThreads(void);
|
||||
void makeThreadKillable(void);
|
||||
void swapMainDbWithTempDb(redisDb *tempDb);
|
||||
void swapMainDbWithTempDb(serverDb *tempDb);
|
||||
sds getVersion(void);
|
||||
|
||||
/* Use macro for checking log level to avoid evaluating arguments in cases log
|
||||
|
@ -59,7 +59,7 @@ redisSortOperation *createSortOperation(int type, robj *pattern) {
|
||||
*
|
||||
* The returned object will always have its refcount increased by 1
|
||||
* when it is non-NULL. */
|
||||
robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {
|
||||
robj *lookupKeyByPattern(serverDb *db, robj *pattern, robj *subst) {
|
||||
char *p, *f, *k;
|
||||
sds spat, ssub;
|
||||
robj *keyobj, *fieldobj = NULL, *o;
|
||||
|
Loading…
x
Reference in New Issue
Block a user