👃🏾 ℹ️ 👦🏻 कैच बिटमैप इंडेक्स ऑन ग्लोबल 🍨 🥢 🏒

Caché ऑब्जेक्ट DBMS बिटमैप और बिटस्लाइक इंडेक्स का समर्थन करता है। वे Caché कक्षाओं में उपयोग करने के लिए बहुत सरल हैं: यह सूचकांक के विवरण में बिटमैप या बिट्सलिस विशेषता को निर्दिष्ट करने के लिए पर्याप्त है, और कुछ एसक्यूएल प्रश्नों के प्रदर्शन में नाटकीय रूप से सुधार होता है। लेकिन यह कैसे काम करता है?
इस लेख से पता चलता है कि बिटमैप इंडेक्स को कैसे संरचित किया जाता है, एक मनमानी वैश्विक संरचना पर बिटमैप इंडेक्स कैसे बनाया जाए, बिट लॉजिक फ़ंक्शन का उपयोग कैसे किया जाए और कैशे में NoSQL चलाने पर उन्हें प्रभावी ढंग से कैसे उपयोग किया जाए।

पूर्व-वस्तु समय के बाद से, जब ग्लोबल्स में ब्याज के रिकॉर्ड को जल्दी से खोजने के लिए आवेदन विकसित करते हैं, तो फॉर्म का सूचकांक सबसे अधिक बार बनाया गया

सेट ^ इंडेक्स ( "संपत्ति" , मूल्य , आईडी ) = ""

इस तरह के सूचकांक आपको आसानी से और जल्दी से रिकॉर्ड प्राप्त करने की अनुमति देते हैं, जिसके लिए ब्याज की संपत्ति का एक निश्चित मूल्य है:

सेट आईडी = "" सेट आईडी के लिए = $ ऑर्डर (^ इंडेक्स ( "संपत्ति" , मूल्य , आईडी )) छोड़ दिया : आईडी = "" आईडी आईडी ,!

उन सभी रिकॉर्डों के पहचानकर्ता देगा जिनके लिए संपत्ति की संपत्ति का मूल्य मूल्य है, और आप इस संपत्ति के मूल्य के साथ रिकॉर्ड के अस्तित्व की जांच कर सकते हैं, उदाहरण के लिए, निम्न कोड का उपयोग करके:

अगर $ डेटा (^ सूचकांक ( "संपत्ति" , मूल्य ))> 1 {
"आईडी" _ $ ऑर्डर (^ सूचकांक ( "संपत्ति" , मूल्य , "" ) _ "" _ मान _ "मौजूद है" के साथ लिखें
और {
"" मान के साथ रिकॉर्ड दर्ज करें " _ मौजूद नहीं है" }

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

एक क्रांतिकारी परिवर्तन पूर्ण- बिट बिट फ़ंक्शंस के कैच में उपस्थिति था: $ बिट (), $ बिटोग्लिक (), $ बिटफ़ीड () और $ बिटकाउंट ()। अब आप बिटमैप इंडेक्स बना सकते हैं, सरलतम स्थिति में - फॉर्म का

$ बिट सेट करें (^ सूचकांक ( "संपत्ति" , मूल्य ), आईडी ) = 1

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

उदाहरण के लिए, उन रिकॉर्ड्स को इकट्ठा करें जिनके लिए "Pr1" संपत्ति में "A" या "B" मूल्य हैं, और "Pr2" संपत्ति का मूल्य "C" है:

सेट ^ mtemp.resbitmap = $ bitlogic (^ इंडेक्स ( "Pr1" , "A" ) ^ इंडेक्स ( "Pr1" , "B" ))
सेट ^ mtemp.resbitmap = $ bitlogic (^ mtemp.resbitmap & ^ Index ( "Pr2" , "C" )

और उन्हें आईडी दें:

अगर ' $ बिटकॉइन (^ mtemp.resbitmap) "कोई रिकॉर्ड नहीं मिला" , लिखो !
और सेट आईडी = 0 सेट आईडी के लिए = $ bitfind (^ mtemp.resbitmap, 1, id ) छोड़ दिया : ' आईडी आईडी आईडी !

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

$ बिट (^ इंडेक्स ( "प्रॉपर्टी" , N ), आईडी ) = NthBitOfValue सेट करें

वास्तव में, फिर से, बिट स्ट्रिंग के बजाय एक सरणी का उपयोग किया जाता है।
बिटकॉइल्स का उपयोग करते समय, यह थोड़ा अधिक जटिल है, उदाहरण के लिए, "अधिक" या "कम" प्रतिबंधों की खोज, लेकिन समूहन कार्यों की गणना में लाभ इस असुविधा को काफी हद तक दूर करता है। वास्तव में, चयनित रिकॉर्ड के लिए ब्याज की संपत्ति के मूल्यों की राशि की गणना करने के लिए, एक रिकॉर्ड लूप की आवश्यकता नहीं है। यह ब्याज की संपत्ति के मूल्यों के सभी बिट्स के लिए परिणामी बिटमैप सूचकांक में संबंधित वज़न $ बिटकाउंट () के साथ योग करने के लिए पर्याप्त है। एक पर्याप्त नमूना आकार के साथ, अतिशयोक्ति के बिना, प्रदर्शन लाभ कहा जा सकता है, भयानक।

कक्षा कोड

/// बिटमैप और बिट-स्लाइस इंडेक्स के साथ बनाने और काम करने के तरीकों का एक सेट
///
/// बिटमैप इंडेक्स की संरचना
/// फॉर्म सरणी (मान) की एक सरणी, जिनके तत्व हैं
/// बिट रिकॉर्ड संख्या के अनुरूप पदों में 1 के साथ तार,
/// जिसके लिए कुछ पैरामीटर मान मान लेता है,
/// $$$ MAXBITLENGTH की अधिकतम लंबाई के साथ तार की एक सरणी में टूट गया
/// रिकॉर्ड नंबरिंग - 1 से, सरणी तत्व - 0 से,
/// (बाद में, संक्षिप्तता, बिटमैप्स के लिए)।
/// भरने का उदाहरण
/// प्रवेश करने के लिए निष्क्रिय पैरामीटर संख्या बराबर है वैल है
/// सेट idf0 = idfact-1 \ $$$ MAXBITLENGTH, idf1 = idfact-1 # $$$ MAXBITLENGTH + 1
/// सेट $ बिट (^ BM ("I", par, val, idf0), idf1) = 1
/// सेट $ बिट (^ BM ("EXIST", idf0), idf1) = 1
/// मौजूदा प्रविष्टियों का सूचकांक उपयोगी है, सबसे पहले, क्योंकि
/// तार्किक विलोपन करना आसान बनाता है, और दूसरी बात,
/// बिना रिपॉजिटरी के रिकॉर्ड की संख्या ज्ञात करना संभव बनाता है
/// अन्य संरचनाओं तक पहुंच, जो सही के लिए आवश्यक है
/// BMNot प्रक्रिया का संचालन (नीचे देखें)
/// बीटल इंडेक्स की संरचना:
/// बिटमैप इंडेक्स की सरणी। सरणी का पहला तत्व - वर्ण सूचकांक
/// मान, दूसरा - कम से कम महत्वपूर्ण बिट्स का सूचकांक (1/0), 3 -
/// पेनॉल्ट का सूचकांक (2/0), आदि।
///
/// भरने का उदाहरण
/// प्रवेश संख्या निष्क्रिय पैरामीटर बराबर एक पूर्णांक है
/// वैल्यू ऑफ वैल
/// सेट idf0 = idfact-1 \ $$$ MAXBITLENGTH, idf1 = idfact-1 # $$$ MAXBITLENGTH + 1
/// सेट वैल = $$ CvtToBin (वैल)
/// के लिए ix = 1: 1: $ लंबाई (वैल) सेट: $ एक्सट्रेक्ट (वैल, ix) $ बिट (^ बीएम ("एस", बराबर, ix, idf0), idf1) = 1
/// बड़े पैमाने पर भरने के क्रम में, विनाशकारी गिरावट से बचने के लिए
/// प्रदर्शन, यह इसी खंड ओवरले करने की सिफारिश की है
/// कोड ऑफ़ फ़ंक्शंस $ sortbegin (^ BM) और $ सॉर्टेंड (^ BM)
/// दिए गए प्रतिबंधों और प्राप्तियों की गणना के अनुसार तथ्यों के चयन के लिए
/// समूहीकरण कार्यों "योग", "अधिकतम" और "न्यूनतम" के नमूने
/// फ़ंक्शन BSSum (), BSMax () और BSMin () हैं
वर्ग उपयोगकर्ता.बिटमैप लिंक% पंजीकृत पंजीकृत करता है [ विशेषण ]
{

/// नाम ($ ना) वैश्विक जहां बिटमैप्स और बिटक्लेसेस को स्टोर करने के लिए
/// डिफ़ॉल्ट मान "^ BM" है
संपत्ति BMGLOB % स्ट्रिंग के रूप में ( TRUNCATE = 1 ) [ InitialExpression = "^ BM" ];

/// अधिकतम बिट स्ट्रिंग का उपयोग करने के लिए अधिकतम लंबाई
पैरामीटर MAXBITLENGTH = 64000 ;

/// वैश्विक वैश्विक उप-नाम का नाम ($ na) () बनाता है और लौटाता है
/// इंटरमीडिएट बिटमैप को संग्रहीत करने के लिए
ClassMethod GetNewTMP () % स्ट्रिंग के रूप में
{
$ नाम (^ कैशटेम्प ( "बी.एम." , $ जॉब _ $ जूटिल (110), $ इंक्रीमेंट ) (^ कैचेम्प ( "बी.एम." , $ जॉब _ $ जूटिल (110))))
}

/// इस प्रक्रिया द्वारा बनाए गए सभी अस्थायी सबनेट को हटाता है
ClassMethod KillAllTMP ()
{
मार ^ कैशेटेम्प ( "बीएम" , $ नौकरी _ $ जूटिल (110)) छोड़ दिया
}

/// बिटमैप पर परिचालन
/// इसके बाद, लचीलेपन के लिए, बिट इंडेक्स,
/// ऐरे और स्लाइस नाम से पारित किए जाते हैं ($ na ())
///
/// स्थिति को एकल बिट के साथ स्थिति का अनुसरण करता है
/// बीएम में - बिटमैप नाम से पारित
विधि BMOrder ( bm % स्ट्रिंग के रूप में , pos %% स्ट्रिंग के रूप में ) % स्ट्रिंग के रूप में
{
सेट उप = स्थिति \ ।। #MAXBITLENGTH , ix = $ bitfind ( $ get (@ bm @ ( उप )), 1, pos # .. #MAXBITLENGTH +1)
पदभार : ix उप * .. #MAXBITLENGTH + ix
सेट उप के लिए = $ ऑर्डर (@ bm @ ( उप )) से बाहर निकलें : ' सब सेट ix = $ bitfind ( $ get (@ bm @ ( उप )), 1) छोड़ें : ix
पदभार : ix उप * .. #MAXBITLENGTH + ix
"" छोड़ो
}

/// bmdest = bmdest & bmsrc
विधि BMAnd ( bmdest % स्ट्रिंग के रूप में , bmsrc % स्ट्रिंग के रूप में )
{
सेट सब 1 = $ ऑर्डर (@ bmdest @ ( $ char (0)), - 1), सब = $ ऑर्डर (@ bmsrc @ ( $ char (0)), - 1))
सेट : उप < सब 1 उप = सब 1
ix = 0: 1 के लिए: उप- सेट : $ डेटा (@ bmdest @ ( ix )) और $ डेटा (@ bmsrc @ ( ix )) @ bmdest @ ( ix ) = $ bitlogic (@ bmdest @ ( ix ) & @ bmsrc ) @ ( ix )) मार : ' $ डेटा (@ bmsrc @ ( ix )) @ bmdest @ ( ix )
छोड़ना
}

/// bmdest = bmdest | bmsrc
विधि BMOr ( bmdest % स्ट्रिंग के रूप में , bmsrc % स्ट्रिंग के रूप में )
{
सेट सब 1 = $ ऑर्डर (@ bmdest @ ( $ char (0)), - 1), सब = $ ऑर्डर (@ bmsrc @ ( $ char (0)), - 1))
सेट : उप < सब 1 उप = सब 1
ix = 0: 1 के लिए: उप सेट : $ डेटा (@ bmsrc @ ( ix )) @ bmdest @ ( ix ) = $ चयन ( $ डेटा (@ bmdest @ ( ix )): $ bitlogic (@ bmdest @ ( ix )) | @ bmsrc @ ( ix )), 1: @ bmsrc @ ( ix ))
छोड़ना
}

विधि BMNot ( %% स्ट्रिंग के रूप में )
{
सेट मैक्सब्ल्क = $ ऑर्डर (@ (.. बीएमजीएलओबी ) @ ( " एक्स्टिस्ट " , "" ), - १), ब्लेकलेन = $ बिटकाउंट (@ (.. बीएमजीएलओबी ) @ ( " एक्स्टिस्ट " , मैक्सब्लेक )
ix = maxblk : -1: 0 सेट blk = $ get (@ bm @ ( ix )) सेट : $ bitcount ( blk ) < blklen $ bit ( blk , blklen ) = 0 set @ bm ( ix ) = $ bitlogic (~ blk ), blklen = .. #MAXBITLENGTH
do .. BMAnd ( bm , $ नाम (@ (.. BMGLOB ) @ ( " एक्स्टीस्ट " )))
छोड़ना
}

/// सरणी में यूनिट बिट्स की संख्या लौटाता है
विधि BMCount ( % String के रूप में bm ) % पूर्णांक के रूप में
{
सेट ix = "" , bmcret = 0
सेट के लिए ix = $ ऑर्डर (@ bm @ ( ix )) छोड़ दें : ix '= + ix सेट bmcret = bmcret + $ bitcount (@ bm @ ( ix ), 1)
Bmcret को छोड़ दें
}

/// bmdest बिटमैप में बिटमैप इंडेक्स vbmsrc से चयन करता है,
/// जहां पैरामीटर वैल्यू वैल है
///
विधि BMEq ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग , वैल % स्ट्रिंग के रूप में )
{
मार डालो @ bmdest मर्ज @ bmdest = @ vbmsrc @ ( val )
छोड़ना
}

/// bmdest बिटमैप में बिटमैप इंडेक्स vbmsrc से चयन करता है,
/// जहां पैरामीटर मान वैल के बराबर नहीं है
विधि BMNe ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग , वैल % स्ट्रिंग के रूप में )
{
do .. BMEq ( bmdest , vbmsrc , val ) करते हैं .. BMNot ( bmdest )
छोड़ना
}

/// bmdest बिटमैप में बिटमैप इंडेक्स vbmsrc से चयन करता है,
/// जहां पैरामीटर वैल्यू कम है (सॉर्ट किया गया) वैल
/// bmdest: = U (vbmsrc (v): v <val)
विधि BMLt ( % स्ट्रिंग के रूप में bmdest , % स्ट्रिंग के रूप में vbmsrc , % स्ट्रिंग के रूप में वैल )
{
@ bmdest सेट ix = val को मारें
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix ), - 1) छोड़ दें : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// बीएमएलटी () के समान लेकिन "से कम या बराबर"
विधि बीएमएलई ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , मान % स्ट्रिंग के रूप में )
{
मार @ bmdest मर्ज @ bmdest = @ vbmsrc @ ( वैल ) सेट ix = वैल
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix ), - 1) छोड़ दें : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// BMLe के समान है, लेकिन "इससे अधिक या बराबर"
विधि बीएमजी ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , वैल स्ट्रिंग% के रूप में )
{
मार @ bmdest मर्ज @ bmdest = @ vbmsrc @ ( वैल ) सेट ix = वैल
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दें : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// इसी प्रकार, मान से अधिक या न्यूनतम के बराबर और अधिकतम से कम या बराबर
विधि BMGeLe ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , न्यूनतम स्ट्रिंग स्ट्रिंग , न्यूनतम स्ट्रिंग स्ट्रिंग के रूप में अधिकतम )
{
मार @ bmdest मर्ज @ bmdest = @ vbmsrc @ ( न्यूनतम ) सेट ix = मिनट
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दिया : ix ]] अधिकतम छोड़ दिया : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix ))
छोड़ना
}

/// बीएमजी के समान (), लेकिन "सख्ती से बड़ा"
विधि BMGt ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , %% स्ट्रिंग के रूप में वैल )
{
@ bmdest सेट ix = val को मारें
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दें : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// समान रूप से, न्यूनतम से अधिक और अधिकतम से कम मूल्य
विधि BMGtLt ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , न्यूनतम स्ट्रिंग स्ट्रिंग , न्यूनतम स्ट्रिंग स्ट्रिंग के रूप में अधिकतम )
{
मार @ bmdest सेट ix = मिनट
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दिया : अधिकतम ']] ix छोड़ दिया : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// इसी तरह, मान से अधिक या न्यूनतम के बराबर और अधिकतम से कम
विधि BMGeLt ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , मिनट % स्ट्रिंग के रूप में , अधिकतम स्ट्रिंग स्ट्रिंग के रूप में )
{
मार @ bmdest मर्ज @ bmdest = @ vbmsrc @ ( न्यूनतम ) सेट ix = मिनट
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दिया : अधिकतम ']] ix छोड़ दिया : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix )))
छोड़ना
}

/// समान रूप से, न्यूनतम से अधिक और अधिकतम के बराबर या उससे कम मान
विधि BMGtLe ( bmdest % स्ट्रिंग के रूप में , vbmsrc % स्ट्रिंग के रूप में , मिनट स्ट्रिंग के रूप में न्यूनतम , % स्ट्रिंग के रूप में अधिकतम )
{
मार @ bmdest सेट ix = मिनट
सेट के लिए ix = $ ऑर्डर (@ vbmsrc @ ( ix )) छोड़ दिया : ix ]] अधिकतम छोड़ दिया : ix = "" करते हैं .. BMOr ( bmdest , $ name (@ vbmsrc @ ( ix ))
छोड़ना
}

/// ऑपरेशंस बिट-स्लीक डेटा पर
/// एक पूर्णांक मान को एक पाठ बिट स्ट्रिंग में कनवर्ट करता है
/// {साइन, 1,2,4, ..., 2 ** एन}
ClassMethod CvtToBin ( मान के रूप में% पूर्णांक ) % स्ट्रिंग के रूप में
{
सेट मान = $ fnumber (+ मान , "" , 0), Res = ( मान <0)
पद छोड़ने के लिए : ' मान सेट रेस = रेस _ ( मान # 2), मान = मान \ 2
रेज छोड़ो
}

/// $ पूर्णांक बिट सूची (संकेत, 1,2,4, ... 2 ** एन) को पूर्णांक में रूपांतरित करता है
ClassMethod CvtFromSlice ( % स्ट्रिंग के रूप में टुकड़ा ) % पूर्णांक के रूप में
{
सेट Res = 0
के लिए मैं = $ सूची ( टुकड़ा ): - १: २ सेट रेस = रेस + रेस सेट रेस = रेस + $ लिस्टेट ( टुकड़ा , मैं , ०)
$ चुनिंदा छोड़ें ( $ श्रोता ( टुकड़ा ): - रेस , 1: रेस )
}

/// बिट्स की स्थिति से बिट्स को सूची में डाल देता है ($ lb ())
विधि GetSlice ( %% स्ट्रिंग के रूप में vbs , % पूर्णांक के रूप में स्थिति ) % स्ट्रिंग के रूप में
{
सेट उप = pos \ .. #MAXBITLENGTH , ix = pos -1 # .. #MAXBITLENGTH +1
i = 1: 1 के लिए: $ ऑर्डर (@ vbs @ ( "" ), - 1) सेट $ सूची ( टुकड़ा , i ) = $ बिट ( $ get (@ vbs @ ( i , sub )), ix )
टुकड़ा छोड़ दो
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर वैल्यू वैल है
विधि BSEq ( bmdest as % String , vbs as % String , val as % पूर्णांक )
{
set bswork = .. GetNewTMP () सेट vbit = .. CvtToBin ( val )
@ bmdest मर्ज @ bmdest = @ (.. बीएमजीएलओबी ) @ ( " एक्स्टिस्ट " ) को मारें
सेट की अधिकतम सीमा = $ ऑर्डर (@ vbs @ ( "" ), - १) सेट : अधिकतम < $ लंबाई ( vbit ) अधिकतम सीमा = $ लंबाई ( vbit )
ix = 1: 1 के लिए: अधिकतम मार @ bswork मर्ज @ bswork = @ vbs @ ( ix ) करते हैं : ' $ extract ( vbit , ix ) .. BMNot ( bswork ) do .. BMAnd ( bmdest , bswork )
मार @ bswork छोड़ दिया
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर का मान वैल से अधिक या उसके बराबर है
विधि BSGe ( bmdest % स्ट्रिंग के रूप में , vbs % स्ट्रिंग के रूप में , वैल %% पूर्णांक के रूप में )
{
do .. BSLt ( bmdest , vbs , val ), .. BMNot ( bmdest ) ने पद छोड़ दिया
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर मान वैल के बराबर नहीं है
विधि BSNe ( bmdest % स्ट्रिंग के रूप में , vbs % स्ट्रिंग के रूप में , वैल %% पूर्णांक के रूप में )
{
करते हैं .. BSEq ( bmdest , vbs , val ), .. बीएमनॉट ( bmdest )
छोड़ना
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर वैल्यू वैल्यू से अधिक है
///
विधि BSGt ( bmdest % String , vbs as % String , val as % Integer )
{
do .. BSLe ( bmdest , vbs , val ), .. BMNot ( bmdest ) ने पद छोड़ दिया
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहाँ पैरामीटर का चिह्न चिन्ह है (शून्य को सकारात्मक माना जाता है)
विधि BSSign ( bmdest % स्ट्रिंग के रूप में , vbs % स्ट्रिंग के रूप में,% पूर्णांक के रूप में हस्ताक्षर करें )
{
सेट करें bswork = .. GetNewTMP () @ bmdest को मारें
मर्ज @ bmdest = @ (.. BMGLOB ) @ ( " EXIST " ), @ bswork = @ vbs @ (1)
do : $ get ( साइन ) '<0 .. BMNot ( bswork ) do .. BMAnd ( bmdest , bswork )
मार @ bswork छोड़ दिया
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां वैल्यू वैल्यू वैल्यू से कम या बराबर है
विधि BSLe ( bmdest % String , vbs as % String , val as % पूर्णांक )
{
सेट tmpLe = .. GetNewTMP ()
do .. BSLtAbs ( bmdest , vbs , val ), .. BSSign ( tmpLe , vbs , -1)
अगर वैल '<0 do .. BMOr ( bmdest , tmpLe ), .. BSEq ( tmpLe , vbs , वैल ), .. BMOr ( bmdest , tmpLe ) अगर 1
वरना .. बीएमनॉट ( बीएमडीईएसटी ), .. बीएमएएमडी ( बीएमडीएसटी , टीएमपीएलई )
@ tmpLe को मार डालो
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर वैल्यू वैल से कम है
विधि BSLt ( bmdest % स्ट्रिंग के रूप में , vbs % स्ट्रिंग के रूप में,%% पूर्णांक के रूप में वैल )
{
सेट tmpLt = .. GetNewTMP ()
do .. BSLtAbs ( bmdest , vbs , val ), .. BSSign ( tmpLt , vbs , -1)
अगर वैल '<0 do .. BMOr ( bmdest , tmpLt ) अगर 1
ELSE do .. BMNot ( bmdest ), .. BMAnd ( bmdest , tmpLt ), .. BSNe ( tmpLt , vbs , val ), .. BMAnd ( bmdest , tmpLt )
@ tmpLt को मार डालो
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर मान val1 से अधिक या बराबर है और val2 के बराबर या उससे कम है
विधि BSGeLe ( bmdest as % String , vbs as % String , val1 as % पूर्णांक , val2 as % पूर्णांक )
{
tmpGeLe = .. GetNewTMP () सेट करें
do .. BSGe ( bmdest , vbs , val1 ), .. BSLe ( tmpGeLe , vbs , val2 ), .. BMAnd ( bmdest , tmpGeLe )
@ tmpGeLe को मार डालो
}

/// vbs बिट-स्लाइस इंडेक्स से bmdest बिटमैप में चयन करता है,
/// जहां पैरामीटर मान val1 से अधिक या बराबर है और val2 से कम है
विधि BSGeLt ( bmdest as % String , vbs as % स्ट्रिंग , val1 as % पूर्णांक , val2 as % पूर्णांक )
{
सेट tmpGeLt = .. GetNewTMP ()
do .. BSGe ( bmdest , vbs , val1 ), .. BSLt ( tmpGeLt , vbs , val2 ), .. BMAnd ( bmdest , tmpGeLt )
@ tmpGeLt को मार डालो
}

/// स्थान bmdest बिट सरणी में vbs बिट-स्लाइस इंडेक्स से एक नमूना,
/// जहां पैरामीटर मान val1 से अधिक है और val2 से कम या बराबर है
विधि BSGtLe ( bmdest as % String , vbs as % String , val1 as % पूर्णांक , val2 as % पूर्णांक )
{
सेट tmpGtLe = .. GetNewTMP ()
do .. BSGt ( bmdest , vbs , val1 ), .. BSLe ( tmpGtLe , vbs , val2 ), .. BMAnd ( bmdest , tmpGtLe )
@ tmpGtLe को मार डालो
}

/// vbs बिट-स्लाइस इंडेक्स से bmdest बिटमैप में चयन करता है,
/// जहां पैरामीटर मान val1 से अधिक है और val2 से कम है
विधि BSGtLt ( bmdest as % String , vbs as % स्ट्रिंग , val1 as % पूर्णांक , val2 as % पूर्णांक )
{
सेट tmpGtLt = .. GetNewTMP ()
do .. BSGt ( bmdest , vbs , val1 ), .. BSLt ( tmpGtLt , vbs , val2 ), .. BMAnd ( bmdest , tmpGtLt )
@ tmpGtLt को मार डालो
}

/// vbs बिट-स्लाइस इंडेक्स से bmdest बिटमैप में चयन करता है,
/// जहां पूर्ण मान में पैरामीटर मान वैल से कम है
विधि BSLtAbs ( bmdest as % String , vbs as % String , val as % पूर्णांक )
{
set bswork = .. GetNewTMP (), test = .. GetNewTMP ()
मार @ bmdest सेट vbit = .. CvtToBin ( वैल ), ixmax = $ ऑर्डर (@ vbs @ ( "" ), - 1)
मार @ टेस्ट मर्ज @ टेस्ट = @ (.. बीएमजीएलओबी ) @ ( " एक्जिस्ट " )
अगर ixmax < $ लंबाई ( vbit ) {
मर्ज @ bmdest = @ परीक्षण
} {
ix = ixmax के लिए : -1: 2 {
मार @ bswork मर्ज @ bswork = @ vbs @ ( ix )
करते हैं .. बीएमनोट ( बोस्कोर ), .. बीएमएएनडी ( बोस्कोर , टेस्ट )
do : $ अर्क ( vbit , ix ) .. BMOr ( bmdest , bswork ), .. BMNot ( bswork )
करो .. बीएमएएनडी ( परीक्षण , बोस्कोर )
}
}
@ @ मार डालो , @ bswork को छोड़ दिया
}

/// समूहबद्धता सूचकांकों के लिए कार्य करता है
/// अधिकतम मान लौटाता है (एक वैकल्पिक पैरामीटर के साथ
/// bsmin '= 0 - न्यूनतम) vbs बिट-स्लाइस इंडेक्स से बिटमैप चुनने के लिए
विधि BSMax ( % स्ट्रिंग के रूप में vbs , % स्ट्रिंग के रूप में बिटमैप , % स्ट्रिंग के रूप में bsmin ) % पूर्णांक के रूप में
{
सेट bsmin = '' $ get ( bsmin ), bswork = .. GetNewTMP ()
सेट ResBSM = .. GetNewTMP (), tmpBSM = .. GetNewTMP ()
मर्ज @ resBSM = @ vbs @ (1) करते हैं : ' bsmin .. BMNot ( resBSM ) करते हैं .. BMAnd ( resBSM , bitmap )
अगर .. BMCount ( resBSM ) मिनट = 0 सेट करें
ELSE सेट मिनट = 1 किल @ resBSM मर्ज @ resBSM = @ vbs @ (1) करते हैं : bsmin .. BMNot ( resBSM ) करना .. BMAnd ( resBSM , bitmap )
ix के लिए = $ ऑर्डर (@ vbs @ ( "" ), - १): - १: २ {
@ tmpBSM , @ bswork मर्ज @ tmpBSM = @ resBSM , @ bswork = @ vbs @ ( ix ) को मारें
do : min .. BMNot ( bswork ) do .. BMAnd ( tmpBSM , bswork )
if .. BMCount ( tmpBSM ) @ resBSM मर्ज @ resBSM = @ tmpBSM मारते हैं
}
सेट पोज़ = .. BMOrder ( resBSM , 0) छोड़ दिया : ' पॉस 0
सेट वैल = .. CvtFromSlice (.. GetSlice ( vbs , pos ))
@ bswork , @ resBSM , @ tmpBSM को छोड़ो वैल को मारो
}

विधि BSMin ( % स्ट्रिंग के रूप में vbs , % स्ट्रिंग के रूप में बिटमैप ) % पूर्णांक के रूप में
{
छोड़ दिया .. BSMax ( vbs , बिटमैप , 1)
}

/// बिट्स-इंडेक्स से बिटमैप नमूने के लिए मानों का योग लौटाता है
विधि BSSum ( % स्ट्रिंग के रूप में vbs , % स्ट्रिंग के रूप में बिटमैप ) % पूर्णांक के रूप में
{
set bswork = .. GetNewTMP (), resBSSum = .. GetNewTMP (), tmpbSSum = .. GetNewTMP ()
मर्ज @ resBSSum = @ vbs @ (1) करते हैं .. BMNot ( resBSSum ), .. BMAnd ( resBSSum , बिटमैप ) सेट स्लाइस = ""
ix = 2: 1 के लिए: $ आदेश (@ vbs @ ( "" ), - 1) किल @ tmpBSSum मर्ज @ tmpBSSum = @ vbs @ ( ix ) करते हैं .. BMAnd ( tmpbum , resBSSum ) $ सूची ( टुकड़ा , ix ) सेट करें ) = .. BMCount ( tmpbSSum )
सेट वैल = .. CvtFromSlice ( टुकड़ा )
मार @ resBSSum मर्ज @ resBSSum = @ vbs @ (1) करते हैं .. BMAnd ( resBSSum , बिटमैप ) सेट स्लाइस = ""
ix = 2: 1 के लिए: $ आदेश (@ vbs @ ( "" ), - 1) किल @ tmpBSSum मर्ज @ tmpBSSum = @ vbs @ ( ix ) करते हैं .. BMAnd ( tmpbum , resBSSum ) $ सूची ( टुकड़ा , ix ) सेट करें ) = .. BMCount ( tmpbSSum )
सेट वैल = वैल - .. CvtFromSlice ( टुकड़ा )
@ @ bswork , @ resBSSum , @ tmpBSSum को छोड़ दें , वैल को मारें
}

/// बिटमैप्स और बिट-स्लाइस इंडेक्स भरने के तरीके
///
/// बिटमैप इंडेक्स में संबंधित बिट सेट करता है
/// इस संपत्ति का मूल्य दिया
/// वैकल्पिक पैरामीटर सेटेक्सिस्ट = 1 के साथ बिट को भी सेट करता है
मौजूदा रिकॉर्ड्स का /// बिटमैप इंडेक्स (सही के लिए आवश्यक)
/// BMNot () विधि का संचालन
विधि सेटबिट मैप ( % पूर्णांक के रूप में निष्क्रियता , संपत्ति स्ट्रिंग के रूप में संपत्ति , % स्ट्रिंग के रूप में मूल्य , % स्ट्रिंग के रूप में सेटेक्सिस्ट )
{
सेट idf0 = idfact -1 \ .. #MAXBITLENGTH , idf1 = idfact -1 # .. #MAXBITLENGTH +1
सेट : $ get ( सेटटेक्सिस्ट ) $ बिट (@ (.. BMGLOB ) @ ( " एक्स्टिस्ट " , idf0 ), idf1 ) = १
$ बिट सेट करें (@ (.. BMGLOB ) @ ( "I" , संपत्ति , मूल्य , idf0 ), idf1 ) 1
छोड़ना
}

/// बीटल्स इंडेक्स में संबंधित बिट सेट करता है
इस संपत्ति के दिए गए मूल्य का ///।
/// वैकल्पिक पैरामीटर सेटेक्सिस्ट - सेटबिट मैप के समान ()
विधि सेटबीट्लिस ( आईडी % के रूप में बेकार , संपत्ति के रूप में% स्ट्रिंग , मूल्य के रूप में% पूर्णांक , सेटटेक्सिस्ट % स्ट्रिंग के रूप में )
{
सेट idf0 = idfact -1 \ .. #MAXBITLENGTH , idf1 = idfact -1 # .. #MAXBITLENGTH +1
सेट : $ get ( सेटटेक्सिस्ट ) $ बिट (@ (.. BMGLOB ) @ ( " एक्स्टिस्ट " , idf0 ), idf1 ) = १
सेट v = .. CvtToBin (+ मान )
ix = 1: 1: $ लंबाई ( v ) सेट : $ एक्सट्रेक्ट ( v , ix ) $ बिट (@ (.. BMGLOB ) @ ( "S" , संपत्ति , ix , idf0 ), idf1 ) = 1
छोड़ना
}

/// इंडेक्स ग्लोबल वाले सबनॉड का नाम देता है
/// बिटमैप इंडेक्स (यदि स्लाइस = 0 या परिभाषित नहीं है) या बिटस्लाइस (जीएचबी स्लाइस '= 0)
/// इस संपत्ति के लिए। यदि संपत्ति खाली है या परिभाषित नहीं है -
/// तो मौजूदा रिकॉर्ड्स का बिटमैप इंडेक्स
विधि GetBitMapName ( % स्ट्रिंग के रूप में संपत्ति , % स्ट्रिंग के रूप में स्लाइस ) % स्ट्रिंग के रूप में
{
छोड़ दिया : $ get ( संपत्ति ) = "" $ नाम (@ (.. BMGLOB ) @ ( " एक्स्टिस्ट " ))
$ नाम छोड़ें (@ (.. BMGLOB ) @ ( $ चयन (+ $ get ( स्लाइस ): "S" , 1: "I" ), संपत्ति )
}

/// डेमो भरने और चयन
///
क्लासमैथोड पॉप्युलेट ( % स्ट्रिंग = 10000 के रूप में गिनें )
{
सेट ix = .. % नया ()
ix सेट करें । BMGLOB = $ नाम (^ BMI)
set count = $ get ( गिनती , 10000), m = 0
सेट नाम = $ सूची ( "सांता क्लॉज़" , "क्रोकोडाइल" , "सिम्बा" )
सेट रंग = $ सूची ( "सियान" , "मैजेंटा" , "येलो" , "ब्लैक" )
अगर $ सॉर्टबगिन (^ बीएमआई)
मुहावरे के लिए = 1: 1: गिनती {
सेट नाम = $ सूची ( नाम , 1 + $ यादृच्छिक ( $ सूची सूची ( नाम )))
सेट रंग = $ सूची ( रंग , 1 + $ यादृच्छिक ( $ सूची ) ( रंग )
सेट लंबाई = 10 + $ यादृच्छिक (90)
सेट वजन = (10+ $ यादृच्छिक (40)) * 100
; रंग के लिए एक बिटमैप इंडेक्स बनाएं
ix करो । सेटबिट मैप ( निष्क्रियता , "सी" , रंग , 1)
; वजन और लंबाई के लिए हम बीटल इंडेक्स बनाते हैं
ix करो । सेटबीट्लिस ( निष्क्रियता , "एल" , लंबाई )
ix करो । सेटबिट्लिस ( निष्क्रियता , "डब्ल्यू" , वजन )
; परीक्षण नमूने का परीक्षण करने के लिए (नीचे देखें), हम विचार करते हैं
; 45-70 सेमी लंबे काले और पीले मगरमच्छों का कुल वजन
; सम्मिलित
सेट : (( रंग = "काला" )! ( रंग = "पीला" )) और ( लंबाई '<45) और ( लंबाई '> 70) m = m + वजन
}
यदि $ सॉर्ट (^ बीएमआई)
m _ "ग्रामो कुल" लिखें,!
ix मारना छोड़ दिया
}

/// परीक्षण नमूना
ClassMethod TestGetData ()
{
सेट ix = .. % नया ()
ix सेट करें । BMGLOB = $ नाम (^ BMI)
सेट b = .. GetNewTMP (), b1 = .. GetNewTMP ()
ix करो । BMEq ( b , ix । GetBitMapName ( "C" ), "ब्लैक"
ix करो । BMEq ( b1 , ix । GetBitMapName ( "C" ), "येलो" )
ix करो । बीएमओआर ( बी , बी 1 )
ix करो । BSGeLe ( b1 , ix । GetBitMapName ( "L" , 1), 45.70)
ix करो । बीएमएंड ( बी , बी 1 )
set count = ix । BMCount ( b )
गिनती _ "आइटम चयनित" लिखें;
; चयनित का कुल वजन निर्धारित करें
ix लिखें । BSSum ( ix । GetBitMapName ( "W" , 1), b ) _ "कुल ग्राम"!
करो .. KillAllTMP ()
ix मारना छोड़ दिया
}

}

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

do ## वर्ग ( User.BitMapSlice )। आबाद (1,000,000) ; मिलियन रिकॉर्ड

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

do ## वर्ग ( User.BitMapSlice )। टेस्टगेटडाटा ()

आप परिणाम और उस पर खर्च किए गए समय की तुलना कर सकते हैं।

उन लोगों के लिए जो संक्षिप्त COS सिंटैक्स के आदी हैं, मैं आपको याद दिलाता हूं कि Caché Studio, जो संस्करण 5.2 से शुरू होता है, आपको आसानी से चयनित कोड के टुकड़े को पूर्ण रूप से संक्षिप्त रूप में बदलने की अनुमति देता है - Ctrl-Shift-E और इसके विपरीत - Ctrl-E ।
निष्कर्ष में, एक सूक्ष्मता पर टिप्पणी करना आवश्यक है। Ache कैशेटेम्प या es मेटेम्प उपसर्गों के साथ ग्लोबल्स में लाने के लिए मध्यवर्ती और परिणामस्वरूप बिटमैप इंडेक्स बनाने की सिफारिश की जाती है।ऐसे ग्लोबल्स भौतिक रूप से CACHETEMP डेटाबेस में स्थित हैं और इस तथ्य के कारण कि वे लॉग नहीं हैं , जिनकी हमें कोई आवश्यकता नहीं है, उनके साथ काम करना स्थानीय चर के साथ भी अधिक उत्पादक है। इस उद्देश्य के लिए स्थानीय चर का उपयोग एक अन्य कारण के लिए भी अवांछनीय है - उपयोगकर्ता प्रक्रिया की 16-मेगाबाइट मेमोरी सीमा में चलाने की क्षमता।

इटैलिक्स में जोर कैच डीबीएमएस के नए संस्करणों पर लागू नहीं होता है:
बड़े स्थानीय एरे
विस्तारित मेमोरी
असीमित स्थानीय सरणियाँ

इस लेख में वर्णित कोड दीपसी उत्पाद की प्रस्तुतियों में से एक पर InterSystems द्वारा प्रदान की गई जानकारी के लिए अपनी उपस्थिति के कारण दिखाई देता है, और बाद में इसके Ortofact डेटा वेयरहाउस में MacovaSoft द्वारा उपयोग किया गया था।

कैच बिटमैप इंडेक्स ऑन ग्लोबल

More articles: