🌡️ 🤞🏿 👈🏾 गैर परमाणु गुण को अनुक्रमणित करना 👨🏼‍🏫 👻 🚴🏼

विकिपीडिया से उद्धरण ( 1NF ):

पंक्ति और स्तंभ के प्रत्येक चौराहे में संबंधित डोमेन से बिल्कुल एक मान होता है (और अधिक कुछ नहीं)।

इस मूल्य के अर्थ के आधार पर एक और एक ही मूल्य परमाणु या गैर-परमाणु हो सकते हैं। उदाहरण के लिए, मान "4286" है
परमाणु , यदि इसका अर्थ "क्रेडिट कार्ड पिन" है (जब टूट गया या पुन: व्यवस्थित किया गया, तो अर्थ खो गया है)
गैर-परमाणु , यदि इसका अर्थ "संख्याओं का समूह" है (भागों में विभाजित होने या पुन: व्यवस्थित होने पर, अर्थ खो नहीं जाता है)

यह आलेख निम्न फ़ील्ड प्रकारों के लिए SQL क्वेरी को गति देने के लिए मानक तरीकों पर चर्चा करेगा: स्ट्रिंग, तिथि, सरल सूची ($ एलबी प्रारूप में), सूची संग्रह और सरणी संग्रह।

सामग्री की तालिका:

परिचय

सबसे पहले, फोन की सूची के उदाहरण के क्लासिक संस्करण पर विचार करें।
परीक्षण डेटा बनाएँ:

create table cl_phones(tname varchar2(100), phone varchar2(30)); insert into cl_phones(tname,phone) values ('','867-843-25'); insert into cl_phones(tname,phone) values ('','830-044-35'); insert into cl_phones(tname,phone) values ('','530-055-35'); insert into cl_phones(tname,phone) values ('','530-055-35'); insert into cl_phones(tname,phone) values ('','555-011-35'); insert into cl_phones(tname,phone) values ('','530-055-31'); insert into cl_phones(tname,phone) values ('','531-051-32'); insert into cl_phones(tname,phone) values ('','532-052-33'); insert into cl_phones(tname,phone) values ('','533-053-35');

अब प्रत्येक नाम के लिए फोन की अल्पविराम से अलग सूची मुद्रित करें:

का चयन करें
% सटीक ( tname ) tname ,
लिस्ट ( फोन ) फोनस्टार
Cl_phones से
ग्रुप द्वारा tname

या तो:

का चयन करें
अलग % सटीक ( tname ) tname ,
लिस्ट ( फोन % foreach ( tname )) फोनस्टार
Cl_phones से

परिणाम:

tname	phonestr
एंड्रयू	867-843-25,830-044-35,530-055-35
वन्या	530-055-31,531-051-32,532-052-33,533-053-35
कहावत	530-055-35,555-011-35

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

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

तो क्या करें?

विशेष रूप से ऐसे मामलों के लिए, एक विशेष प्रकार का सूचकांक संग्रह वाले क्षेत्रों के लिए पेश किया गया था।
संग्रह या तो "वास्तविक" (अंतर्निहित <...> और सरणी की <...> ) या "आभासी" सूची हो सकती है।
अंतर्निहित संग्रह के मामले में, सिस्टम उन पर इस तरह के एक सूचकांक बनाने के लिए जिम्मेदार है, और प्रोग्रामर इस प्रक्रिया को बदल नहीं सकता है, आभासी लोगों के मामले में, सूचकांक बनाने की ज़िम्मेदारी प्रोग्रामर के पास है।
एक विभाजक, तारीख, एक साधारण सूची के साथ एक सरल स्ट्रिंग - ये ऐसे "आभासी" संग्रह के उदाहरण हैं।

इसलिए, संग्रह पर अनुक्रमित का सिंटैक्स निम्नानुसार है:

INDEX idx1 ON (MyField (ELEMENTS));

या

INDEX idx1 ON (MyField (KEYS));

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

ClassMethod propertynameBuildValueArray ( मान , ByRef valueArray ) % स्थिति के रूप में

जहां:

मूल्य - तत्वों में तोड़ने के लिए फ़ील्ड मान;
valueArray परिणामी सरणी है जिसमें अलग-अलग तत्व होते हैं।
एक सरणी फॉर्म का एक कुंजी / मान है:
सरणी (की 1) = मान 1
सरणी (की 2) = मान 2
आदि

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

आइए ऐसे इंडेक्स बनाएं और देखें कि उन्हें हमारे SQL प्रश्नों में कैसे उपयोग किया जाए।

नोट: ताकि पिछले उदाहरण से कोई कलाकृतियां न बची हों, यह अनुशंसा की जाती है कि प्रत्येक नए से पहले कक्षा के ग्लोबल्स और स्टोरेज स्कीम को पूरी तरह से साफ कर दें।

सीमांकित स्ट्रिंग

निम्न वर्ग बनाएं:

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

फोन ( सूचकांक ) पर सूचकांक iPhones;

% स्ट्रिंग के रूप में संपत्ति फ़ोन ;

क्लासमेथ फोन
मूल्य,
ByRef array ) % स्टेटस के रूप में
{
यदि मान = "" {
सेट सरणी (0) = मान
} {
सेट सूची = $ ListFromString ( मान , "," ), ptr = 0
जबकि $ ListNext ( सूची , ptr , आइटम ) {
सेट सरणी ( ptr ) = आइटम
}
}
$ $ $ $ ठीक है
}

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
& sql ( डेमो टेस्ट में डालें ) ( फोन )
अशक्त संघ का चयन करें
सभी संघ का चयन करें
'b, a' सभी का चयन करें
सभी का चयन करें 'बी, बी'
'a, c, b' सभी का चयन करें
'का चयन करें ,'
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

टर्मिनल में भरें () विधि चलाएँ:

USER>do ##class(demo.test).Fill()
^demo.testD=6
^demo.testD(1)=$lb("","")
^demo.testD(2)=$lb("","a")
^demo.testD(3)=$lb("","b,a")
^demo.testD(4)=$lb("","b,b")
^demo.testD(5)=$lb("","a,c,b")
^demo.testD(6)=$lb("",",,")
^demo.testI("iPhones"," ",1)=""
^demo.testI("iPhones"," ",6)=""
^demo.testI("iPhones"," A",2)=""
^demo.testI("iPhones"," A",3)=""
^demo.testI("iPhones"," A",5)=""
^demo.testI("iPhones"," B",3)=""
^demo.testI("iPhones"," B",4)=""
^demo.testI("iPhones"," B",5)=""
^demo.testI("iPhones"," C",5)=""

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

हमारी तालिका की सामग्री इस प्रकार होगी:

आईडी	फ़ोनों
1	(शून्य)
2	एक
3	बी, ए
4	बी, बी
5	ए, सी, बी
6	,,

अब मूल्य "a" वाली सभी लाइनों को खोजने का प्रयास करें। इसके लिए, '% xxx%' या [ xxx] जैसे विधेयकों का आमतौर पर उपयोग किया जाता है, उदाहरण के लिए:

डेमो से * का चयन करें । परीक्षण जहां फोन [ 'ए'
डेमो से * का चयन करें । परीक्षण जहां फोन '% a%' जैसे हैं

लेकिन इस मामले में, हमारे iPhones इंडेक्स का उपयोग नहीं किया जाएगा। इसका उपयोग करने के लिए, आपको एक विशेष विधेय का उपयोग करना चाहिए

FOR SOME %ELEMENT() (%VALUE = )

पूर्वगामी के आधार पर, हमारा अनुरोध निम्नलिखित रूप लेगा:

डेमो से * का चयन करें । परीक्षण जहां कुछ% तत्व ( फ़ोन ) ( % मान = 'a' ) के लिए

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

( % मान % STARTSWITH 'a' )
( % मूल्य [ 'ए' और % मूल्य [ 'बी' )
( % मान में ( 'c' , 'd' ))
( % मान शून्य है )

और अब थोड़ा जादू ...

संवेदनशील डेटा छिपाना

BuildValueArray विधि में , हम आमतौर पर मूल्य में मूल्य के आधार पर एक सरणी को आबाद करते हैं।

लेकिन अगर हम इस नियम का पालन नहीं करेंगे तो क्या होगा?

आइए इस तरह से एक उदाहरण की कोशिश करें:

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

सूचकांक iLogin लॉग इन (तत्व);

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

ClassMethod LoginBuildValueArray (
मूल्य,
ByRef array ) % स्टेटस के रूप में
{
यदि मान = "बॉब" {
सेट सरणी (0) = "test1"
सेट सरणी (1) = "परीक्षण 2 "
सेट सरणी (2) = "परीक्षण 3"
} ElseIf मान = " पेट्या " {
सेट सरणी ( "-" ) = "111"
सेट सरणी ( "5.4" ) = "222"
सेट सरणी ( "एफजी" ) = "333"
} {
सेट सरणी ( "कुंजी" ) = "मान"
}
$ $ $ $ ठीक है
}

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
& sql ( डेमो टेस्ट में डालें ) ( लॉगिन )
सभी को 'वास्य' संघ चुनें
सभी को 'वास्य' संघ चुनें
सभी 'पेट्या' संघ का चयन करें
सभी 'पेट्या' संघ का चयन करें
सभी 'इवान' संघ का चयन करें
'इवान' का चयन करें
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

भरने के बाद, तालिका की सामग्री इस प्रकार होगी:

आईडी	लॉग इन
1	Vasya
2	Vasya
3	पेट्या
4	पेट्या
5	इवान
6	इवान

और अब - ध्यान! - निम्नलिखित अनुरोध को निष्पादित करने का प्रयास करें:

डेमो से * का चयन करें । परीक्षण करें जहाँ कुछ% तत्व ( लॉगिन ) ( % मान = '111' )

हम लौटेंगे:

आईडी	लॉग इन
3	पेट्या
4	पेट्या

नतीजतन, हम देखते हैं कि डेटा का हिस्सा तालिका में दिखाई देता है, और भाग - सूचकांक में छिपा हुआ है, लेकिन जिसके द्वारा हम फिर भी एक खोज कर सकते हैं।

हम इसे कहां उपयोगी पा सकते हैं?

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

संवेदनशील डेटा छिपाना (जारी)

यदि आप ग्लोबल्स को देखते हैं जिसमें डेटा और इंडेक्स हमारी टेबल के लिए संग्रहीत किए जाते हैं, तो हम वहां अपनी कुंजियों के मूल्यों को नहीं देखेंगे: "5.4", "एफजी", आदि:

^demo.testD=6
^demo.testD(1)=$lb("","")
^demo.testD(2)=$lb("","")
^demo.testD(3)=$lb("","")
^demo.testD(4)=$lb("","")
^demo.testD(5)=$lb("","")
^demo.testD(6)=$lb("","")
^demo.testI("iLogin"," 111",3)=""
^demo.testI("iLogin"," 111",4)=""
^demo.testI("iLogin"," 222",3)=""
^demo.testI("iLogin"," 222",4)=""
^demo.testI("iLogin"," 333",3)=""
^demo.testI("iLogin"," 333",4)=""
^demo.testI("iLogin"," TEST1",1)=""
^demo.testI("iLogin"," TEST1",2)=""
^demo.testI("iLogin"," TEST2",1)=""
^demo.testI("iLogin"," TEST2",2)=""
^demo.testI("iLogin"," TEST3",1)=""
^demo.testI("iLogin"," TEST3",2)=""
^demo.testI("iLogin"," VALUE",5)=""
^demo.testI("iLogin"," VALUE",6)=""

फिर हमने उनसे क्यों पूछा?

इस प्रश्न का उत्तर देने के लिए, हम अपने सूचकांक को थोड़ा संशोधित करते हैं और तालिका को फिर से भरते हैं।

सूचकांक iLogin On (लॉगिन (KEYS), लॉगिन (तत्व));

ग्लोबल्स एक अलग रूप धारण करेंगे (मैं केवल वैश्विक सूचकांक के साथ दे दूँगा):

^demo.testI("iLogin"," -"," 111",3)=""
^demo.testI("iLogin"," -"," 111",4)=""
^demo.testI("iLogin"," 0"," TEST1",1)=""
^demo.testI("iLogin"," 0"," TEST1",2)=""
^demo.testI("iLogin"," 1"," TEST2",1)=""
^demo.testI("iLogin"," 1"," TEST2",2)=""
^demo.testI("iLogin"," 2"," TEST3",1)=""
^demo.testI("iLogin"," 2"," TEST3",2)=""
^demo.testI("iLogin"," 5.4"," 222",3)=""
^demo.testI("iLogin"," 5.4"," 222",4)=""
^demo.testI("iLogin"," FG"," 333",3)=""
^demo.testI("iLogin"," FG"," 333",4)=""
^demo.testI("iLogin"," KEY"," VALUE",5)=""
^demo.testI("iLogin"," KEY"," VALUE",6)=""

महान, अब हम दोनों प्रमुख मूल्यों और तत्व मूल्यों को स्वयं संग्रहीत करते हैं। यह भविष्य में कैसे काम आ सकता है?

उदाहरण के लिए, पासवर्ड के साथ पहले प्रस्तावित संस्करण में, पासवर्ड के अलावा, आप उस दिनांक को संग्रहीत कर सकते हैं जब तक कि यह पासवर्ड मान्य नहीं होगा, या कुछ और। और फिर हमारे अनुरोध में इस तथ्य का उपयोग इस प्रकार किया जा सकता है:

डेमो से * का चयन करें । परीक्षण जहां कुछ% तत्व ( लॉगिन ) ( % कुंजी = '- और % मान = ' 111 ' )

आपके लिए कहां और क्या स्टोर करना है, केवल एक चीज जो आपको याद रखने की जरूरत है, वह यह है कि चाबियाँ अद्वितीय हैं, लेकिन मूल्य नहीं हैं।
इसके अलावा, "संग्रह" सूचकांक में और साथ ही मानक सूचकांक में, आप अतिरिक्त डेटा स्टोर कर सकते हैं:

सूचकांक iLogin ऑन (लॉगिन (कुंजी), लॉगिन (तत्व)) [ डेटा = ( लॉगिन , लॉगिन (तत्व))];

इस विकल्प के साथ, उपरोक्त अनुरोध अब डेटा तक नहीं पहुंचेगा, लेकिन सब कुछ सूचकांक से ले जाएगा, जो समय भी बचाएगा।

दिनांक (समय, आदि)

ऐसा लगता है, संग्रह के साथ तारीखों का क्या करना है? सबसे तत्काल, क्योंकि अक्सर आपको केवल दिन, महीने या वर्ष के आधार पर खोज करनी होती है। यहां सामान्य सूचकांक हमारी मदद नहीं करेगा, लेकिन "संग्रह" एक बहुत उपयुक्त होगा।

आइए निम्नलिखित उदाहरण देखें:

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

सूचकांक iBirthDay On (बर्थडे (KEYS), जन्मतिथि (तत्व));

संपत्ति जन्म तिथि% के रूप में ;

क्लासमैथ बर्थडेबयूडिलवैल्यूएरे (
मूल्य,
ByRef array ) % स्टेटस के रूप में
{
यदि मान = "" {
सेट सरणी (0) = मान
} {
सेट d = $ zd ( मान , 3)
सेट सरणी ( "yy" ) = + $ p ( d , "-" , 1)
सेट सरणी ( "मिमी" ) = + $ p ( d , "-" , २)
सेट सरणी ( "dd" ) = + $ p ( d , "-" , 3)
}
$ $ $ $ ठीक है
}

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
और sql ( डेमो टेस्ट में डालें ) ( जन्मदिन )
{ d '2000-01-01' } सभी का चयन करें
{ d '2000-01-02' } सभी का चयन करें
{ d '2000-02-01' } सभी का चयन करें
{ d '2001-01-01' } सभी का चयन करें
{ d '2001-01-02' } सभी का चयन करें
{ d '2001-02-01' का चयन करें
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

भरने के बाद हमारी तालिका की सामग्री निम्नलिखित रूप लेगी:

आईडी	जन्मदिन
1	2000/01/01
2	2000/01/02
3	2000/01/02
4	2001/01/01
5	2001/01/02
6	2001/01/02

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

डेमो से * का चयन करें । परीक्षण करें जहाँ कुछ% तत्व ( जन्म दिन ) ( % कुंजी = 'मिमी' और % मान = २)

परिणाम:

आईडी	जन्मदिन
3	2000/01/02
6	2001/01/02

सरल सूची

कैच डीबीएमएस में एक साधारण सूची ( % सूची ) के लिए एक विशेष डेटा प्रकार होता है, जिसे एक विभाजक की पसंद के साथ कठिनाइयां होने पर स्ट्रिंग के बजाय उपयोग किया जा सकता है।
ऐसे क्षेत्र का उपयोग करना स्ट्रिंग के साथ काम करने से बहुत अलग नहीं है।

एक छोटे से उदाहरण पर विचार करें:

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

सूची पर सूची (तत्व) सूचकांक ;

संपत्ति सूची % सूची के रूप में ;

क्लासमेथोड सूचीबाइल्डवैल्यूअरे (
मूल्य,
ByRef array ) % स्टेटस के रूप में
{
यदि मान = "" {
सेट सरणी (0) = मान
} {
सेट ptr = 0
जबकि $ ListNext ( मूल्य , ptr , आइटम ) {
सेट सरणी ( ptr ) = आइटम
}
}
$ $ $ $ ठीक है
}

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
& sql ( डेमो टेस्ट में डालें ) ( सूची )
अशक्त संघ का चयन करें
$ LISTBUILD ( 'a' ) संघ का चयन करें
$ LISTBUILD ( 'b' , 'a' ) सभी का चयन करें
$ LISTBUILD ( 'b' , 'b' ) सभी का चयन करें
$ LISTBUILD ( 'a' , 'c' , 'b' ) सभी का चयन करें
$ LISTBUILD का चयन करें ( 'ए,' , अशक्त , अशक्त )
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

ODBC प्रदर्शन मोड में तालिका की सामग्री इस तरह दिखाई देगी:

नोट: Caché में डेटा प्रस्तुत करने के लिए तीन मोड हैं: तार्किक, ODBC और डेटा डिस्प्ले विकल्प ।

आईडी	सूची
1	(शून्य)
2	एक
3	बी, ए
4	बी, बी
5	ए, सी, बी
6	"ए ,," ,,

इस मामले में, तत्व विभाजक शामिल नहीं है, इसलिए हम तत्वों में किसी भी वर्ण का उपयोग कर सकते हैं।

ODBC मोड में टाइप % सूची के क्षेत्र को आउटपुट करते समय , ODBCDELIMITER पैरामीटर को एक विभाजक के रूप में उपयोग किया जाता है, जो "," के लिए डिफ़ॉल्ट है।

उदाहरण के लिए, ऐसे क्षेत्र के साथ, हमारी तालिका इस तरह दिखाई देगी:

संपत्ति सूची % सूची ( ODBCDELIMITER = "^" );

आईडी	सूची
1	(शून्य)
2	एक
3	b ^ ए
4	b ^ b
5	a ^ c ^ b
6	a ^ ^ ^

आइटम ढूँढना सीमांकित स्ट्रिंग से अलग नहीं है:

डेमो से * का चयन करें । परीक्षण जहां कुछ% तत्व ( सूची ) ( % मान = 'ए,' ) के लिए

आईडी	सूची
6	"ए ,," ,,

यह विशेष रूप से ध्यान देने योग्य है कि % INLIST वाला विकल्प अभी तक "संग्रह" अनुक्रमित का उपयोग नहीं करता है, और इसलिए यह ऊपर की तुलना में धीमा होगा:

डेमो से * का चयन करें । परीक्षण जहां 'ए,' % सूची सूची

संग्रह सूची

हम उपरोक्त उदाहरण को फिर से लिखते हैं, लेकिन एक साधारण सूची का उपयोग करने के बजाय, सूची संग्रह का उपयोग करें:

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

इंडेक्स iListStr ऑन लिस्टस्टार (तत्व);

% स्ट्रिंग की सूची के रूप में संपत्ति की सूची ;

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
& sql ( डेमो टेस्ट में सम्मिलित करें ) ( सूची )
अशक्त संघ का चयन करें
$ LISTBUILD ( 'a' ) संघ का चयन करें
$ LISTBUILD ( 'b' , 'a' ) सभी का चयन करें
$ LISTBUILD ( 'b' , 'b' ) सभी का चयन करें
$ LISTBUILD ( 'a' , 'c' , 'b' ) सभी का चयन करें
$ LISTBUILD का चयन करें ( 'ए,' , अशक्त , अशक्त )
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

इस उदाहरण में, लगभग सब कुछ समान है, लेकिन काफी नहीं है। विशेष रूप से निम्नलिखित बातों पर ध्यान दिया जाना चाहिए:

सरणी में हमारे क्षेत्रों, कुंजियों और सूचकांक तत्वों के संकलन मूल्यों द्वारा, जो वैश्विक स्तर पर बचत से पहले संबंधित परिवर्तनों से गुजरते हैं।
दोनों उदाहरणों में वैश्विक सूचकांक में मूल्यों की तुलना करें, विशेषकर NULL मूल्य का प्रतिनिधित्व;
BuildValueArray विधि अनुपलब्ध है, इसलिए हम कुंजियों का उपयोग नहीं कर सकते हैं, लेकिन केवल तत्वों के मान;
हमारा क्षेत्र प्रकार एक विशेष संग्रह वर्ग ( % ListOfDataTypes ) है।

संग्रह संग्रह

जैसा कि ऊपर उल्लेख किया गया है, संग्रह सूची हमें कुंजियों का उपयोग करने की अनुमति नहीं देती है। सरणी संग्रह इस दोष को ठीक करता है।

निम्न वर्ग बनाएं:

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

सूचकांक iArrayStr On (ArrayStr (KEYS), ArrayStr (ELEMENTS));

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

% स्ट्रिंग के रूप में संपत्ति ArrayStr ;

ClassMethod भरें ()
{
और sql ( छोटा टेबल डेमो । परीक्षण )
& sql ( डेमो टेस्ट में सम्मिलित करें ) ( str )
अशक्त संघ का चयन करें
सभी को 'आओ' संघ का चयन करें
सभी का चयन करें 'bbb'
सभी का चयन करें 'bbb'
सभी 'ccc' यूनियन का चयन करें
अशक्त का चयन करें
)
& sql ( डेमो में डालें । test_ArrayStr ( परीक्षण , element_key , arraystr )
1, '0' , 'test1' सभी का चयन करें
1, '1' , 'test2' सभी का चयन करें
1, '2' , 'test3' सभी का चयन करें
2, '0' , 'test1' सभी का चयन करें
2, '1' , 'test2' सभी का चयन करें
2, '2' , 'test3' सभी का चयन करें
3, '-' , '111' सभी का चयन करें
3 का चयन करें , '5.4' , '222' सभी
3 का चयन करें , 'एफजी' , '333' संघ सभी
4, '-' , '111' सभी का चयन करें
4 का चयन करें , '5.4' , '222' संघ सभी
4, 'fg' , '333' सभी का चयन करें
5 का चयन करें , 'कुंजी' , 'मान' सभी
6 का चयन करें , 'कुंजी' , 'मूल्य'
)

ZWrite ^ Demo.testD
ZWrite ^ Demo.testI
}

}

यहाँ आपको कुछ स्पष्टीकरण करने की आवश्यकता है:

हमारा डेटा अभी भी दो ग्लोबल्स में संग्रहीत है: ^ कक्षा डी का नाम (वास्तविक डेटा) और ^ कक्षा I (सूचकांक) का नाम;
एक वर्ग होने के बावजूद, हमारे पास पहले से ही दो टेबल हैं: हमेशा की तरह, डेमो.टेस्ट और एक सहायक डेमो ।est_ArrayStr ;
Demo.test_ArrayStr तालिका सरणी डेटा के लिए सुविधाजनक SQL एक्सेस प्रदान करती है और इसमें निम्नलिखित फ़ील्ड होते हैं, जिनके कुछ नाम पूर्वनिर्धारित हैं:
- element_key - मुख्य मान (फ़ील्ड नाम पूर्वनिर्धारित है);
- ArrayStr - तत्व मूल्य;
- परीक्षण - मूल तालिका का लिंक डेमो । टेस्ट ;
- आईडी - सेवा प्राथमिक कुंजी, जिसमें प्रारूप परीक्षण है। तत्व_की (क्षेत्र का नाम पूर्वनिर्धारित है);
हमारे क्षेत्र का प्रकार एक विशेष संग्रह वर्ग ( % ArrayOfDataTypes ) है।

तो, भरण () विधि के बाद हमारे तालिकाओं की सामग्री इस प्रकार होगी:

तालिका का डेमो

आईडी	str
1	(शून्य)
2	aaa
3	bbb
4	bbb
5	सीसीसी
6	(शून्य)

तालिका Demo.test_ArrayStr

आईडी	कसौटी	element_key	ArrayStr
१ \|\| ०	1	0	test1
१ \|\| १	1	1	test2
१ \|\| २	1	2	test3
2 \|\| 0	2	0	test1
2 \|\| 1	2	1	test2
2 \|\| 2 \|\|	2	2	test3
3 \|\| 5.4	3	5.4	222
3 \|\| -	3	-	111
3 \|\| fg	3	FG	333
4 \|\| 5.4	4	5.4	222
4 \|\| -	4	-	111
4 \|\| fg	4	FG	333
5 \|\| कुंजी	5	कुंजी	मूल्य
6 \|\| कुंजी	6	कुंजी	मूल्य

ऐसा लगता है कि एक के बजाय दो तालिकाओं के होने के बाद, हम अब उनके बीच जोइन करने के लिए मजबूर हैं, लेकिन ऐसा नहीं है।

SQL के लिए Caché DBMS द्वारा प्रदान की गई वस्तु एक्सटेंशन को ध्यान में रखते हुए, "-" कुंजी और तत्व "111" के साथ स्ट्रिंग के लिए Demo.test से str फ़ील्ड प्रदर्शित करने वाली हमारी परीक्षा क्वेरी निम्न रूप लेगी:

टेस्ट आईडी का चयन करें , परीक्षण -> डेमो से मुक्त । test_ArrayStr जहां element_key = '-' और arraystr = '111'

या ऐसे

% ID का चयन करें , डेमो से मुक्त । परीक्षण जहाँ test_ArrayStr -> element_key = '-' और test_ArrayStr -> arraystr = 111 '

परिणाम:

आईडी	str
3	bbb
4	bbb

जैसा कि आप देख सकते हैं, कुछ भी जटिल और कोई JOIN नहीं है, क्योंकि हमारे सभी डेटा वास्तव में एक वैश्विक में संग्रहीत हैं और Caché इन तालिकाओं की "संबंधितता" के बारे में जानता है। इसलिए, फ़ील्ड को दोनों तालिकाओं से संदर्भित किया जा सकता है। Demo.test तालिका में test_ArrayStr फ़ील्ड वास्तव में मौजूद नहीं है, हालांकि हम इसके माध्यम से संबंधित तालिका तक पहुंच सकते हैं।

निष्कर्ष में

यहाँ वर्णित इंडेक्सिंग मैकेनिज़्म का व्यापक रूप से कुछ सिस्टम वर्गों में उपयोग किया जाता है, जैसे, उदाहरण के लिए, % Stream.GlobalCharacterSearchable , जो किसी पाठ स्ट्रीम को अनुक्रमणित करने और SQL के माध्यम से इसे खोजने के लिए प्रदान करता है। लेख विशेष रूप से कक्षाओं में अनुक्रमित संग्रह के उदाहरणों को कवर नहीं करता है, उनकी विस्तृत विविधता को देखते हुए: एम्बेडेड, संग्रहीत, स्ट्रीम, उपयोगकर्ता-परिभाषित, संग्रह के संग्रह के साथ, और अन्य। इसके अलावा, उनमें से कई के साथ यह एसक्यूएल के माध्यम से काम करने के लिए हमेशा सुविधाजनक और कुशल नहीं है, क्योंकि लेखक को कुछ बहुत ही दुर्लभ मामलों को छोड़कर ऐसे संग्रह की बहुत आवश्यकता नहीं है। इसके अलावा, पूर्ण-पाठ खोज यहां कवर नहीं की गई है, क्योंकि यह एसक्यूएल के माध्यम से काम करने के लिए अपने स्वयं के अनुक्रमित और दृष्टिकोण के साथ एक और क्षेत्र है। इसके अलावा, SqlListType और SqlListDelimiter जैसे गुणों के उपयोग के उदाहरणों को छोड़ दिया गया था , लेकिन एक जिज्ञासु पाठक, मुझे आशा है, स्वतंत्र रूप से उन्हें कार्रवाई में आज़मा सकते हैं।

उपयोगी लिंक:

गैर परमाणु गुण को अनुक्रमणित करना

परिचय

सीमांकित स्ट्रिंग

संवेदनशील डेटा छिपाना

संवेदनशील डेटा छिपाना (जारी)

दिनांक (समय, आदि)

सरल सूची

संग्रह सूची

संग्रह संग्रह

निष्कर्ष में

More articles: