Redis हैशेज में महारत हासिल करें: तेज़, लचीला डेटा स्टोरेज

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

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)

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

Dwemthy's Array!

Dwemthy's Array Why the Lucky Stiff द्वारा लिखित एक छोटा उदाहरण रोल प्लेइंग गेम (RPG) है Why's (poignant) guide to Ruby में Ruby मेटाप्रोग्रामिंग को समझाने में मदद करने के लिए। यहां, हम उसी RPG विचार को लेने जा रहे हैं, और इसे Redis हैशेज (थोड़ी सी Redis सरणी की मदद से) का उपयोग करके लागू करेंगे।

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

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 बदमाश के लिए एक हैश बनाता है। एक बार ऐसा होने पर, हम बदमाश की कुंजी को Redis लिस्ट में धकेलते हैं, जिसे यहां एक साधारण कतार के रूप में उपयोग किया जा रहा है।

जब सभी बदमाश सेट हो जाते हैं, तो हम तब 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"])

अंतिम पंक्ति पर 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

निष्कर्ष

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