渐进式解析 Redis 源码 - 有序集合类型 t_zset

阅读量

有序集合类型 的对象编码方式为 OBJ_ENCODING_ZIPLIST 和 OBJ_ENCODING_SKIPLIST，对应的 底层数据结构为 压缩列表ziplist 和 跳跃表skiplist

zset 在使用 ziplist 作为底层数据结构的时候，每个 集合元素 使用紧挨着的两个压缩列表节点表示，第一个节点 保存元素 成员，第二个节点 保存元素 分值；压缩列表中集合元素都是按照 分值 从小到大 进行排序存储的，分值比较小的放在靠近 表头的方向

而 zset 在使用 skiplist 作为底层数据结构的时候，跳跃表存储部分 之前在 跳跃表 skiplist 篇 写的非常详细了，需要注意的是 每个 zset 结构都是 包含一个 数据字典 和 一个跳跃表

1
2
3
4
5
6
7
// zset 结构
typedef struct zset {
    // 数据字典
    dict *dict;
    // 跳跃表数据
    zskiplist *zsl;
} zset;

zset 数据结构中的 数据字典dict 部分为 有序集合 创建了一个从 成员到分值 的映射，字典中每个 键值对都保存了一个集合元素：键保存了元素成员，值保存了元素分值；有了这个字典，获取指定元素的分值的复杂度就是 O(1)，比如 zscore 命令等

另外值得一提的是，虽然 zset 在上述情况中 同时 使用了 跳跃表 和 字典 来保存有序集合元素，但是两种数据都会通过指针来共享相同元素的成员和分值，所以即使 同时使用两种 存储方式，却也 不会 产生重复 的成员数据，不会浪费过多额外的内存

编码转换

跟 上一篇 的 集合类型 一样道理，有序集合类型 涉及到了 两个数据结构 压缩列表 ziplist 和 跳跃表 skiplist ，所以也会涉及 两个结构的编码转换

当 有序集合条件 可以同时满足以下条件的时候，对象使用 ziplist 结构，否则就使用 skiplist 结构 作为底层实现

  • 有序集合保存的元素个数小于 128个（这个限制是由 zset-max-ziplist-entries 参数控制，对应 server 全局变量为 server.zset_max_ziplist_entries，默认 128）
  • 有序集合保存的所有元素成员的长度都小于 64 字节（这个限制是由 zset-max-ziplist-value 参数控制，对应 server 全局变量为 server.zset_max_ziplist_value，默认 64）

对于使用 ziplist 编码的有序集合对象来说，当使用 ziplist 编码所需的两条件任意一个不被满足，就会执行对象的 编码转换操作，原本保存在 压缩列表 ziplist 中的元素都会被转移到 zset 结构中，编码也会跟着变成 skiplist

下面我们就 Redis 有序集合类型 一些典型的 API 进行解析~~~

源码解析

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

首先我们上面提到的编码类型转换函数为 zsetConvert()

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
/* t_zset.c: line 1115 */
void zsetConvert(robj *zobj, int encoding) {
    zset *zs;
    zskiplistNode *node, *next;
    sds ele;
    double score;
    // 如果编码类型一样，就不必转换了
    if (zobj->encoding == encoding) return;
    // 如果编码类型为 ziplist，则为转为 skiplist
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl = zobj->ptr;
        unsigned char *eptr, *sptr;
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;
        // 如果传递的编码类型不是 skiplist，那么就是 异常了
        if (encoding != OBJ_ENCODING_SKIPLIST)
            serverPanic("Unknown target encoding");
        zs = zmalloc(sizeof(*zs));
        // 新建字典 dict 和 跳跃表
        zs->dict = dictCreate(&zsetDictType,NULL);
        zs->zsl = zslCreate();
        // 获取第一个节点
        eptr = ziplistIndex(zl,0);
        // 如果节点为空那么就是异常
        serverAssertWithInfo(NULL,zobj,eptr != NULL);
        // 下一个节点
        sptr = ziplistNext(zl,eptr);
        serverAssertWithInfo(NULL,zobj,sptr != NULL);
        // 遍历 压缩表
        while (eptr != NULL) {
            // 我们上面提到，因为 元素和分值 在压缩列表 中都是 相邻存放的，所以 前一个获取的为 元素，后一个获取的为 分值
            // 获取 分值
            score = zzlGetScore(sptr);
            // 获取 元素内容
            serverAssertWithInfo(NULL,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
            // 如果是 整型则转换成 long 类型
            if (vstr == NULL)
                ele = sdsfromlonglong(vlong);
            else
            // 如果是 字符串则转换为 sds 结构数据
                ele = sdsnewlen((char*)vstr,vlen);
            // 插入 skiplist 节点
            node = zslInsert(zs->zsl,score,ele);
            // 字典 添加数据
            serverAssert(dictAdd(zs->dict,ele,&node->score) == DICT_OK);
            // 获取 后续的连续 两个节点
            zzlNext(zl,&eptr,&sptr);
        }
        zfree(zobj->ptr);
        // 将 跳跃表 绑定到 zset 对象中
        zobj->ptr = zs;
        // 修改编码
        zobj->encoding = OBJ_ENCODING_SKIPLIST;
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
    // skiplist 转换为 ziplist
    
        unsigned char *zl = ziplistNew();
        // 如果传递的编码类型不是 ziplist，那么就是 异常了
        if (encoding != OBJ_ENCODING_ZIPLIST)
            serverPanic("Unknown target encoding");
        // 获取 skiplist 地址
        zs = zobj->ptr;
        // 释放字典结构
        dictRelease(zs->dict);
        // 获取 skiplist 首节点
        node = zs->zsl->header->level[0].forward;
        zfree(zs->zsl->header);
        zfree(zs->zsl);
        // 遍历压缩列表，这里遍历就不需要跳跃了，直接遍历所有
        while (node) {
            // 将 元素和分值 取出来 写入 压缩列表 相邻的两个 节点中
            zl = zzlInsertAt(zl,NULL,node->ele,node->score);
            // 获取下一个跳跃表节点
            next = node->level[0].forward;
            zslFreeNode(node);
            node = next;
        }
    
        zfree(zs);
        // 将 压缩列表 绑定到 zset 对象中
        zobj->ptr = zl;
        // 修改编码
        zobj->encoding = OBJ_ENCODING_ZIPLIST;
    } else {
        serverPanic("Unknown sorted set encoding");
    }
}

有序集合添加元素命令 zadd 使用的 函数为 zaddCommand()，那么具体的逻辑在 zaddGenericCommand() 函数中，不过命令中有几个参数需要解释一下

  • XX 表示只有当元素存在的时候才更新其分值，不存在时不添加新元素
  • NX 表示只添加新元素，如果存在则不作处理
  • CH 修改返回值为发生变化的成员总数，原始是返回新添加成员的总数；更改的成员是新添加的成员，已经存在的成员更新分数；所以在命令中指定的成员有相同的分数的话，不计算在内；在通常情况下，ZADD返回值只计算新添加成员的数量。
  • INCR 当ZADD指定这个选项时，成员的操作就等同ZINCRBY命令，对成员的分数进行递增操作
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* t_zset.c: line 1486 */
void zaddGenericCommand(client *c, int flags) {
    static char *nanerr = "resulting score is not a number (NaN)";
    // 有序集合 key 值
    robj *key = c->argv[1];
    robj *zobj;
    sds ele;
    double score = 0, *scores = NULL;
    int j, elements;
    int scoreidx = 0;
    
    // 以下变量用来标记何种命令被执行，为了给客户端回复，发送事件通知等
    // 添加的元素个数
    int added = 0;
    // 更新的元素个数
    int updated = 0;
    // 被处理过的元素个数
    int processed = 0;
    
    // 解析命令参数
    // 分值参数开始序号
    scoreidx = 2;
    while(scoreidx < c->argc) {
        // 判定命令参数
        char *opt = c->argv[scoreidx]->ptr;
        if (!strcasecmp(opt,"nx")) flags |= ZADD_NX;
        else if (!strcasecmp(opt,"xx")) flags |= ZADD_XX;
        else if (!strcasecmp(opt,"ch")) flags |= ZADD_CH;
        else if (!strcasecmp(opt,"incr")) flags |= ZADD_INCR;
        else break;
        scoreidx++;
    }
    // 简单判定变量
    int incr = (flags & ZADD_INCR) != 0;
    int nx = (flags & ZADD_NX) != 0;
    int xx = (flags & ZADD_XX) != 0;
    int ch = (flags & ZADD_CH) != 0;
    // 命令中的元素和分值总个数
    elements = c->argc-scoreidx;
    // 验证 元素和分值 是否成对出现
    if (elements % 2 || !elements) {
        addReply(c,shared.syntaxerr);
        return;
    }
    // 元素个数
    elements /= 2;
    
    // nx / xx 不能同时设定
    if (nx && xx) {
        addReplyError(c,
            "XX and NX options at the same time are not compatible");
        return;
    }
    // incr 操作的时候，element / scores 只能有一个
    if (incr && elements > 1) {
        addReplyError(c,
            "INCR option supports a single increment-element pair");
        return;
    }
    // 解析所有的分值，验证分值对象是 double 类型的整数
    scores = zmalloc(sizeof(double)*elements);
    for (j = 0; j < elements; j++) {
        // 从对象中得到 double 类型的分值
        if (getDoubleFromObjectOrReply(c,c->argv[scoreidx+j*2],&scores[j],NULL)
            != C_OK) goto cleanup;
    }
    // 检查 key 是否存在
    zobj = lookupKeyWrite(c->db,key);
    if (zobj == NULL) {
        // 如果键不存在，且设置了xx，则直接回复给客户端，不做任何处理
        if (xx) goto reply_to_client;
        // 检查配置参数，判断使用 ziplist 和 skiplist 哪种编码
        if (server.zset_max_ziplist_entries == 0 ||
            server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+1]->ptr))
        {
            // 创建 skiplist编码的 zset对象
            zobj = createZsetObject();
        } else {
            // ziplist 最大能存储的节点个数大于0且待添加的元素的长度没有超过设定的阈值 zset_max_ziplist_value
            zobj = createZsetZiplistObject();
        }
        // 添加键值对到数据库
        dbAdd(c->db,key,zobj);
    } else {
        // 如果键存在，但不是有序集合键，清理临时变量，并返回回复
        if (zobj->type != OBJ_ZSET) {
            addReply(c,shared.wrongtypeerr);
            goto cleanup;
        }
    }
    // 循环处理每一个键值对
    for (j = 0; j < elements; j++) {
        double newscore;
        // 分值
        score = scores[j];
        int retflags = flags;
        // 元素
        ele = c->argv[scoreidx+1+j*2]->ptr;
        // 添加键值对
        int retval = zsetAdd(zobj, score, ele, &retflags, &newscore);
        if (retval == 0) {
            addReplyError(c,nanerr);
            goto cleanup;
        }
        // 统计数据
        if (retflags & ZADD_ADDED) added++;
        if (retflags & ZADD_UPDATED) updated++;
        if (!(retflags & ZADD_NOP)) processed++;
        score = newscore;
    }
    server.dirty += (added+updated);
reply_to_client:
    // 给客户端回复
    // INCR命令或者设定了incr选项
    if (incr) {
        if (processed)
            addReplyDouble(c,score);
        else
            addReply(c,shared.nullbulk);
    } else {
    // 回复执行了add命令
        addReplyLongLong(c,ch ? added+updated : added);
    }
cleanup:
    // 释放临时变量
    zfree(scores);
    if (added || updated) {
        // 标记修改的键
        signalModifiedKey(c->db,key);
        // 发送事件通知
        notifyKeyspaceEvent(NOTIFY_ZSET,
            incr ? "zincr" : "zadd", key, c->db->id);
    }
}

上面添加元素的逻辑中使用了一个 zsetAdd() 函数，具体逻辑如下

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
124
125
/* t_zset.c: line 1261 */
int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
    // 参数简单判断变量
    int incr = (*flags & ZADD_INCR) != 0;
    int nx = (*flags & ZADD_NX) != 0;
    int xx = (*flags & ZADD_XX) != 0;
    *flags = 0;
    double curscore;
    // 判断 分值有效性
    if (isnan(score)) {
        *flags = ZADD_NAN;
        return 0;
    }
    // 添加的为 ziplist 编码
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *eptr;
        // 元素存在
        if ((eptr = zzlFind(zobj->ptr,ele,&curscore)) != NULL) {
            // nx 选项设定，不处理当前元素，继续处理下一个元素
            if (nx) {
                *flags |= ZADD_NOP;
                return 1;
            }
            // incr 选项设定，表示需要递增分数
            if (incr) {
                score += curscore;
                // 判断 分值 有效性
                if (isnan(score)) {
                    *flags |= ZADD_NAN;
                    return 0;
                }
                if (newscore) *newscore = score;
            }
            // 分值发生变化的时候，删除 原集合元素，再 重新添加新元素
            if (score != curscore) {
                zobj->ptr = zzlDelete(zobj->ptr,eptr);
                zobj->ptr = zzlInsert(zobj->ptr,ele,score);
                *flags |= ZADD_UPDATED;
            }
            return 1;
        } else if (!xx) {
        // 该元素不存在，且没有设定xx选项
        
            // 添加新元素以及分数到 ziplist
            zobj->ptr = zzlInsert(zobj->ptr,ele,score);
            // 检查ziplist中的元素个数是否超出设定值，如超出则需要转换成skiplist 编码
            if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries)
                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
            // 检查待添加元素的长度是否超过规定阈值，如超出则需要转换成skiplist 编码
            if (sdslen(ele) > server.zset_max_ziplist_value)
                zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
            if (newscore) *newscore = score;
            *flags |= ZADD_ADDED;
            return 1;
        } else {
            *flags |= ZADD_NOP;
            return 1;
        }
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
    // 添加的为 skiplist 编码
        zset *zs = zobj->ptr;
        zskiplistNode *znode;
        dictEntry *de;
        // 查找元素
        de = dictFind(zs->dict,ele);
        // 元素存在
        if (de != NULL) {
            // nx选项被设定，元素存在的时候不做处理
            if (nx) {
                *flags |= ZADD_NOP;
                return 1;
            }
            // 获取当前元素的 节点 和 分数
            curscore = *(double*)dictGetVal(de);
            // 设定的incr选项
            if (incr) {
                score += curscore;
                // 验证 score 有效性
                if (isnan(score)) {
                    *flags |= ZADD_NAN;
                    return 0;
                }
                if (newscore) *newscore = score;
            }
            // 分值发生变化的时候，删除 原集合元素，再 重新添加新元素，字典中不需要移除，只需要更新分数即可
            if (score != curscore) {
                zskiplistNode *node;
                // 删除元素
                serverAssert(zslDelete(zs->zsl,curscore,ele,&node));
                // 添加元素
                znode = zslInsert(zs->zsl,score,node->ele);
                node->ele = NULL;
                zslFreeNode(node);
                // 字典中不需要移除，只需要更新分数即可
                dictGetVal(de) = &znode->score;
                *flags |= ZADD_UPDATED;
            }
            return 1;
        } else if (!xx) {
        // 如果键不存在，且没有设定xx选项
        
            ele = sdsdup(ele);
            // 插入元素和分值
            znode = zslInsert(zs->zsl,score,ele);
            // 添加到字典结构中
            serverAssert(dictAdd(zs->dict,ele,&znode->score) == DICT_OK);
            *flags |= ZADD_ADDED;
            if (newscore) *newscore = score;
            return 1;
        } else {
            *flags |= ZADD_NOP;
            return 1;
        }
    } else {
        serverPanic("Unknown sorted set encoding");
    }
    return 0;
}

上述也用到了 在指定 ziplist 位置插入元素 的函数 zzlInsert()，假定该元素不存在于该 ziplist中，其中元素按分值大小排序，如果分值相同，则按 字典里的顺序排序

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
/* t_zset.c: line 1001 */
unsigned char *zzlInsert(unsigned char *zl, sds ele, double score) {
    // 获取第一个元素
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double s;
    
    // 遍历压缩列表元素
    while (eptr != NULL) {
        // 当前元素的下一个元素，因为 集合元素在 ziplist 里面都是 成对 存储的
        sptr = ziplistNext(zl,eptr);
        serverAssert(sptr != NULL);
        // 获取分值
        s = zzlGetScore(sptr);
        // ziplist 本身是排序的，如果找到第一个分值大于 score 的元素，则表明给定元素应该插在当前找的元素的前面
        if (s > score) {
            zl = zzlInsertAt(zl,eptr,ele,score);
            break;
        } else if (s == score) {
        // 如果分值相同，则按字典排列
            if (zzlCompareElements(eptr,(unsigned char*)ele,sdslen(ele)) > 0) {
                zl = zzlInsertAt(zl,eptr,ele,score);
                break;
            }
        }
        // 遍历到下一个元素
        eptr = ziplistNext(zl,sptr);
    }
    // 如果所有分值均小于 score，则插入到 ziplist 末尾
    if (eptr == NULL)
        zl = zzlInsertAt(zl,NULL,ele,score);
    return zl;
}

以上为比较经典的函数逻辑解析，另外我从 其他资料找到了 一些 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
// 获取zset对象中sptr指向的分值score
double zzlGetScore(unsigned char *sptr);
// 获取zset对象中sptr指向的元素，返回一个新的Redis string对象，该对象存放元素值
robj *ziplistGetObject(unsigned char *sptr);
// 比较zset对象中eptr指向的元素与给定元素的大小
int zzlCompareElements(unsigned char *eptr, unsigned char *cstr, unsigned int clen);
// 获取zset对象中eptr指向元素的下一个元素
void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) ;
// 获取zset对象中元素的个数，为ziplist中元素个数的一半
unsigned int zzlLength(unsigned char *zl);
// 获取zset对象中eptr指向的元素的前一个元素
void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr);
// 如果给定ziplist中至少有一个节点在range范围内，返回1；反之返回0
int zzlIsInRange(unsigned char *zl, zrangespec *range);
// 返回第一个score值在给定范围内的节点，没有则返回 NULL
unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range);
// 返回最后一个score值在给定范围内的节点，没有则返回 NULL
unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range);
// 判断指定元素与给定范围的最小值的大小
static int zzlLexValueGteMin(unsigned char *p, zlexrangespec *spec);
// 判断指定元素与给定范围的最大值的大小
static int zzlLexValueLteMax(unsigned char *p, zlexrangespec *spec);
// 判断指定元素是否存在于给定范围内，与zzlIsInRange不同的是，前者比较元素，后者比较score分值
int zzlIsInLexRange(unsigned char *zl, zlexrangespec *range);
// 返回ziplist中第一个存在于给定范围内的元素
unsigned char *zzlFirstInLexRange(unsigned char *zl, zlexrangespec *range);
// 返回ziplist中最后一个存在于给定范围内的元素
unsigned char *zzlLastInLexRange(unsigned char *zl, zlexrangespec *range);
// 查找ziplist中是否存在给定元素与分值
unsigned char *zzlFind(unsigned char *zl, robj *ele, double *score);
// 删除元素及其分值(element,score)
unsigned char *zzlDelete(unsigned char *zl, unsigned char *eptr);
// 在指定位置插入一个元素及其分值(element score)，如果eptr为空，插入到ziplist尾部
unsigned char *zzlInsertAt(unsigned char *zl, unsigned char *eptr, robj *ele, double score);
// 在指定位置插入一个元素及其分值(element,score)，假定该元素不存在于该ziplist中，其中元素按分值大小排序，如果分值相同，则按字典序排序
unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score);
// 删除给定score范围内的数据
unsigned char *zzlDeleteRangeByScore(unsigned char *zl, zrangespec *range, unsigned long *deleted);
// 删除给定元素范围内的数据
unsigned char *zzlDeleteRangeByLex(unsigned char *zl, zlexrangespec *range, unsigned long *deleted);
// 删除给定排名范围内的数据，zset根据分值排名，如分值相同根据字典序排名
unsigned char *zzlDeleteRangeByRank(unsigned char *zl, unsigned int start, unsigned int end, unsigned long *deleted);
// 向skiplist插入给定的(element,score)对
zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj);
// 删除sjiplist中的给定的(element,score)对
int zslDelete(zskiplist *zsl, double score, robj *obj);
// 判断skiplist中的元素是否存在于range范围内，其中range为分值范围
int zslIsInRange(zskiplist *zsl, zrangespec *range);
// 返回skiplist中第一个存在于range分值范围内的节点
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range);
// 返回skiplist中最后一个存在于range分值范围内的节点
zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range);
// 删除skiplist中给定分值范围内的节点
unsigned long zslDeleteRangeByScore(zskiplist *zsl, zrangespec *range, dict *dict);
// 删除skiplist中给定元素范围内的节点
unsigned long zslDeleteRangeByLex(zskiplist *zsl, zlexrangespec *range, dict *dict);
// 删除skiplist中给定排名范围内的节点
unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) ;
// 获取给定节点(element,score)对的排名
unsigned long zslGetRank(zskiplist *zsl, double score, robj *o);
// 根据排名获取节点
zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank);
// 判断skiplist中的节点是否存在与对象范围range中
int zslIsInLexRange(zskiplist *zsl, zlexrangespec *range);
// 返回skiplist中第一个存在于对象范围range中的节点
zskiplistNode *zslFirstInLexRange(zskiplist *zsl, zlexrangespec *range);
// 返回skiplist中最后一个存在于对象范围range中的节点
zskiplistNode *zslLastInLexRange(zskiplist *zsl, zlexrangespec *range);

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-zset.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 /> 喵喵、念念、健身、吉他！