Caché DBMS 2013.1 में नया: लाइव क्लासेस पर इंडेक्स जोड़ना और बनाना

मान लीजिए कि आपके पास बड़ी संख्या में अभिलेखों के साथ एक तालिका है और आपको निम्नलिखित शर्तों के साथ इसमें एक या एक से अधिक अनुक्रमित जोड़ने की आवश्यकता है:

1. उनकी पीढ़ी जितनी जल्दी हो सके उतनी तेजी से होनी चाहिए
2. ताकि पीढ़ी को बैचों में किया जा सके।
   उदाहरण के लिए, यदि 300M रिकॉर्ड के लिए एक तालिका है और आप घंटों के बाद ही इसके साथ काम कर सकते हैं, तो आप पूरी प्रक्रिया को तीन रातों में 100M रिकॉर्ड के साथ विभाजित कर सकते हैं
3. नए सूचकांक की उपस्थिति और उनकी पीढ़ी की प्रक्रिया को वर्ग / तालिका के साथ वर्तमान कार्य में हस्तक्षेप नहीं करना चाहिए

ऐसा करने के लिए, कोई भी ज्ञात विधि % BuildIndices () का उपयोग कर सकता है, लेकिन इस मामले में यह हमारी शर्तों को पूरा नहीं करेगा।

रास्ता क्या है?

सिद्धांत

एक नया % Library.IndexBuilder वर्ग Caché 2013.1 में जोड़ा गया है, लेकिन एक शक्तिशाली % ConstructIndicesParallel () विधि के साथ।
नाम से यह पहले से ही स्पष्ट हो जाता है कि पीढ़ी सभी प्रोसेसर कोर की भागीदारी के साथ समानांतर में होगी।

तो, इस विधि के मापदंडों पर अधिक विस्तार से विचार करें:

ClassMethod % ConstructIndicesParallel ( pTaskId = "" , pStartId As% Integer = 0 , pEndId as % Integer = -1 , pSortBegin As% Integer = 1 , pDroneCount As% Integer = 0 , pLockFlag As% Integer = 0 , pLockFlag As% Integer = 1 , p1 = 1 p = 1 ) % स्थिति के रूप में

• pTaskId - पृष्ठभूमि प्रक्रिया की आईडी। इंटरेक्टिव कॉल के लिए खाली / अपरिभाषित छोड़ दें
• pStartId - आईडी जिसमें से पीढ़ी शुरू करना है। डिफ़ॉल्ट 1
• pEndId - ID जिस पर जनरेशन को पूरा करना है। डिफ़ॉल्ट -1 है, जिसका अर्थ तालिका में अंतिम आईडी है
• pSortbegin - 1/0 ध्वज जो यह निर्धारित करता है कि उत्पन्न करते समय $ SortBegin का उपयोग करना है या नहीं।
• pDroneCount - अनुक्रमित उत्पन्न करने के लिए पृष्ठभूमि प्रक्रियाओं की संख्या।
  डिफ़ॉल्ट मान 0. है। इस मामले में, कोड स्वतंत्र रूप से प्रक्रियाओं की इष्टतम संख्या निर्धारित करेगा, जो उपलब्ध कोर / प्रोसेसर की संख्या और संसाधित रिकॉर्ड की संख्या के आधार पर होगी।
• pLockFlag पीढ़ी के दौरान लॉकिंग के व्यवहार को परिभाषित करने वाला एक ध्वज है:
  
  • 0 = लॉक नहीं
  • 1 = अत्यधिक लॉकिंग - पीढ़ी के दौरान पूरी सीमा पर एक विशेष लॉक हो जाता है
  • 2 = पंक्ति स्तर लॉकिंग - संसाधित किए गए प्रत्येक पंक्ति और तत्व के लिए अनुक्रमणिका नोड पर एक साझा लॉक होता है। जब एक विशिष्ट पंक्ति के लिए अनुक्रमणिका पीढ़ी पूरी हो जाती है, तो पंक्ति तुरंत लॉक हो जाती है।
• pJournalFlag - 0/1 ध्वज जो लॉगिंग के उपयोग को परिभाषित करता है:
  1 - इंडेक्स जेनरेशन लॉग इन होगा, 0 - नहीं होगा।

अभ्यास

अब एक नया वर्ग लागू करने के एक उदाहरण पर विचार करें।

सबसे पहले, USER क्षेत्र में एक क्लास बनाएं, इसे 1M रिकॉर्ड के साथ वेरिएबल-लेंथ स्ट्रिंग्स [1-100] से भरें, और क्लासिक % BuildIndices () का उपयोग करके इंडेक्स बनाएं ताकि तुलना करने के लिए कुछ हो:

क्लास डेमो.टेस्ट का विस्तार लगातार% है
{

सूचकांक idxn n के रूप में SQLUPPER ( 6 );

गुण n % स्ट्रिंग ( MAXLEN = 100 );

ClassMethod Fill ( n % Integer = 10000000 )
{
सेट डेटा = $ बदलें ( $ औचित्य ( "" , 100), "" , "ए" )
सेट समय = $ ZHorolog
कर योग्य ^% NOJRN
करो .. % KillExtent ()
सेट ^ डेमो .estD = n
सेट ^ Demo.testD (1) = $ ListBuild ( "" , $ एक्सट्रेक्ट ( डेटा , 1, $ रैंडम (100% +1))
i = 2: 1: n सेट ^ ( i ) = $ ListBuild ( "" , $ Extract ( डेटा , 1, $ रैंडम (100) +1))
सक्षम करें ^% NOJRN
"इन्सर्ट =" लिखें , $ ZHorolog - time , "sec।" ,!
}

ClassMethod BIndex ()
{
सेट समय = $ ZHorolog
करो .. % बिल्डइंडिस (, 1,1)
"reindexing =" , $ ZHorolog - time , "sec।" लिखें । ,!
}

}

मेरे परिणाम:
USER>do ##class(demo.test).Fill()
= 9.706935 .

USER>do ##class(demo.test).BIndex()
= 71.966953 .

अब नए % IndexBuilder वर्ग का उपयोग करें। ऐसा करने के लिए, इन चरणों का पालन करें:

1. पहले, % PurgeIndices () विधि (वैकल्पिक चरण) का उपयोग करके पिछले परीक्षण के सूचकांक डेटा को साफ़ करें
2. % IndexBuilder से हमारी कक्षा विरासत में मिली
3. INDEXBUILDERFILTER पैरामीटर में अल्पविराम द्वारा अलग किए गए सूचकांकों की सूची लिखें।
   यदि यह पैरामीटर खाली छोड़ दिया जाता है, तो सभी अनुक्रमित पुनर्जीवित हो जाएंगे
4. हमारे सूचकांक को एसक्यूएल के लिए अदृश्य बना दें ताकि ऑप्टिमाइज़र एक इंडेक्स का उपयोग न करे जो अभी ऑपरेशन के लिए तैयार नहीं है।
   ऐसा करने के लिए, हम $ System.SQL.SetMapSelectability () विधि का उपयोग करते हैं:
   
   ClassMethod SetMapSelectability ( pTablename as % Library.String = "" , pMapname as % Library.String = "" , pValue as % Boolean = "" ) % Library.Sring के रूप में
   
   तर्कों का विवरण:
   
   • pTablename - टेबल का नाम
   • pMapname - सूचकांक नाम
   • pValue - 0/1 ध्वज जो SQL एग्जीक्यूटिव के लिए इंडेक्स की दृश्यता (1) या अदर्शन (0) निर्धारित करता है

   नोट: कक्षा में जोड़े जाने से पहले आप एक सूचकांक को अदृश्य बना सकते हैं।

5. % ConstructIndicesParallel () विधि को कॉल करें
6. एसक्यूएल को हमारे सूचकांक को दृश्यमान बनाएं
7. लाभ!

परिणामस्वरूप, हमारी कक्षा निम्नलिखित रूप लेगी:

क्लास डेमो.टेस्ट का विस्तार ( % स्थायी , % इंडेक्सब्युलेर )
{

पैरामीटर INDEXBUILDERFILTER = "idxn" ;

पैरामीटर BITMAPCHUNKINMEMORY = 0 ;

सूचकांक idxn n के रूप में SQLUPPER ( 6 );

गुण n % स्ट्रिंग ( MAXLEN = 100 );
...
ClassMethod FastBIndex ()
{
करो .. % PurgeIndices ( $ ListBuild ( "idxn" ))
$ System .SQL करो । SetMapSelectability ( $ classname (), "idxn" , $$$ NO )
करो .. % निर्माण
$ System .SQL करो । SetMapSelectability ( $ classname (), "idxn" , $$$ YES )
}
}

मेरे परिणाम:
USER>do ##class(demo.test).FastBIndex()

Building 157 chunks and will use parallel build algorithm with 4 drone processes.
SortBegin is requested.
Started drone process: 3812
Started drone process: 4284
Started drone process: 7004
Started drone process: 7224
Expected time to complete is 43 secs to build 157 chunks of 64,000 objects using 4 processes.
Waiting for processes to complete....done.
Elapsed time using 4 processes was 34.906643.

जैसा कि आप देख सकते हैं, गति दोगुनी हो गई है।

आपके हार्डवेयर और आपके डेटा पर, परिणाम और भी बेहतर हो सकते हैं।

और भी तेज?

लेकिन क्या अनुक्रमणिका के उत्थान में और तेजी लाने का अवसर है?
अगर आपके पास स्टॉक में बहुत अधिक रैम है, तो हाँ।

सूचकांक उत्पन्न करने की प्रक्रिया में, आंतरिक जरूरतों के लिए निर्माणकर्ता अस्थायी रूप से तथाकथित बिटमैप ब्लॉक बनाता है। डिफ़ॉल्ट रूप से, वे निजी ग्लोबल्स को लिखे जाते हैं, लेकिन BITMAPCHUNKINMEMORY बूलियन पैरामीटर का उपयोग करके, आप यह निर्दिष्ट कर सकते हैं कि वे RAM में बनाते हैं। ऐसा करने के लिए, पैरामीटर को 1 असाइन करें।
ध्यान दें कि यदि RAM को थोड़ा आवंटित किया गया है और अनुक्रमित बड़े हैं, तो आपको एक <STORE> त्रुटि हो सकती है।
डिफ़ॉल्ट रूप से, BITMAPCHUNKINMEMORY 0 है।