REDIS数据库通用操作

EXISTS key

可用版本: >= 1.0.0
时间复杂度: O(1)

检查给定 key 是否存在。

返回值

若key 存在,返回1 ,否则返回 0


TYPE key

可用版本: >= 1.0.0
时间复杂度: O(1)
返回 key 所储存的值的类型。

返回值

  • none (key不存在)
  • string (字符串)
  • list (列表)
  • set (集合)
  • zset (有序集)
  • hash (哈希表)
  • stream (流)

代码示例

# 字符串
redis> SET weather "sunny"
OK
redis> TYPE weather
string

# 列表
redis> LPUSH book_list "programming in scala"
(integer) 1
redis> TYPE book_list
list

# 集合
redis> SADD pat "dog"
(integer) 1
redis> TYPE pat
set

RENAME key newkey

可用版本: >= 1.0.0
时间复杂度: O(1)

key 改名为 newkey
keynewkey 相同,或者 key 不存在时,返回一个错误。

newkey 已经存在时, RENAME命令将覆盖旧值。

返回值

改名成功时提示 OK ,失败时候返回一个错误。

代码示例

# key 存在且 newkey 不存在

redis> SET message "hello world"
OK

redis> RENAME message greeting
OK

redis> EXISTS message               # message 不复存在
(integer) 0

redis> EXISTS greeting              # greeting 取而代之
(integer) 1

# 当 key 不存在时,返回错误

redis> RENAME fake_key never_exists
(error) ERR no such key

# newkey 已存在时, RENAME 会覆盖旧 newkey

redis> SET pc "lenovo"
OK

redis> SET personal_computer "dell"
OK

redis> RENAME pc personal_computer
OK

redis> GET pc
(nil)

redis:1> GET personal_computer      # 原来的值 dell 被覆盖了
"lenovo"

RENAMENX key newkey

可用版本: >= 1.0.0
时间复杂度: O(1)

当且仅当 newkey 不存在时,将 key 改名为 newkey

key 不存在时,返回一个错误。

返回值

修改成功时,返回 1 ; 如果 newkey 已经存在,返回 0


RANDOMKEY

可用版本: >= 1.0.0
时间复杂度: O(1)

从当前数据库中随机返回(不删除)一个 key

返回值

当数据库不为空时,返回一个 key 。 当数据库为空时,返回 nil

代码示例

# 数据库不为空

redis> MSET fruit "apple" drink "beer" food "cookies"   # 设置多个 key
OK

redis> RANDOMKEY
"fruit"

redis> RANDOMKEY
"food"

redis> KEYS *    # 查看数据库内所有key,证明 RANDOMKEY 并不删除 key
1) "food"
2) "drink"
3) "fruit"

# 数据库为空

redis> FLUSHDB  # 删除当前数据库所有 key
OK

redis> RANDOMKEY
(nil)

DBSIZE

可用版本: >= 1.0.0
时间复杂度: O(1)

返回当前数据库的 key 的数量。

返回值

当前数据库的 key 的数量。

代码示例

redis> DBSIZE
(integer) 5

redis> SET new_key "hello_moto"     # 增加一个 key 试试
OK

redis> DBSIZE
(integer) 6

KEYS pattern

可用版本: >= 1.0.0

时间复杂度: O(N), N 为数据库中 key 的数量。

查找所有符合给定模式 patternkey , 比如说:

  • KEYS * 匹配数据库中所有 key
  • KEYS h?llo 匹配 hellohallohxllo 等。
  • KEYS h*llo 匹配 hlloheeeeello 等。
  • KEYS h[ae]llo 匹配 hellohallo ,但不匹配 hillo

特殊符号用 \ 隔开。

Warning

KEYS 的速度非常快,但在一个大的数据库中使用它仍然可能造成性能问题,如果你需要从一个数据集中查找特定的 key ,你最好还是用 Redis 的集合结构(set)来代替。

返回值

符合给定模式的 key 列表。

代码示例

redis> MSET one 1 two 2 three 3 four 4  # 一次设置 4 个 key
OK

redis> KEYS *o*
1) "four"
2) "two"
3) "one"

redis> KEYS t??
1) "two"

redis> KEYS t[w]*
1) "two"

redis> KEYS *  # 匹配数据库内所有 key
1) "four"
2) "three"
3) "two"
4) "one"

SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern …]] [ASC | DESC] [ALPHA] [STORE destination]

可用版本: >= 1.0.0
时间复杂度: O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。

返回或保存给定列表、集合、有序集合 key 中经过排序的元素。

排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较。

一般 SORT 用法

最简单的 SORT 使用方法是 SORT keySORT key DESC

  • SORT key 返回键值从小到大排序的结果。
  • SORT key DESC 返回键值从大到小排序的结果。

假设 today_cost 列表保存了今日的开销金额, 那么可以用 SORT 命令对它进行排序:

# 开销金额列表

redis> LPUSH today_cost 30 1.5 10 8
(integer) 4

# 排序

redis> SORT today_cost
1) "1.5"
2) "8"
3) "10"
4) "30"

# 逆序排序

redis 127.0.0.1:6379> SORT today_cost DESC
1) "30"
2) "10"
3) "8"
4) "1.5"

使用 ALPHA 修饰符对字符串进行排序

因为 SORT 命令默认排序对象为数字, 当需要对字符串进行排序时, 需要显式地在 SORT 命令之后添加 ALPHA 修饰符:

# 网址

redis> LPUSH website "www.reddit.com"
(integer) 1

redis> LPUSH website "www.slashdot.com"
(integer) 2

redis> LPUSH website "www.infoq.com"
(integer) 3

# 默认(按数字)排序

redis> SORT website
1) "www.infoq.com"
2) "www.slashdot.com"
3) "www.reddit.com"

# 按字符排序

redis> SORT website ALPHA
1) "www.infoq.com"
2) "www.reddit.com"
3) "www.slashdot.com"

如果系统正确地设置了 LC_COLLATE 环境变量的话,Redis能识别 UTF-8 编码。

使用 LIMIT 修饰符限制返回结果

排序之后返回元素的数量可以通过 LIMIT 修饰符进行限制, 修饰符接受 offsetcount 两个参数:

  • offset 指定要跳过的元素数量。
  • count 指定跳过 offset 个指定的元素之后,要返回多少个对象。

以下例子返回排序结果的前 5 个对象( offset0 表示没有元素被跳过)。

# 添加测试数据,列表值为 1 指 10

redis 127.0.0.1:6379> RPUSH rank 1 3 5 7 9
(integer) 5

redis 127.0.0.1:6379> RPUSH rank 2 4 6 8 10
(integer) 10

# 返回列表中最小的 5 个值

redis 127.0.0.1:6379> SORT rank LIMIT 0 5
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"

可以组合使用多个修饰符。以下例子返回从大到小排序的前 5 个对象。

redis 127.0.0.1:6379> SORT rank LIMIT 0 5 DESC
1) "10"
2) "9"
3) "8"
4) "7"
5) "6"

使用外部 key 进行排序

可以使用外部 key 的数据作为权重,代替默认的直接对比键值的方式来进行排序。

假设现在有用户数据如下:

以下代码将数据输入到 Redis 中:

# admin

redis 127.0.0.1:6379> LPUSH uid 1
(integer) 1

redis 127.0.0.1:6379> SET user_name_1 admin
OK

redis 127.0.0.1:6379> SET user_level_1 9999
OK

# jack

redis 127.0.0.1:6379> LPUSH uid 2
(integer) 2

redis 127.0.0.1:6379> SET user_name_2 jack
OK

redis 127.0.0.1:6379> SET user_level_2 10
OK

# peter

redis 127.0.0.1:6379> LPUSH uid 3
(integer) 3

redis 127.0.0.1:6379> SET user_name_3 peter
OK

redis 127.0.0.1:6379> SET user_level_3 25
OK

# mary

redis 127.0.0.1:6379> LPUSH uid 4
(integer) 4

redis 127.0.0.1:6379> SET user_name_4 mary
OK

redis 127.0.0.1:6379> SET user_level_4 70
OK

BY 选项

默认情况下, SORT uid 直接按 uid 中的值排序:

redis 127.0.0.1:6379> SORT uid
1) "1"      # admin
2) "2"      # jack
3) "3"      # peter
4) "4"      # mary

通过使用 BY 选项,可以让 uid 按其他键的元素来排序。

比如说, 以下代码让 uid 键按照 user_level_{uid} 的大小来排序:

redis 127.0.0.1:6379> SORT uid BY user_level_*
1) "2"      # jack , level = 10
2) "3"      # peter, level = 25
3) "4"      # mary, level = 70
4) "1"      # admin, level = 9999

user_level_* 是一个占位符, 它先取出 uid 中的值, 然后再用这个值来查找相应的键。

比如在对 uid 列表进行排序时, 程序就会先取出 uid 的值 1234 , 然后使用 user_level_1user_level_2user_level_3user_level_4 的值作为排序 uid 的权重。

GET 选项

使用 GET 选项, 可以根据排序的结果来取出相应的键值。

比如说, 以下代码先排序 uid , 再取出键 user_name_{uid} 的值:

redis 127.0.0.1:6379> SORT uid GET user_name_*
1) "admin"
2) "jack"
3) "peter"
4) "mary"

组合使用 BY 和 GET

通过组合使用 BYGET , 可以让排序结果以更直观的方式显示出来。

比如说, 以下代码先按 user_level_{uid} 来排序 uid 列表, 再取出相应的 user_name_{uid} 的值:

redis 127.0.0.1:6379> SORT uid BY user_level_* GET user_name_*
1) "jack"       # level = 10
2) "peter"      # level = 25
3) "mary"       # level = 70
4) "admin"      # level = 9999

现在的排序结果要比只使用 SORT uid BY user_level_* 要直观得多。

获取多个外部键

可以同时使用多个 GET 选项, 获取多个外部键的值。

以下代码就按 uid 分别获取 user_level_{uid}user_name_{uid}

redis 127.0.0.1:6379> SORT uid GET user_level_* GET user_name_*
1) "9999"       # level
2) "admin"      # name
3) "10"
4) "jack"
5) "25"
6) "peter"
7) "70"
8) "mary"

GET 有一个额外的参数规则,那就是 —— 可以用 # 获取被排序键的值。

以下代码就将 uid 的值、及其相应的 user_level_*user_name_* 都返回为结果:

redis 127.0.0.1:6379> SORT uid GET # GET user_level_* GET user_name_*
1) "1"          # uid
2) "9999"       # level
3) "admin"      # name
4) "2"
5) "10"
6) "jack"
7) "3"
8) "25"
9) "peter"
10) "4"
11) "70"
12) "mary"

获取外部键,但不进行排序

通过将一个不存在的键作为参数传给 BY 选项, 可以让 SORT 跳过排序操作, 直接返回结果:

redis 127.0.0.1:6379> SORT uid BY not-exists-key
1) "4"
2) "3"
3) "2"
4) "1"

这种用法在单独使用时,没什么实际用处。

不过,通过将这种用法和 GET 选项配合, 就可以在不排序的情况下, 获取多个外部键, 相当于执行一个整合的获取操作(类似于 SQL 数据库的 join 关键字)。

以下代码演示了,如何在不引起排序的情况下,使用 SORTBYGET 获取多个外部键:

redis 127.0.0.1:6379> SORT uid BY not-exists-key GET # GET user_level_* GET user_name_*
1) "4"      # id
2) "70"     # level
3) "mary"   # name
4) "3"
5) "25"
6) "peter"
7) "2"
8) "10"
9) "jack"
10) "1"
11) "9999"
12) "admin"

将哈希表作为 GET 或 BY 的参数

除了可以将字符串键之外, 哈希表也可以作为 GETBY 选项的参数来使用。

比如说,对于前面给出的用户信息表:

我们可以不将用户的名字和级别保存在 user_name_{uid}user_level_{uid} 两个字符串键中, 而是用一个带有 name 域和 level 域的哈希表 user_info_{uid} 来保存用户的名字和级别信息:

redis 127.0.0.1:6379> HMSET user_info_1 name admin level 9999
OK

redis 127.0.0.1:6379> HMSET user_info_2 name jack level 10
OK

redis 127.0.0.1:6379> HMSET user_info_3 name peter level 25
OK

redis 127.0.0.1:6379> HMSET user_info_4 name mary level 70
OK

之后, BYGET 选项都可以用 key->field 的格式来获取哈希表中的域的值, 其中 key 表示哈希表键, 而 field 则表示哈希表的域:

redis 127.0.0.1:6379> SORT uid BY user_info_*->level
1) "2"
2) "3"
3) "4"
4) "1"

redis 127.0.0.1:6379> SORT uid BY user_info_*->level GET user_info_*->name
1) "jack"
2) "peter"
3) "mary"
4) "admin"

保存排序结果

默认情况下, SORT 操作只是简单地返回排序结果,并不进行任何保存操作。

通过给 STORE 选项指定一个 key 参数,可以将排序结果保存到给定的键上。

如果被指定的 key 已存在,那么原有的值将被排序结果覆盖。

# 测试数据

redis 127.0.0.1:6379> RPUSH numbers 1 3 5 7 9
(integer) 5

redis 127.0.0.1:6379> RPUSH numbers 2 4 6 8 10
(integer) 10

redis 127.0.0.1:6379> LRANGE numbers 0 -1
1) "1"
2) "3"
3) "5"
4) "7"
5) "9"
6) "2"
7) "4"
8) "6"
9) "8"
10) "10"

redis 127.0.0.1:6379> SORT numbers STORE sorted-numbers
(integer) 10

# 排序后的结果

redis 127.0.0.1:6379> LRANGE sorted-numbers 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"
10) "10"

可以通过将 SORT 命令的执行结果保存,并用 EXPIRE key seconds 为结果设置生存时间,以此来产生一个 SORT 操作的结果缓存。

这样就可以避免对 SORT 操作的频繁调用:只有当结果集过期时,才需要再调用一次 SORT 操作。

另外,为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行 SORT 操作,并保存为结果集),具体参见 SETNX key value 命令。

返回值

没有使用 STORE 参数,返回列表形式的排序结果。 使用 STORE 参数,返回排序结果的元素数量。


FLUSHDB 清空数据库

可用版本: >= 1.0.0
时间复杂度: O(1)

清空当前数据库中的所有 key。

此命令从不失败。

返回值

总是返回 OK

代码示例

redis> DBSIZE    # 清空前的 key 数量
(integer) 4

redis> FLUSHDB
OK

redis> DBSIZE    # 清空后的 key 数量
(integer) 0

FLUSHALL

可用版本: >= 1.0.0
时间复杂度: O(N)

清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。

此命令从不失败。

返回值

总是返回 OK

redis> DBSIZE            # 0 号数据库的 key 数量
(integer) 9

redis> SELECT 1          # 切换到 1 号数据库
OK

redis[1]> DBSIZE         # 1 号数据库的 key 数量
(integer) 6

redis[1]> flushall       # 清空所有数据库的所有 key
OK

redis[1]> DBSIZE         # 不但 1 号数据库被清空了
(integer) 0

redis[1]> SELECT 0       # 0 号数据库(以及其他所有数据库)也一样
OK

redis> DBSIZE
(integer) 0

SELECT index

可用版本: >= 1.0.0
时间复杂度: O(1)

切换到指定的数据库,数据库索引号 index 用数字值指定,以 0 作为起始索引值。

默认使用 0 号数据库。

返回值

OK

代码示例

redis> SET db_number 0         # 默认使用 0 号数据库
OK

redis> SELECT 1                # 使用 1 号数据库
OK

redis[1]> GET db_number        # 已经切换到 1 号数据库,注意 Redis 现在的命令提示符多了个 [1]
(nil)

redis[1]> SET db_number 1
OK

redis[1]> GET db_number
"1"

redis[1]> SELECT 3             # 再切换到 3 号数据库
OK

redis[3]>                      # 提示符从 [1] 改变成了 [3]

SWAPDB db1 db2

版本要求: >= 4.0.0
时间复杂度: O(1)

对换指定的两个数据库, 使得两个数据库的数据立即互换。

返回值

OK

代码示例

# 对换数据库 0 和数据库 1
redis> SWAPDB 0 1
OK

过期设置

EXPIRE key seconds 设置过期时间

可用版本: >= 1.0.0
时间复杂度: O(1)

为给定 key 设置生存时间,当 key 过期时(生存时间为 0 ),它会被自动删除。

在 Redis 中,带有生存时间的 key 被称为『易失的』(volatile)。

生存时间可以通过使用 DEL 命令来删除整个 key 来移除,或者被 SETGETSET 命令覆写(overwrite),这意味着,如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话,那么生存时间不会被改变。

比如说,对一个 key 执行 INCR 命令,对一个列表进行 LPUSH 命令,或者对一个哈希表执行 HSET 命令,这类操作都不会修改 key 本身的生存时间。

另一方面,如果使用 RENAME 对一个 key 进行改名,那么改名后的 key 的生存时间和改名前一样。

RENAME 命令的另一种可能是,尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ,这时旧的 another_key (以及它的生存时间)会被删除,然后旧的 key 会改名为 another_key ,因此,新的 another_key 的生存时间也和原本的 key 一样。

使用 PERSIST 命令可以在不删除 key 的情况下,移除 key 的生存时间,让 key 重新成为一个『持久的』(persistent) key

更新生存时间

可以对一个已经带有生存时间的 key 执行 EXPIRE 命令,新指定的生存时间会取代旧的生存时间。

过期时间的精确度

在 Redis 2.4 版本中,过期时间的延迟在 1 秒钟之内 —— 也即是,就算 key 已经过期,但它还是可能在过期之后一秒钟之内被访问到,而在新的 Redis 2.6 版本中,延迟被降低到 1 毫秒之内。

Redis 2.1.3 之前的不同之处

在 Redis 2.1.3 之前的版本中,修改一个带有生存时间的 key 会导致整个 key 被删除,这一行为是受当时复制(replication)层的限制而作出的,现在这一限制已经被修复。

返回值

设置成功返回 1 。 当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间),返回 0

代码示例

redis> SET cache_page "www.google.com"
OK

redis> EXPIRE cache_page 30  # 设置过期时间为 30 秒
(integer) 1

redis> TTL cache_page    # 查看剩余生存时间
(integer) 23

redis> EXPIRE cache_page 30000   # 更新过期时间
(integer) 1

redis> TTL cache_page
(integer) 29996

模式:导航会话

假设你有一项 web 服务,打算根据用户最近访问的 N 个页面来进行物品推荐,并且假设用户停止阅览超过 60 秒,那么就清空阅览记录(为了减少物品推荐的计算量,并且保持推荐物品的新鲜度)。
这些最近访问的页面记录,我们称之为『导航会话』(Navigation session),可以用 INCRRPUSH命令在 Redis 中实现它:每当用户阅览一个网页的时候,执行以下代码:

MULTI
    RPUSH pagewviews.user: http://.....
    EXPIRE pagewviews.user: 60
EXEC

如果用户停止阅览超过 60 秒,那么它的导航会话就会被清空,当用户重新开始阅览的时候,系统又会重新记录导航会话,继续进行物品推荐。


EXPIREAT key timestamp 按时间戳设置到期时间

可用版本: >= 1.2.0
时间复杂度: O(1)

EXPIREAT 的作用和 EXPIRE 类似,都用于为 key 设置生存时间。

不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

返回值

如果生存时间设置成功,返回 1 ; 当 key 不存在或没办法设置生存时间,返回 0

代码示例

redis> SET cache www.google.com
OK

redis> EXPIREAT cache 1355292000     # 这个 key 将在 2012.12.12 过期
(integer) 1

redis> TTL cache
(integer) 45081860

TTL key 查看KEY的生存时间,单位秒

可用版本: >= 1.0.0
时间复杂度: O(1)

以秒为单位,返回给定 key 的剩余生存时间(TTL, time to live)。

返回值

key 不存在时,返回 -2 。 当 key 存在但没有设置剩余生存时间时,返回 -1 。 否则,以秒为单位,返回 key 的剩余生存时间。

Note

在 Redis 2.8 以前,当 key 不存在,或者 key 没有设置剩余生存时间时,命令都返回 -1

代码示例

# 不存在的 key
redis> FLUSHDB
OK

redis> TTL key
(integer) -2

# key 存在,但没有设置剩余生存时间
redis> SET key value
OK

redis> TTL key
(integer) -1

# 有剩余生存时间的 key
redis> EXPIRE key 10086
(integer) 1

redis> TTL key
(integer) 10084

PERSIST key 移除生存时间

可用版本: >= 2.2.0
时间复杂度: O(1)

移除给定 key 的生存时间,将这个 key 从“易失的”(带生存时间 key )转换成“持久的”(一个不带生存时间、永不过期的 key )。

返回值

当生存时间移除成功时,返回 1 . 如果 key 不存在或 key 没有设置生存时间,返回 0

代码示例

redis> SET mykey "Hello"
OK

redis> EXPIRE mykey 10  # 为 key 设置生存时间
(integer) 1

redis> TTL mykey
(integer) 10

redis> PERSIST mykey    # 移除 key 的生存时间
(integer) 1

redis> TTL mykey
(integer) -1

PEXPIRE key milliseconds 以毫秒为单位设置过期时间

可用版本: >= 2.6.0
时间复杂度: O(1)

这个命令和 EXPIRE 命令的作用类似,但是它以毫秒为单位设置 key 的生存时间,而不像 EXPIRE命令那样,以秒为单位。

返回值

设置成功,返回 1 key 不存在或设置失败,返回 0

代码示例

redis> SET mykey "Hello"
OK

redis> PEXPIRE mykey 1500
(integer) 1

redis> TTL mykey    # TTL 的返回值以秒为单位
(integer) 2

redis> PTTL mykey   # PTTL 可以给出准确的毫秒数
(integer) 1499

PTTL key 获取以毫秒为单位的生存时间

可用版本: >= 2.6.0
复杂度: O(1)

这个命令类似于 TTL 命令,但它以毫秒为单位返回 key 的剩余生存时间,而不是像 TTL 命令那样,以秒为单位。

返回值

  • key 不存在时,返回 -2
  • key 存在但没有设置剩余生存时间时,返回 -1
  • 否则,以毫秒为单位,返回 key 的剩余生存时间。

Note

在 Redis 2.8 以前,当 key 不存在,或者 key 没有设置剩余生存时间时,命令都返回 -1

代码示例

# 不存在的 key
redis> FLUSHDB
OK

redis> PTTL key
(integer) -2

# key 存在,但没有设置剩余生存时间

redis> SET key value
OK

redis> PTTL key
(integer) -1

# 有剩余生存时间的 key

redis> PEXPIRE key 10086
(integer) 1

redis> PTTL key
(integer) 6179

你可能感兴趣的:(REDIS数据库通用操作)