渐进式解析 Redis 源码 - 哈希类型 t_hash

阅读量

有序集合类型 的对象编码方式为 OBJ_ENCODING_ZIPLIST 和 OBJ_ENCODING_HT，对应的 底层数据结构为 压缩列表ziplist 和 字典dict

其实 哈希类型 和 有序集合类型 一定程度上很像，特别是在 ziplist 的类型限制条件上

哈希类型 在使用 ziplist 作为底层数据结构的时候，每个 集合元素 使用紧挨着的两个压缩列表节点表示，第一个节点 保存元素 成员，第二个节点 保存元素 分值；压缩列表中集合元素都是按照 添加时间上 进行排序存储的，后添加的 键值对 从 压缩列表 尾部 压入

而 哈希类型 中的 字典结构 就比较简单了，哈希类型 每个键值对 都对应 字典中的每个键值对，就像我们在 字典篇章 中提到的，比如 HMSET person name "kety" age 20 weight "75kg" height 20，即为 操作 key 为 person 的字典，而 值也是由字典结构数据组成，key=name | key=age | key=weight | key=height

编码转换

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

当 哈希条件 可以同时满足以下条件的时候，对象使用 ziplist 结构，否则就使用 dict 结构 作为底层实现

  • 哈希类型 保存的所有键值对个数小于 128个（这个限制是由 hash-max-ziplist-entries 参数控制，对应 server 全局变量为 server.hash_max_ziplist_entries，默认 128）
  • 哈希类型 保存的所有键值对的长度都小于 64 字节（这个限制是由 hash-max-ziplist-value 参数控制，对应 server 全局变量为 server.hash_max_ziplist_value，默认 64）

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

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

源码解析

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

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

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
/* t_hash.c: line 465 */
void hashTypeConvertZiplist(robj *o, int enc) {
    serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);
    // 如果 传递的是 ziplist 就啥也不做
    if (enc == OBJ_ENCODING_ZIPLIST) {
        /* Nothing to do... */
    } else if (enc == OBJ_ENCODING_HT) {
    // 编码转为 hashtable
    
        hashTypeIterator *hi;
        dict *dict;
        int ret;
        // 新建迭代器
        hi = hashTypeInitIterator(o);
        dict = dictCreate(&hashDictType, NULL);
        // 遍历元素
        while (hashTypeNext(hi) != C_ERR) {
            sds key, value;
            // 键值对在 压缩列表中是连续成对出现，所以获取都是连续读取
            // 获取 键
            key = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_KEY);
            // 获取 值
            value = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_VALUE);
            // 添加到 字典中
            ret = dictAdd(dict, key, value);
            if (ret != DICT_OK) {
                serverLogHexDump(LL_WARNING,"ziplist with dup elements dump",
                    o->ptr,ziplistBlobLen(o->ptr));
                serverPanic("Ziplist corruption detected");
            }
        }
        // 释放迭代器
        hashTypeReleaseIterator(hi);
        zfree(o->ptr);
        // 修改编码
        o->encoding = OBJ_ENCODING_HT;
        o->ptr = dict;
    } else {
        serverPanic("Unknown hash encoding");
    }
}

比较典型的 hset 添加命令 的 入口函数为 hsetCommand()，具体处理逻辑为 hashTypeSet()

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
/* t_hash.c: line 530 */
void hsetCommand(client *c) {
    int i, created = 0;
    robj *o;
    // 验证是否缺少参数，正常参数应该是 偶数
    if ((c->argc % 2) == 1) {
        addReplyError(c,"wrong number of arguments for HMSET");
        return;
    }
    // 查找对象，如果不存在则创建，返回 对象指针
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    // 检查待添加元素的情况，判断是否需要将 ziplist 转为 hashtable
    hashTypeTryConversion(o,c->argv,2,c->argc-1);
    for (i = 2; i < c->argc; i += 2)
        // 依次成对添加 元素+值，并记录 添加成功个数
        created += !hashTypeSet(o,c->argv[i]->ptr,c->argv[i+1]->ptr,HASH_SET_COPY);
    // HMSET 和 HSET 命令返回的内容不一样，需要分别处理，不过 HMSET 已经不推荐使用了
    // 命令
    char *cmdname = c->argv[0]->ptr;
    // 如果第二个字母是 S，证明是 HSET 命令
    if (cmdname[1] == 's' || cmdname[1] == 'S') {
        addReplyLongLong(c, created);
    } else {
    // HMSET 命令
        addReply(c, shared.ok);
    }
    // 发送键修改信号
    signalModifiedKey(c->db,c->argv[1]);
    // 发送事件通知
    notifyKeyspaceEvent(NOTIFY_HASH,"hset",c->argv[1],c->db->id);
    // 数据保存记录增加，dirty 用来存储上次保存前所有数据变动的长度，用于以后判断在执行命令的过程中是否有了db中数据的变化，用得到的结果来判断要不要执行aof操作
    server.dirty++;
}

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
/* t_hash.c: line 202 */
int hashTypeSet(robj *o, sds field, sds value, int flags) {
    int update = 0;
    // ziplist 编码类型的 设置逻辑
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl, *fptr, *vptr;
        // 获取 ziplist 指针
        zl = o->ptr;
        // 获取头指针
        fptr = ziplistIndex(zl, ZIPLIST_HEAD);
        if (fptr != NULL) {
            // 获取 数据部分
            fptr = ziplistFind(fptr, (unsigned char*)field, sdslen(field), 1);
            if (fptr != NULL) {
                // 获取挨后续节点
                vptr = ziplistNext(zl, fptr);
                serverAssert(vptr != NULL);
                // 更新数据
                update = 1;
                // 先删除，在添加
                zl = ziplistDelete(zl, &vptr);
                zl = ziplistInsert(zl, vptr, (unsigned char*)value, sdslen(value));
            }
        }
        // 原本不存在，则添加
        if (!update) {
            // 将 key push 进 ziplist 尾部
            zl = ziplistPush(zl, (unsigned char*)field, sdslen(field), ZIPLIST_TAIL);
            // 将 value push 进 ziplist 尾部
            zl = ziplistPush(zl, (unsigned char*)value, sdslen(value), ZIPLIST_TAIL);
        }
        o->ptr = zl;
        // 判断是否需要转换编码
        if (hashTypeLength(o) > server.hash_max_ziplist_entries)
            hashTypeConvert(o, OBJ_ENCODING_HT);
    } else if (o->encoding == OBJ_ENCODING_HT) {
    // hashtable 编码类型的 设置逻辑
        // 查找 key 对象
        dictEntry *de = dictFind(o->ptr,field);
        // 如果已经存在
        if (de) {
            // 释放键值，重新添加
            sdsfree(dictGetVal(de));
            // 原值添加
            if (flags & HASH_SET_TAKE_VALUE) {
                dictGetVal(de) = value;
                value = NULL;
            } else {
            // 字符串值添加
                dictGetVal(de) = sdsdup(value);
            }
            update = 1;
        } else {
            sds f,v;
            // key 格式化
            if (flags & HASH_SET_TAKE_FIELD) {
                f = field;
                field = NULL;
            } else {
                f = sdsdup(field);
            }
            // value 格式化
            if (flags & HASH_SET_TAKE_VALUE) {
                v = value;
                value = NULL;
            } else {
                v = sdsdup(value);
            }
            // 字典值 添加
            dictAdd(o->ptr,f,v);
        }
    } else {
    // 未知类型
        serverPanic("Unknown hash encoding");
    }
    // 根据需求释放变量
    if (flags & HASH_SET_TAKE_FIELD && field) sdsfree(field);
    if (flags & HASH_SET_TAKE_VALUE && value) sdsfree(value);
    return update;
}

以上为比较经典的函数逻辑解析，另外我从 其他资料找到了 一些 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
// 检查ziplist存放的数长度是否超过，如超过，则将编码类型转换成字典编码
void hashTypeTryConversion(robj *o, robj **argv, int start, int end);
// 当hash采用OBJ_ENCODING_HT编码的时候，需要将键值对转换成字符串编码
void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2);
// 当hash采用OBJ_ENCODING_ZIPLIST编码的时候，根据域field获取值
int hashTypeGetFromZiplist(robj *o, robj *field, unsigned char **vstr, unsigned int *vlen, long long *vll);
// 当hash采用OBJ_ENCODING_HT编码的时候，根据域field获取它的值
int hashTypeGetFromHashTable(robj *o, robj *field, robj **value);
// 根据键获取值得泛型实现，当底层编码为OBJ_ENCODING_HT时，调用上述 hashTypeGetFromHashTable 函数，当底层编码为OBJ_ENCODING_ZIPLIST时，调用上述hashTypeGetFromZiplist函数
robj *hashTypeGetObject(robj *o, robj *field);
// 获取hash对象中域field所指向值的长度
size_t hashTypeGetValueLength(robj *o, robj *field);
// 判断域field是否存在于hash对象中
int hashTypeExists(robj *o, robj *field);
// 向hash对象中添加键值对数据，如果该键存在，则更新它的值；反之则添加新键值对
int hashTypeSet(robj *o, robj *field, robj *value);
// 删除hash对象中域field及其对应的值
int hashTypeDelete(robj *o, robj *field);
// 返回hash对象中所有数据项的数量
unsigned long hashTypeLength(robj *o);
// 根据当前迭代器指向的位置，获取ziplist结构中当前位置的key或value，至于是key或者value，由what参数执行，其取值为 OBJ_HASH_KEY 或 OBJ_HASH_VALUE
void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what, unsigned char **vstr, unsigned int *vlen, long long *vll);
// 同上，根据当前迭代器指向的位置，获取字典结构中当前位置上的key或者value
void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst);
// 获取迭代器当前位置上的key或value的泛型实现
robj *hashTypeCurrentObject(hashTypeIterator *hi, int what);
// 在当前数据库中查找指定key是否存在，如果不存在就创建
robj *hashTypeLookupWriteOrCreate(client *c, robj *key);
// 将当前hash对象的编码类型由OBJ_ENCODING_HT转换成OBJ_ENCODING_ZIPLIST
void hashTypeConvertZiplist(robj *o, int enc);
// hash对象的底层编码转换的泛型实现
void hashTypeConvert(robj *o, int enc);
// 添加函数操作，如果域field存在则不做处理，反之则添加
void hsetnxCommand(client *c);
// 添加一个或多个键值对到hash对象中
void hmsetCommand(client *c);
// 给指定hash对象中的域field对应的值执行增加某个增量操作，值必须是整数
void hincrbyCommand(client *c);
// 同上，只不过增量是float类型
void hincrbyfloatCommand(client *c);
// 获取一个或多个域field对应的值
void hmgetCommand(client *c);
// 删除hash对象中的指定域field
void hdelCommand(client *c);
// 获取hash对象中所有键值对的总个数
void hlenCommand(client *c);
// 获取hash对象中指定域field对应的值的长度
void hstrlenCommand(client *c);
// 通过当前迭代器指向的位置获取键值对并回复，genericHgetallCommand的底层实现函数
static void addHashIteratorCursorToReply(client *c, hashTypeIterator *hi, int what);
// 获取哈希对象中所有的键值对的泛型实现
void genericHgetallCommand(client *c, int flags);
// 获取哈希对象中所有的域
void hkeysCommand(client *c);
// 获取哈希对象中所有的值
void hvalsCommand(client *c);
// 获取哈希对象中所有的域和值
void hgetallCommand(client *c);
// 判断哈希对象中是否存在该域field
void hexistsCommand(client *c);
// 客户端扫描操作
void hscanCommand(client *c);

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