小菜鸟
0%

redis数据类型

发表于 更新于 分类于 阅读次数： Valine：

redis数据类型

redis全名(Remote Dictionary Server)，即远程字典服务

redis的值可以有五大数据类型，String、List、Set、Hash、zset(sorted set，有序集合)

注意：我使用的版本是6.0.10，不同版本可能略有差别

1
2
3
4
5
6
7
8
9
typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

redis中实际的数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#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. */

/* The "module" object type is a special one that signals that the object
 * is one directly managed by a Redis module. In this case the value points
 * to a moduleValue struct, which contains the object value (which is only
 * handled by the module itself) and the RedisModuleType struct which lists
 * function pointers in order to serialize, deserialize, AOF-rewrite and
 * free the object.
 *
 * Inside the RDB file, module types are encoded as OBJ_MODULE followed
 * by a 64 bit module type ID, which has a 54 bits module-specific signature
 * in order to dispatch the loading to the right module, plus a 10 bits
 * encoding version. */
#define OBJ_MODULE 5    /* Module object. */
#define OBJ_STREAM 6    /* Stream object. */

redis的编码分类

1
2
3
4
5
6
7
8
9
10
11
#define OBJ_ENCODING_RAW 0     /* Raw representation */
#define OBJ_ENCODING_INT 1     /* Encoded as integer */
#define OBJ_ENCODING_HT 2      /* Encoded as hash table */
#define OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define OBJ_ENCODING_LINKEDLIST 4 /* No longer used: old list encoding. */
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define OBJ_ENCODING_INTSET 6  /* Encoded as intset */
#define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
char *strEncoding(int encoding) {
    switch(encoding) {
    case OBJ_ENCODING_RAW: return "raw";
    case OBJ_ENCODING_INT: return "int";
    case OBJ_ENCODING_HT: return "hashtable";
    case OBJ_ENCODING_QUICKLIST: return "quicklist";
    case OBJ_ENCODING_ZIPLIST: return "ziplist";
    case OBJ_ENCODING_INTSET: return "intset";
    case OBJ_ENCODING_SKIPLIST: return "skiplist";
    case OBJ_ENCODING_EMBSTR: return "embstr";
    case OBJ_ENCODING_STREAM: return "stream";
    default: return "unknown";
    }
}

String类型

string类型属于单值单value，是一个可变的字节数组，就像StringBuilder似的，可以追加、获取长度、截取等操作

扩容：当字符串长度小于1M时，扩容是现有空间进行加倍；当字符串长度超过1M，扩容只会多扩1M的空间。且字符串最长为512M

源码结构

1
2
3
4
5
6
7
8
9
struct __attribute__ ((__packed__)) sdshdr64 {
    // 字符串长度
    uint64_t len; /* used */
      // 内存分配
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
      // 字节数组
    char buf[];
};

编码格式

编码 对象
OBJ_ENCODING_INT 使用整数值实现的字符串对象
OBJ_ENCODING_EMBSTR 使用embstr编码的简单动态字符串实现的字符串对象
OBJ_ENCODING_RAW 使用简单动态字符串实现的字符串对象

string有三种编码格式

  • int 整数值
  • embstr 字符串长度小于44字节使用，数据保存在一块连续的内存里
  • raw 字符串值长度大于44字节使用

操作命令

值拼接

1
2
3
4

#给key对应的value进行拼接，返回的是拼接之后的字符长度
append k1 qwe
(integer) 5

值长度

1
strlen k1

数字运算操作

1
2
3
4
5
6
7
8
#加一
INCR k2
#减一
DECR k2
#加3
INCRBY k2 3
#减2
DECRBY k2 2

注意：这几个命令只能对数字进行操作，范围是Long.MIN~Long.MAX

获取值

1
2
3
4
get k1

#只获取该key所对应value的部分字符
getrange k1 0 2

设置值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# setrange覆盖部分值  其中0为从下标为0的字符开始替换
setrange k1 0 zx
(integer) 5

#设置值时设置过期时间
#setex key seconds value
setex k3 20 b

#如果key不存在设置值,防止覆盖(set if not exists)
#setnx key value
setnx k1 1

# 设置key的值，并返回key的旧值
getset k1 vv1

多值操作

1
2
3
4
5
6
7
8
9
#同时set多个键值
#mset key value [key value ...]
mset k4 v4 k5 v5
#同时获取多个键的值
#mget key  [key ...]
mget k4 k5 
#同时set多个键值(全部不存在时才会设置值)
#msetnx key value [key value ...]
msetnx k6 v6 k7 k8

List类型

List属于单值多value，列表用的是双向链表结构

list支持pop、push来操作头部和尾部，既可以用做栈也可以用做队列

源码结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
typedef struct listNode {
      // 前驱节点
    struct listNode *prev;
      // 后继节点
    struct listNode *next;
      // 值
    void *value;
} listNode;

typedef struct list {
      // 头节点
    listNode *head;
      // 尾结点
    listNode *tail;
      // 节点复制函数
    void *(*dup)(void *ptr);
      // 节点释放函数
    void (*free)(void *ptr);
  
    int (*match)(void *ptr, void *key);
    unsigned long len;
} list;

这个结构不知道还用不用，因为看源码来说在创建list的时候创建的是quicklist

quicklist结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
typedef struct quicklist {
    quicklistNode *head;
    quicklistNode *tail;
    unsigned long count;        /* total count of all entries in all ziplists */
    unsigned long len;          /* number of quicklistNodes */
    int fill : QL_FILL_BITS;              /* fill factor for individual nodes */
    unsigned int compress : QL_COMP_BITS; /* depth of end nodes not to compress;0=off */
    unsigned int bookmark_count: QL_BM_BITS;
    quicklistBookmark bookmarks[];
} quicklist;

typedef struct quicklistEntry {
    const quicklist *quicklist;
    quicklistNode *node;
    unsigned char *zi;
    unsigned char *value;
    long long longval;
    unsigned int sz;
    int offset;
} quicklistEntry;

而对于quicklist编码的定义是

1
OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */

看代码像是存到quicklist中，然后又使用ziplist压缩的，毕竟不是专业的c语言，看的并不是那么明白

操作命令

设置值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#lpush(指从左边进 左进右出  就想是栈一样)
#lpush key element [element ...]
lpush list1 1 2 3 4 5
#取值
#lrange key start end   (负下标表示的是从后往前，如-1表示倒数第一)
lrange list1 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
#rpush(指从右边进 右进左出  就想是栈一样)
#rpush key element [element ...]
rpush list2 1 2 3 4 5

#给某个索引位置赋值
#lset key index element
lset list1 0 q

#在某个元素之前或之后插入一个元素
#linsert key before|after pivot element
linsert list1 before q zz

取值

1
2
3
4
5
6
7
8
9
10
#弹出栈顶元素(从左边开始弹出，弹出之后，list中就不存在该元素了)
#lpop key 
lpop list1
#弹出栈顶元素(从右边开始弹出，弹出之后，list中就不存在该元素了)
#rpop key 
rpop list1

#按照索引位置取值
#lindex key index
lindex list1 0

列表长度

1
llen list1

删除值

1
2
3
4
5
6
7
8
9
10
11
12
#删除几个某个元素
#lrem key count element
lrem list1 1 2

#截取指定范围的值赋给key(范围是索引)
#ltrim key start stop
ltrim list1 0 0

# 从头部删除元素  出栈
lpop list1
# 从尾部删除元素
rpop list1

出栈入栈

1
2
3
#从源列表右出栈压入左目标列表
#rpoplpush source dest
rpoplpush list2 list1

Set类型

set类型是单值多value，与List的区别在于不可重复，类似于HashSet，通过hash table实现的

set除了基本的增删改查操作之外，还可以使用集合来取并集、交集、差集，可以用来实现好友推荐等功能

编码格式

编码 对象
OBJ_ENCODING_INTSET 使用整数集合实现的集合对象
OBJ_ENCODING_HT 使用的hash table

set有两种编码格式

  • intset 保存的元素全都是整数
  • hash table 保存的不是整数

操作命令

设置值

1
2
3
4
#设置值
#sadd key member [member ...]
sadd set1 vv vc vb vv

取值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#取值
#smembers key
smembers set1
1) "vc"
2) "vb"
3) "vv"

#判断该元素是否在set中
#sismember key member
sismember set1 vv

#获取随机的元素(count表示获取的数量，默认为1)
#srandmember key [count]
srandmember set1 2

查看集合元素个数

1
2
#scard key
scard set1

删除

1
2
3
4
5
6
#srem key member
srem set1 vb

#随机出栈(默认数量为1)
#spop key [count]
spop set1

随机抽取

1
2
3
#随机从集合中抽取2个(默认1个)
#srandmember key [count]
srandmember set1 2
1
2
3
#将源集合中的值移至目标集合
#smove source dest member
smove set1 set2 5

差集 交集 并集

1
2
3
4
5
6
7
8
9
10
#差集 返回的是其他key与第一个key的差集
#sdiff key [key ...]
sdiff set1 set2

#交集
#sinter key [key ...]
sinter set1 set2
#并集
#sunion key [key ...]
sunion set1 set2

Hash类型

value是键值对，相当于HashMap，对于hash碰撞也是采用的HashMap的处理方式，数组+链表

更适合存储对象，将一个对象存储在hash类型中会占用更少的内存，且可以更方便的存取整个对象

编码格式

编码 对象
OBJ_ENCODING_ZIPLIST 使用ziplist
OBJ_ENCODING_HT 使用的hash table

set有两种编码格式

  • ziplist 一开始存储使用的ziplist，但是当满足一定条件时会转换为hash table
  • hash table

源码结构

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
typedef struct dictht {
      // 哈希表数组
    dictEntry **table;
      // 哈希表大小
    unsigned long size;
      // 哈希表大小掩码，用于计算索引值
    unsigned long sizemask;
      // 哈希表已有节点数量
    unsigned long used;
} dictht;

typedef struct dictEntry {
      // 键
    void *key;
      // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
      // 下一个哈希节点，链表
    struct dictEntry *next;
} dictEntry;

typedef struct dict {
      // 类型
    dictType *type;
      // 私有数据
    void *privdata;
      // 哈希表
      // ht[0]:用来存放真是的数据
      // ht[1]:用于扩容
    dictht ht[2];
      //rehash 如果为-1表示没有进行rehash
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    int16_t pauserehash; /* If >0 rehashing is paused (<0 indicates coding error) */
} dict;

redis哈希冲突将新节点添加在链表的表头

操作命令

设置值

1
2
3
4
5
6
7
8
9
10
11
#Redis4.0之后可以设置多个值，与hmset功能相同
#hset key field value [field value ...]
hset user id 123

#设置多个字段
#hmset key field value [field value ...]
hmset user name zhangsan age 18

#不存在则设置值
#hsetnx key field value
hsetnx user id 12

获取值

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
#hget key field
hget user id
#获取多个字段的值
#hmget key field [field ...]
hmget user id name sex age

#可以获取该key所对应的map
#hgetall key
hgetall user

#获取key对应的map有几个字段
#hlen key
hlen user

#判断该key的某个字段是否存在
#hexists key field
hexists user id

#获取该key下所有的字段
#hkeys key
hkeys user

#获取该key下所有的字段值
#hvals key 
hvals user

删除字段值

1
2
3
#支持删除多个
#hdel key field [field ...]
hdel user age

数值操作

1
2
3
# 加2
# hincrby key field increment
hincrby user id 2

Zset类型

zset是sorted set，即有序的集合，在set的基础上加了一个score，类似于TreeSet，使用score来进行排序，也可以根据score的范围来获取元素的列表

原本set值为k1 v1 k2 v2，而zset是k1 score1 v1 k2 score2 v2

底层使用的是hash和跳表，hash用来关联value和score，保证value的唯一性，同时通过value可以获取到score。跳表的作用在于给value排序以及根据score的范围来获取元素列表

编码格式

编码 对象
OBJ_ENCODING_ZIPLIST 使用ziplist
OBJ_ENCODING_SKIPLIST 使用的skiplist

zset有两种编码格式

  • ziplist 满足条件使用ziplist，否则使用skiplist
  • skiplist

操作命令

设置值

1
2
#zadd key score member [score member ...]
zadd zset1 1 q 2 w

取值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#WITHSCORES表示查询结果是否带着score
#zrange key start stop [WITHSCORES]
zrange zset1 0 -1

#根据score范围查询
#zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
zrangebyscore zset2 0 1

#根据score的范围来计数
#zcount key min max
 zcount zset2 0 10
 
 #根据值来获取下标(根据score从小到大来排的序)
 #zrank key member
 zrank zset2 d
 
 #根据值来获取下标(根据score从大到小来排的序)
 #zrevrank key member
 zrevrank zset2 d
 
 #根据值来获取score
 #zscore key member
 zscore zset2 c

查看集合元素个数

1
2
#该key的元素个数
zcard zset2

删除

1
2
3
4
5
6
7
8
9
10
#zrem key member
zrem zset2 s

# 根据下标区间来删除(根据score从小到大来排的序)
#zremrangebyrank key start stop
zremrangebyrank zset1 5 8

# 根据score区间来删除
# zremrangebyscore key min max
zremrangebyscore zset1 7 10

数值操作

1
2
3
# 如果key中存在该元素，则该元素的score增加increment，否则新增该元素
# zincrby key increment member
zincrby zset1 2 b