Redis源码学习（11），t_hash.c 学习（二），hget 相关命令学习

最新推荐文章于 2024-04-29 11:15:21 发布
最新推荐文章于 2024-04-29 11:15:21 发布
阅读量443 收藏 3
点赞数
分类专栏： Redis源码学习 文章标签： Redis源码 Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kelinfeng16/article/details/124447184
版权

1 hgetCommand

1.1 方法说明

  获取hash键的键值

1.2 命令实践

在这里插入图片描述

1.3 方法源代码

void hgetCommand(redisClient *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,o,REDIS_HASH)) return;

    addHashFieldToReply(c, o, c->argv[2]);
}

1.4 相关源代码

1.4.1 addHashFieldToReply
static void addHashFieldToReply(redisClient *c, robj *o, robj *field) {
    int ret;
	
	//如果对象为null，返回null
    if (o == NULL) {
        addReply(c, shared.nullbulk);
        return;
    }
	
	//如果数据结构为压缩表
    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;
		
        ret = hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll);
        if (ret < 0) {
            addReply(c, shared.nullbulk);
        } else {
            if (vstr) {
                addReplyBulkCBuffer(c, vstr, vlen);
            } else {
                addReplyBulkLongLong(c, vll);
            }
        }

    }
    //如果数据额结构为哈希表 
    else if (o->encoding == REDIS_ENCODING_HT) {
        robj *value;

        ret = hashTypeGetFromHashTable(o, field, &value);
        if (ret < 0) {
            addReply(c, shared.nullbulk);
        } else {
            addReplyBulk(c, value);
        }

    } else {
        redisPanic("Unknown hash encoding");
    }
}
1.4.2 hashTypeGetFromZiplist
/* Get the value from a ziplist encoded hash, identified by field.
 1. Returns -1 when the field cannot be found. */
int hashTypeGetFromZiplist(robj *o, robj *field,
                           unsigned char **vstr,
                           unsigned int *vlen,
                           long long *vll)
{
    unsigned char *zl, *fptr = NULL, *vptr = NULL;
    int ret;

    redisAssert(o->encoding == REDIS_ENCODING_ZIPLIST);

    field = getDecodedObject(field);

    zl = o->ptr;
    //获取压缩表头部的位置
    fptr = ziplistIndex(zl, ZIPLIST_HEAD);
    if (fptr != NULL) {
    	//先找到键的位置
        fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
        if (fptr != NULL) {
            /* Grab pointer to the value (fptr points to the field) */
            //获取下一个位置的指针
            vptr = ziplistNext(zl, fptr);
            redisAssert(vptr != NULL);
        }
    }

    decrRefCount(field);

    if (vptr != NULL) {
    	//根据值的指针获取值
        ret = ziplistGet(vptr, vstr, vlen, vll);
        redisAssert(ret);
        return 0;
    }

    return -1;
}
1.4.3 hashTypeGetFromHashTable
/* Get the value from a hash table encoded hash, identified by field.
 2. Returns -1 when the field cannot be found. */
int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) {
    dictEntry *de;

    redisAssert(o->encoding == REDIS_ENCODING_HT);

    de = dictFind(o->ptr, field);
    if (de == NULL) return -1;
    *value = dictGetVal(de);
    return 0;
}

1.5 代码理解

  1. 先获取键对象，并判断对象类型是否为hash。
  2. 调用addHashFieldToReply 方法获取某个键的值。
  3. 判断数据结构是压缩表还是哈希表。
  4. 如果是压缩表，则调用压缩表相关方法获取某个键的值。
  5. 如果是哈希表，则调用哈希表相关方法获取某个键的值。

  这里面主要方法是 hashTypeGetFromZiplist 和 hashTypeGetFromHashTable，都是根据键来获取值，不同的是两者数据结构不同，所以获取值的逻辑也大不一样。

  hashTypeGetFromZiplist 要先获取键的位置，再来根据键的位置通过 ziplistNext 获取下一个位置的指针，在用这个新位置的指针通过 ziplistGet 获取值，从代码大概能看出来压缩表所有的值是紧凑挨在一起的，类似数组一样，具体详细内容等后面学习到压缩表的专门代码文件的时候再仔细研究。

  hashTypeGetFromHashTable 相对来说就简单明了一点，直接使用键通过 dictFind 找到指针，在通过dictGetVal找到相应地值就可以。

2 genericHgetallCommand

2.1 方法说明

  这个方法是hgetall、hvals、hkeys 的通用方法。

2.2 方法源代码

void genericHgetallCommand(redisClient *c, int flags) {
    robj *o;
    hashTypeIterator *hi;
    int multiplier = 0;
    int length, count = 0;
	
	//获取键对象，并判断对象类型是否为hash类型
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk)) == NULL
        || checkType(c,o,REDIS_HASH)) return;

	//如果标记是key，则加一
    if (flags & REDIS_HASH_KEY) multiplier++;
	
	//如果标记是value，则加一
    if (flags & REDIS_HASH_VALUE) multiplier++;
	
	//计算结果值个数
    length = hashTypeLength(o) * multiplier;
    addReplyMultiBulkLen(c, length);
	
	//初始化迭代对象
    hi = hashTypeInitIterator(o);

	//从头部向后面遍历hash元素
    while (hashTypeNext(hi) != REDIS_ERR) {
        if (flags & REDIS_HASH_KEY) {
            addHashIteratorCursorToReply(c, hi, REDIS_HASH_KEY);
            count++;
        }
        if (flags & REDIS_HASH_VALUE) {
            addHashIteratorCursorToReply(c, hi, REDIS_HASH_VALUE);
            count++;
        }
    }
	
	//释放迭代器
    hashTypeReleaseIterator(hi);
    redisAssert(count == length);
}

2.3 相关源代码

2.3.1 hashTypeInitIterator
hashTypeIterator *hashTypeInitIterator(robj *subject) {
    hashTypeIterator *hi = zmalloc(sizeof(hashTypeIterator));
    hi->subject = subject;
    hi->encoding = subject->encoding;

    if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
        hi->fptr = NULL;
        hi->vptr = NULL;
    } else if (hi->encoding == REDIS_ENCODING_HT) {
        hi->di = dictGetIterator(subject->ptr);
    } else {
        redisPanic("Unknown hash encoding");
    }

    return hi;
}
2.3.2 hashTypeNext
/* Move to the next entry in the hash. Return REDIS_OK when the next entry
 * could be found and REDIS_ERR when the iterator reaches the end. */
int hashTypeNext(hashTypeIterator *hi) {
    if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *zl;
        unsigned char *fptr, *vptr;

        zl = hi->subject->ptr;
        fptr = hi->fptr;
        vptr = hi->vptr;

        if (fptr == NULL) {
            /* Initialize cursor */
            redisAssert(vptr == NULL);
            fptr = ziplistIndex(zl, 0);
        } else {
            /* Advance cursor */
            redisAssert(vptr != NULL);
            fptr = ziplistNext(zl, vptr);
        }
        if (fptr == NULL) return REDIS_ERR;

        /* Grab pointer to the value (fptr points to the field) */
        vptr = ziplistNext(zl, fptr);
        redisAssert(vptr != NULL);

        /* fptr, vptr now point to the first or next pair */
        hi->fptr = fptr;
        hi->vptr = vptr;
    } else if (hi->encoding == REDIS_ENCODING_HT) {
        if ((hi->de = dictNext(hi->di)) == NULL) return REDIS_ERR;
    } else {
        redisPanic("Unknown hash encoding");
    }
    return REDIS_OK;
}
2.3.3 addHashIteratorCursorToReply
static void addHashIteratorCursorToReply(redisClient *c, hashTypeIterator *hi, int what) {
    
    //如果是压缩表
    if (hi->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;
		
		//从压缩表中获取当前位置值
        hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
        if (vstr) {
            addReplyBulkCBuffer(c, vstr, vlen);
        } else {
            addReplyBulkLongLong(c, vll);
        }

    }
    //如果是哈希表
	 else if (hi->encoding == REDIS_ENCODING_HT) {
        robj *value;

		//从哈希表中获取当前位置的值
        hashTypeCurrentFromHashTable(hi, what, &value);
        addReplyBulk(c, value);

    } else {
        redisPanic("Unknown hash encoding");
    }
}
2.3.4 hashTypeCurrentFromZiplist
/* Get the field or value at iterator cursor, for an iterator on a hash value
 * encoded as a ziplist. Prototype is similar to `hashTypeGetFromZiplist`. */
void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
                                unsigned char **vstr,
                                unsigned int *vlen,
                                long long *vll)
{
    int ret;

    redisAssert(hi->encoding == REDIS_ENCODING_ZIPLIST);

    if (what & REDIS_HASH_KEY) {
        ret = ziplistGet(hi->fptr, vstr, vlen, vll);
        redisAssert(ret);
    } else {
        ret = ziplistGet(hi->vptr, vstr, vlen, vll);
        redisAssert(ret);
    }
}
2.3.5 hashTypeCurrentFromHashTable
/* Get the field or value at iterator cursor, for an iterator on a hash value
 * encoded as a ziplist. Prototype is similar to `hashTypeGetFromHashTable`. */
void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst) {
    redisAssert(hi->encoding == REDIS_ENCODING_HT);

    if (what & REDIS_HASH_KEY) {
        *dst = dictGetKey(hi->de);
    } else {
        *dst = dictGetVal(hi->de);
    }
}

2.4 代码理解

  1. 获取键对象，并判断对象类型是否为hash类型
  2. 计算要遍历的结果值长度
  3. 初始化迭代对象
  4. 从头部向后面遍历hash元素
  5. 释放迭代器

  这里面的主要获取值的方法是 hashTypeCurrentFromZiplist 和 hashTypeCurrentFromHashTable，通过看代码和上面的注释可以看出来这两个方法和上面我们刚学习的 hashTypeGetFromZiplist 和 hashTypeGetFromHashTable 高度相似，核心不同点是前者是已知指针位置直接通过当前指针获取值就可以，后者要先根据键的位置找到键的指针，再来获取值。

  根据这个方法的参数和逻辑可以看出来，这个方法可以根据传入的flag来查找键、值、或者键值，刚好也就对应了hkeys、hvals、hgetall三个方法，发现redis中很多参数之间都是用这种二进制的 与或 来做判断，是一种不错的实践方法。

3 hkeysCommand

3.1 方法说明

  获取一个hash的所有键

3.2 命令实践

在这里插入图片描述

3.3 命令源代码

void hkeysCommand(redisClient *c) {
    genericHgetallCommand(c,REDIS_HASH_KEY);
}

3.4 代码理解

   直接调用了 genericHgetallCommand 方法，并传入了REDIS_HASH_KEY，来表示只获取键。

4 hvalsCommand

4.1 方法说明

  获取一个hash的所有值

4.2 命令实践

在这里插入图片描述

4.3 方法源代码

void hvalsCommand(redisClient *c) {
    genericHgetallCommand(c,REDIS_HASH_VALUE);
}

   直接调用了 genericHgetallCommand 方法，并传入了REDIS_HASH_VALUE，来表示只获取值。

5 hvalsCommand

5.1 方法说明

  获取一个hash的所有键和值

5.2 命令实践

在这里插入图片描述

5.3 方法源代码

void hgetallCommand(redisClient *c) {
    genericHgetallCommand(c,REDIS_HASH_KEY|REDIS_HASH_VALUE);
}

   直接调用了 genericHgetallCommand 方法，并传入了REDIS_HASH_KEY|REDIS_HASH_VALUE，来表示只获取键和值，这里就可以看到使用二进制运算的便捷性。

6 总结

  1. 有hashType前缀的方法，里面都包含了两种数据结构的处理逻辑。
  2. hgetall、hvals、hkeys 三个命令都会调用 genericHgetallCommand 方法。
  3. hashTypeGetFromZiplist 和hashTypeGetFromHashTable 先根据键找到键的位置，再来获取值。
  4. hashTypeCurrentFromZiplist 和 hashTypeCurrentFromHashTable 直接根据当前位置获取值。
  5. 有标记逻辑的时候，都会使用二进制运算来控制，并且这些枚举值都是 0 1 2 4 8 之类。
无痕之意
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hget和get redis_Redis 5种主要数据类型和命令
weixin_39921504的博客
12-20 576
redis是键值对的数据库，有5中主要数据类型：字符串类型(string)，散列类型(hash)，列表类型(list)，集合类型(set)，有序集合类型(zset)几个基本的命令：KEYS * 获得当前数据库的所有键EXISTS key [key ...] 判断键是否存在，返回个数，如果key有一样的也是叠加数DEL key [key ...] 删除键，返回删除的个数TYPE key...
Redis Hget 命令
qq_34579060的博客
04-26 8093
Redis Hget 命令用于返回哈希表中指定字段的值。语法redis Hget 命令基本语法如下：redis 127.0.0.1:6379&gt; HGET KEY_NAME FIELD_NAME 可用版本&gt;= 2.0.0返回值返回给定字段的值。如果给定的字段或 key 不存在时，返回 nil 。实例# 字段存在 redis&gt; HSET site redis redis.com (...
Redis 源码解析 - Redis hget 相关命令学习
最新发布
qq_33240556的博客
04-29 319
Redis 的HGET命令用于获取哈希（hash）数据类型中指定字段的值。了解其源码实现有助于深入理解Redis如何高效地处理哈希类型的数据读取操作。
redis中hget命令
热门推荐
qq_30505673的博客
10-21 1万+
HGETALL 名字 “field1” 值1 “field2” 值2
Redis学习之hget命令
爱喝水的qdy的博客
12-15 8170
目录hget命令语法返回值例子 hget命令 Redis hget，命令用于返回哈希表中指定字段的值 语法 hget key field 返回值 返回给定字段的值。 如果给定的字段或 key 不存在时，返回 nil 例子 字段存在 127.0.0.1:6379> hset website test:hget "abc" (integer) 1 127.0.0.1:6379> h...
redis源码分析与思考（十五）——哈希类型的命令实现(t_hash.c)
溯夜，逆流而上
10-17 325
哈希类型又叫做字典，在redis中，哈希类型本身是一个键值对，而哈希类型里面也存贮着键值对，其对应关系是，每个哈希类型的值对应着一个键值对或多对键值对，如图所示： ...
Redis全套学习笔记-带章节目录-114页.pdf
06-13
* 哈希（Hash）：哈希是Redis的一种数据类型，使用hset命令设置field的值，hget命令获取field的值。 * 有序集合（Zset）：有序集合是Redis的一种数据类型，使用zadd命令添加元素，zrange命令获取指定索引范围内的...
Redis全套学习笔记
06-07
Redis是一款高性能的Key-Value数据库，常用于缓存和数据持久化...以上就是Redis的主要学习内容，包括其基本概念、数据类型、操作命令以及发布订阅功能。掌握这些知识点对于理解和使用Redis进行数据存储和处理至关重要。
Redis学习 - Nyima's Blog.pdf
11-17
本文主要基于Nyima's Blog中的Redis学习笔记，详细介绍了Redis的一些基础操作和数据类型。 1. Redis常用指令： Redis提供了丰富的命令来操作数据，如`set`用于设置键值对，`get`用于获取键对应的值，`del`用于删除...
Redis String 类型和 Hash 类型学习笔记与总结
09-10
Redis String 类型和 Hash 类型是 Redis 数据库中两种基本的数据结构，它们各自有着独特的特性和应用场景。在本篇学习笔记中，我们将深入探讨这两种类型，了解它们的功能、操作方法以及如何在实际应用中有效利用。 ...
基于Spark的机器学习资料63、后台服务工具redis：详解redis操作命令.pdf
11-18
基于Spark的机器学习资料63、后台服务工具Redis详解Redis操作命令 基于Spark的机器学习资料63、后台服务工具Redis，是一个高性能的基于内存的数据存储系统，支持五种基本数据类型：string（字符串）、hash（哈希）...
reids源码 t_hash.c 实现
lxlmycsdnfree的博客
01-18 286
t_hash.c文件代码： #include "redis.h" #include /*----------------------------------------------------------------------------- * Hash type API *--------------------------------------------------------
Redis源码学习（12），t_hash.c 学习（三），学习总结
无痕之意的博客
04-27 144
1 方法列表 void hashTypeTryConversion(robj *o, robj **argv, int start, int end) void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2) int hashTypeGetFromZiplist(robj *o, robj *field, unsigned char **vstr,
Redis源码分析（十）——哈希表类型t_hash
艰难困苦如同欢乐，终将成为人生最后的财富
10-22 843
哈希表是HSET、HLEN等命令的操作对象，他使用REDIS_ENCODING_ZIPLIST（压缩列表）和REDIS_ENCODING_HT（字典）两种编码方式。 当哈希表使用字典编码时，程序将哈希表的键保存为字典的键，将哈希表的值保存为字典的值。哈希表使用的字典的键和值都是字符串对象。 当哈希表使用压缩列表编码时，程序通过将键和值交叉存入压缩列表中，从而形成保存哈希表需所需的键——值对结构
c++ 哈希_Redis源码解析十一--Hash键实现Redis 哈希键命令实现(t_hash)
weixin_39777242的博客
11-24 276
Redis 哈希键命令实现(t_hash)1. 哈希命令介绍Redis 所有哈希命令如下表所示：Redis 哈希命令详解2. 哈希类型的实现之前在redis对象系统源码剖析和注释中提到，一个哈希类型的对象的编码有两种，分别是OBJ_ENCODING_ZIPLIST和OBJ_ENCODING_HT。redis 压缩列表源码剖析和注释redis 字典结构源码剖析和注释但是默认创建的哈希类型的对象编码为...
Redis源码学习（10），t_hash.c 学习（一），hset、hmset 命令学习
无痕之意的博客
04-26 1705
   学习完 t_string.c、t_list.c文件后，现在开始学习 t_hash.c 的代码，从文件名可以看到是相关hash的相关命令代码。 1 hsetCommand 1.1 方法说明    对一个hash键，设置一个键值对。 1.2 命令实践 新增成功返回1，修改返回0 1.3 方法源代码 void hsetCommand(redisClient *c) { int update; robj *o; //获取键对象，如果不存在就创建一个 if ((o = hashTyp
Redis源码分析（八）--- t_hash哈希转换
走在前往架构师的路上
10-13 4512
在上次的zipmap分析完之后，其实关于redis源代码结构体部分的内容其实已经全部结束了，因为下面还有几个和结构体相关的操作类，就页把他们归并到struct包下了。这类的文件有：t_hash.c,z_list,z_set.c,t_string.c,t_zset.c,这些文件的功能其实都差不多，就是用来实现Client和Server之间的命令处理的操作类，通过robj的形式，把dict,zipli
redis命令之哈希表类型hget命令用法详情（不支持多field）
张步云的专栏
08-18 5556
哈希表 HGET命令 命令:hget key field，通过key获取field的值，不能同时获取多个field！一次只能获取一个field的value。 127.0.0.1:6381> flushall OK 127.0.0.1:6381> hset user_id_1 name "Jordan" age 18 (integer) 2 127.0.0.1:6381> hget user_id_1 name age #不支持同时获取多个field域的值 (error) ERR
hget和get redis_Redis 哈希(hash)命令
06-13
是的，hget和get是两个不同的Redis命令。 get命令用于获取存储在指定键(key)中的值，而hget命令用于获取存储在指定哈希键(hash key)中的值。 例如，如果我们有一个键为"name"，值为"John"的字符串类型数据，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值