Zend_Db_Table उपयोग में आसानी

कुछ लोग पूरी क्षमता से इस अद्भुत वर्ग का उपयोग करते हैं। कुछ ने अपनी कुछ छिपी संभावनाओं के बारे में अनुमान लगाया, जैसे मैंने इस क्षण तक किया था।

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

जैसा कि आप जानते हैं, Zend_Db_Table क्लास, डेटाबेस टेबल के लिए ऑब्जेक्ट-ओरिएंटेड इंटरफ़ेस है। पहली उपयोगी खोज यह थी कि Zend_Db_Table कनेक्शन रिकॉर्ड्स को हटाने और कैस्केडिंग अपडेट करने में सक्षम है, जिसके लिए यह आवश्यक है, ताकि संदर्भ मान को हटाते / अपडेट करते समय, निर्भर तालिकाओं में रिकॉर्ड हटाए / अपडेट किए जाएं। उदाहरण के लिए, हम MyISAM डेटा स्टोरेज इंजन के साथ एक MySQL डेटाबेस का उपयोग करेंगे, जो घोषणात्मक संदर्भात्मक अखंडता का समर्थन नहीं करता है।

अब एक छोटा सा विषयांतर। उदाहरण के लिए, हमें निम्नलिखित तालिकाओं से मिलकर एक छोटा डेटाबेस चाहिए: उत्पाद, इकाइयाँ और समूह। हम खाद्य उत्पादों (उत्पादों), माप की इकाइयों (इकाइयों) और उत्पाद समूहों (समूहों) के बारे में बात करेंगे।

तालिकाओं को बनाने और आबाद करने के लिए नीचे SQL प्रश्न हैं:

 # उत्पाद इकाइयाँ DROP टेबल तालिकाएँ यदि `इकाइयाँ’ हैं;  रचनात्मक तालिका `इकाइयां` (` Unit_id` INT (10) UNSIGNED NOT NULL AUTO_INCREMENT, `Unit_name` VARCHAR (256) NOT NULL DEFAULT’, PRIMARY KEY (`Unit_id`)) इंजन = MYISAM AUTO_INCREMENT = 1 DEFAULT CHARSET =  INSERT INTO `इकाइयां` SET` Unit_name` = 'ग्राम';  INSERT INTO `इकाइयाँ` SET` unit_name` = 'मिलिलिटर';  उत्पाद समूहों की # सारणी यदि `समूहों’ को छोड़ दी जाती है, तो उन्हें छोड़ दें;  रचनात्मक तालिका `समूह` (` group_id` INT (10) UNSIGNED NOT NULL AUTO_INCREMENT, `group_name` VARCHAR (256) NOT NULL DEFAULT '', PRIMARY KEY (` group_id`)) इंजन = MYISAM AUTO_INCREMENT = 1 DEFAULT CHARSET =  INSERT INTO `समूहों` सेट` group_name` = 'सब्जियों';  INSERT INTO `समूह` SET` group_name` = 'फल';  INSERT INTO `समूह` SET` group_name` = 'डेयरी';  INSERT INTO `समूह` SET` group_name` = 'मांस';  # उत्पाद तालिका ड्रॉप टेबल यदि उत्पाद `उत्पादों`;  रचनात्मक टेबल `उत्पादों` (` product_id` INT (10) UNSIGNED NOT NULL AUTO_INCREMENT, `group_id` INT (10) DEFAULT NULL,` Unit_id` INT (10) DEDULT NULL, `product_name` VARCHAR (256) NOT NULL DEFAULT '' , प्राथमिक कुंजी (`product_id`)) इंजन = MYISAM DEFAULT CHARSET = utf8;  # सब्जियां INSERT INTO `उत्पादों '(` group_id`, `unit_id`,` product_name`) VALUES (1, 1,' आलू ');  INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (1, 1, ato टमाटर ’);  # फल INSERT INTO `उत्पाद` (` group_id`, `unit_id`,` product_name`) मूल्य (2, 1, 'खुबानी');  INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (2, 1, 'Apple');  # डेयरी INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (3, 1, 'Brynza');  INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (3, 2, 'दूध ’);  # मांस INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (4, 1,) Veal ’);  INSERT INTO `उत्पादों` (` group_id`, `unit_id`,` product_name`) VALUES (4, 1, 'पोर्क'); 

अब जब टेबल्स बनाये जाते हैं और टेस्ट डेटा से भरे जाते हैं, तो हम अपनी टेबलों के लिए कक्षाएं बनाने के लिए आगे बढ़ते हैं:

 वर्ग उत्पाद Zend_Db_Table_Abstract का विस्तार करते हैं
 {
     संरक्षित $ _name = 'उत्पाद';
     संरक्षित $ _primary = array ('product_id');
 }
        
 वर्ग इकाइयाँ Zend_Db_Table_Abstract तक फैली हुई हैं
 {
     संरक्षित $ _name = 'इकाइयाँ';
     संरक्षित $ _primary = array ('unit_id');
 }
 
 वर्ग समूह Zend_Db_Table_Abstract का विस्तार करते हैं
 {
     संरक्षित $ _name = 'समूह';
     संरक्षित $ _primary = array ('group_id');
 }

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

 $ productsTable = नए उत्पाद;
 $ productsRowset = $ productsTable-> fetchAll ();
 foreach ($ पंक्ति के रूप में $ productsRowset) {
     गूंज '<pre>'।  Print_r ($ row-> toArray (), true)।  '</ Pre>'।  PHP_EOL;
 }

जैसा कि आप देख सकते हैं, fetchAll पद्धति एक पंक्तियों को लौटाती है, जहां प्रत्येक $ पंक्ति हमारी तालिका से एक पंक्ति से मेल खाती है। यदि आप निम्न कोड को foreach में जोड़ते हैं, तो यह एक विशिष्ट रिकॉर्ड बदलने में सक्षम है:

 अगर ($ पंक्ति-> product_name == 'पोर्क') {
     $ पंक्ति-> product_name = 'पोर्क बीबीक्यू';
     $ पंक्ति-> बचा ();
 }

हमारी $ पंक्ति पंक्ति के लिए, हम अमूर्त वर्ग Zend_Db_Table_Row_Abstract से सहेजें पद्धति को लागू करते हैं, क्योंकि हमारी पंक्तियाँ foreach को पार्स करती हैं, जो कि Zend_Db_Table_Row_Abbrid से अलग वर्ग Zend_Db_Table_Row_Abstract का एक उदाहरण है। $ पंक्ति स्वयं Zend_Db_Table_Row वर्ग के उदाहरणों से अधिक कुछ नहीं है। Zend_Db_Table_Row वर्ग के उदाहरणों के साथ छेड़छाड़ के लिए गहन ज्ञान की आवश्यकता नहीं है, इसलिए हम उन पर ध्यान नहीं देंगे, लेकिन निम्नलिखित के बारे में बात करेंगे।

मान लीजिए कि आप समूह तालिका में प्राथमिक कुंजी के आदेश की तरह नहीं हैं और आप चाहते हैं कि वे शुरू करें, उदाहरण के लिए, 100 के साथ, कोई समस्या नहीं है, लेकिन इसे लागू करने के लिए कितने कार्यों की आवश्यकता है? सिर घूमने लगता है। उत्पादों की तालिका देखें, इसमें हमने group_id कुंजी द्वारा समूह तालिका को एक बाहरी कनेक्शन प्रदान किया है। और हमारे परिवर्तनों के बाद, उत्पादों को अपने समूहों को फिट करना होगा। शायद यह एक उदाहरण नहीं है जिसे आप देखना चाहते हैं और एक खड़े ओवेशन का नाटक नहीं करते हैं, लेकिन यह दिखाने में सक्षम है कि Zend_Db_Table कक्षाओं के बीच Zend फ्रेमवर्क में बातचीत का तंत्र कैसे लागू किया जाता है।
तो चलिए शुरू करते हैं। पैरेंट टेबल के लिए ऑब्जेक्ट मॉडल में, आपको निर्भर टेबल निर्दिष्ट करना होगा। समूह वर्ग में, आपको निम्न गुण जोड़कर निर्भर वर्ग उत्पाद निर्दिष्ट करना होगा

 संरक्षित $ _dependentTables = array ('उत्पाद');

यह भी इकाइयों वर्ग में किया जाना चाहिए। ये हमें बताते हैं कि माता-पिता के बदलने पर आश्रित तालिकाओं में रिकॉर्ड को ध्यान में रखा जाएगा। लेकिन इसके लिए हमें उत्पाद वर्ग में इकाइयों और समूह तालिकाओं के लिंक जोड़ने की आवश्यकता है। इसे लागू करने के कई तरीके हैं, उदाहरण के लिए, उत्पाद वर्ग में $ _referenceMap संपत्ति जोड़ना:

 संरक्षित $ _referenceMap = सरणी (
     'refUnits' => सरणी (
         स्वयं :: COLUMNS => 'unit_id',
         स्व :: REF_TABLE_CLASS => 'इकाइयाँ',
         स्व :: REF_COLUMNS => 'unit_id',
         स्वयं :: ON_DELETE => स्वयं :: CASCADE,
         स्वयं :: ON_UPDATE => स्वयं :: CASCADE
     )
     'RefGroups' => सरणी (
         स्वयं :: COLUMNS => 'group_id',
         स्वयं :: REF_TABLE_CLASS => 'समूह',
         स्वयं :: REF_COLUMNS => 'group_id'
         स्वयं :: ON_DELETE => स्वयं :: CASCADE,
         स्वयं :: ON_UPDATE => स्वयं :: CASCADE
     )
 );

$ _ReferenceMap संपत्ति आपको बाहरी तालिका के लिए लिंक जोड़ने की अनुमति देती है, इसलिए हमें कई-से-एक संबंध मिलते हैं। निम्नलिखित मापदंडों को निर्धारित करना आवश्यक है

1. सहयोगी कुंजी
2. संदर्भ तालिका में विदेशी कुंजी क्षेत्र का नाम
3. तालिका का वर्ग नाम जिसे हम संदर्भित करते हैं
4. जिस तालिका का हम उल्लेख करते हैं, उस फ़ील्ड का नाम
5. आपके द्वारा हटाए जाने पर होने वाली कार्रवाई
6. अद्यतन करते समय होने वाली क्रिया

एक पूरे के रूप में कोड:

 वर्ग उत्पाद Zend_Db_Table_Abstract का विस्तार करते हैं
 {
     संरक्षित $ _name = 'उत्पाद';
     संरक्षित $ _primary = array ('product_id');

     संरक्षित $ _referenceMap = सरणी (
         'refUnits' => सरणी (
             स्वयं :: COLUMNS => 'unit_id',
             स्व :: REF_TABLE_CLASS => 'इकाइयाँ',
             स्व :: REF_COLUMNS => 'unit_id',
             स्वयं :: ON_DELETE => स्वयं :: CASCADE,
             स्वयं :: ON_UPDATE => स्वयं :: CASCADE
         )
         'RefGroups' => सरणी (
             स्वयं :: COLUMNS => 'group_id',
             स्वयं :: REF_TABLE_CLASS => 'समूह',
             स्वयं :: REF_COLUMNS => 'group_id'
             स्वयं :: ON_DELETE => स्वयं :: CASCADE,
             स्वयं :: ON_UPDATE => स्वयं :: CASCADE
         )
     );
 }

 वर्ग इकाइयाँ Zend_Db_Table_Abstract तक फैली हुई हैं
 {
     संरक्षित $ _name = 'इकाइयाँ';
     संरक्षित $ _primary = array ('unit_id');

     संरक्षित $ _dependentTables = array ('उत्पाद');
 }

 वर्ग समूह Zend_Db_Table_Abstract का विस्तार करते हैं
 {
     संरक्षित $ _name = 'समूह';
     संरक्षित $ _primary = array ('group_id');

     संरक्षित $ _dependentTables = array ('उत्पाद');
 }

अब हमारे पास संबंधित टेबल हैं और हम चिंता नहीं कर सकते हैं और शांति से अपनी आईडी कुंजियों को अपडेट कर सकते हैं।
वैसे, मैं यह उल्लेख करना भूल गया कि जब आप किसी उत्पाद समूह को हटाते हैं, तो स्वयं उत्पाद जो इन समूहों से मेल खाते हैं, वे भी हटा दिए जाते हैं। आप उनमें से किसी को भी प्रयोग और हटा सकते हैं। यदि आप रुचि रखते हैं, तो एब्स्ट्रैक्ट क्लास Zend_Db_Table_Abstract के _cascadeUpdate और _cascadeDelete के तरीके अपडेट करने और डिलीट करने के लिए जिम्मेदार हैं और उन्हें तब बुलाया जाता है जब क्रमशः $-> सेव () और $ row-> डिलीट () कहा जाता है। आप findParentRow मेथड को कॉल करके पैरेंट रिकॉर्ड (पंक्ति) भी प्राप्त कर सकते हैं

 $ productsTable = नए उत्पाद;
 $ productsRowset = $ productsTable-> fetchAll ();
 foreach ($ पंक्ति के रूप में $ productsRowset) {
     गूंज '-----------------------'।  PHP_EOL;
     गूंज '<pre>'।  Print_r ($ row-> toArray (), true)।  '</ Pre>'।  PHP_EOL;
     गूंज '<pre>'।  Print_r ($ row-> findParentRow ('Unit') -> toArray (), true)।  '</ Pre>'।  PHP_EOL;
     गूंज '<pre>'।  Print_r ($ row-> findParentRow ('Group') -> toArray (), true)।  '</ Pre>'।  PHP_EOL;
     गूंज '-----------------------'।  PHP_EOL;
 }

या तो findD dependentRowset विधि को कॉल करके सभी निर्भर रिकॉर्ड (पंक्तियाँ) प्राप्त करें

 $ groupRowset = $ groupTable-> fetchAll ();
 foreach ($ पंक्ति के रूप में $ groupRowset) {
     गूंज '-----------------------'।  PHP_EOL;
     गूंज '<pre>'।  Print_r ($ row-> toArray (), true)।  '</ Pre>'।  PHP_EOL;
     गूंज '<pre>'।  Print_r ($ पंक्ति-> findD dependentRowset ('उत्पाद') -> toArray (), सच)।  '</ Pre>'।  PHP_EOL;
     गूंज '-----------------------'।  PHP_EOL;
 }

प्राप्त पंक्तियों के साथ, आप Zend_Db_Table_Row वर्ग के उदाहरणों के साथ भी स्वतंत्र रूप से काम कर सकते हैं। सौभाग्य है

ps हाय जोस, आपकी सभी इच्छाओं को ध्यान में रखा गया है।