keys Use

grammar ：keys PATTERN： Used to find all that match a given pattern PATTERN Of key

keys * #  Inquire about  redis  All of the  key

keys h?llo  # ?:  Pass on a single character ,  It can be  hello hallo ...,  It doesn't contain  hllo.

keys h*llo  # *  With any number of characters , hllo hello heello heallo ... 

keys h[ae]llo  # []:  Wildcard a character in parentheses , You can find out  hello hallo,  We can't find out  hllo.

keys h[^e]llo  #  matching  e  The previous letter ,  It can be  hallo ... hdllo , It doesn't contain  hello.

keys h[a-b]llo # -  amount to  or,  matching  a  or  b,  It can be  hallo hbllo;  You can add more conditions , such as : keys h[a-b-c-d]llo 

# The above syntax can also be combined accordingly , Such as 
keys h[a-b]*llo  #  matching  ha( Any number of characters )llo  and  hb( Any number of characters )llo

The formal environment is disabled keys Why

keys The time complexity of is ：O(N), among N Is the number of keys in the database , Suppose that the key name in the database and the length of the given schema are limited . Although its complexity is O(N), But the duration is very short , You can do it on an entry-level computer 40ms scanning 100 Ten thousand data .

But if it is High concurrency Under the condition of , Use keys There will be problems , because Redis Is a single threaded database , The database will be locked every time the command is executed , also keys The command has no paging function , It will traverse the whole database every time , If 20ms After performing an operation , If it is a million level concurrency , that Redis Every time you execute a command, there will be a brief lock , This leads to a large number of requests being blocked , Make other services unavailable , And then CPU High usage , Finally, the server goes down .

keys The problem is ：

1. No paging , It will traverse all databases at once , And find out all qualified key value ; But the results of the query may be very useful, which is very resource consuming .

2. Although the query speed is very fast , But as the amount of data grows , The longer the query time will become .

SCAN Use

grammar ：SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]

SCAN Is a cursor based iterator . This means that every time the command is called , The server will return the corresponding query data and a new cursor , The user needs to use this cursor as a cursor parameter in the next call .

The cursor is set to 0 when , The iteration will begin , The cursor returned by the server is 0 when , The iteration will end .

Parameter description ：

• cursor: Cursor position ( hash The index value of the bucket ), An integer value ; from 0 Start , To 0 end ; The result of the query may be 0 individual , But the cursor is not 0, As long as the cursor is not 0, It means that the traversal is not over yet .
• match pattern: Regular match fields （ Optional ）
• count: Limit the number of single scans limit hint（ reference value , The number of bottom traversals is not necessarily ）, The default is 10. It is not the maximum number of returned query results . such as count by 10000, Means every scan 1w Bar record , But maybe only 10 One that meets the conditions or has 2w Records conform to .（ Optional ）

matters needing attention ：

1. A cursor is a Hash value , It's out of order , A traversal from from 0 Start , To 0 end , It means returning to the starting point .
2. There is no need to use the same... For each iteration COUNT value . As long as the cursor obtained last time is passed in the next traversal , So the next traversal will use the last COUNT value .
3. scan The returned result may have duplicate data , The client needs to be de duplicated
4. The new data may not be traversed to

127.0.0.1:6379> scan 0 match 1* count 15
 1) "17"
 2)  1) "key:12"
     2) "key:18"
     3) "key:14"
     4) "key:14"
     5) "key:16"
     6) "key:17"
     7) "key:15"
     8) "key:10"
     9) "key:13"
    10) "key:17"
    11) "key:1"  #  scanning  15  Elements , But only  11  Elements match 
127.0.0.1:6379> scan 17  # count  Will use the last  15
 1) "0"    #  The cursor value is  0, It means that the traversal is over 
 2) 1) "key:15"
    2) "key:118"
    3) "key:10"
    4) "key:112"
    5) "key:119"
    6) "key:13"
    7) "key:16"
    8) "key:19"    
    9) "key:111"

Blog address : Redis How to query a from massive data Key ?