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參數，返回排序結果的元素數量。