NoSQL डेटा के लिए एसक्यूएल एक्सेस: कैच में SQL प्रक्रिया को डायनामिक रूप से परिभाषित मेटाडेटा को परिभाषित करने के साथ लागू करना

जैसा कि आप जानते हैं, Caché का उपयोग एक संबंधपरक DBMS के रूप में किया जा सकता है, जिसमें JDBC / ODBC ड्राइवर शामिल होते हैं , जिसमें मनमाने ढंग से SQL प्रश्नों को निष्पादित करने और SQL प्रक्रियाओं को लागू करने की क्षमता होती है।
यह भी ज्ञात है कि कैच का सारा डेटा बहुआयामी विरल सरणियों - ग्लोबल्स में संग्रहित है। यह व्यक्तिगत SQL प्रक्रिया के अपर्याप्त प्रदर्शन के मामले में, मानक CachéSQL इंजन का उपयोग नहीं करने की अनुमति देता है, लेकिन सर्वर व्यवसाय तर्क Caché ObjectScript (COS) में इसके निष्पादन कोड को फिर से लिखना, जिसमें आप SQL प्रक्रिया को निष्पादित करने के लिए इष्टतम एल्गोरिथ्म को लागू कर सकते हैं, अक्सर अधिक इष्टतम का उपयोग करते हुए। NoSQL डेटा स्ट्रक्चर्स (ग्लोबल्स)।
हालांकि, कैच मानक कक्षा के पुस्तकालय में, एक सीमा है: एसक्यूएल प्रक्रियाओं के लिए जिसमें सीओएस कोड का उपयोग करके चयन किया जाता है, संकलन चरण में लौटे फ़ील्ड के सेट को निर्धारित करना आवश्यक है - i.e. SQL प्रक्रिया के लिए मेटाडेटा को गतिशील रूप से सेट करने का कोई तरीका नहीं है जो NoSQL संरचनाओं के साथ काम करता है।

कट के तहत इस प्रतिबंध को कैसे हटाया जाए।

Caché में SQL प्रक्रिया के साथ कार्य करना

JDBC / ODBC से गैर-संबंधपरक Caché संरचनाओं के माध्यम से क्वेरी निम्नानुसार संग्रहीत प्रक्रियाओं का उपयोग करके कार्यान्वित की जाती हैं:



इस तरह की संग्रहित प्रक्रिया एक या अधिक रिकॉर्ड्स (परिणाम), या स्केलर मान सेट कर सकती है।

एक उदाहरण के रूप में, हम संग्रहीत प्रक्रिया का नमूना कहेंगे। ODBC के साथ काम करने के लिए एक उपकरण का उपयोग करके नमूने क्षेत्र से S.S__ample_y_Name:



SQL प्रक्रिया के हस्ताक्षर से, यह ज्ञात नहीं है कि यह क्या लौटेगा; यह केवल प्रक्रिया के निष्पादन के दौरान ज्ञात हो जाता है।

कैच आपको वर्ग विधियों को संग्रहीत SQL प्रक्रियाओं को बनाने की अनुमति देता है जो या तो एक मान लौटाते हैं या एक ResultSet लौटाते हैं। उदाहरण के लिए, एक संग्रहीत प्रक्रिया घोषित की जाती है जो एक परिणाम देता है:

ClassMethod SomeSqlProc ( p1 As Integer = 0 ) [ ReturnResultsets , SqlProc ]

इस निर्माण का उपयोग करते हुए, आप Caché ObjectScript कोड लिख सकते हैं जिसे ODBC के माध्यम से एक संग्रहीत प्रक्रिया के रूप में कहा जा सकता है जो कि ResultSet (या अधिक) लौटाएगा।

Caché के पास दो मानक तरीके हैं, जो NoSQL डेटा के परिणाम के रूप में लौटाते हैं:

पहला तरीका। कक्षा के प्रश्नों का उपयोग करना

विस्तार से यहाँ देखें

यह विधि आपको Caché ObjectScript में डेटा जनरेट करने के लिए मनमाना कोड लिखने की अनुमति देती है, लेकिन लौटाए गए ResultSet का मेटाडेटा% Query के आधार पर कंपाइलर द्वारा बनाया जाता है। # ROWSPEC पैरामीटर, अर्थात्। संकलन के समय।

दूसरा तरीका। % SQL.CustomResultSet का उपयोग करना

% SQL.CustomResultSet के बारे में अधिक पढ़ें, एक उदाहरण कार्यान्वयन।

विधि पिछले एक के समान है, लेकिन मेटाडेटा इनहेरिटेंस क्लास% SQL.CustomResultSet की परिभाषा के आधार पर उत्पन्न होता है - पिछले मामले में, संकलन के दौरान।

नोट: आप उसी तरह SQL डेटा प्राप्त कर सकते हैं:


इस स्थिति में, मेटाडेटा रनटाइम पर उत्पन्न होता है, लेकिन डेटा केवल SQL से प्राप्त किया जा सकता है।

इस प्रकार, यदि हम रनटाइम में परिणाम मेटाडेटा उत्पन्न करना चाहते हैं और डेटा उत्पन्न करने के लिए Caché ObjectScript का उपयोग करते हैं, तो यह स्पष्ट है कि Caché की आपूर्ति में उपलब्ध धन पर्याप्त नहीं है।

समस्या हल करना

समस्या के 4 समाधान हैं:

• रन टाइम के दौरान, उत्पन्न-पर-उड़ान ROWSPEC के साथ वर्ग क्वेरी युक्त एक क्लास बनाएं;
• चलाने के समय में, फ़ील्ड से आवश्यक सेट के साथ% SQL.CustomResultSet से विरासत में मिला एक वर्ग बनाएं;
• % SQL.CustomResultSet के विकल्प को लागू करें, जो कॉल मापदंडों के आधार पर रन टाइम पर मेटाडेटा उत्पन्न करेगा, और संकलन समय पर नहीं;
• % Query के लिए एक विकल्प लागू करें, जो रनटाइम पर मेटाडेटा उत्पन्न करेगा।

मैंने आखिरी तरीका चुना - यह मुझे सबसे सुंदर लग रहा था (आगे देखते हुए, मैं अभी भी बैसाखी के बिना नहीं कर सकता)।

सबसे पहले, User.Query वर्ग बनाएं और इसे% Query से वारिस करें - ताकि सभी% क्वेरी के कार्यान्वयन को अधिलेखित न किया जा सके। % Query का उपयोग करते समय, उपभोक्ता (% ResultSet) दो वर्ग विधियों के माध्यम से मेटाडेटा का अनुरोध करता है: GetInfo और GetODBCetfo। उत्तराधिकारी वर्ग में, इन विधियों के वैकल्पिक कार्यान्वयन को लिखना आवश्यक है। कई प्रयोगों के माध्यम से (यह जनरेटर को समझने की तुलना में आसान है) मुझे गेटइंफो मापदंडों (.colinfo, .parmininfo, .idinfo, .qHandle, extoption, .extinfo) के बारे में पता चला।

• colinfo - इसमें $ lb ($ lb (नाम, टाइपिड, कैप्शन), ...) जोड़ें, जहाँ नाम फ़ील्ड का आंतरिक नाम है, टाइपिड Caché प्रकार का पहचानकर्ता है, कैप्शन कॉलम शीर्षक है;
• parminfo - इसमें $ lb जोड़ें ($ lb (नाम, टाइपिड), ...) - पिछले पैराग्राफ में एक ही प्रारूप, लेकिन एक शीर्षक के बिना;
• idinfo - आप इसमें $ lb (0,0) जोड़ सकते हैं (सिस्टम की जानकारी, सूचकांक से संबंधित कुछ, हम मानते हैं कि यह नहीं है);
• qHandle - प्रोग्रामर द्वारा गठित बहुआयामी स्थानीय सरणी;
• बाकी को अकेला छोड़ दिया जा सकता है (यह ऑब्जेक्ट संदर्भ के लिए, वैकल्पिक रूप से वस्तुओं की अनुपस्थिति में लगता है)।

GetODBCInfo के साथ सब कुछ समान है, कुछ और क्षेत्र हैं, और परिणाम को एकल-स्तरीय सूचियों में जोड़ा जाना चाहिए, लेकिन सामान्य तौर पर यह समान है।

GetInfo और GetODBCInfo से सही मेटाडेटा वापस करने के लिए, मुझे कई स्पष्ट चालें नहीं मिलनी चाहिए, जो मुख्य रूप से नीचे दी गई हैं:

• Caché (टाइपिड) प्रकार के पहचानकर्ता को प्राप्त करने के लिए, आपको $ $ externaltype ^% apiOLE (ctype, .type, "0") पर कॉल करने की आवश्यकता है, जहां Caché में ctype नाम है (उदाहरण के लिए,% स्ट्रिंग [% स्ट्रिंग वर्ग के लिए संदर्भ])। फ़ंक्शन पहचानकर्ता को प्रकार में डाल देगा।
  पहचानकर्ता को पहचानने से पहले, टाइप (ctype) को सामान्यीकृत करने की आवश्यकता होती है (Package.Class पर डाली जाती है), यह मैक्रो $$$ NormalizeClassname (ctype) के साथ किया जा सकता है
  GetODBCInfo के लिए जानकारी प्राप्त करने के लिए, आपको कॉल करना होगा
  GetODBCColInfo ^% ourODBC ( ctype ; ColParms ।, ColODBCTNName ; ColODBCType ।, MaxLen ।, परिशुद्धता , स्केल ) ।
  जहां Caché में ctype एक प्रकार का नाम है, ज़रूरी नहीं कि इसे सामान्यीकृत किया जाए।
  
  चूंकि हम गतिशील रूप से मेटाडेटा (क्षेत्र के नाम और प्रकार) उत्पन्न करना चाहते हैं, हमें उनके बारे में हमारी क्वेरी को जानकारी देने की आवश्यकता है। ऐसा करने का सबसे स्पष्ट तरीका qHandle पैरामीटर के साथ है। इसके माध्यम से, हम ResultSet के बारे में जानकारी संचारित करेंगे। ऐसा करने के लिए, प्रोग्रामर, क्वेरी निष्पादन (QueryExecute) के अपने कार्यान्वयन में, आवश्यक फ़ील्ड के लिए ROWSPEC लाइन और औपचारिक अनुरोध मापदंडों की रेखा (ROWSPEC के समान) बनाने चाहिए और उन्हें क्रमशः qHandle ("rowspec") और qHandle ("params") में डालें।
  
  परिणामस्वरूप, हम User.Query वर्ग के निम्नलिखित कार्यान्वयन प्राप्त करते हैं:
  
  
  कक्षा उपयोगकर्ता

  वर्ग User.Query% क्वेरी बढ़ाता है
  {
  
  ClassMethod GetInfo ( ByRef colinfo as % List , ByRef parminfo as % List , ByRef idinfo as % List , ByRef qHandle%% के रूप में , extoption as % Intex = 0 , ByRef extinfo as % List ) % की सूची के रूप में
  {
  अगर $ मिलता है ( qHandle ( "colinfo" )) = ""
  {
  सेट रोस्पेक = क्यूहैंडल ( "रोस्पेक" )
  सेटहैंडल ( "कॉलिनफो" ) = ""
  सेट sc = $$$ ठीक है
  i = 1: 1: $ लंबाई ( रोवेसेक , "," )
  {
  सेट कर्ल = $ टुकड़ा ( रोवेसेक , "," , आई )
  सेट नाम = "p" _ i
  ctype = $$$ normalizeClassname ( $ select ( $ piece ( col , ":" , 2) '' = "" : $ piece ( col , ": 2), 1: "% String " ))
  सेट sc = $$ आउटराइप ^% एपीओएलई (ctype; टाइप , "0"।
  छोड़ दिया : $ $ $ ISERR ( sc )
  सेट कैप्शन = $ टुकड़ा ( कॉल , ":" , 1)
  qHandle ( "colinfo" ) = qHandle ( "कॉलिनफ़ो" ) _ $ सूची बनाना ( $ सूची बनाना ( नाम , प्रकार , शीर्षक ))
  }
  छोड़ दिया : $ $ $ ISERR ( sc ) sc
  
  }
  अगर $ मिलता है ( qHandle ( "parminfo" )) = ""
  {
  सेट परम = qHandle ( " परम " )
  सेटहैंडल ( "पर्मींफो" ) = ""
  सेट sc = $$$ ठीक है
  i = 1: 1: $ लंबाई ( परमेस , "," )
  {
  सेट कर्ल = $ टुकड़ा ( परम , "," , i )
  सेट नाम = "p" _ i
  ctype = $$$ normalizeClassname ( $ select ( $ piece ( col , ":" , 2) '' = "" : $ piece ( col , ": 2), 1: "% String " ))
  सेट sc = $$ आउटराइप ^% एपीओएलई (ctype; टाइप , "0"।
  छोड़ दिया : $ $ $ ISERR ( sc )
  सेट qHandle ( "parminfo" ) = qHandle ( "parminfo" ) _ $ सूची बनाना ( $ सूची बनाना ( नाम , प्रकार ))
  }
  छोड़ दिया : $ $ $ ISERR ( sc ) sc
  }
  सेट कॉलिनफो = क्यूहैंडल ( "कॉलिनफो" )
  सेट parminfo = qHandle ( "parminfo" )
  सेट idinfo = $ सूची निर्माण (0,0)
  $ $ $ $ ठीक है
  }
  
  ClassMethod GetODBCInfo ( ByRef colinfo %% सूची , ByRef parminfo %% सूची , ByRef qHandle % Binary )
  { यदि $ मिलता है ( qHandle ( "colinfoodbc" )) = ""
  {
  सेट रोस्पेक = क्यूहैंडल ( "रोस्पेक" )
  सेटहैंडल ( "कॉलिनफूडबेक" ) = $ सूची निर्माण ( $ LENGTH ( रोवेसेक , "," ))
  i = 1: 1: $ लंबाई ( रोवेसेक , "," )
  {
  सेट कर्ल = $ टुकड़ा ( रोवेसेक , "," , आई )
  सेट cype = $ select ( $ piece ( col , ":" , 2) '= "" : $ piece ( col , ":" , 2), 1: "% String" )
  GetODBCColInfo ^% ourODBC ( ctype ; ColParms ,। ColODBCTypeName ; ColODBCType ।, MaxLen ।, परिशुद्धता , स्केल ) ।
  सेट ब्रास = "$ चार (0,0,0,0,0,0,0,0,0,0,0,0,0,0)"
  सेट नाम = $ टुकड़ा ( कॉल , ":" , 1)
  सेट qHandle ( "कॉलिनफूडबैंक" ) = qHandle ( "कॉलिनफूडबैंक" ) _ $ सूची ( नाम , colodBCType , परिशुद्धता , स्केल , 2, नाम , "क्वेरी" , "% लाइब्रेरी , " " , ब्रेस )
  }
  }
  अगर $ मिलता है ( qHandle ( "parminfoodbc" )) = ""
  {
  सेट परम = qHandle ( " परम " )
  सेटहैंडल ( "पार्मिनफॉर्बक" ) = $ सूची ( $ LENGTH ( परमेस , "," ))
  i = 1: 1: $ लंबाई ( रोवेसेक , "," )
  {
  सेट कर्ल = $ टुकड़ा ( परम , "," , i )
  सेट cype = $ select ( $ piece ( col , ":" , 2) '= "" : $ piece ( col , ":" , 2), 1: "% String" )
  GetODBCColInfo ^% ourODBC ( ctype ; ColParms ,। ColODBCTypeName ; ColODBCType ।, MaxLen ।, परिशुद्धता , स्केल ) ।
  सेट नाम = "p" _ i
  सेट qHandle ( "parminfoodbc" ) = qHandle ( "parminfoodbc" ) _ $ सूची ( colodBCType , परिशुद्धता , स्केल , 2, नाम , 1)
  }
  }
  सेट कॉलिनफो = क्यूहैंडल ( "कॉलिनफूडबीसी" )
  parminfo = qHandle ( "पार्मिनफ़ॉर्बक" ) सेट करें
  $ $ $ $ ठीक है
  }
  
  }
  
  
  
  

  User.Query वर्ग को कैसे लागू करें

  
  User.Query का उपयोग करना % Query का उपयोग करने के समान है, लेकिन आरंभीकरण के दौरान, आपको मेटाडेटा बनाने के लिए इसके बारे में जानकारी देने की आवश्यकता है।
  User.Query का उपयोग करने वाला एक वर्ग कुछ इस तरह दिखना चाहिए:
  
  
  कक्षा उपयोगकर्ता

  कक्षा उपयोगकर्ता।
  {
  
  उपयोगकर्ता के रूप में क्वेरी क्वेरी ( p1 As% Integer )
  {
  }
  
  ClassMethod QueryExecute ( ByRef qHandle % Binary , p1 As% Integer ) के रूप में% स्थिति
  {
  /// पूरी तैयारी करना
  , ...
  /// फॉर्म ROWSPEC
  s RowSpec = "ID:% पूर्णांक, दिनांक:% टाइमस्टैम्प, जानकारी:% स्ट्रिंग"
  
  s qHandle ( "rowspec" ) = RowSpec
  /// औपचारिक मापदंडों की एक पंक्ति, निरंतर
  s qHandle ( " परम " ) = "p1:% पूर्णांक"
  
  q $ $ $ ओके
  }
  
  ClassMethod QueryClose ( ByRef qHandle के रूप में% बाइनरी ) % स्थिति [ स्थान पर = QueryExute]
  {
  $ $ $ $ ठीक है
  }
  
  ClassMethod QueryFetch ( ByRef qHandle के रूप में% बाइनरी , ByRef Row %% सूची , ByRef के रूप में% Integer = 0 ) % के रूप में स्थिति [ स्थान = बाद = QueryExecute]
  {
  /// क्लास क्वेरीज़ डॉक्यूमेंटेशन में बताए अनुसार एक रेगुलर QueryFetch लिखें
  }
  }
  
  /// संग्रहीत कार्यविधि का कोड जो User.Query को कॉल करता है:
  क्लासमेथ डायनेमिकप्रोक ( p1 As% Integer = 0 ) [ ReturnResultsets , SqlProc ]
  {
  अगर ' $ isobject ( $ Get ( % sqlcontext )) { सेट % sqlcontext = ## वर्ग ( % ProcedureContext )। % नया () }
  क्वेरी = ## वर्ग ( % परिणाम ) सेट करें । % नया ( "User.DynamicQuery: क्वेरी" )
  प्रश्न करें । निष्पादित ( p1 )
  % sqlcontext करें । AddResultSet ( क्वेरी )
  }
  
  
  
  

  उदाहरण का उपयोग करें

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

  कक्षा उपयोगकर्ता। संसाधन [ सार ]
  {
  
  उपयोगकर्ता के रूप में क्वेरी NoSQL ( ColCount As% Integer )
  {
  }
  
  ClassMethod NoSQLExecute ( ByRef qHandle % Binary , ColCount As% Integer ) के रूप में% स्थिति
  {
  सेट RowSpec = "Id:% Integer"
  ColNum = 1: 1: ColCount के लिए
  {
  सेट RowSpec = RowSpec _ ", p" _ colNum _ ":% Integer"
  }
  qHandle ( "rowspec" ) = RowSpec सेट करें
  qHandle ( "params" ) = "ColCount:% Integer" सेट करें
  
  मार ^ || मायडाटा (+ ## यह )
  रोन्नम के लिए = 1: 1: 100 {
  ColNum = 1: 1: ColCount के लिए
  {
  $ सूची सेट करें (^ || MyData (+ ## यह , पंक्तिनाम ), colNum ) = $ R (1000)
  }
  }
  
  qHandle ( "colcount" ) = ColCount सेट करें
  सेट qHandle ( "कर्सर" ) = $ ऑर्डर (^ || MyData (+ ## यह , "" ))
  
  $ $ $ $ ठीक है
  }
  
  ClassMethod NoSQLClose ( ByRef qHandle % बाइनरी ) % स्थिति के रूप में [ स्थान = बाद = NoSQLExecute]
  {
  मार ^ || मायडेटा (+ ## यह ), qHandle
  
  $ $ $ $ ठीक है
  }
  
  ClassMethod NoSQLFetch ( ByRef qHandle के रूप में% बाइनरी , ByRef Row के रूप में% सूची , ByRef के रूप में% Integer = 0 ) % Status [स्थान पर बाद में = NoSQLExecute]
  {
  अगर qHandle ( "कर्सर" ) = ""
  {
  सेट पंक्ति = "" , AtEnd = 1
  $ $ $ $ ठीक है
  }
  
  सेट पंक्तिनाम = qHandle ( "कर्सर" )
  सेट पंक्ति = $ सूची ( पंक्तिनाम ) _ ^ || मायडेटा (+ ## यह , पंक्तिनाम )
  
  सेटहैंडल ( "कर्सर" ) = $ ऑर्डर (^ || MyData (+ ## यह , पंक्तिनाम ))
  
  $ $ $ $ ठीक है
  }
  
  }
  
  
  
  हमारी क्वेरी कॉलम की संख्या स्वीकार करती है, और यादृच्छिक संख्याओं से भरे 100 रिकॉर्ड लौटाती है। अब प्रोसीजर क्लास लिखते हैं, जिसमें हमारी क्वेरी का उपयोग करके क्लास-स्टोर की गई प्रक्रिया विधि होगी।
  
  
  कक्षा उपयोगकर्ता। प्रक्रियाएं

  वर्ग User.Procedures% Persistent का विस्तार करता है
  {
  
  ClassMethod ProcNoSQL ( p1 As% Integer ) [ ReturnResultsets , SqlName = proc_nosql , SqlProc ]
  {
  अगर ' $ isobject ( $ Get ( % sqlcontext )) { सेट % sqlcontext = ## वर्ग ( % ProcedureContext )। % नया () }
  क्वेरी = ## वर्ग ( % परिणाम ) सेट करें । % नया ( "User.Queries: NoSQL" )
  प्रश्न करें । निष्पादित ( p1 )
  % sqlcontext करें । AddResultSet ( क्वेरी )
  }
  
  ClassMethod ProcSQL ( p1 As% String = "" ) [ ReturnResultsets , SqlName = proc_sql , SqlProc ]
  {
  sqltext सेट करें "" SELECT ID, Name, DOB, SSN "
  sqltext सेट करें = sqltext _ "FROM Sample.Person"
  sqltext = sqltext _ "WHERE (नाम% STARTSWITH '" _ p1 _ "") "
  sqltext = sqltext _ "ORDER BY नाम" सेट करें
  
  अगर ' $ isobject ( $ Get ( % sqlcontext )) { सेट % sqlcontext = ## वर्ग ( % ProcedureContext )। % नया () }
  क्वेरी = ## वर्ग ( % परिणाम ) सेट करें । % नया ( "% डायनेमिकविक्यू: एसक्यूएल" )
  प्रश्न करें । तैयार ( sqltext )
  प्रश्न करें । निष्पादित करें ()
  % sqlcontext करें । AddResultSet ( क्वेरी )
  }
  
  }
  
  
  
  अब बनाई गई SQL प्रक्रिया जो NoSQL क्वेरी को निष्पादित करती है उसे xDBC के माध्यम से बुलाया जा सकता है:
  
  
  
  

  निष्कर्ष

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