रेडिस में हैश का उपयोग करना

रेडिस में हैश संबंधित फ़ील्ड-वैल्यू जोड़े को एक ही कुंजी के तहत संग्रहीत करने का एक तरीका है, जहां फ़ील्ड और मान दोनों स्ट्रिंग हैं। रेडिस समग्र रूप से डेटा संरचना और संरचना के प्रत्येक क्षेत्र में संशोधन की अनुमति देता है। यह इसे किसी एप्लिकेशन में ऑब्जेक्ट के लिए एक बढ़िया (और बहुत तेज़) बैकिंग स्टोर बनाता है।

CLI उदाहरण

दो क्षेत्रों के साथ एक हैश बनाएं:

127.0.0.1:6379> HMSET my_hash key1 "foo" key2 "bar"
OK

हैश से जुड़े क्षेत्रों और मूल्यों की सूची बनाएं:

127.0.0.1:6379> HGETALL my_hash
1) "key1"
2) "foo"
3) "key2"
4) "bar"

किसी एक फ़ील्ड का मान अपडेट करें:

127.0.0.1:6379> HSET my_hash key1 "xyzzy"
(integer) 0
127.0.0.1:6379> HGET my_hash key1
"xyzzy"

हैश से एकल फ़ील्ड हटाएं:

127.0.0.1:6379> HDEL my_hash key2
(integer) 1
127.0.0.1:6379> HGETALL my_hash
1) "key1"
2) "xyzzy"

हैश हटाएं:

127.0.0.1:6379> DEL my_hash
(integer) 1
127.0.0.1:6379> HGETALL my_hash
(empty list or set)

रेडिस के उत्कृष्ट प्रलेखन में हैश के लिए उपलब्ध कमांड के बारे में अधिक जानकारी है। मैं आपके लिए वहां से कॉपी/पेस्ट नहीं करूंगा; इसके बजाय, हम उनके साथ थोड़ी मस्ती करने जा रहे हैं।

ड्वेम्थिस ऐरे!

Dwemthy's Array एक छोटा सा उदाहरण रोल प्लेइंग गेम (RPG) है, जिसे व्हाई द लकी स्टिफ ने क्यों (मर्मस्पर्शी) गाइड टू रूबी में लिखा है। रूबी मेटाप्रोग्रामिंग को समझाने में मदद करने के लिए। यहां, हम एक ही आरपीजी विचार लेने जा रहे हैं, और इसे रेडिस हैश (रेडिस सरणी से थोड़ी मदद के साथ) का उपयोग करके कार्यान्वित करेंगे।

हम सरणी में प्रत्येक राक्षस के लिए एक हैश बनाएंगे, जो कुछ इस तरह दिखेगा:

name: "AssistantViceTentacleAndOmbudsman"
life: 320
strength: 6
charisma: 144
weapon: 50

यहाँ एक उदाहरण है जो सरणी की गहराई में गोता लगाता है:

>>> import redis
>>> import dwemthy
>>> conn = redis.StrictRedis(host="localhost", port=6379)
>>> dw = dwemthy.Array.new(conn,
      {
        "name": "AssistantViceTentacleAndOmbudsman",
        "life": 320,
        "strength": 6,
        "charisma": 144,
        "weapon": 50
      }
    )
"[Get ready. AssistantViceTentacleAndOmbudsman has emerged!]"
>>> rabbit = dwemthy.Rabbit(dw)
>>> rabbit.sword()
"[You hit with 2 points of damage!]"
"[Your enemy hit with 10 points of damage!]"
"[Rabbit has died!]"

और यदि आप इसका अनुसरण करना चाहते हैं, तो समग्र रूप से यह कोड है:dwemthy.py

कोड हाइलाइट

सबसे पहले, जब कोई उपयोगकर्ता प्रदान की गई फ़ैक्टरी विधि के साथ सरणी बनाता है, तो हम अपनी डेटा संरचनाएँ सेट करेंगे और नई dwemthy.Array ऑब्जेक्ट वापस करेंगे:

class Array(object):
    list_key = "dwemethys_array"

    ...

    @classmethod
    def new(cls, conn, *bad_guys):
        """ Create a new set of problems for our hero to boomerang! """

        conn.delete(cls.list_key)

        # Give each bad guy a cozy spot in the array!
        for bad_guy in bad_guys:
            key = uuid.uuid4()
            conn.hmset(key, bad_guy)
            conn.rpush(cls.list_key, key)

        dw_list = cls(conn)
        dw_list.next_enemy()
        return dw_list

यहाँ conn.hmset बुरे आदमी के लिए एक हैश बनाता है। एक बार ऐसा होने पर, हम बैडमैन की कुंजी को एक रेडिस सूची में धकेल देते हैं, जिसका उपयोग यहां एक साधारण कतार के रूप में किया जा रहा है।

जब सभी बुरे लोग सेट हो जाते हैं, तो हम सुनिश्चित करते हैं कि सरणी के शीर्ष पर Array.next_enemy() विधि के साथ तैयार है:

class Array(object):    
    list_key = "dwemethys_array"

    ...

    def next_enemy(self):
        """ Bring out the next enemy for our rabbit to face! """

        # We're moving on!
        if self.current != None:
            self.conn.delete(self.current)

        enemy_key = self.conn.lpop(self.list_key)

        if enemy_key is None:
            # Like a boss!
            print "[Whoa.  You decimated Dwemthy's List!]"
        else:
            # Get the new enemy ready!
            self.current = enemy_key
            print "[Get ready. {} has emerged!]".format(self["name"])

अंतिम पंक्ति पर स्वयं ["नाम"] सरणी ऑब्जेक्ट पर __setitem__ और __getitem__ विधियों को परिभाषित करके किया जाता है। यह हमें सरणी को ज्यादातर अजगर के रूप में मानने की अनुमति देता है, और वर्तमान बुरे आदमी पर फ़ील्ड को आसानी से लाने और संशोधित करने की अनुमति देता है:

class Array(object):

    ...

    def __setitem__(self, key, value): 
        self.conn.hset(self.current, key, value)

    def __getitem__(self, key):
        value = self.conn.hget(self.current, key)

        # hashes only store strings!
        if key != "name":
            return int(value)

        return value

निष्कर्ष

रेडिस के असंख्य तरीके हमें हैश को संशोधित करने की अनुमति देते हैं जिससे डेवलपर्स इसे समस्याओं के एक बड़े समूह को हल करने के लिए उपयोग कर सकते हैं। उम्मीद है कि इस पोस्ट ने आपको अपनी परियोजनाओं में उपयोग करने के लिए विचार दिए हैं।