Redis命令参考(Commands Reference)中文翻译【Key部分】

注意：此文档已经过期，请移步到 http://huangz.iteye.com/blog/1123512 查看最新翻译。

 

进度

 

Redis的官方命令参考共10个部分(Keys, Strings, Hashes, Lists ...)。

计划每3-5天更新一部分，但不保证。

欢迎任何积极性意见和反馈@huangz1990

 

2011.4.17 Keys部分完成

2011.4.21 Strings部分完成

2011.4.29 Hash部分完成，Redis升级到2.2.5。

 

 

KEYS部分

DEL key [key2, ...]

 

    删除指定的key 

 

        复杂度：

            单个字符串O(1), 多个字符串（数量N）为O(N)。

            列表、集合、有序集合和哈希表(list，set，zset，hash)为O(M)，M为以上数据结构内的key数量。

 

        返回值：

            被移除key的数量。

 

redis> mset name "huangz" age 20  # 一次set多个key-value
OK

redis> del name
(integer) 1

redis> del age fake_key  # fake_key不存在，只有age被删除
(integer) 1

 

 

KEYS pattern

 

    查找符合给定模式的key 

 

    h?llo命中hello, hallo and hxllo，等。

    h*llo命中hllo和heeeeello等。

    h[ae]llo命中hello和hallo，但不命中hillo。

 

    特殊符号用"\"隔开

 

        复杂度：

            O(N)，N为数据库中key的数量。

 

            KEYS的速度非常快，使用一般的手提电脑可以在40毫秒内扫描100万个key。

            但在一个大的数据库中频繁使用KEYS命令仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合（set）结构。

 

        返回值：

            符合给定模式的key列表。

 

redis> mset one 1 two 2 three 3 four 4
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"

 

RANDOMKEY

 

    从当前数据库中随机返回一个key

 

        复杂度：

            O(1)

 

        返回值：

            一个key。

            当数据库为空时，返回nil。

 

redis> mset fruit "apple" drink "beer" food "cookies"
OK

redis> randomkey
"fruit"

redis> randomkey
"food"

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

redis> randomkey
(nil)

 

 

TTL key

 

    返回给定key的剩余生存时间。

 

        复杂度：

            O(1)

 

        返回值：

            剩余生存时间（以秒为单位）。

            当key不存在或过期时，返回-1 。

 

redis> set name "huangz"
OK

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

redis> get name
"huangz"

redis> ttl name
(integer) 25

redis> get name
"huangz"

redis> ttl name
(integer) 15

redis> ttl name  # 30秒过去，name过期
(integer) -1

redis> get name
(nil)

 

EXISTS key

 

    检查给定key是否存在。

 

        复杂度：

            O(1)

 

        返回值：

            若key存在，返回1。

            不存在则返回0 。

 

redis> set db "redis"
OK

redis> exists db  # key存在
(integer) 1

redis> del db
(integer) 1

redis> exists db  # key不存在
(integer) 0

 

MOVE key db

 

    将当前数据库（默认为0）的key移动到指定的数据库db。

    如果当前数据库（源数据库）和指定数据库（目标数据库）有相同名字的指定key，或者key不存在于当前数据库，那么MOVE没有任何效果。因此，也可以利用这一特性，将MOVE当作锁（locking）。

 

        复杂度：

            O(1)

 

        返回值：

            移动成功返回1。

            失败则返回0 。

 

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"

  

RENAME key newkey

    

    将key改名为newkey。

    当key和newkey相同或者key不存在时，返回一个错误。

    当newkey已经存在时，RENAME将覆盖之。

        复杂度：

            O(1)

        返回值：

            成功时提示OK。

            失败时候返回一个错误。

redis:1> SET message "hello world"
OK

redis:1> RENAME message greeting
OK

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

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


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

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


# 当newkey已存在时，RENAME会覆盖旧newkey

redis:1> SET pc "lenovo"
OK

redis:1> SET personal_computer "dell"
OK

redis:1> RENAME pc personal_computer
OK

redis:1> GET pc
(nil)

redis:1> GET personal_computer  # dell“没有”了
"lenovo"

 

TYPE key

    返回key中储存的value（值）的类型。

        复杂度：

            O(1)

        返回值：

            字符串，列表，集合，有序集合和哈希表(string, list, set, zset, hash)。

redis:1> SET weather "sunny"  # 构建一个字符串
OK

redis:1> TYPE weather 
string

redis:1> LPUSH book_list "programming in scala"  # 构建一个列表
(integer) 1

redis:1> LPUSH book_list "algorithms in C"
(integer) 2

redis:1> TYPE book_list 
list

redis:1> SADD pat "dog"  # 构建一个集合
(integer) 1

redis:1> TYPE pat
set

 

 

EXPIRE key seconds

    为给定key设置过期时间。

    当key过期时，它会被自动删除。

    在Redis的术语中，带有过期时间的key称为可挥发的(volatile) 。

    

    在版本低于2.1.3版本的Redis中，已存在的过期时间不可覆盖。

    从2.1.3开始，key的过期时间可以被更新，也可以被移除（见PERSIST命令）。

        复杂度：

            O(1)

        返回值：

            设置成功返回1。

            当key不存在或者不能为key设置过期时间（比如在低于2.1.3中你尝试更新key的过期时间），返回0 。

redis> SET cache_page "www.twitter.com/huangz1990"
OK

redis> EXPIRE cache_page 30  # 设置30秒后过期
(integer) 1

redis> TTL cache_page
(integer) 24

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

redis> TTL cache_page
(integer) 29996

 

OBJECT subcommand [arguments [arguments]]

    OBJECT命令允许从内部察看给定key的Redis对象。

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

    当将Redis用作缓存程序时，你也可以通过OBJECT命令中的信息，决定key的驱逐策略（eviction policies）。

    OBJECT命令有多个子命令：

        OBJECT REFCOUNT <key> 返回给定key引用value的次数。此命令主要用于除错。

        OBJECT ENCODING <key> 返回给定key的value所使用的内部表示(representation)。

        OBJECT IDLETIME <key> 返回给定key自储存以来的空转时间（idle， 没有被读取也没有被写入），以秒为单位。

    对象可以以多种方式编码：

        字符串可以被编码为raw（一般字符串）或int（用字符串表示64位数字是为了节约空间）。

        列表可以被编码为ziplist或linkedlist。ziplist是为节约小(small size)列表空间而作的特殊表示。

        集合可以被编码为intset或者hashtable。intset只储存数字的小集合的特殊表示。

        哈希表可以编码为zipmap或者hashtable。zipmap是小哈希表的特殊表示。

        有序集合可以被编码为ziplist或者skiplist格式。ziplist用于表示小的有序集合，而skiplist则用于表示任何大小的有序集合。

        

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

        

        复杂度：

            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 [phone]  # 长的数字被编码为字符串
OK

redis> OBJECT ENCODING phone
"raw"

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

redis> OBJECT ENCODING age
"int"

 

RENAMEX key newkey

    当newkey不存在 时，将key改为newkey

    出错的情况和RENAME一样（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"

 

EXPIREAT key timestamp

   

    EXPIREAT的作用和EXPIRE一样，不同在于EXPIREAT接受的时间参数是unix timestamp。

        复杂度：

            O(1)

        返回值：

            过期时间设置成功，返回1。

            key不存在或没办法设置过期时间，返回0

redis> SET live_man "fake person"
OK

redis> EXPIREAT live_man 2000000000  # unix steamp DATE: 05 / 17 / 33 @ 10:33:20pm EST
(integer) 1

redis> TTL live_man
(integer) 697061482

 

PERSIST key

    移除给定key的过期时间。

        复杂度：

            O(1)

        返回值：

            移除成功，返回1。

            key不存在或key没有设置过期时间，返回0。

redis> SET time_to_say_goodbye "oh, please no delete me"
OK

redis> EXPIRE time_to_say_goodbye 300
(integer) 1

redis> TTL time_to_say_goodbye
(integer) 293

redis> PERSIST time_to_say_goodbye
(integer) 1

redis> TTL time_to_say_goodbye  # 移除成功
(integer) -1

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

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

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

    一般SORT方式

    SORT [data set]

 

    假设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"

 

    当数据集中保存的是字符串值时，你可以用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"

 

    如果你正确设置了!LC_COLLATE环境变量的话，Redis能识别UTF-8编码。

    排序之后返回的元素数量可以通过LIMIT修饰符进行限制。LIMIT修饰符接受两个参数：offset和count。

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

    以下例子返回排序结果的前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"

  

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

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

    使用外部key进行排序

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

    假设现在有以下用户（user）数据：

    id        |  name    |  level

    ---------------------------------------

    1         |  admin    |  9999

    2         |  huangz   | 10 

    59230     |  jack      | 3   

    222       |  hacker    |  9999

    id数据保存在user_id列表中

    name数据保存在user_name_{id}的key中

    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

 

    如果希望按level从大到小排序user_id，可以使用BY操作：

redis> SORT user_id BY user_level_* DESC
1) "222"
2) "1"
3) "2"
4) "59230"

 

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

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

 

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

    比如你不但希望获取用户名，还希望连用户的密码也一并列出，可以使用以下命令：

# 先添加一些测试数据

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"

 

    只获取对象而不排序

    

    BY修饰符可以将一个不存在的key当作权重，让SORT跳过排序操作。

    该方法用于你希望获取外部对象而又不希望引起排序开销 时使用。(这听上去有点像关系数据库的外键？）

# 确保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"
 2) "hacker"
 3) "hey,im in"
 4) "59230"
 5) "jack"
 6) "jack201022"
 7) "2"
 8) "huangz"
 9) "nobodyknows"
10) "1"
11) "admin"
12) "a_long_long_password"

 

    保存排序结果

    默认情况下，SORT操作只是简单地返回排序结果，如果你希望保存排序结果，可以用STORE操作指定一个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"

 

    一个有趣的用法是将SORT结果保存，用EXPIRE为结果集设置过期时间，这样结果集就成了SORT操作的一个缓存。

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

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

    在GET和BY中使用哈希表

    在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) "222"
2) "59230"
3) "2"
4) "1"

 

    字符串"->"用于分割关键字（key name）和索引域（hash field），格式为"key->field"。

    除此之外，哈希表的BY和GET操作和上面介绍的其他数据结构（列表、集合、有序集合）没有什么不同。

        复杂度：

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

   

        返回值：

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

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