शुद्ध रेडिस का उपयोग करके पैटर्न से मेल खाने वाली लाखों चाबियों को परमाणु रूप से कैसे हटाएं?

निम्नलिखित लुआ स्क्रिप्ट SCAN का उपयोग करती है कमांड, इसलिए यह स्क्रिप्ट के भीतर टुकड़ों में हटा देता है - "अनपैक करने के लिए बहुत सारे तत्व" त्रुटि से बचना।

local cursor = 0
local calls = 0
local dels = 0
repeat
    local result = redis.call('SCAN', cursor, 'MATCH', ARGV[1])
    calls = calls + 1
    for _,key in ipairs(result[2]) do
        redis.call('DEL', key)
        dels = dels + 1
    end
    cursor = tonumber(result[1])
until cursor == 0
return "Calls " .. calls .. " Dels " .. dels

यह कितनी बार लौटाता है SCAN कॉल किया गया था और कितनी कुंजियाँ हटाई गईं।

के रूप में प्रयोग करें:

EVAL "local cursor = 0 local calls = 0 local dels = 0 repeat    local result = redis.call('SCAN', cursor, 'MATCH', ARGV[1])     calls = calls + 1   for _,key in ipairs(result[2]) do       redis.call('DEL', key)      dels = dels + 1     end     cursor = tonumber(result[1]) until cursor == 0 return 'Calls ' .. calls .. ' Dels ' .. dels" 0 prefix:1

ध्यान दें कि यह चलते समय सर्वर को ब्लॉक कर देगा, इसलिए इसे उत्पादन के लिए सलाह नहीं दी जाती है।

उत्पादन के लिए, DEL को बदलने पर विचार करें UNLINK . के लिए . आप कर्सर को वापस भी कर सकते हैं (स्क्रिप्ट के अंदर शून्य होने तक दोहराने के बजाय) और थ्रॉटल करने के लिए स्कैन में COUNT पैरामीटर जोड़ें (देखें क्या REDIS में स्कैन / HSCAN कमांड के लिए COUNT का कोई अनुशंसित मान है?) इस तरह आप इसे एक बार के बजाय टुकड़ों में करते हैं, मैं रेडिस में सभी सेट कैसे प्राप्त कर सकता हूं?

या आप इस उत्तर में बताए गए दृष्टिकोण का उपयोग करके कुछ अधिक परिष्कृत कर सकते हैं:Redis `SCAN`:नई आने वाली कुंजियों के बीच संतुलन कैसे बनाए रखें जो उचित समय में अंतिम परिणाम से मेल खा सकें और सुनिश्चित कर सकें?