渐进式解析 Redis 源码 - 数据库 db

阅读量

前面几篇介绍了 各种数据类型以及其底层实现， 从这篇开始我们就要介绍 Redis 的高级功能部分，虽然会比较抽象，但是通过 CGDB 调试辅助，还是可以顺利理解

Redis 数据库为 各种数据类型（字符串、列表、集合、有序集合、哈希 类型）的 存储载体，当然 Redis db 也并不仅仅是 存储功能，这次 我们就对其 进行详细解说 ……

数据库结构

Redis 数据库 的数据结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct redisDb {
    // 数据库 键值对字典指针
    dict *dict;
    // 数据库 键值对过期时间数据
    dict *expires;
    // 阻塞的键以及客户端信息
    dict *blocking_keys;
    // 阻塞后准备好的键信息，用于 解除阻塞
    dict *ready_keys;
    // watch 的键和客户端信息
    dict *watched_keys;
    // 数据库 id
    int id;
    // 平均生存时间
    long long avg_ttl;
} redisDb;

  • *dict 存储 键值对字典地址，为 字典结构 ，存储了所有键值对数据，键为 Redis 数据的 key，值 为 各种数据类型的对象（字符串对象、列表对象、集合对象、有序集合对象、哈希对象），具体 字典 dict 结构 的详解请查看之前的 篇章 字典
  • *expires 存储 过期时间数据，也为 字典结构
  • *blocking_keys 存储 阻塞键 以及客户端信息，比如 list 类型 的 阻塞命令
  • *ready_keys 存储阻塞键 就绪数据信息，对应上面 blocking_keys 数据，用于解除阻塞
  • *watched_keys watch 键 的信息，后续 事务中会提到

服务器在启动的时候会根据 server.dbnum（默认 16） 初始化对应个数的数据库，成功后存储在 redisServer 信息中

1
2
3
4
5
6
7
8
9
struct redisServer {
    // ......
    // 数据库的指针数组
    redisDb *db;
    // ......
    // 数据库个数
    int dbnum;
    // ......
};

客户端 client 在执行 select 切换数据库命令的时候，会将当前客户端执行的目标数据库存储在 client 下的 db 字段中

1
2
3
4
5
typedef struct client {
    // ......
    redisDb *db;
    // ......
} client;

假设有 列表类型 foo1、哈希类型 foo2、字符串类型 foo3，其中 foo1 和 foo3 设置了过期时间；数据库数据存储 图例结构如下：
redis db

所以说 对 数据库的操作 更多是 字典的操作…

过期删除策略

我们上面内容也提到了，数据库中会 特地保存过期数据，那么肯定也有一些策略 专门对 过期数据进行清除

定时删除

【主动策略】在设置键的过期时间的同时，创建一个定时器，让定时器在键的过期时间来临的时候立即执行删除操作

定时删除策略对内存是最友好的，可以保证过期键会尽快被删除，释放占用的多余内存；但是它对 CPU 是最不友好的，在过期键比较多的时候，删除行为会占用相当一部分 CPU 时间，在 内存不紧张 但是 CPU 时间比较紧张的时候，将 CPU 时间用在 删除和当前任务无关的过期键上，无疑会对服务器的响应时间和吞吐量造成影响

而且定时器在 Redis 一般是一个 无序的时间事件链表，所以查找时间的复杂度为 O(n)，所以特别高效的处理大量时间事件并不现实

惰性删除

【被动策略】放任键过期不管，但是每次从键空间获取键的时候，都检查该键是否过期，如果过期就删除，不过期就该干嘛干嘛

惰性删除策略对CPU时间是最友好的，只会在操作键的时候才进行过期检查，可以保证删除过期键的操作只会在非做不可的情况下进行，这样就不会影响其他 业务资源；但是 这个策略对内存却是非常不友好的，因为很有可能有一些键永远都不会被删除，这种情况对于非常依赖内存的内存数据库来说，肯定不是个好事

定期删除

【主动策略】每隔一段时间，程序就会对数据库进行一次检查，删除里面的过期键，至于要删除多少键、检查多少个数据库，又有详细算法

定期删除策略为 上述两种策略的整合和折中，毕竟之前的两种策略在单一使用时都会有明显的缺陷；定期删除策略每隔一段时间执行一次删除过期操作，并通过限制删除操作执行的时间和频率来减少删除操作对 CPU 时间的影响

不过定期删除策略的难点在于确认删除操作执行的时长以及频率

  • 如果删除操作执行的时间太频繁或者执行时间过长，定期删除策略就退化成了定时删除策略，那么 CPU 时间就惨了
  • 如果删除操作执行太少或者执行时间太短，那么又可能退化成惰性删除策略，可能浪费内存

所以针对不同场景，Redis 服务器可以合理的设置 删除操作 的执行 时长和频率

下面我们就 Redis 数据库 一些典型的 API 进行解析~~~

源码解析

由于有些方法里的代码量比较大，我们这里按照 典型的代码片段进行解析，同志们可以根据文章提示的代码位置 和 代码里面的关键词 在源码中搜素，可能数据结构一些元素 看不太懂什么意思，没关系，先混个脸熟，后面看完回头再看过来就明白了

切换数据库

切换数据库命令 select，处理函数为 selectDb()

1
2
3
4
5
6
7
8
9
10
11
/* db.c: line 362 */
int selectDb(client *c, int id) {
    // 判定传递的 id 是否符合 数据库序列 条件
    if (id < 0 || id >= server.dbnum)
        return C_ERR;
    // 设置 客户端 当前操作 db 为 对应序列的 db数组里的数据库
    c->db = &server.db[id];
    // 返回 OK
    return C_OK;
}

数据库添加键值对

添加键值对的 底层操作函数为 dbAdd()，如果注意的话，这个函数在之前的一些源码中都出现过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* db.c: line 167 */
void dbAdd(redisDb *db, robj *key, robj *val) {
    // 复制键对象
    sds copy = sdsdup(key->ptr);
    // 将键值对写入数据库字典
    int retval = dictAdd(db->dict, copy, val);
    // 判断写入结果
    serverAssertWithInfo(NULL,key,retval == DICT_OK);
    // 如果数据类型为 列表类型，执行一些事件炒作，毕竟 list 可能有一些 阻塞操作
    if (val->type == OBJ_LIST) signalListAsReady(db, key);
    // 如果为集群状态，则需要将数据添加到 对应集群 节点
    if (server.cluster_enabled) slotToKeyAdd(key);
 }

数据库删除键值对

删除键值对 底层操作函数为 dbDelete()，删除 字典数据的同时，还需要 去除过期数据；

不过删除并不是简单的 一刀切，Redis 作为一个对效率要求极其苛刻的工具，肯定不会忍受因为 删除大 key 或者 过期淘汰大 key 而引起的阻塞，所以 从 4.0 开始，提供了 lazyfree 机制，可以将一些比较耗费的操作 经过鉴别抛入后台，让后台线程进行处理

所以删除操作其实是 分为了两种情况

1
2
3
4
5
6
/* db.c: line 275 */
int dbDelete(redisDb *db, robj *key) {
    // 如果设置了 lazyfree 内存淘汰机制的 内部删除选项，则 异步删除，否则 同步删除，默认 同步
    return server.lazyfree_lazy_server_del ? dbAsyncDelete(db,key) : dbSyncDelete(db,key);
}

异步删除 dbAsyncDelete()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* lazyfree.c: line 53 */
#define LAZYFREE_THRESHOLD 64
int dbAsyncDelete(redisDb *db, robj *key) {
    // 从 数据库的过期时间字典里面删除 key
    if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);
    // 先解除数据库字典里面的 key，保证 前端访问 的数据纯净
    dictEntry *de = dictUnlink(db->dict,key->ptr);
    if (de) {
        // 获取值
        robj *val = dictGetVal(de);
        // 并不是所有 key 都使用 lazyfree 释放，比较小的 value 直接就普通删除，毕竟 线程操作涉及 线程同步，需要耗费一番，这里获取 元素个数
        size_t free_effort = lazyfreeGetFreeEffort(val);
        // 只有计算出来的 free_effort 大于 LAZYFREE_THRESHOLD(64) 才会进入异步处理
        if (free_effort > LAZYFREE_THRESHOLD && val->refcount == 1) {
            // 原子操作给 lazyfree_objects 加1，以备 info 命令查看有多少对象待后台线程删除
            atomicIncr(lazyfree_objects,1);
            // 创建 BIO_LAZY_FREE 任务，放到异步队列
            bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);
            // value 指针 置为 NULL
            dictSetVal(db->dict,de,NULL);
        }
    }
    // 如果 key 存在，释放字典里面结构
    if (de) {
        // 释放资源
        dictFreeUnlinkedEntry(db->dict,de);
        // 释放 集群节点 中的资源
        if (server.cluster_enabled) slotToKeyDel(key);
        return 1;
    } else {
        return 0;
    }
}

同步删除 dbSyncDelete()，为默认操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* db.c: line 260 */
int dbSyncDelete(redisDb *db, robj *key) {
    // 从 数据库的过期时间字典里面删除 key
    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;
    }
}

数据库设置键值

设置键值函数为 setKey()，可能是 添加 或者 重设

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* db.c: line 206 */
void setKey(redisDb *db, robj *key, robj *val) {
    // 查找键值对
    if (lookupKeyWrite(db,key) == NULL) {
        // 不存在则添加 键值对
        dbAdd(db,key,val);
    } else {
        // 重写键值
        dbOverwrite(db,key,val);
    }
    // 对象引用计数 +1
    incrRefCount(val);
    // 移除过期时间
    removeExpire(db,key);
    // 发送修改事件通知
    signalModifiedKey(db,key);
}

数据库查找键值对

键值对查找函数 不止一个，运用于不同的场景下，而底层操作函数始终为 lookupKey()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* db.c: line 53 */
robj *lookupKey(redisDb *db, robj *key, int flags) {
    // 查找字典键值对
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        // 获取键值对象
        robj *val = dictGetVal(de);
        // 更新 LRU / LFU 操作时间
        if (server.rdb_child_pid == -1 &&
            server.aof_child_pid == -1 &&
            !(flags & LOOKUP_NOTOUCH))
        {
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
                updateLFU(val);
            } else {
                val->lru = LRU_CLOCK();
            }
        }
        // 返回键值 对象
        return val;
    } else {
        return NULL;
    }
}

数据库键操作过期时间

为 key 设置过期时间，数据库部分处理函数为 setExpire()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* db.c: line 1056 */
void setExpire(client *c, redisDb *db, robj *key, long long when) {
    dictEntry *kde, *de;
    // 从字典中查找到键值对
    kde = dictFind(db->dict,key->ptr);
    // 如果键值对为空爆出
    serverAssertWithInfo(NULL,key,kde != NULL);
    // 从过期字典结构中查找，如果不存在添加
    de = dictAddOrFind(db->expires,dictGetKey(kde));
    // 设置过期字典结构中键值为过期时间，when 代表 过期时间
    dictSetSignedIntegerVal(de,when);
    // 判断是否需要同步从库
    int writable_slave = server.masterhost && server.repl_slave_ro == 0;
    // 同步从库
    if (c && writable_slave && !(c->flags & CLIENT_MASTER))
        rememberSlaveKeyWithExpire(db,key);
}

查找、删除 过期时间的逻辑就比较简单了，主要单纯的 操作 过期信息字典

数据库删除策略

上面我们提到 惰性删除策略，它的主要处理函数为 expireIfNeeded()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/* db.c: line 1128 */
int expireIfNeeded(redisDb *db, robj *key) {
    // 获取键的过期时间，这个是从 过期字典里面获取
    mstime_t when = getExpire(db,key);
    mstime_t now;
    // 如果 < 0 ，代表没有设置过期时间
    if (when < 0) return 0; /* No expire for this key */
    // 如果 Redis 服务器正在加载数据，不要处理任何 过期
    if (server.loading) return 0;
    // 如果是 lua 脚本环境中，我们假设现在时间为 脚本开始时间，否则就为 当前服务器时间
    now = server.lua_caller ? server.lua_time_start : mstime();
    // 如果是 主从模式情况，那么 从节点 不随便处理 过期
    if (server.masterhost != NULL) return now > when;
    // now <= when 代表还没过期，否则 过期，执行 后续逻辑
    if (now <= when) return 0;
    // 过期统计 +1
    server.stat_expiredkeys++;
    // propagateExpire()函数的逻辑为 将过期处理的操作同步到 AOF文件 和 从节点
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    // 过期事件通知
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // 删除键值对，这里跟 dbDelete() 的逻辑一样，可以参照上方详解
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) : dbSyncDelete(db,key);
}

定期删除策略 具体逻辑由 activeExpireCycle() 函数处理，该函数不光在 Redis 的事件驱动循环 beforesleep 中执行，也会在 CPU 空闲的时候 通过 databasesCron 定时处理函数进行 调用执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/* expire.c: line 97 */
void activeExpireCycle(int type) {
    // 上次执行到的数据库 id
    static unsigned int current_db = 0;
    // 运行时间已经到了就退出的标识
    static int timelimit_exit = 0;
    // 上次快速定期删除的时间点
    static long long last_fast_cycle = 0;
    int j, iteration = 0;
    // 每次定期删除遍历的数据库数量
    int dbs_per_call = CRON_DBS_PER_CALL;
    long long start = ustime(), timelimit, elapsed;
    // 客户端如果已经暂停就不继续处理
    if (clientsArePaused()) return;
    // 如果为快速模式
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        // 如果时间到了就退出
        if (!timelimit_exit) return;
        // 如果距离上次执行没有间隔一定时间，就不能执行
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        // 执行开始时间
        last_fast_cycle = start;
    }
    // 一般情况下，每次只遍历处理 CRON_DBS_PER_CALL 个数据库，但是也有例外，比如 总数据库数量达不到每次遍历的数量；而如果上次 执行过程中 遇到时间到期退出了，那么就需要 从头开始
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
    // 函数处理的 上限时间（微秒），ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 默认为 25，也就是为 25% 的 CPU 时间，server.hz 为 服务器频率
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;
    
    // 如果为快速模式，那么 时间上限就是 ACTIVE_EXPIRE_CYCLE_FAST_DURATION 微秒，默认 1000微秒
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION;
    long total_sampled = 0;
    long total_expired = 0;
    // 遍历 数据库
    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        int expired;
        // 需要处理的数据库
        redisDb *db = server.db+(current_db % server.dbnum);
        // db id加1，如果 下面 直接跳出，下次就从 下一个 db 直接执行
        current_db++;
        do {
            unsigned long num, slots;
            long long now, ttl_sum;
            int ttl_samples;
            iteration++;
            // 如果当前数据库的 到期字典 数据为空，就继续下一个数据库
            if ((num = dictSize(db->expires)) == 0) {
                db->avg_ttl = 0;
                break;
            }
            // 过期字典里的键值对数量
            slots = dictSlots(db->expires);
            now = mstime();
            // 如果当前数据库的使用率低于 1% ，扫描起来太费力了（大部分都会 MISS），所以先 跳过，等待字典收缩程序运行
            if (num && slots > DICT_HT_INITIAL_SIZE &&
                (num*100/slots < 1)) break;
                
            // 过期数据统计个数
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;
            // 一次执行检查 小于等于 LOOKUPS_PER_LOOP 数量的值
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 遍历键值对
            while (num--) {
                dictEntry *de;
                long long ttl;
                // 随机获取一个键值对
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                // 计算 ttl 时间
                ttl = dictGetSignedIntegerVal(de)-now;
                // 这里为 过期处理函数，如果键 过期，就删除掉，删除个数 +1
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                // 统计 ttl 总量
                if (ttl > 0) {
                    ttl_sum += ttl;
                    ttl_samples++;
                }
                // 累计处理键个数 +1
                total_sampled++;
            }
            // 总过期个数 +1
            total_expired += expired;
            // 为当前数据库更新平均 ttl 统计数据
            if (ttl_samples) {
                // 当前平均值
                long long avg_ttl = ttl_sum/ttl_samples;
                // 如果是第一次设置 数据库的 ttl，那么先初始化
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                // 上次 ttl 平均值 和 这次 ttl 平均值 的平均
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }
            // 每 遍历 16 次 执行一次
            if ((iteration & 0xf) == 0) {
                // 如果遍历次数正好是 16 的倍数 并且遍历的时间超过了 timelimit，那么断开 timelimit_exit
                elapsed = ustime()-start;
                if (elapsed > timelimit) {
                    timelimit_exit = 1;
                    server.stat_expired_time_cap_reached_count++;
                    break;
                }
            }
        // 如果已删除的过期键占当前总数据库带过期时间的键数量的 25%，那么就不再遍历
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // ......
}

上述中提到的 具体执行过期删除的函数 activeExpireCycleTryExpire()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/* expire.c: line 54 */
int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    // 获取过期时间
    long long t = dictGetSignedIntegerVal(de);
    // 如果过期
    if (now > t) {
        // 获取键
        sds key = dictGetKey(de);
        // 复制一个 key 对象副本
        robj *keyobj = createStringObject(key,sdslen(key));
        // propagateExpire()函数的逻辑为 将过期处理的操作同步到 AOF文件 和 从节点
        propagateExpire(db,keyobj,server.lazyfree_lazy_expire);
        // 删除键值对，这里跟 dbDelete() 的逻辑一样，可以参照上方详解
        if (server.lazyfree_lazy_expire)
            dbAsyncDelete(db,keyobj);
        else
            dbSyncDelete(db,keyobj);
        // 发送事件通知
        notifyKeyspaceEvent(NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        // 副本 key 引用计数-1
        decrRefCount(keyobj);
        // 添加过期 key 统计
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}

以上为比较经典的函数逻辑解析，另外我从 其他资料找到了 一些 API 的详解，大家可以将就看看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// 从数据库中取出指定键对应的值对象，如不存在则返回NULL 
robj *lookupKey(redisDb *db, robj *key, int flags);
// 先删除过期键，再从数据库中取出指定键对应的值对象，如不存在则返回NULL，底层调用lookupKey函数
robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags);
// 先删除过期键，以读操作的方式从数据库中取出指定键对应的值对象，如不存在则返回NULL，底层调用lookupKey函数
robj *lookupKeyRead(redisDb *db, robj *key);
// 先删除过期键，以写操作的方式从数据库中取出指定键对应的值对象，如不存在则返回NULL，底层调用lookupKeyReadWithFlags函数
robj *lookupKeyWrite(redisDb *db, robj *key);
// 先删除过期键，以读操作的方式从数据库中取出指定键对应的值对象，如不存在则返回NULL，底层调用 lookupKeyRead 函数，此操作需要向客户端回复
robj *lookupKeyReadOrReply(client *c, robj *key, robj *reply);
// 先删除过期键，以写操作的方式从数据库中取出指定键对应的值对象，如不存在则返回NULL，底层调用 lookupKeyWrite 函数，此操作需要向客户端回复
robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply) ;
// 添加元素到指定数据库
void dbAdd(redisDb *db, robj *key, robj *val);
// 重写指定键的值
void dbOverwrite(redisDb *db, robj *key, robj *val);
// 设定指定键的值
void setKey(redisDb *db, robj *key, robj *val);
// 判断指定键是否存在
int dbExists(redisDb *db, robj *key);
// 随机返回数据库中的键
robj *dbRandomKey(redisDb *db);
// 删除指定键
int dbDelete(redisDb *db, robj *key);
// 清空所有数据库，返回键值对的个数
long long emptyDb(void(callback)(void*));
// 清空当前数据库
void flushdbCommand(client *c);
// 清空所有数据库
void flushallCommand(client *c);
// 删除指定键
void delCommand(client *c);
// 判断指定件是否存在
void existsCommand(client *c);
// 选择指定编号的数据库
void selectCommand(client *c);
// 随机返回一个键
void randomkeyCommand(client *c);
// 找出与给定模式匹配的键
void keysCommand(client *c);
// 扫描数据库
void scanCommand(client *c);
// 返回数据库中键的个数
void dbsizeCommand(client *c);
// 返回最近一次存储的时间，与持久化有关
void lastsaveCommand(client *c);
// 返回指定键对象的类型
void typeCommand(client *c);
// 关闭客户端
void shutdownCommand(client *c);
// 给指定键重命名，当key和newkey相同或者key不存在时返回错误，当newkey存在时，将覆盖旧值
void renameCommand(client *c);
// 给指定件重命名，当且仅当newkey不存在才重命名
void renamenxCommand(client *c);
// 移动指定键到另一个数据库
void moveCommand(client *c);
// 设定键的过期时间，给定参数为生存时间，单位为秒，即，该键的生存时间为给定的秒数
void expireCommand(client *c);
// 设定键的过期时间，给定参数为时间戳，单位为秒，即，该键到给定时间戳是过期
void expireatCommand(client *c);
// 设定键的过期时间，给定参数为生存时间，单位为毫秒，同上
void pexpireCommand(client *c);
// 设定键的过期时间，给定参数为时间戳，单位为毫秒，同上
void pexpireatCommand(client *c);
// 获取指定键的剩余生存时间，单位为秒
void ttlCommand(client *c);
// 获取指定键的剩余生存时间，单位为毫秒
void pttlCommand(client *c);

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-db.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

wettper <br /><br /> 现 离职状态 程序猿 <br /><br /> 叫醒我的不止阳光，还有梦想！<br /><br /> 喵喵、念念、健身、吉他！