Redis 3 Hash SortedSet
uwupu 啦啦啦啦啦
  2022-09-21 09:23 2022-09-21 09:23   2024-10-17 22:27      5.8k 字  27 分钟  

Hash

Hash用于存储field和value的映射表，适用于存储对象。

每个hash中可以存储2^32-1个field-value pair；

使用/场景

场景

缓存：更直观地维护缓存信息，如用户信息、饰品信息；

例子：存储用户的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
127.0.0.1:6379> hset user:001 username ZhangSan firstName San lastName zhang age 21  # 在user:001中存储键值对 
#其中分别为 username:ZhangSan  firstName:San lastName:zhang age:21
(integer) 4  # 返回field value对的数量
127.0.0.1:6379> hget user:001 username  # 查询user:001的username
"ZhangSan"
127.0.0.1:6379> hgetall user:001  # 获取user:001的所有 field-value pair
1) "username"
2) "ZhangSan"
3) "firstName"
4) "San"
5) "lastName"
6) "zhang"
7) "age"
8) "21"

例子：存储设备的访问状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
127.0.0.1:6379> hincrby device:2:stats pings 1  # device:2:stats的pings加一
(integer) 1
127.0.0.1:6379> hincrby device:2:stats pings 1
(integer) 2
127.0.0.1:6379> hincrby device:2:stats pings 1
(integer) 3
127.0.0.1:6379> hincrby device:2:stats requests 1  # device:2:stats的requests加一
(integer) 1
127.0.0.1:6379> hincrby device:2:stats errors 1  # device:2:stats的errors加一
(integer) 1
127.0.0.1:6379> hget device:2:stats pings # 获取device:2:stats的pings
"3"
127.0.0.1:6379> hmget device:2:stats requests errors  # 获取device:2:stats的requests和errors
1) "1"
2) "1"

基础命令

hset：hash设置值；

hget：hash获取值；

hmget：hash获取多个值；

hincrby：若value可以为整数，则增加value的值。

其他命令

增 删 查
HSET HDEL HGET
HSETNX HMGET
HINCRBY HEXISTS
HINCRBYFLOAT HLEN
HSTRLEN
HRANDFIELD

HSET 设置值 可以多个

hset key field value [field value ...]

设置hash的多个field-value对；

返回添加的field-value对数量。

HSETNX 当field不存在则设置值

hsetnx key field value

当集合中没有指定field时，为集合添加field-value对；若集合中存在指定field，则不进行操作；

若key对应的set不存在，则创建一个集合；

返回值：

  • 若成功添加返回1；
  • 若field已存在，操作没有执行，返回0。
1
2
3
4
127.0.0.1:6379> hsetnx user:1 age 3
(integer) 1
127.0.0.1:6379> hsetnx user:1 age 5
(integer) 0

HGET 获得field的value

hget key field

获取集合中field对应的值；

若集合中没有field或集合不存在则返回nil；

1
2
3
4
127.0.0.1:6379> hsetnx user:1 age 3  # 设置user:1的age的值为3
(integer) 1
127.0.0.1:6379> hget user:1 age  # 获取user:1的age值
"3"

HMGET 获取field的value 可以多个

hmget key field [field ...]

获取集合中field对应的value。

返回一个数组，包含每个field对应的value；

若field不存在，则为nil；

若key不存在，视作空hash，将返回一个值为nil的数组；

1
2
3
4
5
6
7
8
9
127.0.0.1:6379> hset user:3 name zhangsan age 12 psw 1234565
(integer) 3
127.0.0.1:6379> hmget user:3 name age pass
1) "zhangsan"
2) "12"
3) (nil)
127.0.0.1:6379> hmget user:4 name age
1) (nil)
2) (nil)

HGETALL 获得所有field-value

hgetall key

获取集合中所有的field-value对；

1
2
3
4
5
6
7
8
9
127.0.0.1:6379> hset user:2 name ZhangSan age 12 psw 123456
(integer) 3
127.0.0.1:6379> hgetall user:2
1) "name"
2) "ZhangSan"
3) "age"
4) "12"
5) "psw"
6) "123456"

HDEL 删除field 可以多个

hdel key field [field ...]

删除集合中的field-value 对；

返回成功删除的field的数量；

若key不存在，则返回0；

1
2
3
4
5
6
7
8
9
10
11
12
127.0.0.1:6379> hgetall user:2
1) "name"
2) "ZhangSan"
3) "age"
4) "12"
5) "psw"
6) "123456"
127.0.0.1:6379> hdel user:2 name age
(integer) 2
127.0.0.1:6379> hgetall user:2
1) "psw"
2) "123456"

HEXISTS 查询field存在

hexists key field

若集合中存在field返回1，否则返回0；

HLEN 获得field数量

hlen key

返回集合field的数量。

HSTRLEN 获得value的长度

hstrlen key field

返回集合中field对应的value的长度，若key或field不存在返回0；

HINCRBY 增加整型的值

hincrby key field increment

增加集合中field整型变量的值；

若key不存在，则自动创建一个集合，若field不存在，则在操作执行前将field的值设为0；

（即若key或field不存在，设集合key的field值为1）

（increment非可选变量，是必选变量）

1
2
3
4
127.0.0.1:6379> hincrby user:5 age 1
(integer) 1
127.0.0.1:6379> hget user:5 age
"1"

HINCRBYFLOAT 增加浮点数的值

hincrbyfloat key field increment

Hash INCREment FLOAT

功能与hincrby类似，不同的是hincrbyfloat可以增加浮点数。

若increment为负，则为减少指定的值；

若key或field不存在，则在操作执行前，将key集合的field设为0（即操作执行后，值为1）

若field的value的类型不是数字或value的值不可被解析为一个浮点数，将返回错误信息；

若执行成功，返回增加后的值。

1
2
3
4
5
6
7
8
127.0.0.1:6379> hset user:6 age 3
(integer) 1
127.0.0.1:6379> hincrbyfloat user:6 age 1.23
"4.23"
127.0.0.1:6379> hset user:6 name ZhangSan
(integer) 1
127.0.0.1:6379> hincrbyfloat user:6 name 1.23
(error) ERR hash value is not a float

HRANDFIELD 随机获取field

hrandfield key [count [WITHVALUES]]

获取集合中随机的field值；

若包含WITHVALUES参数，则返回field-value对；

关于count的使用：

  • 若count为正，返回指定数量的field，若count大于集合的基数，则返回集合的基数数量的field；
  • 若count为负，返回|count|数量的field，且返回值可能存在重复；不论count与集合的基数大小关系，返回的结果的数量绝对是|count|；

返回值：

  • 若没有count参数，则返回一个value；若key不存在返回nil；
  • 若有count参数，则返回一个数组，若key不存在返回空数组；若包含WITHVALUES参数，则返回field和它对应的value。
1
2
3
4
5
6
7
8
9
10
11
12
127.0.0.1:6379> hrandfield user:7 2
1) "name"
2) "psw"
127.0.0.1:6379> hrandfield user:7 10
1) "name"
2) "age"
3) "psw"
127.0.0.1:6379> hrandfield user:7 2 WITHVALUES
1) "name"
2) "XiaoMing"
3) "psw"
4) "xm123"

HVALS 获取所有的values

HVALS key

Hash VALueS

返回所有的values；

1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> hgetall user:7
1) "name"
2) "XiaoMing"
3) "age"
4) "15"
5) "psw"
6) "xm123"
127.0.0.1:6379> hvals user:7
1) "XiaoMing"
2) "15"
3) "xm123"

HMSET（弃用） 与hset一致

与hset功能相同，即将被弃用

Sorted Set

带有排序功能的set；

排序方式：按照scores顺序存储字符串，若字符串有相同scores，则按照字典序存储字符串；

应用举例：

  • 游戏排名最高分；
  • 通过滑动窗口限制同一时间内的API请求数量。

实现

Redis Sorted Set实现原理

  1. 压缩列表（ziplist）：ziplist是为了提高存储效率而设计的一种特殊编码的双向链表，可以存储字符串或整数；存储整数采用二进制而不是字符串；Ziplist能在O(1)的复杂度下完成list两端的push和pop操作；每次操作都需要重新分配ziplist的内存，实际复杂度与ziplist的内存使用量有关；
  2. 跳跃表(zSkiplist)：跳跃表的性能可以保障查找、删除和添加等操作在对数期望时间内完成，跳跃表的复杂度是O(log(n))；

例子：游戏排名最高分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
127.0.0.1:6379> zadd leaderboard 100 user:1 # 设置user:1的得分是100
(integer) 1
127.0.0.1:6379> zadd leaderboard 89 user:2 # 设置user:2的得分是89
(integer) 1
127.0.0.1:6379> zadd leaderboard 201 user:3 # 设置user:3的得分是201
(integer) 1
127.0.0.1:6379> zadd leaderboard 23 user:4
(integer) 1
127.0.0.1:6379> zadd leaderboard 111 user:5
(integer) 1
127.0.0.1:6379> zrange leaderboard 0 2 REV WITHSCORES # 获取范围 0 2，REV逆序，WITHSCORES包含分数
1) "user:3"
2) "201"
3) "user:5"
4) "111"
5) "user:1"
6) "100"

基础命令

ZADD：添加新的对象和分数到有序集合中，若对象存在，则更新分数；

ZRANGE：返回排序后的对象列表，可以选择排行榜的范围；

ZRANK：返回对象所在的排名；

ZREVRANK：返回集合在逆序下，对象所在的排名。

性能

zrange：O(log(n))

其他：O(log(n)+m)

其他命令

增 删 查 自增 并 交 差
ZADD ZREM ZCARD ZINCRBY ZUNION ZINTER ZDIFF
ZREMRANGEBYLEX ZCOUNT ZUNIONSTORE ZINTERCARD ZDIFFSTORE
ZREMRANGEBYRANK ZLEXCOUNT ZINTERSTORE
ZREMRANGEBYSCORE ZSCORE
ZPOPMAX ZMSCORE
ZPOPMIN ZRANDMEMBER
ZMPOP ZRANGE
ZRANGEBYLEX
ZRANGEBYSCORE
ZRANGESTORE
ZREVRANGE
ZREVRANGEBYLEX
ZREVRANGEBYSCORE
ZRANK
ZREVRANK

增

ZADD

介绍/使用

ZADD key [MX | XX] [GT | LT] [CH] [INCR] score member [score member ...]

  • 向有序集合中添加指定的对象和scores，可以指定多个member-score对；

  • 如果集合中已存在要添加的member，则更新member的score为新输入的score；

  • 如果key不存在，则创建相应的有序集合并将对象和score放进集合中；若key存在且类型不为有序集合，则返回错误；

  • score的值应为双精度浮点数的string格式；

可以用的参数
  • XX：仅更新已存在的元素，不添加新的元素；
  • NX：仅添加新的元素，不更新已存在的元素；
  • LT：若输入的score值小于原本的score值，则更新存在的值；
  • GT：若输入的score值大于原本的score值，则更新存在的值；
  • CH：返回值改为更新的元素数量；
  • INCR：将ZADD的作用变为ZINCRBY，此时只能指定一个score-element对；

注意：GT、LT和NX三者是互斥的。

实现

Redis采用64位双精度浮点数来表示score，依据IEEE 754实现，能够精确的表示-(2^53 )到+(2^53)之间的数字。

返回值

默认返回添加到有序集合的元素数量；

如果指定CH选项，则返回改变的元素的数量；

如果指定incr选项，若执行成功返回对象的score，操作取消则返回nil（被XX或NX选项阻止）。

代码
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
127.0.0.1:6379> zadd ss 10 a 20 b  # 设置 a=10 b=20
(integer) 2
127.0.0.1:6379> zadd ss XX CH 20 a 30 b  # 仅更新值，不添加新的元素
(integer) 1
127.0.0.1:6379> zrange ss 0 -1 WITHSCORES
1) "a"
2) "20"
3) "b"
4) "30"
127.0.0.1:6379> zadd ss NX 5 c 69 b  # 仅添加新的元素，不更新值
(integer) 1
127.0.0.1:6379> zrange ss 0 -1 WITHSCORES
1) "c"  # c被添加
2) "5"
3) "a"
4) "20"
5) "b"
6) "30"  # b没有被更新
127.0.0.1:6379> zadd ss LT 19 a 31 b # 仅当输入值小于原来的值时更新 
(integer) 0
127.0.0.1:6379> zrange ss 0 -1 WITHSCORES
1) "c"
2) "5"
3) "a"
4) "19"   # a被更新
5) "b"
6) "30"  # b没有被更新
127.0.0.1:6379> zadd ss INCR 1 a   # 自增
"20"

LT : less than <

GT : great than >

LE : less equal <=

GE : great equal >=

删

ZREM

ZREM key member [member …]

删除指定的对象；

成功返回移除的对象数量，不包含不存在的对象；若key不存在返回错误。

1
2
3
4
5
6
7
127.0.0.1:6379> zadd ss 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zrem ss a d # 删除a成功， d不存在被忽略
(integer) 1
127.0.0.1:6379> zrange ss 0 -1
1) "b"
2) "c"

ZREMRANGEBYLEX

ZREMRANGEBYLEX key min max

删除字典序排序从min到max的元素；

返回被移除的元素数量。

1
2
3
4
5
6
7
8
9
127.0.0.1:6379> zadd ss 1 a 2 d 3 e 4 g 5 i 6 w 7 y 8 z
(integer) 8
127.0.0.1:6379> zremrangebylex ss [e [w
(integer) 4
127.0.0.1:6379> zrange ss 0 -1
1) "a"
2) "d"
3) "y"
4) "z"

在命令内部使用 “[字符串”表示范围，如：[assd

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE key min max

删除score值是从min到max的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
127.0.0.1:6379> zrange ss2 0 -1 WITHSCORES
 1) "w"
 2) "7"
 3) "s"
 4) "8"
 5) "c"
 6) "9"
 7) "x"
 8) "10"
 9) "l"
10) "11"
127.0.0.1:6379> ZREMRANGEBYSCORE ss2 8 9  # 删除scores范围为 8 ~ 9 的值。
(integer) 2
127.0.0.1:6379> zrange ss2 0 -1 WITHSCORES
1) "w"
2) "7"
3) "x"
4) "10"
5) "l"
6) "11"

ZREMRANGEBYRANK

ZREMRANGEBYRANK key start stop

删除排名从start到stop的元素；

1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> zrange ss 0 -1
1) "a"
2) "c"
3) "d"
4) "w"
5) "f"
127.0.0.1:6379> zremrangebyrank ss 1 3  # 删除排名位于 1 ~ 3 的元素
(integer) 3
127.0.0.1:6379> zrange ss 0 -1
1) "a"
2) "f"

ZPOPMAX、ZPOPMIN

ZPOPMAX key [count]

ZPOPMIN key [count]

移除scores值 MAX最高（MIN最低）的count个元素；

若没有count属性，默认count为1；

返回多个元素，score最大（MAX为最大的，MIN为最小的）的元素在首位，其他依次向下排列；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
127.0.0.1:6379> zrange ss2 0 -1 WITHSCORES
1) "w"
2) "7"
3) "x"
4) "10"
5) "l"
6) "11"
127.0.0.1:6379> zpopmax ss2 2
1) "l"
2) "11"
3) "x"
4) "10"
127.0.0.1:6379> zrange ss2 0 -1 WITHSCORES
1) "w"
2) "7"

ZMPOP 依据提供的方向删除指定集合指定数量的元素

ZMPOP numkeys key [key …] <MIN | MAX> [COUNT count]

从给定的集合中从前往后寻找非空集合，删除并返回多个元素。

可以指定多个集合；

在MIN下，将对在非空集合中score最低的元素进行pop；MAX反之；

COUNT指定要pop的数量；

返回值：

  • 返回一个二维数组（[n][2]），子数组包含删除元素的对象和score；
  • 若没有元素被pop则返回nil

查

ZCARD

ZCARD key

查询集合的基数。

ZCOUNT、ZLEXCOUNT

ZCOUNT key min max 获取score在min到max之间的元素。O(log(N))。

ZLEXCOUNT key min max 依据字典序获得min到max之间的元素。O(log(N))。

返回指定结果数量；

ZSCORE

ZSCORE key member

返回成员的score；

若成员或key不存在，返回nil；

ZMSCORE

ZMSCORE key member [member ...]

返回多个成员的score；

对于每个成员，若member不存在，则score以nil代替。

1
2
3
4
5
127.0.0.1:6379> zadd ss 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zmscore ss a b
1) "1"
2) "2"

ZRANDMEMBER

ZRANDMEMBER key [count [WITHSCORES]]

若只有key参数，则在集合中随机获取一个元素并返回其成员名；

若有count参数，

  • 若count为正数，在集合中随机获取多个元素并返回其成员名，数量取count和基数的最小值；
  • 若count为负数，获取的结果会有重复，返回的数量绝对为count，不受基数大小限制。

若加上WITHSCORES，返回参数包含成员名及其scores。

1
2
3
4
5
6
7
8
127.0.0.1:6379> ZRANDMEMBER ss 2
1) "c"
2) "a"
127.0.0.1:6379> ZRANDMEMBER ss 2 WITHSCORES
1) "b"
2) "2"
3) "a"
4) "1"

ZRANGE

介绍

ZRANGE key start stop [BYSCORE | BYLEX] [REV] [LIMIT offset count] [WITHSCORES]

依据条件进行查询，返回结果顺序默认从低到高；若start大于基数或stop，则返回空集合；若stop大于基数，视为最后一个元素。

ZRANGE可以查询来自不同类型范围的元素；

参数

start，stop：值的起点和终点，即值的范围为 start ~ stop；

  • 第一个元素用0表示，第二个为1，其他依次类推；
  • start/stop值也可以为负，-1表示倒数第一个，-2表示倒数第二个；
  • 对于不同的排序依据，可以使用的值不同；
    • 默认情况下
      • start/stop表示查询地范围，结果包含start/stop索引所在位置的值；
    • 对于BYSCORE
      • 默认情况下，结果包含start/stop指定的索引位置，可以通过添加前缀”**(**“来表示不包含start/stop指定的索引位置的值；
      • 默认情况下，start表示最小score，stop表示最大score；
      • 也可以为 “+inf”或“-inf”，分别表示正无穷和负无穷。
      • 若使用REV参数，就必须将start和stop的值反过来使用，也就是start > stop，否则将获得一个空的结果；start表示最大score，stop表示最score。
    • 对于BYLEX
      • start/stop值必须包含“(”或“[”表示不包含或包含start/stop指定的索引位置的值；
      • 可以使用“+”或者“-”表示正无穷和负无穷；
      • 若使用REV参数，就必须将start和stop的值反过来，也就是 start > stop，否则将返回一个空的结果。

BYSCORE：依据score；

BYLEX：依据字典序；在此模式下不支持REV参数，会返回错误；

REV：查询结果默认排序为从低到高，使用REV参数后排序改为从高到低；

LIMIT：在获得结果中取出指定范围的数据进行返回；offset为起点；count为取出的数量，若count为负则取出从offset到最后所有的元素；注意若offset很大，需要遍历从offset到最后一个元素之间的所有元素，时间复杂度为O(N)；

WITHSCORES：返回值包含score；

返回值

返回数组，包含元素列表；若有WITHSCORES，则同时包含scores。

代码示例
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
127.0.0.1:6379> zadd ss 12 a 23 b 34 c 45 d 56 e 67 f
(integer) 6
127.0.0.1:6379> zrange ss 0 -1 # 查询队列中所有的元素
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
127.0.0.1:6379> zrange ss 2 -1 WITHSCORES # 查询队列中从位置2到最后的元素，包含scores
1) "c"
2) "34"
3) "d"
4) "45"
5) "e"
6) "56"
7) "f"
8) "67"
127.0.0.1:6379> zrange ss 45 56 BYSCORE WITHSCORES # 查询score从45到56范围内的元素
1) "d"
2) "45"
3) "e"
4) "56"
127.0.0.1:6379> zrange ss 56 45 REV BYSCORE WITHSCORES # 逆序，start/stop需要倒过来
1) "e"
2) "56"
3) "d"
4) "45"
127.0.0.1:6379> zrange ss (c [e REV BYLEX WITHSCORES # 使用BYLEX不能使用WITHSCORES
(error) ERR syntax error, WITHSCORES not supported in combination with BYLEX
127.0.0.1:6379> zrange ss (c [e REV BYLEX # 使用REV需要将start/stop的值倒过来，否则返回空数组
(empty array)
127.0.0.1:6379> zrange ss (c [e BYLEX # 不包含c，包含e的结果。
1) "d"
2) "e"
127.0.0.1:6379> zrange ss (c [e BYLEX LIMIT 1 1 # 取出结果中从索引1开始，1个元素
1) "e"

ZRANGESTORE

ZRANGESTORE dst src min max [BYSCORE | BYLEX] [REV] [LIMIT offset count]

查询方式与ZRANGE一致；

不同的是，可以将返回结果存储到指定集合中；

返回值为结果集的元素数量；

注意：不能使用WITHSCORES。

1
2
3
4
5
6
7
8
9
10
11
12
127.0.0.1:6379> zrange ss 45 56 BYSCORE WITHSCORES
1) "d"
2) "45"
3) "e"
4) "56"
127.0.0.1:6379> zrangestore ss2 ss 45 56 BYSCORE
(integer) 2
127.0.0.1:6379> zrange ss2 0 -1 WITHSCORES
1) "d"
2) "45"
3) "e"
4) "56"

ZRANK

ZRANK key member

将集合按照score大小进行排序，返回排序结果中member的位置。

排序顺序从小到大；

1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> zrange ss 0 -1
1) "a" #  0 5
2) "b" #  1 4
3) "c" #  2 3  c的正序位置在2，逆序位置在3
4) "d" #  3 2
5) "e" #  4 1
6) "f" #  5 0
127.0.0.1:6379> zrank ss c
(integer) 2
127.0.0.1:6379> zrevrank ss c
(integer) 3

ZREVRANK

ZREVRANK key member

返回集合按照score排行，反转后的member的位置；

排行按照从高到低；

返回值：若成员存在，返回成员的排行；若成员或key不存在，返回nil；

ZRANGEBYLEX、ZRANGEBYSCORE （弃用）

将会被ZRANGE取代；

ZRANGEBYLEX key min max [LIMIT offset count]

ZRANGEBYSCORE key min max [LIMIT offset count] WITHSCORES

ZREVRANGE（弃用）

ZREVRANGE key start stop [WITHSCORES]

ZREVRANGEBYLEX（弃用）

ZREVRANGEBYLEX key max min [LIMIT offset count]

ZRANGEBYSCORE（弃用）

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

并集

ZUNIONSTORE

ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREAGTE <SUM | MIN MAX>]

计算numkeys个集合的并集结果，对于每个相同的member，将相应的score进行处理（相加，MAX，MIN），然后存储计算结果到destination中；

在提供key和其他参数之前，必须提供numkeys；

参数介绍：

  • 使用WEIGHTS参数，指定多个乘数，将为每个集合的score值在处理之前与指定的乘数相乘，乘法因子默认为1；

    • 如：
    • 设 k1 = {a:1,b:2} k2 = {b:3,c:4}
    • 如：ZUNIONSTORE out 2 k1 k2 WEIGHTS 2 3 AGGREGATE SUM
      1. k1’ = {a:2,b:4} k2’ = {b:9,c:12}
      2. out = {a:2,b:13,c:12}

  • 使用AGGREGATE选项，可以指定UNION过程score的处理方法，默认为SUM；

    • SUM：将所有score相加；
    • MAX：取所有score最大值；
    • MIN：取所有score最小值。

若destination中有值，则进行覆盖。

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
127.0.0.1:6379> zadd s1 1 a 4 b  # s1 = {a:1, b:4}
(integer) 2
127.0.0.1:6379> zadd s2 4 a 5 c  # s2 = {a:4, c:5}
(integer) 2
127.0.0.1:6379> ZUNIONSTORE out1 2 s1 s2 WEIGHTS 2 3 # 将s1和s2进行UNION操作，AGGREGATE为SUM
(integer) 3 # 结果集的值的数量
127.0.0.1:6379> ZRANGE out1 0 -1 WITHSCORES # 查询
1) "b"
2) "8"   # 4x2 = 8
3) "a"
4) "14"  # 1x2 + 4x3 = 14
5) "c"
6) "15"  # 5x3 = 15
127.0.0.1:6379> ZUNIONSTORE out2 2 s1 s2 WEIGHTS 2 3 AGGREGATE MAX # 将s1和s2进行UNION操作，AGGREGATE为MAX
(integer) 3
127.0.0.1:6379> ZRANGE out2 0 -1 WITHSCORES
1) "b"
2) "8"   # 4x2 = 8
3) "a"
4) "12"  # max(1x2, 4x3) = 12
5) "c"
6) "15"  # 5x3 = 15
127.0.0.1:6379> ZUNIONSTORE out3 2 s1 s2 WEIGHTS 2 3 AGGREGATE MIN # 将s1和s2进行UNION操作，AGGREGATE为MIN
(integer) 3
127.0.0.1:6379> ZRANGE out3 0 -1 WITHSCORES
1) "a"
2) "2"  # min(2x1, 3x4) = 2
3) "b"
4) "8"
5) "c"
6) "15"

ZUNION

ZUNION numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE <SUM | MIN | MAX>] [WITHSCORES]

功能类似于ZUNIONSTORE，不同的是，ZUNION将计算结果返回到客户端；

交集

ZINTER

ZINTER numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE <SUM | MIN | MAX>][WITHSCORES]

将交集结果返回到客户端；

时间复杂度：

O(NK)+O(Mlog(M))

N：最小有序集合

K：有序集合的数量

M：结果集元素数量

返回交集结果。

ZINTERCARD

ZINTERCARD numkeys key [key ...] [LIMIT limit]

返回结果集的基数；

若key为空，则被视为空集合，返回0；

默认情况下，ZINTERCARD计算集合中所有的数量，可以通过给出参数LIMIT（默认为0）来限制计算数量，这样可以减少计算加速运行；

ZINTERSTORE

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE <SUM | MIN |MAX>]

计算交集结果并存放在destination中；

若destination原本存在，则进行覆盖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
127.0.0.1:6379> zrange s1 0 -1 WITHSCORES # s1 = {a:1, b:4}
1) "a"
2) "1"
3) "b"
4) "4"
127.0.0.1:6379> zrange s2 0 -1 WITHSCORES # s2 = {a:4, c:5}
1) "a"
2) "4"
3) "c"
4) "5"
127.0.0.1:6379> ZINTERSTORE out4 2 s1 s2 WEIGHTS 2 3 # 将交集计算结果存放到out4中，
(integer) 1
127.0.0.1:6379> zrange out4 0 -1 WITHSCORES
1) "a"
2) "14"  # 1x2 + 3x4 = 14

差集

ZDIFFSTORE

ZDIFFSTORE destination numkeys key [key ...]

计算第一个集合与其他集合的差集，将结果存放到destination；

numkeys为指定key的数量；

若destination存在，则进行覆盖。

与INTER和UNION不同，DIFF不对SCORE进行运算，而是仅使用member作为依据对集合进行差集运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
127.0.0.1:6379> zrange s1 0 -1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "4"
127.0.0.1:6379> zrange s2 0 -1 WITHSCORES
1) "a"
2) "4"
3) "c"
4) "5"
127.0.0.1:6379> ZDIFFSTORE out5 2 s1 s2
(integer) 1
127.0.0.1:6379> zrange out5 0 -1 WITHSCORES # s1与s2的差集为{b:4}
1) "b" 
2) "4"

ZDIFF

ZDIFF numkeys key [key ...] [WITHSCORES]

功能类似于ZDIFFSTORE，不同的是，ZDIFF将计算结果返回到客户端；

Redis 3 Hash SortedSet
2022/09/21/Redis/Redis-3/
作者
uwupu
发布于
2022-09-21 09:23
许可
 评论
  1. 1. Hash
    1. 1.1. 使用/场景
      1. 1.1.1. 场景
      2. 1.1.2. 例子：存储用户的属性
      3. 1.1.3. 例子：存储设备的访问状态
    2. 1.2. 基础命令
    3. 1.3. 其他命令
      1. 1.3.1. HSET 设置值 可以多个
      2. 1.3.2. HSETNX 当field不存在则设置值
      3. 1.3.3. HGET 获得field的value
      4. 1.3.4. HMGET 获取field的value 可以多个
      5. 1.3.5. HGETALL 获得所有field-value
      6. 1.3.6. HDEL 删除field 可以多个
      7. 1.3.7. HEXISTS 查询field存在
      8. 1.3.8. HLEN 获得field数量
      9. 1.3.9. HSTRLEN 获得value的长度
      10. 1.3.10. HINCRBY 增加整型的值
      11. 1.3.11. HINCRBYFLOAT 增加浮点数的值
      12. 1.3.12. HRANDFIELD 随机获取field
      13. 1.3.13. HVALS 获取所有的values
      14. 1.3.14. HMSET（弃用） 与hset一致
  2. 2. Sorted Set
    1. 2.1. 实现
    2. 2.2. 例子：游戏排名最高分
    3. 2.3. 基础命令
    4. 2.4. 性能
    5. 2.5. 其他命令
      1. 2.5.1. 增
        1. 2.5.1.1. ZADD
          1. 2.5.1.1.1. 介绍/使用
          2. 2.5.1.1.2. 可以用的参数
          3. 2.5.1.1.3. 实现
          4. 2.5.1.1.4. 返回值
          5. 2.5.1.1.5. 代码
      2. 2.5.2. 删
        1. 2.5.2.1. ZREM
        2. 2.5.2.2. ZREMRANGEBYLEX
        3. 2.5.2.3. ZREMRANGEBYSCORE
        4. 2.5.2.4. ZREMRANGEBYRANK
        5. 2.5.2.5. ZPOPMAX、ZPOPMIN
        6. 2.5.2.6. ZMPOP 依据提供的方向删除指定集合指定数量的元素
      3. 2.5.3. 查
        1. 2.5.3.1. ZCARD
        2. 2.5.3.2. ZCOUNT、ZLEXCOUNT
        3. 2.5.3.3. ZSCORE
        4. 2.5.3.4. ZMSCORE
        5. 2.5.3.5. ZRANDMEMBER
        6. 2.5.3.6. ZRANGE
          1. 2.5.3.6.1. 介绍
          2. 2.5.3.6.2. 参数
          3. 2.5.3.6.3. 返回值
          4. 2.5.3.6.4. 代码示例
        7. 2.5.3.7. ZRANGESTORE
        8. 2.5.3.8. ZRANK
        9. 2.5.3.9. ZREVRANK
        10. 2.5.3.10. ZRANGEBYLEX、ZRANGEBYSCORE （弃用）
        11. 2.5.3.11. ZREVRANGE（弃用）
        12. 2.5.3.12. ZREVRANGEBYLEX（弃用）
        13. 2.5.3.13. ZRANGEBYSCORE（弃用）
      4. 2.5.4. 并集
        1. 2.5.4.1. ZUNIONSTORE
        2. 2.5.4.2. ZUNION
      5. 2.5.5. 交集
        1. 2.5.5.1. ZINTER
        2. 2.5.5.2. ZINTERCARD
        3. 2.5.5.3. ZINTERSTORE
      6. 2.5.6. 差集
        1. 2.5.6.1. ZDIFFSTORE
        2. 2.5.6.2. ZDIFF