अनुप्रयोग इंजन में संबंध मॉडलिंग

जीएई डेवलपर्स जो रिलेशनल डीबीएमएस और ओआरएम के साथ काम करने के आदी हैं, उनमें से एक समस्या का सामना ऐप इंजन में लिंक और संबंधों के साथ किया जाता है। यह मार्गदर्शिका दो प्रश्नों पर चर्चा करती है: पहला, डीबीएमएस में सामान्य रूप से क्या संबंध हैं ?; दूसरे, वे GAE में कैसे उपयोग किए जाते हैं?

संबंध प्रकार

DBMS कई प्रकार के रिश्तों के साथ काम करते हैं - एक-से-एक, एक से कई, और कई-से-कई रिश्ते। शब्दावली में अंतर के बावजूद, संबंध लिंक के समान सिद्धांतों पर काम करते हैं। एक लिंक एक इकाई क्षेत्र है जिसमें अन्य इकाई की कुंजी है - उदाहरण के लिए, यदि "पालतू" "मालिक" को संदर्भित करता है, तो इसका मतलब है कि "पालतू" इकाई में इकाई "मालिक" की कुंजी वाला क्षेत्र है।



सभी प्रकार के संबंधों को लिंक के रूप में दर्शाया जा सकता है। सबसे सरल रूप में एक-से-कई प्रकार एक लिंक है: प्रत्येक "पालतू" का अपना "मालिक" है, इसलिए "मालिक" के पास कई "पालतू जानवर" हो सकते हैं। उसी समय, "मालिक" स्वयं नहीं बदलता है - यह व्यक्तिगत "पालतू जानवर" पर आधारित है जो उसे अपना मालिक कहते हैं।



एक-से-एक संबंध अतिरिक्त प्रतिबंध के साथ एक-से-कई संबंध है कि केवल एक "पालतू" है जो "मालिक" को संदर्भित करता है। क्रॉस-रेफ़रेंस (प्रत्येक इकाई में एक दूसरे से फ़ील्ड-लिंक) को संग्रहीत करके इस सीमा को मजबूत किया जा सकता है।



कई-कई रिश्ते थोड़े अधिक जटिल होते हैं। उन्हें कई तरीकों से लागू किया जा सकता है, लेकिन वे सभी लिंक के जोड़े की सूची में आते हैं। एक उदाहरण के रूप में एक वेब पेज पर विचार करें। प्रत्येक पृष्ठ में कई इनबाउंड और आउटबाउंड लिंक हैं। उन्हें फॉर्म की जोड़ी (from_url, to_url) की सूची के रूप में दर्शाया जा सकता है। संबंधपरक डीबीएमएस में, ऐसे पत्राचार को अलग-अलग तालिकाओं में संग्रहीत किया जाता है, जो संबंधित रिकॉर्ड की खोज करने के लिए प्रश्नों में शामिल होते हैं।



अब देखते हैं कि उपरोक्त प्रकार के लिंक ऐप इंजन में कैसे काम करते हैं। सामान्य तौर पर, "एक-से-कई" और अन्य की शब्दावली से छुटकारा पाने के लिए और वस्तु-उन्मुख दृष्टिकोण से संस्थाओं पर विचार करने के लिए अक्सर उपयोगी होता है। हमने प्रश्न को अलग तरीके से बताया: आपके डेटा संरचना को फिट करने के लिए एक इकाई को दूसरे को कैसे संदर्भित करना चाहिए?

ऐप इंजन में संबंध

एक से कई

इस प्रकार का संबंध किसी भी प्रणाली में आसानी से लागू हो जाता है। ऐप इंजन प्लेटफ़ॉर्म "कई" पक्ष से "एक" पक्ष की कुंजी का भंडारण प्रदान करता है। पायथन में, इसके लिए ReferenceProperty लिंक फ़ील्ड का उपयोग किया जाता है:

class Owner(db.Model): name = db.StringProperty() class Pet(db.Model): name = db.StringProperty() owner = db.ReferenceProperty(Owner)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

"पालतू" के लिए "मालिक" को खोजने के लिए, हम pet.owner विशेषता की ओर मुड़ते हैं, और ऐप इंजन उस इकाई को स्वचालित रूप से लोड करता है जिसे हम संदर्भित कर रहे हैं। सभी "पालतू जानवरों" को खोजने के लिए जो एक विशिष्ट "मालिक" को संदर्भित करते हैं, यह निम्नलिखित प्रश्न करने के लिए पर्याप्त है:

 pets = Pet.all().filter('owner =', owner).fetch(100)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक समान परिणाम आसान प्राप्त किया जा सकता है: ReferenceProperty स्वचालित रूप से संबंधित डेटा के त्वरित और सुविधाजनक उपयोग के लिए मालिक वर्ग में एक संपत्ति बनाता है, इसलिए आप इस तरह "पालतू जानवरों" की एक सूची प्राप्त कर सकते हैं:

 pets = Owner.owner_set.fetch(100)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिफ़ॉल्ट रूप से, App Engine इस संपत्ति को फ़ील्ड नाम + "_set" के रूप में नाम देता है, लेकिन आप अपना स्वयं का उल्लेख कर सकते हैं:

 class Pet(db.Model): name = db.StringProperty() owner = db.ReferenceProperty(Owner, collection_name='pets') pets = owner.pets.fetch(100)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक-से-कई संबंधों को मॉडल करने का एक और तरीका यह है कि इकाई को माता-पिता से जोड़ा जाए। जब एक इकाई बनाई जाती है, तो एक माता-पिता को इसे सौंपा जा सकता है। इस स्थिति में, मूल इकाई की कुंजी बच्चे की कुंजी का हिस्सा बन जाती है और भविष्य में इसे बदला नहीं जा सकता। यह हमारे उदाहरण में ऐसा दिखता है:

 class Owner(db.Model): name = db.StringProperty() class Pet(db.Model): name = db.StringProperty() bob = Owner(name='Bob') felix = Pet(name='Felix', parent=bob) owner_of_felix = felix.parent
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसके अलावा, हम स्पष्ट रूप से कहीं भी संस्थाओं के बीच संबंध को इंगित नहीं करते हैं - यह निर्माण के समय माता-पिता के निर्देशों का पालन करता है। रेफ़रेंस फ़ील्ड (ReferenceProperty) के बजाय पैरेंटल बाइंडिंग का उपयोग करना कब बेहतर है? यह लेनदेन के संचालन को प्रभावित करता है: ऐप इंजन में, प्रत्येक व्यक्तिगत लेनदेन में, आप केवल एक समूह की संस्थाओं पर काम कर सकते हैं, अर्थात्। एक ही समूह से माता-पिता के साथ कई संस्थाएं। यदि आप संबंधित संस्थाओं को लेनदेन में प्रवेश करने से रोकना चाहते हैं, तो लिंक फ़ील्ड का उपयोग करें। यह भी याद रखें कि एक इकाई में केवल एक तत्काल माता-पिता हो सकते हैं, और इसकी कुंजी को निर्माण के बाद नहीं बदला जा सकता है।

एक से एक

एक-से-एक रिश्ते एक-से-कई रिश्तों का एक विशेष मामला है। वे लिंक फ़ील्ड के "एक" पक्ष पर किसी अन्य इकाई में संग्रहीत करके किए जाते हैं।

कई-से-अनेक

कई-कई को लागू करना सबसे मुश्किल है। ऐप इंजन के लिए, उनके निर्माण के लिए कई समाधान हैं। सबसे स्पष्ट दृष्टिकोण एक संबंधपरक डेटाबेस के समान एक लिंक तालिका है, जिसमें रिश्ते के दोनों पक्षों के लिए महत्वपूर्ण जोड़े हैं। हमारे "पालतू जानवर / मालिकों" उदाहरण के लिए, यह इस तरह दिखेगा:

 class Owner(db.Model): name = db.StringProperty() class Pet(db.Model): name = db.StringProperty() class PetOwner(db.Model): pet = db.ReferenceProperty(Pet, collection_name='owners') owner = db.ReferenceProperty(Owner, collection_name='pets')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस पद्धति के फायदे यह हैं कि आप रिश्तों में अतिरिक्त गुण जोड़ सकते हैं - उदाहरण के लिए, जब एक पृष्ठ के लिए लिंक लिंक मॉडलिंग करते हैं, तो आप रिश्ते के लिंक पाठ के साथ एक फ़ील्ड जोड़ सकते हैं। डेटा एक्सेस चरणों में किया जाता है: संबंधित जोड़े पाए जाते हैं, जिसमें से वांछित निकाय निकाले जाते हैं। उदाहरण इस आलेख में वर्णित लिंक से संस्थाओं के बैच निष्कर्षण के पैटर्न का उपयोग करता है * :

 petowners = felix.owners.fetch(100) prefetch_refprops(owners, 'owner') owners = [x.owner for x in petowners]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक अन्य दिशा में संस्थाओं का निष्कर्षण ("मालिक" से "पालतू जानवर" तक) समान रूप से किया जाता है।



एक अन्य दृष्टिकोण रिश्ते की दूसरी तरफ इकाई कुंजी की एक सूची को संग्रहीत करना है। यह तब उपयोगी होता है जब संग्रहित वस्तुओं की संख्या जानबूझकर सीमित होती है (जैसे, कुछ सौ या उससे कम)। ऐसी सूची के साथ, बैच संचालन करना सुविधाजनक है। उदाहरण के लिए:

 class Pet(db.Model): name = db.StringProperty() class Owner(db.Model): name = db.StringProperty() pets = db.ListProperty(db.Key)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रत्येक "मालिक" से आप उसके "पालतू जानवरों" की सूची निकाल सकते हैं:

 pets = db.get(bob.pets)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और दिए गए "पालतू" के लिए सभी "मालिकों" को खोजने के लिए, इस क्वेरी को चलाएं:

 owners = Owner.all().filter('pets =', felix).fetch(100)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंत में, एक हाइब्रिड दृष्टिकोण सबसे अधिक उत्पादक और लचीला हो सकता है। इस विषय पर, मैं आपको Brett Slatkins द्वारा एक अद्भुत रिपोर्ट को देखने की सलाह देता हूं जो ऐप इंजन पर जटिल स्केलेबल एप्लिकेशन विकसित कर रहा है ।



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