MUMPS ग्लोबल्स: एक्सट्रीम डेटाबेस प्रोग्रामिंग। भाग ३

भाग 1 , भाग 2 देखना शुरू करें।

द्वितीयक सूचकांक

संबंधपरक डेटाबेस में, सामान्य सूचकांक आमतौर पर निर्दिष्ट किया जाता है जब तालिकाओं को परिभाषित करना, या ALTER TABLE का उपयोग करने के बाद। यदि कोई इंडेक्स परिभाषित किया गया है, तो यह स्वचालित रूप से बनाया जाता है, और फिर डेटा में बदलाव होने पर डेटाबेस द्वारा बनाए रखा और पुनर्गणित किया जाता है।

MUMPS इंडेक्स में प्रोग्रामर द्वारा स्पष्ट रूप से कार्य किया जाता है, उदाहरण के लिए, टेबल अपडेट फ़ंक्शन में।

MUMPS स्टोर की पदानुक्रमित प्रकृति के कारण, प्राथमिक इंडेक्स वाले फ़ील्ड को कुंजी के रूप में उपयोग किया जाता है।

उदाहरण के लिए, ORDER में एक नई पंक्ति जोड़ने के लिए MUMPS फ़ंक्शन पर विचार करें:

setOrder(orderNo,data) ; new rec,itemNo,ok if orderNo="" Quit 0 ;     set data("totalValue")=0 set itemNo="" for set itemNo=$Order(^ITEM(orderNo,itemNo)) Quit:itemNo="" do . set ok=$$getItem(orderNo,itemNo,.itemData) . Set data("totalValue")=data("totalValue")+itemData("price") set rec=data("custNo")_"~"_data("orderDate")_"~"_data("invoiceDate") set rec=rec_"~"_data("totalValue") set ^ORDER(orderNo)=rec Quit 1 

आदेश की कुल लागत की गणना करने के लिए कोड पर ध्यान दें। हम एक विशिष्ट क्रम संख्या ऑर्डर के लिए ITEM से सभी प्रविष्टियों के माध्यम से जाते हैं और प्रत्येक आइटम का मूल्य प्राप्त करने के लिए $ $ getItem () फ़ंक्शन का उपयोग करते हैं। $$ getItem () फ़ंक्शन के लिए कोड इस प्रकार है:

 getItem(orderNo,itemNo,itemData) kill itemData s itemData("price")=0 if orderNo="" Quit 0 if itemNo="" Quit 0 if '$data(^ITEM(orderNo,itemNo)) Quit 0 set itemData("price")=^ITEM(orderNo,itemNo) Quit 1 

एक विशिष्ट आदेश संख्या और आइटम नंबर के लिए वैश्विक में किसी आइटम के अस्तित्व की जांच करने वाली समय सीमा को देखें। यह MUMPS फ़ंक्शन $ डेटा और निगेटिव ऑपरेटर एकल उद्धरण `का उपयोग करता है।

आइए प्रत्येक ग्राहक की खरीदारी तक त्वरित पहुँच के लिए एक सूचकांक जोड़ें।

इंडेक्स को स्टोर करने के लिए, एक नया वैश्विक ^ ORDERX1 बनाएं। हम वैश्विक रूप से कुछ कुंजियाँ सहेजेंगे: ग्राहक संख्या (कस्टर्नो) और क्रम संख्या (आदेशो)।

इंडेक्स (कस्टर्नो, ऑर्डरनो) कार्य करने के लिए, हम सेटऑर्डर फ़ंक्शन का विस्तार निम्नानुसार करते हैं:

 setOrder(orderNo,data) ; new rec,itemNo,ok if orderNo="" Quit 0 ;    set data("totalValue")=0 set itemNo="" for set itemNo=$Order(^ITEM(orderNo,itemNo)) Quit:itemNo="" do . set ok=$$getItem(orderNo,itemNo,.itemData) . Set data("totalValue")=data("totalValue")+itemData("price") set rec=data("custNo")_"~"_data("orderDate")_"~"_data("invoiceDate") set rec=rec_"~"_data("totalValue") set ^ORDER(orderNo)=rec if data("custNo")`="" set ^ORDERX1(data("custNo"),orderNo)="" Quit 1 

एक आदेश बनाने के लिए, हम इस फ़ंक्शन का उपयोग इस प्रकार करेंगे:

 set orderNo=21 kill data set data("custNo")=101 set data("orderDate")="4/5/2003" set data("invoiceDate")="4/7/2003" set ok=$$setOrder(orderNo,.data) 

प्रासंगिक अखंडता

संदर्भात्मक अखंडता को बनाए रखना डेटाबेस में सभी संदर्भीय कार्यों की सबसे प्रसिद्ध बात लगती है।
संदर्भ क्रियाओं में वे सभी क्रियाएं शामिल होती हैं जिन्हें किसी अन्य तालिका में परिवर्तित होने के तथ्य के कारण एक तालिका के साथ किया जाना चाहिए।

संदर्भात्मक अखंडता को बनाए रखने की प्रक्रिया संबंधित तालिकाओं के बीच अर्थ (मूल, अर्थिक) अखंडता को बनाए रखने के लिए जिम्मेदार है। विशेष रूप से, यह NATURAL JOIN पर आधारित तालिकाओं के बीच संबंधों के रखरखाव के कारण है (विभिन्न तालिकाओं में स्तंभ हैं जो उसी प्रकार के मूल्यों को संग्रहीत करते हैं जिनके द्वारा तालिकाओं के बीच संबंध बनाया जाता है) या प्राथमिक / विदेशी कुंजी।

उदाहरण के लिए, जब ग्राहक संख्या CUSTOMER.custNo को बदल दिया जाता है या हटा दिया जाता है, तो ग्राहक तालिका और आदेश तालिका के बीच शब्दार्थ अखंडता बनाए रखने के लिए, ORDER.custNo फ़ील्ड का एक उपयुक्त परिवर्तन किया जाना चाहिए।

इसी तरह, जब ऑर्डर संख्या ORDER.orderNo को बदल दिया जाता है (या हटा दिया जाता है), तब आदेशों और चीजों की तालिका (जिसमें ऑर्डर किए जाते हैं) के बीच शब्दार्थ अखंडता बनाए रखने के लिए, इसी परिवर्तन को ITEM.orderNo फ़ील्ड के साथ किया जाना चाहिए।

रिलेशनल डेटाबेस (आरडीबीएमएस) में, प्राथमिक और विदेशी कुंजी का उपयोग करते हुए टेबल बनाते समय अखंडता नियमों को निर्दिष्ट किया जाता है। MUMPS में, ये नियम हमारे कार्यों के अंदर लागू किए जा सकते हैं।

ग्राहक तालिकाओं और उनके आदेशों के बीच संबंध को ध्यान में रखते हुए, ग्राहक अपडेट ऑपरेशन निम्नानुसार होगा:

एसक्यूएल

 UPDATE CUSTOMER A SET custNo = :newCustNo WHERE A.custNo = :oldCustNo 

अनुरोध के परिणामस्वरूप, ORDER तालिका में संबंधित प्रविष्टियाँ अपडेट की जाएंगी (CUSTOMER.custNo = ORDER.custNo लिंक द्वारा), यदि डेटाबेस संरचना को परिभाषित करते समय संबंधित विदेशी कुंजियों को सही ढंग से सेट किया गया था।

MUMPS

 updateCustomer(oldCustNo,newCustNo,newData) ; new result,orderData,orderNo if (oldCustNo="")!(newCustNo="") Quit 0 set orderNo="" for set orderNo=$order(^ORDERX1(oldCustNo,orderNo)) Quit:orderNo="" do . set result=$$getOrder(orderNo,.orderData) . set orderData("custNo")=newCustNo . set ok=$$setOrder(orderNo,.orderData) set ok=$$setCustomer(newCustNo,.newData) if newCustNo`=oldCustNo set ok=$$deleteCustomer(oldCustNo) Quit 1 

ध्यान दें कि अधिकांश भाग के लिए यह कोड उन कार्यों में शामिल है, जिन्हें हमने पहले ही ग्राहक और आदेश तालिका के लिए बनाया है। MUMPS में, कोड का पुन: उपयोग करें।

अब $ $ getOrder फ़ंक्शन बनाएं:

 getOrder(orderNo,orderData) ; new record if (orderNo="") Quit 0 set record=$g(^ORDER(orderNo)) set orderData("custNo")=$piece(record,"~",1) set orderData("orderDate")=$piece(record,"~",2) set orderData("invoiceDate")=$piece(record,"~",3) set orderData("totalValue")=$piece(record,"~",4) Quit 1 

हमें अपने मूल सरल फंक्शन $$ deleteCustomer () को भी विस्तारित करने की आवश्यकता है। क्लाइंट टेबल से पंक्ति विलोपन पर समान विचार लागू होते हैं।

SQL क्वेरी और M में इसके समकक्ष नीचे दिखाए गए हैं:

एसक्यूएल

 DELETE FROM CUSTOMER A WHERE A.custNo = :custNo 

इस अनुरोध के परिणामस्वरूप, संबंधित आदेश रिकॉर्ड ORDER तालिका (संबंध CUSTOMER.custNo = ORDER.custNo और डेटाबेस स्कीमा बनाते समय परिभाषित अखंडता नियमों के अनुसार) से हटा दिए जाएंगे। उदाहरण के लिए, विदेशी कुंजी का उपयोग करके अखंडता के नियम निर्धारित किए जा सकते हैं।

MUMPS

 deleteCustomer(custNo) ; new orderNo if custNo="" Quit 0 set orderNo="" for set orderNo=$order(^ORDERX1(custNo,orderNo)) Quit:orderNo="" do . set result=$$deleteOrder(custNo,orderNo) kill ^CUSTOMER(custNo) Quit 1 

उपरोक्त कोड के लिए, आपको $$ deleteOrder () फ़ंक्शन की आवश्यकता है। यहाँ यह है:

 deleteOrder(custNo,orderNo) ; kill ^ITEM(orderNo) ;       kill ^ORDER(orderNo) ;   kill ^ORDERX1(custNo,orderNo) ;       ,     Quit 1 

ध्यान दें कि एक विशेष क्रम में शामिल सभी चीजों के बारे में रिकॉर्ड क्रम संख्या के साथ सूचकांक पर सिर्फ एक KILL कमांड के साथ हटाए जाते हैं। ऐसा इसलिए है क्योंकि ग्राहकों के साथ तालिकाओं और उनके क्रम संख्या (SQL शब्दों में) के बीच एक बड़ा संबंध है।

यदि किसी ग्राहक को हटाते समय उसके आदेशों के बारे में जानकारी को सहेजना आवश्यक होता है, तो ग्राहक और उसके आदेशों के बीच संबंध तोड़ते हैं, तो डिलीट फंक्शन फ़ंक्शन निम्न रूप लेगा:

 deleteCustomer(custNo) ; new orderNo,result,orderData if custNo="" Quit 0 set orderNo="" for set orderNo=$order(^ORDERX1(custNo,orderNo)) Quit:orderNo="" do . set result=$$getOrder(orderNo,.orderData) . set orderData("custNo")="" . set result=$$setOrder(orderNo,.orderData) kill ^CUSTOMER(custNo) Quit 1 

इसी तरह के तर्क को ITEM तालिका में संग्रहीत डेटा पर लागू किया जाना चाहिए जब ORDER तालिका में आदेश संख्या ORDER.orderNo को परिवर्तित या हटा दिया गया हो।

ट्रिगर्स

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

रिलेशनल डेटाबेस में, ट्रिगर्स को डेटाबेस स्कीमा स्तर पर परिभाषित किया जाता है। MUMPS में, हम डेटाबेस की सेवा करने वाले कार्यों में कोई भी ट्रिगर कोड रख सकते हैं।

उदाहरण के लिए, किसी विशेष ग्राहक के लिए आदेशों की संख्या, CUSTOMER.totalOrders लें। हमें ORDER तालिका से एक आदेश जोड़ते या हटाते समय इस फ़ील्ड को स्वचालित रूप से अपडेट करने के लिए ट्रिगर को परिभाषित करना चाहिए।

एसक्यूएल

CUSTOMER.totalOrders में सही मान सुनिश्चित करने के लिए इस SQL ​​अभिव्यक्ति को ORDER तालिका के लिए ट्रिगर कोड में शामिल किया जाना चाहिए:

 SELECT COUNT(A.orderNo) FROM A.ORDER WHERE A.custNo = :custNo 

यह क्वेरी ORDER तालिका में सम्मिलित किए गए और पंक्ति संचालन को हटा देगा (संबंध CUSTOMER.custNo = ORDER.custNo के अनुसार)

MUMPS

हम केवल ORDER तालिका के पंक्ति पंक्ति फ़ंक्शन में निम्न (ट्रिगर) कोड जोड़ते हैं:

 setOrder(orderNo,data) ; new rec,itemNo,ok if orderNo="" Quit 0 ;       set data("totalValue")=0 set itemNo="" for set itemNo=$Order(^ITEM(orderNo,itemNo)) Quit:itemNo="" do . set ok=$$getItem(orderNo,itemNo,.itemData) . Set data("totalValue")=data("totalValue")+itemData("price") set rec=data("custNo")_"~"_data("orderDate")_"~"_data("invoiceDate") set rec=rec_"~"_data("totalValue") set ^ORDER(orderNo)=rec ;       if data("custNo")`="" set ^ORDERX1(data("custNo"),orderNo)="" ; ;    CUSTOMER.totalOrders new custData Set ok=$$getCustomer(data("custNo"),.custData) ;       CUSTOMER.totalOrders. .   setCustomer     Set ok=$$setCustomer(data("CustNo"),.custData) ; Quit 1 

ORDER तालिका से पंक्तियों को हटाने पर समान विचार लागू होते हैं। ऑर्डर में चीजों को जोड़ते समय आदेश मान ORDER.totalValue को स्वचालित रूप से अपडेट करने के लिए एक समान योजना का उपयोग किया जा सकता है।

एसक्यूएल

नए आदेश मान ORDER.Value की गणना करने के लिए निम्नलिखित SQL कोड को ITEM तालिका के ट्रिगर के अंदर रखा जाना चाहिए:

 SELECT SUM(A.price) FROM A.ITEM WHERE A.orderNo = :orderNo 

अनुरोध ITEM तालिका पर सभी सम्मिलित करने और हटाने के संचालन के लिए ट्रिगर किया जाएगा (संबंध ORDER.orderNo = ITEM.orderNo के अनुसार)।

MUMPS

ITEM तालिका के साथ पंक्ति सम्मिलित फ़ंक्शन में निम्न (ट्रिगर) कोड जोड़ें:

 setItem(orderNo,itemNo,data) ; new ok if (orderNo="")!(itemNo="") Quit 0 set ^ITEM(orderNo,itemNo)=data("price") set^ORDERX1(custNo,orderNo)="" ;    ORDER.totalValue set ok=$$getOrder(orderNo,.orderData) ;     ORDER.totalValue   set ok=$$setOrder(orderNo,.orderData) Quit 1 

ITEM तालिका से पंक्तियों को हटाने के लिए संचालन पर समान विचार लागू होते हैं।
हमारे डेटाबेस में ट्रिगर्स का उपयोग करने का अगला उदाहरण किसी ग्राहक के लिए चालान की स्वचालित पीढ़ी होगा जैसे ही इसकी निर्माण तिथि ORDER.invoiceDate फ़ील्ड में संग्रहीत की जाती है। हम बहुत ही सरलता से इस कार्यक्षमता को अपनी ORDER तालिका अद्यतन प्रक्रिया में जोड़ सकते हैं:

 setOrder(orderNo,data) ; new rec,itemNo,ok if orderNo="" Quit 0 ;    set data("totalValue")=0 set itemNo="" for set itemNo=$Order(^ITEM(orderNo,itemNo)) Quit:itemNo="" do . set ok=$$getItem(orderNo,itemNo,.itemData) . Set data("totalValue")=data("totalValue")+itemData("price") set rec=data("custNo")_"~"_data("orderDate")_"~"_data("invoiceDate") set rec=rec_"~"_data("totalValue") set ^ORDER(orderNo)=rec if data("custNo")`="" set ^ORDERX1(data("custNo"),orderNo)="" ; ;   CUSTOMER.totalOrders new custData Set ok=$$getCustomer(data("custNo"),.custData) Set ok=$$setCustomer(data("CustNo"),.custData) ; ;  -,     if Data("invoiceDate")`="" Set Result=$$invoiceOrder(orderNo) ; Quit 1 

बेशक, चालान उत्पन्न करने के लिए सभी आवश्यक चरणों को पूरा करने के लिए $ $ चालानऑर्डर () फ़ंक्शन को लिखा जाना चाहिए।

लेन-देन

एक पूर्ण डेटाबेस अपडेट में अक्सर कई टेबल के कई अपडेट होते हैं। इन सभी संबंधित अद्यतनों की गारंटी दी जानी चाहिए ताकि मुख्य अद्यतन (या लेनदेन) पूरा होने से पहले पूरा हो सके।

एक नियम के रूप में, लेन-देन रिलेशनल डेटाबेस में डिफ़ॉल्ट रूप से सक्षम होते हैं। दूसरे शब्दों में, डेटाबेस में परिवर्तन तब तक दर्ज नहीं किया जाता है जब तक कि संशोधित प्रक्रिया एक COMMIT कमांड जारी नहीं करती है, जिसके बाद सभी परिवर्तनों की पुष्टि हो जाती है और एक नया लेनदेन शुरू होता है।

MUMPS इस संबंध में बहुत समान है, सिवाय इसके कि लेनदेन को स्पष्ट रूप से शामिल किया जाना चाहिए। कार्यक्रम को आवश्यक रूप से लेन-देन TSTART शुरू करने के लिए कमांड निष्पादित करना चाहिए, और केवल TCOMMIT द्वारा इसके पूरा होने की पुष्टि नहीं करनी चाहिए।

एसक्यूएल

हम वर्तमान लेनदेन की पुष्टि करते हैं और (संक्षेप में) एक नया लॉन्च करते हैं:

 COMMIT 

MUMPS

एक नया लेनदेन शुरू करें:

 TSTART 

लेन-देन की पुष्टि करें:

 TCOMMIT 

यदि MUMPS सिस्टम में लेन-देन प्रबंधन स्पष्ट रूप से सक्षम नहीं है, तो सभी अद्यतन तुरंत वर्तमान रिपॉजिटरी में लागू हो जाएंगे। दूसरे शब्दों में, वैश्विक या इसके तत्व पर किसी भी सेट या KILL कमांड को एक पूर्ण लेनदेन माना जा सकता है।

निष्कर्ष

पारंपरिक संबंधपरक डेटाबेस पर MUMPS का उपयोग करने के कई महत्वपूर्ण लाभ हैं।

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