Caché में बीज डेटा की तैनाती के लिए XML क्रमांकन। भाग I

मुझे लगता है कि यह कहना कोई अतिशयोक्ति नहीं है कि कार्यान्वयन के दौरान प्रारंभिक डेटा उत्पन्न करने के कार्य के साथ एक सूचना प्रणाली के लगभग हर डेवलपर का सामना करना पड़ता है।
प्रारंभिक डेटा को आरंभ करने के लिए कैच डेवलपर्स के पास कई मानक दृष्टिकोण हैं:

• बाहरी फ़ाइलों से संदर्भ कक्षाओं के लिए डेटा लोड करना,
• ऑनलाइन सेवाओं से डेटा प्राप्त करना,
• वैश्विक फ़ाइलों से स्थैतिक डेटा का आयात,
• डेटा कोड में "वायर्ड" से प्रारंभिक डेटा बनाने वाले क्लास के तरीकों का निष्पादन।

स्थैतिक डेटा, छोटे संदर्भों या सिस्टम के किसी भी कॉन्फ़िगरेशन डेटा के प्रारंभ के लिए, एक और तरीका है, जिस पर लेख में चर्चा की जाएगी।

Caché में XML डेटा ब्लॉक को क्लास कोड - XDATA ब्लॉक में शामिल करने की क्षमता है। आमतौर पर, इस डेटा का उपयोग ज़ेन पृष्ठ रूपों और ज़ेन रिपोर्ट के बारे में डेटा को स्टोर करने के लिए किया जाता है। इन ब्लॉकों में, आप लगातार कक्षाओं के लिए प्रारंभिक डेटा को पूरी तरह से संग्रहीत कर सकते हैं।

XData से देशीकरण

एक संपत्ति के साथ एक साधारण संग्रहित वर्ग के उदाहरण पर विचार करें। यह नामों के साथ क्षेत्रों का एक वर्ग होगा - एक निर्देशिका का एक विशिष्ट उदाहरण।

Caché में इस वर्ग के लिए कोड निम्नानुसार है:

वर्ग का नक्शा। रैगियन का विस्तार% Persistent है
{
/// नाम
संपत्ति का नाम % स्ट्रिंग के रूप में ;
}

XML प्रपत्र में प्रारंभिक डेटा को XData ब्लॉक में वर्ग में जोड़ें:

Xdata आबाद
{
< xml >
< आइटम >
< नाम > क्रास्नोयार्स्क क्षेत्र </ / नाम >
</ आइटम >
< आइटम >
< नाम > Sverdlovsk क्षेत्र </ / नाम >
</ आइटम >
< आइटम >
< नाम > खाबरोवस्क क्षेत्र </ नाम >
</ आइटम >
</ xml >
}

इस डेटा को क्लास से लोड करने के लिए, हम पॉप्युलेट क्लास मेथड जोड़ते हैं। इसके अलावा, XML डेटा के साथ काम करने के लिए, आपको वर्ग XML- सक्षम बनाने की आवश्यकता है - हम विरासत सूची में% XML.Adaptor वर्ग भी जोड़ते हैं। परिणामस्वरूप, परिवर्तित वर्ग कोड इस प्रकार है:

कक्षा का नक्शा। विस्तार बढ़ाता है ( % स्थायी , % XML.Adaptor )
{

/// नाम
संपत्ति का नाम % स्ट्रिंग के रूप में ;

ClassMethod पॉपुलेट () % स्थिति के रूप में
{
#dim sc % स्थिति = $ $ $ ठीक है
// स्पष्ट मौजूदा डेटा
s sc = .. % DeleteExtent ()
अगर $$$ ISERR (sc) ने sc छोड़ दिया

// संकलित वर्ग पुस्तकालय से XData ब्लॉक का xml डेटा लोड करें
#dim स्ट्रीम % Stream.Object = ## वर्ग ( % Dictionary.CompiledXData ) के रूप में। % OpenId (.. % ClassName (1) _ "||" _ "आबाद" )। डेटा
// एक XML रीडर का एक उदाहरण बनाएँ
#dim रीडर % XML.Reader = ## वर्ग ( % XML.Reader ) के रूप में। % नया ()
// रीडर में xml स्ट्रीम खोलें
सेट sc = पाठक। ओपनस्ट्रीम (धारा, "शाब्दिक" )
अगर $$$ ISERR (sc) ने sc छोड़ दिया
// पाठक को बताएं कि क्लास डेटा के लिए कौन सा तत्व देखना है
पाठक करो। सहसंबंध ( "आइटम" , .. % ClassName (1))

#dim % स्थायी के रूप में obj
// एक क्लास लूप में लोड
जबकि पाठक। अगला (.obj, .sc)
{
अगर $ $ $ ISERR (sc) छोड़ दिया
// डेटाबेस को xml उदाहरण से रीड को सेव करें
सेट sc = obj। % बचाओ ()
अगर $ $ $ ISERR (sc) छोड़ दिया

सेट obj = ""
}

sc छोड़ दिया
}

Xdata आबाद
{
< xml >
< आइटम >
< नाम > क्रास्नोयार्स्क क्षेत्र </ / नाम >
</ आइटम >
< आइटम >
< नाम > Sverdlovsk क्षेत्र </ / नाम >
</ आइटम >
< आइटम >
< नाम > खाबरोवस्क क्षेत्र </ नाम >
</ आइटम >
</ xml >
}

}

जैसा कि आप कोड से देख सकते हैं, सभी काम% XML.Reader वर्ग द्वारा किया जाता है, जो आपको XML के "ऑब्जेक्ट" डेटा को पढ़ने की अनुमति देता है।

तैनाती के दौरान कक्षा में डेटा लोड करने के लिए, पॉप्युलेट क्लास की विधि को निष्पादित करने के लिए पर्याप्त है:
डब्ल्यू ## वर्ग ( मानचित्र । राइज़ियन )। आबाद ()

सुनिश्चित करें कि वर्ग उदाहरण वास्तव में बनाए गए हैं। आइए टर्मिनल के SQL शेल में क्वेरी को निष्पादित करें:

XMLDEPLOY>d $System.SQL.Shell() SQL Command Line Shell ---------------------------------------------------- The command prefix is currently set to: <<nothing>>. Enter q to quit, ? for help. XMLDEPLOY>>select * from map.Region 1. select * from map.Region ID Name 1   2   3   3 Rows(s) Affected statement prepare time: 0.9125s, elapsed execute time: 0.0687s. --------------------------------------------------------------------------- XMLDEPLOY>>quit XMLDEPLOY> 

XData जनसंख्या

जाहिर है, XData ब्लॉक को "मैन्युअल रूप से" भरा जा सकता है। और यह सुविधाजनक है अगर कक्षा में कुछ ऑब्जेक्ट हैं। लेकिन अगर उनमें से बहुत सारे हैं, तो कार्यक्रम यह कर सकता है।
हम% XML.Writer वर्ग का उपयोग करेंगे, जो हमें XML में वर्ग उदाहरणों को क्रमबद्ध करने की अनुमति देता है।
ऐसा करने के लिए, श्रेणी के लिए क्रमांकन विधि जोड़ें:

ClassMethod SerializeToFile ( % स्ट्रिंग के रूप में फ़ाइल ) % स्थिति के रूप में
{
#dim sc %% स्थिति के रूप में
#dim wr % XML.Writer के रूप में
सेट wr = ## वर्ग ( % XML.Writer )। % नया ()
// आउटपुट डिवाइस के रूप में फ़ाइल को स्थापित करें
सेट sc = wr। OutputToFile (फ़ाइल) यदि $$$ ISERR (sc) sc छोड़ दिया
// रूट टैग खोलें
सेट sc = wr। RootElement ( "xml" ) अगर $$$ ISERR (sc) sc छोड़ दिया
# रिम्स % RultSet के रूप में शुरू होता है
// क्लास के सभी ऑब्जेक्ट्स में एक एक्स्टेंशन रिक्वेस्ट एक्सेप्ट करें
सेट रसेट = ## वर्ग ( % परिणाम )। % नया ( "मानचित्र। क्रम: विस्तार" )
परेशान करना। निष्पादित करें ()
# दिम ओब्ज
जबकि (rset। अगला ) () {
सेट obj = ## वर्ग ( मानचित्र । रीजन )। % OpenId (rset। डेटा ( "आईडी" ))
// वस्तु को क्रमबद्ध करें
सेट sc = wr। ऑब्जेक्ट (obj)
अगर $ $ $ ISERR (sc) छोड़ दिया
}
अगर $$$ ISERR (sc) ने sc छोड़ दिया
// रूट टैग को बंद करें
सेट sc = wr। EndRootElement ()
sc छोड़ दिया
}

यह विधि एक्सएमएल में क्रमबद्ध श्रेणी के सभी ऑब्जेक्ट को फ़ाइल में आउटपुट करती है।
आइए टर्मिनल में विधि निष्पादित करें:

 XMLDEPLOY>D $System.OBJ.DisplayError(##class(map.Region).SerializeToFile("C:\cache\region.xml")) XMLDEPLOY> 

और फिर किसी भी संपादक / दर्शक के साथ फाइल खोलें:

परिणामी XML XData ब्लॉक में डालने के लिए पहले से ही आसान है।

कुल मिलाकर

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