Redis基本数据类型

---

Redis基本数据类型

0.RedisObject

Redis中的任意数据类型的键和值都会被封装为一个RedisObject，也叫做Redis对象，源码如下：

#define LRU_BITS 24
typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;//底层编码方式
    unsigned lru:LRU_BITS; // 最久未使用的，便于回收长时间未使用的key
    int refcount;// 对象引用计数，用于回收对象
    void *ptr;//指针，指向存放实际数据的空间
} robj;

• type对象类型，取值如下，分别是string、list、set、zset、hash

#define OBJ_STRING 0    /* String object. */
#define OBJ_LIST 1      /* List object. */
#define OBJ_SET 2       /* Set object. */
#define OBJ_ZSET 3      /* Sorted set object. */
#define OBJ_HASH 4      /* Hash object. */  

Redis这个对象头占16个字节，如果使用string这种数据结构，那么每一个string都需要一个对象头来记录就会有一定的内存消耗，而使用list的话只需要一个对象头，后面只需要存储数据即可。如果有大量的数据要存储，建议使用其它集合，减少内存消耗。

Redis中会根据存储的数据类型不同，选择不同的编码方式，共包含11种不同类型：

编号	编码方式	说明
0	OBJ_ENCODING_RAW	raw编码动态字符串
1	OBJ_ENCODING_INT	long类型的整数的字符串
2	OBJ_ENCODING_HT	hash表（字典dict）
3	OBJ_ENCODING_ZIPMAP	已废弃
4	OBJ_ENCODING_LINKEDLIST	双端链表
5	OBJ_ENCODING_ZIPLIST	压缩列表
6	OBJ_ENCODING_INTSET	整数集合
7	OBJ_ENCODING_SKIPLIST	跳表
8	OBJ_ENCODING_EMBSTR	embstr的动态字符串
9	OBJ_ENCODING_QUICKLIST	快速列表
10	OBJ_ENCODING_STREAM	Stream流

Redis中会根据存储的数据类型不同，选择不同的编码方式。每种数据类型的使用的编码方式如下：

数据类型	编码方式
OBJ_STRING	int、embstr、raw
OBJ_LIST	LinkedList和ZipList(3.2以前)、QuickList（3.2以后）
OBJ_SET	intset、HT
OBJ_ZSET	ZipList、HT、SkipList
OBJ_HASH	ZipList、HT

1. String

String是Redis中最常见的数据存储类型：

• 其基本编码方式是RAW，基于简单动态字符串（SDS）实现，存储上限为512mb。

struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* buf已经保存的字符串字节个数，不包含结束标识符 */
    uint32_t alloc; /* buf申请的总的字节数，不包含结束标识 */
    unsigned char flags; /* 不同的SDS的头类型，用来控制SDS头的大小 */
    char buf[];
};

• 如果存储的SDS长度小于44字节，则会采用EMBSTR编码，此时object head与SDS是一段连续空间。申请内存时只需要调用一次内存分配函数，效率更高。
• 如果存储的字符串是整数值，并且大小在LONG_MAX范围内，则会采用INT编码：直接将数据保存在RedisObject的ptr指针位置（刚好8字节），不再需要SDS了。

3种编码方式的类型结构

2. List

Redis的List类型可以从首、尾操作列表中的元素：

• 在3.2版本之前，Redis采用ZipList和LinkedList来实现List，当元素数量小于512并且元素大小小于64字节时采用ZipList编码，超过则采用LinkedList编码。
• 在3.2版本之后，Redis统一采用QuickList来实现List：

添加元素部分源码：

/* 实现 LPUSH/RPUSH/LPUSHX/RPUSHX 操作。
 * 'xx': 若键存在则进行推送。 */
// 每个客户端和Redis建立连接都会创建一个 client对象
void pushGenericCommand(client *c, int where, int xx) {
    int j;

    // 遍历参数，检查每个元素的长度是否超过最大限制
    for (j = 2; j < c->argc; j++) {
        // 如果元素长度超过最大限制，则返回错误
        if (sdslen(c->argv[j]->ptr) > LIST_MAX_ITEM_SIZE) {
            addReplyError(c, "Element too large");
            return;
        }
    }

    // 尝试获取到KEY对应的list返回的是一个RedisObject对象
    robj *lobj = lookupKeyWrite(c->db, c->argv[1]);
    // 判断返回类型是否为list
    if (checkType(c, lobj, OBJ_LIST)) return;
    // 判断是否为空
    if (!lobj) {
        if (xx) {
            addReply(c, shared.czero);
            return;
        }

        // 为空创建一个新的 quicklist 对象
        lobj = createQuicklistObject();
        // 设置 quicklist 的选项
        quicklistSetOptions(lobj->ptr, server.list_max_ziplist_size,
                            server.list_compress_depth);
        // 将键和 quicklist 对象添加redis中
        dbAdd(c->db, c->argv[1], lobj);
    }
    //......
}

robj *createQuicklistObject(void) {
    // 申请内存并初始化QuickList
    quicklist *l = quicklistCreate();
    // 创建RedisObject ,type为 OBJ_LIST
    // 将ptr指向QUickList
    robj *o = createObject(OBJ_LIST,l);
    // 设置编码格式为QuickList
    o->encoding = OBJ_ENCODING_QUICKLIST;
    return o;
}

list的内存结构：

3. Set

Set是Redis中的单列集合，满足下列特点：

• 不保证有序性
• 保证元素唯一
• 可以求交集、并集、差集

Set是Redis中的集合，不一定确保元素有序，可以满足元素唯一、查询效率要求极高。

• 为了查询效率和唯一性，set采用HT编码（Dict）。Dict中的key用来存储元素，value统一为null。
• 当存储的所有数据都是整数，并且元素数量不超过set-max-intset-entries时，Set会采用IntSet编码，以节省内存。

创建set源码

在第一次添加的时候会创建set

robj *setTypeCreate(sds value) {
    // 判断value是否为数值类型 （long long）
    if (isSdsRepresentableAsLongLong(value,NULL) == C_OK)
        // 如果是数值类型，则采用IntSet编码
        return createIntsetObject();
    // 否则采用默认编码，也就是HT
    return createSetObject();
}

如果此时set的编码类型是intset，当插入的元素不是数字或者元素数量超过set-max-intset-entries的时候，就会进行编码转换，转换成HT。部分源码

int setTypeAdd(robj *subject, sds value) {
    long long llval;
    if (subject->encoding == OBJ_ENCODING_HT) {// 已经是HT编码直接添加元素
        dict *ht = subject->ptr;
        dictEntry *de = dictAddRaw(ht,value,NULL);
        if (de) {
            dictSetKey(ht,de,sdsdup(value));
            dictSetVal(ht,de,NULL);
            return 1;
        }
    } else if (subject->encoding == OBJ_ENCODING_INTSET) {//如果是INTSET编码
        // 判断value是否是整数
        if (isSdsRepresentableAsLongLong(value,&llval) == C_OK) {
            uint8_t success = 0;// 是整数直接添加元素到Set
            subject->ptr = intsetAdd(subject->ptr,llval,&success);
            if (success) {
                //当ineset元素数量超过server.set_max_intset_entries
                // 则转为HT
                size_t max_entries = server.set_max_intset_entries;
                /* limit to 1G entries due to intset internals. */
                if (max_entries >= 1<<30) max_entries = 1<<30;
                if (intsetLen(subject->ptr) > max_entries)
                    setTypeConvert(subject,OBJ_ENCODING_HT);
                return 1;
            }
        } else {
            //不是整数转为HT
            setTypeConvert(subject,OBJ_ENCODING_HT);

            
            serverAssert(dictAdd(subject->ptr,sdsdup(value),NULL) == DICT_OK);
            return 1;
        }
    } else {
        serverPanic("Unknown set encoding");
    }
    return 0;
}

set对应的内存结构

4. ZSet

ZSet也就是SortedSet，其中每一个元素都需要指定一个score值和member值：

• 可以根据score值排序后
• member必须唯一
• 可以根据member查询分数

因此，zset底层数据结构必须满足键值存储、键必须唯一、可排序这几个需求。之前学习的哪种编码结构可以满足？

• SkipList：可以排序，并且可以同时存储score和ele值（member）
• HT（Dict）：可以键值存储，并且可以根据key找value

没错ZSet底层采用SkipList+Dict两种结构进行存储，就可以满足排序、范围查找、根据key查询score。

内存结构图：

当元素数量不多时，HT和SkipList的优势不明显，而且更耗内存。因此zset还会采用ZipList结构来节省内存，不过需要同时满足两个条件：

1. 元素数量小于zset_max_ziplist_entries，默认值128
2. 每个元素都小于zset_max_ziplist_value字节，默认值64

Zset添加元素源码

void zaddGenericCommand(client *c, int flags) {
    // 省略大量代码...
    // zadd添加元素时，先根据key找到zset，不存在则创建新的zset
    zobj = lookupKeyWrite(c->db,key);
    if (checkType(c,zobj,OBJ_ZSET)) goto cleanup;
    // 判断是否存在
    if (zobj == NULL) {
        if (xx) goto reply_to_client; /* No key + XX option: nothing to do. */
        //zset_max_ziplist_entries如果设置为0就是禁用了ZipList
        if (server.zset_max_ziplist_entries == 0 ||
            // 或者value超过了zset_max_ziplist_value,则采用HT+SkipList
            server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+1]->ptr))
        {
            zobj = createZsetObject();
        } else {
            // 否则采用ZipList
            zobj = createZsetZiplistObject();
        }
        dbAdd(c->db,key,zobj);
    }
    // 省略大量代码
}

元素少的时候采用HT+ZipList来节省内存，如果在添加元素的时候返现不满足上诉两点要求，就会将ZipList编码转换为SkipList编码。

ziplist本身没有排序功能，而且没有键值对的概念，因此需要有zset通过编码实现：

• ZipList是连续内存，因此score和element是紧挨在一起的两个entry， element在前，score在后
• score越小越接近队首，score越大越接近队尾，按照score值升序排列

内存结构图：

5.Hash

Hash结构与Redis中的Zset非常类似：

• 都是键值存储

• 都需求根据键获取值

• 键必须唯一

区别如下：

• zset的键是member，值是score；hash的键和值都是任意值
• zset要根据score排序；hash则无需排序

因此，Hash底层采用的编码与Zset也基本一致，只需要把排序有关的SkipList去掉即可：

• Hash结构默认采用ZipList编码，用以节省内存。 ZipList中相邻的两个entry 分别保存field和value
• 当数据量较大时，Hash结构会转为HT编码，也就是Dict，触发条件有两个：
  • ZipList中的元素数量超过了hash-max-ziplist-entries（默认512）
  • ZipList中的任意entry大小超过了hash-max-ziplist-value（默认64字节）

---