redis命令参考

\color{red}{当前命令集未注明统一参考版本 >= 1.x}


\color{green}{key}

  • 格式:DEL key [key ...]

  • 时间复杂度: 删N为O ( N ) ,删单个key,为O ( 1 );

  • 返回值: 受影响的数量

删除单个 key

redis> SET name huangz
OK

redis> DEL name
(integer) 1

删除一个不存在的 key

redis> EXISTS phone
(integer) 0

redis> DEL phone  # 失败,没有 key 被删除
(integer) 0

同时删除多个 key

redis> SET name "redis"
OK

redis> SET type "key-value store"
OK

redis> SET website "redis.com"
OK

redis> DEL name type website
(integer) 3

\color{green}{keys}

  • 格式:keys pattern

\color{grey}{ 查找所有符合给定模式 pattern 的 key}

\color{grey}{KEYS * 匹配数据库中所有 key }

\color{grey}{KEYS h?llo 匹配 hello , hallo 和 hxllo 等}

\color{grey}{KEYS h*llo 匹配 hllo 和 heeeeello 等}

\color{grey}{KEYS h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo}

\color{grey}{特殊符号用\ 斜杠 \ 隔开}

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

  • 时间复杂度: O ( N ) N为key的size

  • 返回值: 匹配到的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"


\color{green}{randomkey}

  • 格式:randomkey

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

  • 时间复杂度: O ( 1 );

  • 返回值: 受影响的数量

    ​ 当数据库不为空时,返回一个 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)

\color{green}{ ttl}

  • 格式:ttl key

  • 时间复杂度: O ( 1 );

  • 返回值:

    当 key 不存在时,返回 -2 。

    当 key 存在但没有设置剩余生存时间时,返回 -1 。

    否则,以秒为单位,返回 key 的剩余生存时间。

    \color{red}{注:在 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

\color{green}{ pttl}

  • 格式:pttl key

  • 参考版本:>= 2.6X

  • 时间复杂度: O ( 1 );

  • 返回值:

当 key 不存在时,返回 -2 。

当 key 存在但没有设置剩余生存时间时,返回 -1 。

否则,以毫秒为单位,返回 key 的剩余生存时间。

\color{red}{注:在 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

\color{green}{ exists}

  • 格式:exists key

  • 时间复杂度: O ( 1 );

  • 返回值: 若 key 存在,返回 1 ,否则返回 0

redis> SET db "redis"
OK

redis> EXISTS db
(integer) 1

redis> DEL db
(integer) 1

redis> EXISTS db
(integer) 0

\color{green}{move}

  • 格式:move key db

\color{grey}{将当前数据库的 key 移动到给定的数据库 db 当中}

\color{grey}{如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ,}
\color{grey}{或者key 不存在于当前数据库,那么 MOVE 没有任何效果}

\color{grey}{因此,也可以利用这一特性,将 MOVE 当作锁(locking)原语(primitive)}

  • 时间复杂度: O ( 1 );
  • 返回值: 移动成功返回 1 ,失败则返回 0
# key 存在于当前数据库
redis> SELECT 0 #redis 默认使用数据库 0,为了清晰起见,这里再显式指定一次。
OK

redis> SET song "secret base - Zone"
OK

redis> MOVE song 1 # 将 song 移动到数据库 1
(integer) 1

redis> EXISTS song # song 已经被移走
(integer) 0

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

redis:1> EXISTS song # 证实 song 被移到了数据库 1 (注意命令提示符变成了"redis:1",表明正在使用数据库 1)
(integer) 1

# 当 key 不存在的时候
redis:1> EXISTS fake_key
(integer) 0

redis:1> MOVE fake_key 0 # 试图从数据库 1 移动一个不存在的 key 到数据库0,失败
(integer) 0

redis:1> select 0 # 使用数据库 0
OK

redis> EXISTS fake_key # 证实 fake_key 不存在
(integer) 0

# 当源数据库和目标数据库有相同的 key 时
redis> SELECT 0 # 使用数据库 0
OK

redis> SET favorite_fruit "banana"
OK

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

redis:1> SET favorite_fruit "apple"
OK

redis:1> SELECT 0 # 使用数据库 0,并试图将 favorite_fruit 移动到数据库 1
OK

redis> MOVE favorite_fruit 1 # 因为两个数据库有相同的 key,MOVE 失败
(integer) 0

redis> GET favorite_fruit # 数据库 0 的 favorite_fruit 没变
"banana"

redis> SELECT 1
OK

redis:1> GET favorite_fruit # 数据库 1 的 favorite_fruit 也是
"apple"

\color{green}{rename}

  • 格式:randomkey

\color{grey}{将 key 改名为 newkey }

\color{grey}{当 key 和 newkey 相同,或者 key 不存在时,返回一个错误}

\color{grey}{当 newkey 已经存在时, RENAME 命令将覆盖旧值}

  • 时间复杂度: O ( 1 );
  • 返回值: 改名成功时提示 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 #这里相当于value换了一个新的地址引用
OK

redis> GET pc
(nil)

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

\color{green}{ renamenx}

  • 格式:renamenx key newkey

\color{grey}{当且仅当 newkey 不存在时,将 key 改名为 newkey }

\color{grey}{当 key 不存在时,返回一个错误}

  • 时间复杂度: O ( 1 );
  • 返回值:

修改成功时,返回 1

如果 newkey 已经存在,返回 0

# newkey 不存在,改名成功
redis> SET player "MPlyaer"
OK

redis> EXISTS best_player
(integer) 0

redis> RENAMENX player best_player
(integer) 1

# newkey 存在时,失败
redis> SET animal "bear"
OK

redis> SET favorite_animal "butterfly"
OK

redis> RENAMENX animal favorite_animal
(integer) 0

redis> get animal
"bear"

redis> get favorite_animal
"butterfly"

\color{green}{type}

  • 格式:type key

\color{grey}{返回 key 所储存的值的类型}

  • 时间复杂度: O ( 1 );
  • 返回值:
none (key 不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)
# 字符串
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

\color{green}{ expire}

  • 格式:expire key seconds

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

\color{grey}{在 Redis 中,带有生存时间的 key 被称为『可挥发』(volatile)的}

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

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

\color{grey}{另一方面,如果使用 RENAME 对一个 key 进行改名,那么改名后的 key 的生存时间和改名前一样。}
\color{grey}{RENAME 命令的另一种可能是,尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ,这时旧的 another_key (以及它的生存时间)会被删除,然后旧的 key 会改名为 another_key ,因此,新的another_key 的生存时间也和原本的 key 一样。}

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

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

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

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

  • 时间复杂度: O ( 1 );

  • 返回值:

    设置成功返回 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),可以用 INCR 和 RPUSH 命令在 Redis 中实现它:每当用户阅览一个网页的时候,执行以下代码:

MULTI
 RPUSH pagewviews.user:<userid> http://.....
 EXPIRE pagewviews.user:<userid> 60
EXEC

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

\color{green}{ pexpire}

  • 格式:pexpire key milliseconds

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

  • 参考版本: >= 2.6X
  • 时间复杂度: O ( 1 );
  • 返回值:

设置成功,返回 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

\color{green}{ expireat}

  • 格式:expireat key timestamp

\color{grey}{EXPIREAT 的作用和 EXPIRE 类似,都用于为 key 设置生存时间}

\color{grey}{不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)}

  • 参考版本: >= 1.2X
  • 时间复杂度: O ( 1 );
  • 返回值:

如果生存时间设置成功,返回 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

\color{green}{ pexpireat}

  • 格式:pexpireat key milliseconds

\color{grey}{这个命令和 EXPIREAT 命令类似,但它以毫秒为单位设置 key 的过期 unix 时间戳,而不是像 EXPIREAT 那样,以秒为单位}

  • 参考版本: >= 2.6X
  • 时间复杂度: O ( 1 );
  • 返回值:

如果生存时间设置成功,返回 1 。

当 key 不存在或没办法设置生存时间时,返回 0

redis> SET mykey "Hello"
OK

redis> PEXPIREAT mykey 1555555555005
(integer) 1

redis> TTL mykey # TTL 返回秒
(integer) 223157079

redis> PTTL mykey # PTTL 返回毫秒
(integer) 223157079318

\color{green}{ persist}

  • 格式:persist key

\color{grey}{移除给定 key 的生存时间,将这个 key 从『可挥发』的(带生存时间 key )转换成『持久化』的(一个不带生存时间、永不过期的 key )。}

  • 参考版本: >= 2.2X
  • 时间复杂度: O ( 1 );
  • 返回值:

当生存时间移除成功时,返回 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

\color{green}{ sort}

  • 格式:sort key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

\color{grey}{返回或保存给定列表、集合、有序集合 key 中经过排序的元素}

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

\color{grey}{**一般 SORT 用法** }

\color{grey}{最简单的 SORT 使用方法是 SORT key }

\color{grey}{假设 today_cost 是一个保存数字的列表, SORT 命令默认会返回该列表值的递增(从小到大)排序结果}

# 将数据一一加入到列表中
redis> LPUSH today_cost 30
(integer) 1

redis> LPUSH today_cost 1.5
(integer) 2

redis> LPUSH today_cost 10
(integer) 3

redis> LPUSH today_cost 8
(integer) 4

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

\color{grey}{当数据集中保存的是字符串值时,你可以用 ALPHA 修饰符(modifier)进行排序。}

# 将数据一一加入到列表中
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"

\color{grey}{如果你正确设置了 !LC_COLLATE 环境变量的话,Redis 能识别 UTF-8 编码。}

\color{grey}{排序之后返回的元素数量可以通过 LIMIT 修饰符进行限制。}

\color{grey}{LIMIT 修饰符接受两个参数: offset 和 count 。}

\color{grey}{offset 指定要跳过的元素数量, count 指定跳过 offset 个指定的元素之后,要返回多少个对象。}

\color{grey}{以下例子返回排序结果的前 5 个对象( offset 为 0 表示没有元素被跳过)。}

# 将数据一一加入到列表中
redis> LPUSH rank 30
(integer) 1

redis> LPUSH rank 56
(integer) 2

redis> LPUSH rank 42
(integer) 3

redis> LPUSH rank 22
(integer) 4

redis> LPUSH rank 0
(integer) 5

redis> LPUSH rank 11
(integer) 6

redis> LPUSH rank 32
(integer) 7

redis> LPUSH rank 67
(integer) 8

redis> LPUSH rank 50
(integer) 9

redis> LPUSH rank 44
(integer) 10

redis> LPUSH rank 55
(integer) 11

# 排序
redis> SORT rank LIMIT 0 5 # 返回排名前五的元素
1) "0"
2) "11"
3) "22"
4) "30"
5) "32"

\color{grey}{修饰符可以组合使用。以下例子返回降序(从大到小)的前 5 个对象}

redis> SORT rank LIMIT 0 5 DESC
1) "78"
2) "67"
3) "56"
4) "55"
5) "50"

\color{grey}{**使用外部 key 进行排序**}

\color{grey}{有时候你会希望使用外部的 key 作为权重来比较元素,代替默认的对比方法。}

\color{grey}{假设现在有用户(user)数据如下}

image.png

\color{grey}{id 数据保存在 key 名为 user_id 的列表中}

\color{grey}{name 数据保存在 key 名为 user_name_{id} 的列表中}

\color{grey}{level 数据保存在 user_level_{id} 的 key 中}

# 先将要使用的数据加入到数据库中
# admin
redis> LPUSH user_id 1
(integer) 1

redis> SET user_name_1 admin
OK

redis> SET user_level_1 9999
OK

# huangz
redis> LPUSH user_id 2
(integer) 2

redis> SET user_name_2 huangz
OK

redis> SET user_level_2 10
OK

# jack
redis> LPUSH user_id 59230
(integer) 3

redis> SET user_name_59230 jack
OK

redis> SET user_level_59230 3
OK

# hacker
redis> LPUSH user_id 222
(integer) 4

redis> SET user_name_222 hacker
OK

redis> SET user_level_222 9999
OK

\color{grey}{如果希望按 level 从大到小排序 user_id ,可以使用以下命令:}

redis> SORT user_id BY user_level_* DESC
1) "222" # hacker
2) "1" # admin
3) "2" # huangz
4) "59230" # jack

但是有时候只是返回相应的 id 没有什么用,你可能更希望排序后返回 id 对应的用户名,这样更友好一点,使用 GET 选项可以做到这一点

redis> SORT user_id BY user_level_* DESC GET user_name_*
1) "hacker"
2) "admin"
3) "huangz"
4) "jack"

\color{grey}{可以多次地、有序地使用 GET 操作来获取更多外部 key 。}

\color{grey}{比如你不但希望获取用户名,还希望连用户的密码也一并列出,可以使用以下命令}

# 先添加一些测试数据
redis> SET user_password_222 "hey,im in"
OK

redis> SET user_password_1 "a_long_long_password"
OK

redis> SET user_password_2 "nobodyknows"
OK

redis> SET user_password_59230 "jack201022"
OK

# 获取 name 和 password
redis> SORT user_id BY user_level_* DESC GET user_name_* GET 
user_password_*
1) "hacker" # 用户名
2) "hey,im in" # 密码
3) "jack"
4) "jack201022"
5) "huangz"
6) "nobodyknows"
7) "admin"
8) "a_long_long_password"

# 注意 GET 操作是有序的,GET user_name_* GET user_password_* 和 GET 
user_password_* GET user_name_*返回的结果位置不同
redis> SORT user_id BY user_level_* DESC GET user_password_* GET 
user_name_*
1) "hey,im in" # 密码
2) "hacker" # 用户名
3) "jack201022"
4) "jack"
5) "nobodyknows"
6) "huangz"
7) "a_long_long_password"
8) "admin"

GET 还有一个特殊的规则—— "GET #" ,用于获取被排序对象(我们这里的例子是user_id)的当前元素。

比如你希望 user_id 按 level 排序,还要列出 id 、 name 和 password ,可以使用以下命令:

redis> SORT user_id BY user_level_* DESC GET # GET user_name_* GET 
user_password_*
1) "222" # id
2) "hacker" # name
3) "hey,im in" # password
4) "1"
5) "admin"
6) "a_long_long_password"
7) "2"
8) "huangz"
9) "nobodyknows"
10) "59230"
11) "jack"
12) "jack201022"

\color{grey}{**只获取对象而不排序**}

\color{grey}{BY 修饰符可以将一个不存在的 key 当作权重,让 SORT 跳过排序操作。}

\color{grey}{该方法用于你希望获取外部对象而又不希望引起排序开销时使用。}

# 确保 fake_key 不存在
redis> EXISTS fake_key
(integer) 0

# 以 fake_key 作 BY 参数,不排序,只 GET name 和 GET password
redis> SORT user_id BY fake_key GET # GET user_name_* GET 
user_password_*
1) "222" # id
2) "hacker" # user_name
3) "hey,im in" # password
4) "59230"
5) "jack"
6) "jack201022"
7) "2"
8) "huangz"
9) "nobodyknows"
10) "1"
11) "admin"
12) "a_long_long_password"

\color{grey}{**保存排序结果**}

默认情况下, SORT 操作只是简单地返回排序结果,如果你希望保存排序结果,可以给STORE 选项指定一个 key 作为参数,排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在,则覆盖。

redis> EXISTS user_info_sorted_by_level # 确保指定 key 不存在
(integer) 0

redis> SORT user_id BY user_level_* GET # GET user_name_* GET 
user_password_* STORE user_info_sorted_by_level # 排序
(integer) 12 # 显示有 12 条结果被保存了

redis> LRANGE user_info_sorted_by_level 0 11 # 查看排序结果
1) "59230"
2) "jack"
3) "jack201022"
4) "2"
5) "huangz"
6) "nobodyknows"
7) "222"
8) "hacker"
9) "hey,im in"
10) "1"
11) "admin"
12) "a_long_long_password"

\color{grey}{一个有趣的用法是将 SORT 结果保存,用 EXPIRE 为结果集设置生存时间,这样结果集就成了 SORT 操作的一个缓存。}

\color{grey}{这样就不必频繁地调用 SORT 操作了,只有当结果集过期时,才需要再调用一次 SORT操作。}

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

\color{grey}{**在 GET 和 BY 中使用哈希表** }

\color{grey}{可以使用哈希表特有的语法,在 SORT 命令中进行 GET 和 BY 操作。}

# 假设现在我们的用户表新增了一个 serial 项来为作为每个用户的序列号
# 序列号以哈希表的形式保存在 serial 哈希域内。
redis> HMSET serial 1 23131283 2 23810573 222 502342349 59230 
2435829758
OK

# 用 serial 中值的大小为根据,对 user_id 进行排序
redis> SORT user_id BY *->serial
1) "59230"
2) "222"
3) "2"
4) "1"

\color{grey}{符号 "->" 用于分割哈希表的键名(key name)和索引域(hash field),格式为"key->field"}

\color{grey}{除此之外,哈希表的 BY 和 GET 操作和上面介绍的其他数据结构(列表、集合、有序集合)没有什么不同。}

  • 时间复杂度:

O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。

如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。

  • 返回值:

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

使用 STORE 参数,返回排序结果的元素数量。

\color{green}{ object}

  • 格式:object subcommand [arguments [arguments]]
    • \color{grey}{OBJECT 命令允许从内部察看给定 key 的 Redis 对象。}

    • \color{grey}{它通常用在除错(debugging)或者了解为了节省空间而对 key 使用特殊编码的情况。}

    • \color{grey}{当将 Redis 用作缓存程序时,你也可以通过 OBJECT 命令中的信息,决定 key 的驱逐策略(eviction policies)。}

​ 1. \color{grey}{**OBJECT 命令有多个子命令:**}

  • \color{grey}{OBJECT REFCOUNT <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。}
  • \color{grey}{OBJECT ENCODING <key> 返回给定 key 锁储存的值所使用的内部表示(representation)}
  • \color{grey}{OBJECT IDLETIME <key> 返回给定 key 自储存以来的空转时间(idle, 没有被读取也没有被写入),以秒为单位。}

​ 2. \color{grey}{**对象可以以多种方式编码:**}

  • \color{grey}{字符串可以被编码为 raw (一般字符串)或 int (用字符串表示 64 位数字是为了节约空间)。}
  • \color{grey}{列表可以被编码为 ziplist 或 linkedlist 。ziplist 是为节约大小较小的列表空间而作的特殊表示。}
  • \color{grey}{集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。}
  • \color{grey}{哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。}
  • 有序集合可以被编码为 ziplist 或者 skiplist 格式。ziplist 用于表示小的有序集合,而 skiplist 则用于表示任何大小的有序集合。

假如你做了什么让 Redis 没办法再使用节省空间的编码时(比如将一个只有 1 个元素的集合扩展为一个有 100 万个元素的集合),特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。

  • 参考版本: >= 2.2X

  • 时间复杂度: O ( 1 );

  • 返回值:

    REFCOUNT 和 IDLETIME 返回数字。

    ENCODING 返回相应的编码类型

redis> SET game "COD" # 设置一个字符串
OK

redis> OBJECT REFCOUNT game # 只有一个引用
(integer) 1

redis> OBJECT IDLETIME game # 等待一阵。。。然后查看空转时间
(integer) 90

redis> GET game # 提取 game, 让它处于活跃(active)状态
"COD"

redis> OBJECT IDLETIME game # 不再处于空转
(integer) 0

redis> OBJECT ENCODING game # 字符串的编码方式
"raw"

redis> SET phone 15820123123 # 大的数字也被编码为字符串
OK

redis> OBJECT ENCODING phone
"raw"

redis> SET age 20 # 短数字被编码为 int
OK

redis> OBJECT ENCODING age
"int"

\color{green}{migrate}

  • 格式:migrate host port key destination-db timeout

    ​ - 将 key 原子性地从当前实例传送到目标实例的指定数据库上,一旦传送成功, key 保证会出现在目标实例上,而当前实例上的 key 会被删除。

    ​ - 这个命令是一个原子操作,它在执行的时候会阻塞进行迁移的两个实例,直到以下任意结果发生:迁移成功,迁移失败,等到超时。

    ​ - 命令的内部实现是这样的:它在当前实例对给定 key 执行 DUMP 命令 ,将它序列化,然后传送到目标实例,目标实例再使用 RESTORE 对数据进行反序列化,并将反序列化所得的数据添加到数据库中;当前实例就像目标实例的客户端那样,只要看到 RESTORE 命令返回 OK ,它就会调用 DEL 删除自己数据库上的 key 。

    ​ - timeout 参数以毫秒为格式,指定当前实例和目标实例进行沟通的最大间隔时间。这说明操作并不一定要在 timeout 毫秒内完成,只是说数据传送的时间不能超过这个 timeout 数。

    ​ - MIGRATE 命令需要在给定的时间规定内完成 IO 操作。如果在传送数据时发生 IO 错误,或者达到了超时时间,那么命令会停止执行,并返回一个特殊的错误: IOERR 。

    ​ - 当 IOERR 出现时,有以下两种可能:

          1. key 可能存在于两个实例
          2. key 可能只存在于当前实例
    

    ​ - 唯一不可能发生的情况就是丢失 key ,因此,如果一个客户端执行 MIGRATE 命令,并且不幸遇上 IOERR 错误,那么这个客户端唯一要做的就是检查自己数据库上的 key 是否已经被正确地删除。

    ​ - 如果有其他错误发生,那么 MIGRATE 保证 key 只会出现在当前实例中。(当然,目标实例的给定数据库上可能有和 key 同名的键,不过这和 MIGRATE 命令没有关系)。

  • 参考版本: >= 2.6X

  • 时间复杂度:

这个命令在源实例上实际执行 DUMP 命令和 DEL 命令,在目标实例执行 RESTORE 命令,查看以上命令的文档可以看到详细的复杂度说明。

key 数据在两个实例之间传输的复杂度为 O(N)

  • 返回值: 迁移成功时返回 OK ,否则返回相应的错误
$ ./redis-server &
[1] 3557
...

$ ./redis-server --port 7777 &
[2] 3560
...

然后用客户端连上 6379 端口的实例,设置一个键,然后将它迁移到 7777 端口的实例上:

$ ./redis-cli
redis 127.0.0.1:6379> flushdb
OK

redis 127.0.0.1:6379> SET greeting "Hello from 6379 instance"
OK

redis 127.0.0.1:6379> MIGRATE 127.0.0.1 7777 greeting 0 1000
OK

redis 127.0.0.1:6379> EXISTS greeting # 迁移成功后 key 被删除
(integer) 0

使用另一个客户端,查看 7777 端口上的实例:

$ ./redis-cli -p 7777
redis 127.0.0.1:7777> GET greeting
"Hello from 6379 instance"

\color{green}{ dump}

  • 格式:dump key

序列化给定 key ,并返回被序列化的值,使用 RESTORE 命令可以将这个值反序列化为Redis 键

序列化生成的值有以下几个特点:

  • 它带有 64 位的校验和,用于检测错误, RESTORE 在进行反序列化之前会先检查校验和。

  • 值的编码格式和 RDB 文件保持一致。

  • RDB 版本会被编码在序列化值当中,如果因为 Redis 的版本不同造成 RDB 格式不兼容,那么Redis 会拒绝对这个值进行反序列化操作。

序列化的值不包括任何生存时间信息。

  • 参考版本: >= 2.6X
  • 时间复杂度:

查找给定键的复杂度为 O(1) ,对键进行序列化的复杂度为 O(N*M) ,其中 N 是构成key 的 Redis 对象的数量,而 M 则是这些对象的平均大小

如果序列化的对象是比较小的字符串,那么复杂度为 O(1)

  • 返回值:

如果 key 不存在,那么返回 nil

否则,返回序列化之后的值

redis> SET greeting "hello, dumping world!"
OK

redis> DUMP greeting "\x00\x15hello, dumping world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"

redis> DUMP not-exists-key
(nil)


\color{green}{未完待续。。。。}

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 211,817评论 6 492
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,329评论 3 385
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 157,354评论 0 348
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,498评论 1 284
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 65,600评论 6 386
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,829评论 1 290
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,979评论 3 408
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,722评论 0 266
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,189评论 1 303
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,519评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,654评论 1 340
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,329评论 4 330
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,940评论 3 313
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,762评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,993评论 1 266
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,382评论 2 360
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,543评论 2 349