Redis数据类型--SortedSet（有序集合）

Posted on | In | Visitors:

有序集合和散列一样，都用于存储键值对：有序集合的键被称为成员（member），每个成员都是各不相同；而有序集合的值则被称为分值（score），分值必须为浮点数。有序集合是Redis里面唯一一个既可以根据成员访问元素（这一点和散列一样），又可以根据分值以及分值的排列顺序来访问元素的结构。字符串成员（member）与浮点数分值（score）之间的有序映射，元素的排列顺序由分值的大小决定。
结构的读写：
 添加、获取、删除单个元素
 根据分值范围（range）或者成员来获取元素

ZADD

ZADD key score member [[score member] [score member] …]

 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
 score 值可以是整数值或双精度浮点数。
 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
 当 key 存在但不是有序集类型时，返回一个错误。
 在 Redis 2.4 版本以前， ZADD 每次只能添加一个元素。

可用版本

版本>= 1.2.0

时间复杂度

O(M*log(N))， N 是有序集的基数， M 为成功添加的新成员的数量。

返回值

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

示例

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
# 添加单个元素
redis> ZADD page_rank 10 google.com
(integer) 1
# 添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，且 score 值不变
redis> ZADD page_rank 10 google.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES  # 没有改变
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，但是改变 score 值
redis> ZADD page_rank 6 bing.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES  # bing.com 元素的 score 值被改变
1) "bing.com"
2) "6"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

ZCARD

ZCARD key

 返回有序集 key 的基数。

可用版本

版本>= 1.2.0

时间复杂度

O(1)

返回值

当 key 存在且是有序集类型时，返回有序集的基数。
当 key 不存在时，返回 0 。

示例

1
2
3
4
5
6
7
8
9
10
11
12
redis > ZADD salary 2000 tom    # 添加一个成员
(integer) 1
redis > ZCARD salary
(integer) 1
redis > ZADD salary 5000 jack   # 再添加一个成员
(integer) 1
redis > ZCARD salary
(integer) 2
redis > EXISTS non_exists_key   # 对不存在的 key 进行 ZCARD 操作
(integer) 0
redis > ZCARD non_exists_key
(integer) 0

ZCOUNT

ZCOUNT key min max

 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

可用版本

版本>= 2.0.0

时间复杂度

O(log(N)+M)， N 为有序集的基数， M 为值在 min 和 max 之间的元素的数量。

返回值

score 值在 min 和 max 之间的成员的数量。

示例

1
2
3
4
5
6
7
8
9
10
11
redis> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"
redis> ZCOUNT salary 2000 5000          # 计算薪水在 2000-5000 之间的人数
(integer) 3
redis> ZCOUNT salary 3000 5000          # 计算薪水在 3000-5000 之间的人数
(integer) 2

ZINCRBY

ZINCRBY key increment member

 为有序集 key 的成员 member 的 score 值加上增量 increment 。
 可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
 当 key 不是有序集类型时，返回一个错误。
 score 值可以是整数值或双精度浮点数。

可用版本

版本>= 1.2.0

时间复杂度

O(log(N))

返回值

member 成员的新 score 值，以字符串形式表示。

示例

1
2
3
4
redis> ZSCORE salary tom
"2000"
redis> ZINCRBY salary 2000 tom   # tom 加薪啦！
"4000"

ZRANGE

ZRANGE key start stop [WITHSCORES]

 返回有序集 key 中，指定区间内的成员。
 其中成员的位置按 score 值递增(从小到大)来排序。
 具有相同 score 值的成员按字典序(lexicographical order )来排列。
 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
 超出范围的下标并不会引起错误。

  • 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。
  • 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。

 可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, …, valueN,scoreN 的格式表示。
 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

可用版本

版本>= 1.2.0

时间复杂度

O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
redis > ZRANGE salary 0 -1 WITHSCORES             # 显示整个有序集成员
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"
redis > ZRANGE salary 1 2 WITHSCORES              # 显示有序集下标区间 1 至 2 的成员
1) "tom"
2) "5000"
3) "boss"
4) "10086"
redis > ZRANGE salary 0 200000 WITHSCORES         # 测试 end 下标超出最大下标时的情况
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"
redis > ZRANGE salary 200000 3000000 WITHSCORES   # 测试当给定区间不存在于有序集时的情况
(empty list or set)

ZRANGEBYSCORE

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

 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
 具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。
 可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
 可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。
 该选项自 Redis 2.0 版本起可用。

区间及无限

 min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

举个例子

 ZRANGEBYSCORE zset (1 5 返回所有符合条件 1 < score <= 5 的成员，而
 ZRANGEBYSCORE zset (5 (10 则返回所有符合条件 5 < score < 10 的成员。

可用版本

版本>= 1.0.5

时间复杂度

O(log(N)+M)， N 为有序集的基数， M 为被结果集的基数。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
redis> ZADD salary 2500 jack                        # 测试数据
(integer) 0
redis> ZADD salary 5000 tom
(integer) 0
redis> ZADD salary 12000 peter
(integer) 0
redis> ZRANGEBYSCORE salary -inf +inf               # 显示整个有序集
1) "jack"
2) "tom"
3) "peter"
redis> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"
redis> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
1) "jack"
2) "2500"
3) "tom"
4) "5000"
redis> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
1) "peter"

ZRANK

ZRANK key member

 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
 使用 ZREVRANK 命令可以获得成员按 score 值递减(从大到小)排列的排名。

可用版本

版本>= 2.0.0

时间复杂度

O(log(N))

返回值

如果 member 是有序集 key 的成员，返回 member 的排名。
如果 member 不是有序集 key 的成员，返回 nil 。

示例

1
2
3
4
5
6
7
8
9
redis> ZRANGE salary 0 -1 WITHSCORES        # 显示所有成员及其 score 值
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"
redis> ZRANK salary tom                     # 显示 tom 的薪水排名，第二
(integer) 1

ZREM

ZREM key member [member …]

 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
 当 key 存在但不是有序集类型时，返回一个错误。
 在 Redis 2.4 版本以前， ZREM 每次只能删除一个元素。

可用版本

= 1.2.0

时间复杂度

O(M*log(N))， N 为有序集的基数， M 为被成功移除的成员的数量。

返回值

被成功移除的成员的数量，不包括被忽略的成员。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 测试数据
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 移除单个元素
redis> ZREM page_rank google.com
(integer) 1
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
# 移除多个元素
redis> ZREM page_rank baidu.com bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)
# 移除不存在元素
redis> ZREM page_rank non-exists-element
(integer) 0

ZREMRANGEBYRANK

ZREMRANGEBYRANK key start stop

 移除有序集 key 中，指定排名(rank)区间内的所有成员。
 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

可用版本

版本>= 2.0.0

时间复杂度

O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

返回值

被移除成员的数量。

示例

1
2
3
4
5
6
7
8
9
10
11
redis> ZADD salary 2000 jack
(integer) 1
redis> ZADD salary 5000 tom
(integer) 1
redis> ZADD salary 3500 peter
(integer) 1
redis> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
(integer) 2
redis> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
1) "tom"
2) "5000"

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE key min max

 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
 自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE 命令。

可用版本

版本>= 1.2.0

时间复杂度

O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

返回值

被移除成员的数量。

示例

1
2
3
4
5
6
7
8
9
10
11
12
redis> ZRANGE salary 0 -1 WITHSCORES          # 显示有序集内所有成员及其 score 值
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"
redis> ZREMRANGEBYSCORE salary 1500 3500      # 移除所有薪水在 1500 到 3500 内的员工
(integer) 2
redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成员
1) "jack"
2) "5000"

ZREVRANGE

ZREVRANGE key start stop [WITHSCORES]

 返回有序集 key 中，指定区间内的成员。
 其中成员的位置按 score 值递减(从大到小)来排列。
 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

可用版本

版本>= 1.2.0

时间复杂度

O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
redis> ZRANGE salary 0 -1 WITHSCORES        # 递增排列
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"
redis> ZREVRANGE salary 0 -1 WITHSCORES     # 递减排列
1) "jack"
2) "5000"
3) "tom"
4) "4000"
5) "peter"
6) "3500"

ZREVRANGEBYSCORE

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

 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。
 除了成员按 score 值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

可用版本

版本>= 2.2.0

时间复杂度

O(log(N)+M)， N 为有序集的基数， M 为结果集的基数。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
redis > ZADD salary 10086 jack
(integer) 1
redis > ZADD salary 5000 tom
(integer) 1
redis > ZADD salary 7500 peter
(integer) 1
redis > ZADD salary 3500 joe
(integer) 1
redis > ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
1) "jack"
2) "peter"
3) "tom"
4) "joe"
redis > ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
1) "peter"
2) "tom"
3) "joe"

ZREVRANK

ZREVRANK key member

 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。
 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。

可用版本

版本>= 2.0.0

时间复杂度

O(log(N))

返回值

如果 member 是有序集 key 的成员，返回 member 的排名。
如果 member 不是有序集 key 的成员，返回 nil 。

示例

1
2
3
4
5
6
7
8
9
10
11
redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"
redis> ZREVRANK salary peter     # peter 的工资排第二
(integer) 1
redis> ZREVRANK salary tom       # tom 的工资最高
(integer) 0

ZSCORE

ZSCORE key member

 返回有序集 key 中，成员 member 的 score 值。
 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

可用版本

版本>= 1.2.0

时间复杂度

O(1)

返回值

member 成员的 score 值，以字符串形式表示。

示例

1
2
3
4
5
6
7
8
9
redis> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"
redis> ZSCORE salary peter              # 注意返回值是字符串
"3500"

ZUNIONSTORE

ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]

 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

WEIGHTS

 使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。
 如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。

AGGREGATE

 使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。
 默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。

可用版本

版本>= 2.0.0

时间复杂度

O(N)+O(M log(M))， N 为给定有序集基数的总和， M 为结果集的基数。

返回值

保存到 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
redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"
redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司决定加薪。。。除了程序员。。。
(integer) 6
redis> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
7) "herry"
8) "6000"
9) "mary"
10) "10500"
11) "bob"
12) "12000"

ZINTERSTORE

ZINTERSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]

 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
 关于 WEIGHTS 和 AGGREGATE 选项的描述，参见 ZUNIONSTORE 命令。

可用版本

版本>= 2.0.0

时间复杂度

O(NK)+O(Mlog(M))， N 为给定 key 中基数最小的有序集， K 为给定有序集的数量， M 为结果集的基数。

返回值

保存到 destination 的结果集的基数。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
redis > ZADD mid_test 70 "Li Lei"
(integer) 1
redis > ZADD mid_test 70 "Han Meimei"
(integer) 1
redis > ZADD mid_test 99.5 "Tom"
(integer) 1
redis > ZADD fin_test 88 "Li Lei"
(integer) 1
redis > ZADD fin_test 75 "Han Meimei"
(integer) 1
redis > ZADD fin_test 99.5 "Tom"
(integer) 1
redis > ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3
redis > ZRANGE sum_point 0 -1 WITHSCORES     # 显示有序集内所有成员及其 score 值
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"

ZSCAN

ZSCAN key cursor [MATCH pattern] [COUNT count]

 详细信息请参考 SCAN 命令。

Adhere to the original technology to share, your support will encourage me to continue to create!