🤵🏽 👨‍🏭 👶🏼 SQL में लैम्ब्डा फंक्शन्स ... आइए सोचते हैं 🧓🏼 👩🏽‍⚕️ 👨🏼‍💻

लेख के बारे में क्या होगा, और इसलिए नाम का अर्थ है।

इसके अलावा, लेखक यह बताएगा कि यह उसके दृष्टिकोण से क्यों आवश्यक है, साथ ही यह भी बताएं कि SUBJ केवल एक फैशनेबल तकनीक नहीं है, बल्कि "एक दोगुना आवश्यक व्यवसाय - दोनों सुखद और उपयोगी है।"

यह देखना हमेशा दिलचस्प होता है कि कितने प्रतिभाशाली लोग कुछ करते हैं (एक प्रोग्रामिंग भाषा, क्यों नहीं), यह जानते हुए कि वे किस समस्या को हल कर रहे हैं और वे अपने लिए कौन से कार्य निर्धारित करते हैं। और उनकी रचना को खुद पर भी परखते हैं। विशाल समितियों की स्मारकीय कृतियों के साथ तुलना करने के लिए नहीं, जो ब्रह्मांड में सबसे आगे सद्भाव का रखरखाव करते हैं, जो समझते हैं कि कैसे।

तुलना करें, उदाहरण के लिए, फोरट्रान और पीएल / 1 का भाग्य। अब इस पीएल / 1 के बारे में कौन याद रखेगा।

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

भाषा टाइपलेस है ( यह पूरी तरह सच नहीं है ), इसका सिंटैक्स C के समान है, इसमें फ़िल्टरिंग क्षमताएं, साहचर्य सरणियाँ, स्ट्रीम स्टार्ट / एंड इवेंट्स, न्यूलाइन इवेंट ...

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

इस प्रक्रिया में, लेखक को काफी बार SQL + AWK बंडल का उपयोग करना पड़ता है, और इसीलिए। SQL अभी भी एक प्रारंभिक रूप से घोषित भाषा है जिसे डेटा प्रवाह को नियंत्रित करने के लिए डिज़ाइन किया गया है। यह समग्र कार्यों के रूप में क्वेरी निष्पादन के संदर्भ में काम करने के लिए बहुत सीमित अवसर देता है।

उदाहरण के लिए, SQL का उपयोग करके दो-आयामी हिस्टोग्राम का निर्माण कैसे करें?

--   100 x 100 SELECT count(), round(x, -2) AS cx, round(y, -2) AS cy FROM samples GROUP BY cx, xy

लेकिन ग्रुप बी का उपयोग करते हुए कहने दें कि, यदि आपके पास लाखों (या और भी अधिक) पंक्तियाँ हैं, तो यह एक सस्ता आनंद नहीं है।

UPD: टिप्पणियों में उन्होंने मुझे सही किया कि यह पूरी तरह सच नहीं है (या बिल्कुल नहीं)

SQL प्रोसेसर समूहीकरण कसौटी के अनुसार हैश के निर्माण की प्रक्रिया में समग्र कार्य करने की क्षमता रखता है। इसके लिए यह आवश्यक है कि मेमोरी में हैश मैप को रखने के लिए पर्याप्त मात्रा में मुफ्त मेमोरी हो।

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

मामले में जब समूहों की संख्या अग्रिम में या बहुत बड़ी है, तो SQL प्रोसेसर एक अस्थायी सूचकांक बनाने और एक दूसरे पास में इसके माध्यम से चलाने के लिए मजबूर है।

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

सारांश: SQL प्रोसेसर सॉर्ट करने के लिए रिसॉर्ट करता है जब वह ग्रुप BY के बाद समूहों की संख्या का अनुमान नहीं लगा सकता है। हालाँकि, परिकलित मूल्यों द्वारा समूहीकरण (अक्सर) केवल बहुत मामला है।

इसलिए, आपको कुछ करना होगा:

 psql -t -q -c 'select x, y from samples' | gawk -f mk_hist2d.awk

जहाँ mk_hist2d.awk सहयोगी सारणी में आँकड़े जमा करता है और काम पूरा होने पर प्रदर्शित करता है

 # mk_hist2d.awk { bucket[int($2*0.01), int($3*0.01)]+=$1; } END { for (i=0; i < 500; i++) for (j=0; j < 500; j++) { if ((i, j) in bucket) print i*100." "j*100." "bucket[i, j]; else print i*100." "j*100." 0"; } }

एक BUT है - सर्वर से काम करने वाली मशीन तक पूरा डेटा स्ट्रीम भेजा जाना चाहिए, और यह इतना सस्ता नहीं है।

क्या SQL क्वेरी के निष्पादन के दौरान आंकड़ों को संचित करने के लिए किसी भी तरह से उपयोगी के साथ सुखद संयोजन करना संभव है, लेकिन सॉर्टिंग का सहारा लिए बिना? हां, उदाहरण के लिए, कस्टम कुल कार्यों का उपयोग करना।

कस्टम सकल कार्य

सबज अलग-अलग प्रणालियों में मौजूद है, हर जगह यह अपने तरीके से किया जाता है।

PostgreSQL। प्रलेखन यहाँ है । अधिक जानकारी यहाँ ।
यह वह जगह है जहाँ अधिकतम खाता शेष की गणना की जाती है।
और यह एक उदाहरण है जो गणना करता है कि बूलियन कॉलम में क्या अधिक है - सच या गलत।

ऐसा दिखता है -
```
 CREATE AGGREGATE mode(boolean) ( SFUNC = mode_bool_state, STYPE = INT[], FINALFUNC = mode_bool_final, INITCOND = '{0,0}' ); 
```
यहां SFUNC एक फ़ंक्शन है जिसे स्ट्रीम में प्रत्येक पंक्ति के लिए कहा जाता है,
इसमें पहला तर्क STYPE का है ।

FINALFUNC का उपयोग गणनाओं को अंतिम रूप देने के लिए किया जाता है और कुल का मान लौटाता है।
INITCOND - आंतरिक राज्य ( STYPE ) के प्रारंभिक मूल्य का आरंभीकरण, पहले तर्क के रूप में पारित किया गया।
यह देखते हुए कि फ़ंक्शन को C में लिखा जा सकता है (जिसका अर्थ है कि आंतरिक स्थिति के लिए आप उस मेमोरी का उपयोग कर सकते हैं जो अनुरोध को बंद करने पर स्वचालित रूप से मुक्त हो जाती है), यह एक बहुत शक्तिशाली उपकरण है। इसके उपयोग के दायरे के बाहर, एक को अभी भी जाने में सक्षम होना चाहिए।
MS SQL
पहले (2000), अनुरोध से पहले, इस ऑब्जेक्ट का उपयोग करके एकत्रीकरण करने के लिए, एक ActiveX ऑब्जेक्ट बनाना आवश्यक था।
अब (2016+) यह सीएलआर वातावरण में किया जाता है। आपको एक कस्टम फ़ंक्शन बनाना होगा, एक असेंबली बनाना और पंजीकरण करना होगा। फिर आप एक एग्रीगेट बना सकते हैं।
ज्यामितीय माध्य की गणना करने का एक उदाहरण , साथ ही साथ तार का विलय: अतिरिक्त मापदंडों और एक उपयोगकर्ता-परिभाषित प्रकार के साथ एक मध्यवर्ती राज्य के भंडारण के लिए।
ओरेकल।
ओरेकल में, यह ODCIAggregate Data Cartridge (इंटरफ़ेस) का उपयोग करके किया जाता है।
अपना स्वयं का समुच्चय बनाने के लिए, आपको एक कस्टम प्रकार लिखना होगा जो 4 विधियों को लागू करता है
- आरंभीकरण (ODCIAggregateInitialize), स्थिर, वांछित प्रकार का एक उदाहरण बनाना चाहिए और पैरामीटर के माध्यम से वापस आना चाहिए
- पुनरावृत्तियों (ODCIAggregateIterate), डेटा की प्रत्येक पंक्ति पर कहा जाता है
- मर्ज (ODCIAggregateMerge), समानांतर में निष्पादित समुच्चय को मर्ज करने के लिए उपयोग किया जाता है
- खत्म (ODCIAggregateTerminate) - परिणाम आउटपुट
उदाहरण: 1 , 2 , 3 , 4 ।
डीबी 2।
DB2 में कस्टम समुच्चय का उपयोग करने का कोई स्पष्ट तरीका नहीं है।
लेकिन आप एक मानक फ़ंक्शन (यद्यपि मैक्स) को उपयोगकर्ता परिभाषित प्रकार (जावा में) में पर्ची कर सकते हैं और सिस्टम को फॉर्म के प्रश्नों को निष्पादित कर सकते हैं
```
 CREATE TYPE Complex AS ( real DOUBLE, i DOUBLE ) … CREATE TABLE complexNumbers ( id INTEGER NOT NULL PRIMARY KEY, number Complex ) … SELECT sum..real, sum..i FROM ( SELECT GetAggrResult(MAX(BuildComplexSum(number))) FROM complexNumbers ) AS t(sum) 
```

इन सभी प्रणालियों में क्या उल्लेखनीय है?

एक तरह से या किसी अन्य, आपको डेटाबेस में कुछ ऑब्जेक्ट बनाने की आवश्यकता होगी। यह AGGREGATE या TYPE हो। कम से कम, उचित अधिकारों की आवश्यकता है। और बस अपने घुटने पर कुछ संख्या जोड़ना चाहते हैं।
आपको किसी अन्य भाषा में कुछ लिखना होगा, चाहे वह C, C # या Java हो।
सिस्टम में जो लिखा गया है उसे एकीकृत करने के लिए, फिर से, अधिकारों की आवश्यकता होती है। लेकिन सब मुझे चाहिए ...
आरंभिक कठिनाई। मान लीजिए कि आप विभिन्न टोकरी आकारों के साथ हिस्टोग्राम पढ़ना चाहते हैं। ऐसा लगता है कि यह आसान है - हम समग्र (PostgreSQL) और पूरे व्यवसाय की घोषणा करते समय वांछित INITCOND को इंगित करेंगे। लेकिन फिर टोकरी के प्रत्येक आकार के लिए आपको अपने स्वयं के कुल की आवश्यकता होगी, और इसके लिए फिर से अधिकारों की आवश्यकता है।

यहां आप एक गंदी चाल का सहारा ले सकते हैं और यूनियन प्रोसेसर को इनिशियलाइज़ेशन लाइन (आगे) और डेटा से खिसका सकते हैं, कंस्ट्रक्टर में संदर्भ का निर्माण नहीं कर सकते हैं, लेकिन जब पहली लाइन प्राप्त होती है।
फिर भी, वर्णित सीमाओं के साथ, कस्टम समुच्चय आपको कुछ भी गणना करने की अनुमति देते हैं।
यह महत्वपूर्ण है कि समुच्चय को समानांतर किया जा सकता है , कम से कम PostgreSQL और Oracle (एंटरप्राइज़ संस्करण) ऐसा कर सकते हैं। इसके लिए, सच्चाई को सीखना होगा कि मध्यवर्ती राज्यों को क्रमबद्ध / deserialize कैसे करें और उन्हें विभिन्न धाराओं से प्राप्त फ्रीज भी करें।

विंडो फ़ंक्शन

SQL: 2003 मानक में विंडो फ़ंक्शंस दिखाई दिए। फिलहाल, वे उपरोक्त सभी प्रणालियों द्वारा समर्थित हैं। संक्षेप में, विंडो फ़ंक्शंस इकाइयों के साथ काम का एक विस्तार है। और, ज़ाहिर है, कस्टम कुल कार्य भी एक विंडो संदर्भ में काम करते हैं।

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

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

बड़े झटके

ओवर ()
खिड़की पूरे परिणाम है। मान लें कि नमूनों के रिटर्न से क्वेरी ' सेलेक्ट काउंट (1) 169 है। इस मामले में,' सेम्पल्स से ' (1) ओवर () का चयन करें , हमें एक कॉलम मिलता है, जो 169 बार 169 बार लिखा गया है।
कभी (विभाजन द्वारा)
यह GROUP BY का एक एनालॉग है, प्रत्येक मूल्यों के संयोजन के लिए एक विंडो बनाई जाती है जिसमें समग्र कार्य किए जाते हैं। मान लीजिए कि नमूने तालिका में एक पूर्णांक कॉलम वैल है, डेटा संख्या 1 से 169 तक है।
फिर क्वेरी ' सेलेक्ट काउंट (1) ओवर (पार्टीशन (12 + वैल) / 13) सैंपल से ' एक कॉलम लौटाएगा, जिसमें वैल्यू 13 बार 169 लिखी गई है।
OVER (आदेश द्वारा)
पार्टिशन बाय के साथ जोड़ा जा सकता है, आपको कर्सर के दौरान विंडो के आकार को गतिशील रूप से बदलने की अनुमति देता है, इस मामले में, विंडो समूह की शुरुआत से वर्तमान कर्सर स्थिति तक फैली हुई है। नतीजतन, समूह के लिए, यह समग्र कॉलम में समान मूल्य नहीं देता है, लेकिन इसका अपना है। संचयी मात्रा की गणना के लिए सुविधाजनक है। क्वेरी परिणाम
'सैंपल से वैल (ओवर) (वैल द्वारा आदेश) ' एक कॉलम होगा जिसमें nth तत्व में 1 से n तक प्राकृतिक संख्याओं का योग होगा।
OVER (ROWS)
आपको विंडो फ़्रेम को परिभाषित करने की अनुमति देता है, जो कर्सर की स्थिति या ORDER BY रेंज की शुरुआत / अंत से शुरू होता है।

उदाहरण के लिए, ' ... ROWS 1 PRECEDING ... ' का अर्थ है कि विंडो में वर्तमान लाइन और 1 इससे पहले है। A ... ... ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING ... '- विंडो में कर्सर के तुरंत बाद दो लाइनें होती हैं।

इस मोड में CURRENT ROW वर्तमान कर्सर स्थिति को इंगित करता है। उदाहरण के लिए, ' ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING ' का मतलब है वर्तमान लाइन से लेकर रेंज के अंत तक।
ओवर (रेंज)
उस CURRENT ROW में ROWS से भिन्न का अर्थ यहाँ विंडो की शुरुआत के रूप में ORDER BY से रेंज की शुरुआत है, और विंडो के अंत के रूप में - ORDER BY रेंज की अंतिम पंक्ति।

अलग-अलग सिस्टम पर विंडो फ़ंक्शंस का उपयोग करने का सिंटैक्स थोड़ा अलग है।

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

रिकॉर्ड-रिटर्निंग फ़ंक्शंस

कुल / विंडो फ़ंक्शन के आउटपुट में, प्रत्येक परिणामी पंक्ति आने वाली डेटा स्ट्रीम से पंक्तियों की एक निश्चित सीमा से मेल खाती है। जीवन में, ऐसा पत्राचार हमेशा मौजूद नहीं होता है।

उदाहरण के लिए, एक सहसंयोजक मैट्रिक्स 10X10 का निर्माण करना आवश्यक है (इसके लिए , इसे 672X672 लगेगा)। यह एक पास में किया जा सकता है, इसके लिए हम 10 संख्यात्मक मापदंडों के साथ हमारे द्वारा लिखित कुल फ़ंक्शन को निष्पादित करते हैं। उसके काम का परिणाम 10 मानों की 10 पंक्तियों का एक रिकॉर्ड है, प्रत्येक मैट्रिक्स तत्व इनपुट स्ट्रीम की सभी पंक्तियों को संदर्भित करता है (कोई फर्क नहीं पड़ता कि कितने हैं)।

हम कह सकते हैं - तो क्या, PostgreSQl में, उदाहरण के लिए, आप एक फ़ंक्शन से दो आयामी सरणी वापस कर सकते हैं (Ex: 'ARRAY [[1,2], [3,4]')। या बस मैट्रिक्स को एक पंक्ति में क्रमबद्ध करें।

यह अच्छा है, लेकिन इस दृष्टिकोण के लिए स्वीकार्य रूपरेखा के भीतर परिणाम का आकार रखना हमेशा संभव नहीं होता है।

गीतात्मक विषयांतर

उदाहरण के लिए, हमारा काम ज्यामिति को सामान्य बनाना है।

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

आप निश्चित रूप से, कह सकते हैं कि समस्या दूर की कौड़ी है, कि कोई भी ऐसा नहीं करता है, DBMS में जियोमेट्री को एक विशेष तरीके से संग्रहीत किया जाता है, जियोमेट्री के प्रसंस्करण के लिए विशेष कार्यक्रम हैं, ...

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

जैसे ही ज्यामिति बूँद का औसत आकार पृष्ठ के आकार से अधिक हो जाता है, सीधे अंकों के साथ काम करना अधिक लाभदायक हो जाता है। यदि अंकों के प्रवाह के साथ काम करने का एक भौतिक अवसर था, तो शायद इतिहास का पहिया फिर से बदल जाएगा।

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

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

विकल्प क्या हैं?

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

A.4 के बारे में अधिक जानकारी। इसके लिए दो तंत्र हैं - अस्थायी टेबल और पाइपलाइन कार्य।

कन्वेयर कार्य करता है।
यह तंत्र ओरेकल (9i, 2001 से शुरू) में दिखाई दिया और उस फ़ंक्शन को अनुमति देता है जो डेटा को जमा नहीं करने के लिए रिकॉर्डसेट लौटाता है, लेकिन इसे आवश्यकतानुसार गणना करने के लिए (स्टडआउट के सिंक्रनाइज़ेशन के साथ और पाइप के माध्यम से जुड़ी दो प्रक्रियाओं के स्टैनिन के अनुरूप)।
यानी इस फ़ंक्शन से बाहर निकलने से पहले पाइपलाइन किए गए कार्यों के परिणाम संसाधित होने शुरू हो सकते हैं। ऐसा करने के लिए, यह फ़ंक्शन की परिभाषा में कहने के लिए पर्याप्त है
```
  FUNCTION f_trans(p refcur_t) RETURN outrecset PIPELINED IS … 
```
और शरीर में परिणाम पंक्तियों को पंजीकृत करें
```
 LOOP … out_rec.var_char1 := in_rec.email; out_rec.var_char2 := in_rec.phone_number; PIPE ROW(out_rec); … END LOOP; 
```
नतीजतन, हमारे पास है
```
 SELECT * FROM TABLE( refcur_pkg.f_trans( CURSOR(SELECT * FROM employees WHERE department_id = 60))); 
```
जब पाइपलाइन कार्य होते हैं तो कस्टम समुच्चय की आवश्यकता नहीं होती है।

ब्रावो, ओरेकल!

इतना समय पहले नहीं (2014), पाइपलाइन कार्य भी DB2 (IBM i 7.1 TR9, i 7.2 TR1) में दिखाई दिए ।
अस्थायी टेबल।
शुरू करने के लिए, ऐसा लगता है कि न तो MS SQL और न ही PostgreSQL एक कुल फ़ंक्शन से एक कर्सर वापस कर सकते हैं।

ठीक है, चलो, पाइपलाइन कार्यों के अनुरूप, कर्सर को एक पैरामीटर के रूप में प्राप्त करें, इसे संसाधित करें, इसे एक अस्थायी तालिका में जोड़ें और कर्सर को इसे वापस लौटाएं।

हालाँकि, MS SQL में कर्सर को किसी पैरामीटर द्वारा संग्रहित प्रक्रिया में पारित करना संभव नहीं है , केवल प्रक्रिया में एक कर्सर बनाना और आउटपुट के माध्यम से पैरामीटर को वापस करना संभव है। वही PostgreSQL के लिए कहा जा सकता है।

ठीक है, सब ठीक है, बस कर्सर खोलें, इसे घटाएं, मूल्यों को संसाधित करें, परिणाम की गणना करें, इसे अस्थायी तालिका में जोड़ें और कर्सर को प्रस्तुत करें।

या और भी सरल, हम क्वेरी परिणामों को एक अस्थायी तालिका में जोड़ते हैं, इसे संसाधित करते हैं और कर्सर के माध्यम से परिणामों को किसी अन्य अस्थायी तालिका में वापस करते हैं।

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

इसलिए, रिकॉर्ड लौटाने वाले कार्यों के साथ एक प्रश्न पर विचार करने के बाद, हम निष्कर्ष पर आते हैं:

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

और क्या

वास्तव में, यदि हमारे पास पहले से ही समस्याओं को हल करने का अवसर है, तो लेखक को और क्या चाहिए?
दरअसल, ट्यूरिंग मशीन किसी भी चीज़ की गणना कर सकती है, बस यह बहुत तेज़ नहीं है और बहुत सुविधाजनक भी नहीं है।

हम निम्नानुसार आवश्यकताओं को तैयार करते हैं:

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

एक बार, लेखक ने एक ऐसा ऑपरेटर बनाया जो टीटीएम / ट्यूटोरियल डी के कार्यान्वित सबसेट के स्व-निर्मित प्रोसेसर का विस्तार करता है । अब उसी विचार को SQL के लिए प्रस्तावित किया जा रहा है।

यह चेतावनी के लायक है, यहां एसक्यूएल समाप्त होता है और सुधार शुरू होता है। वाक्यविन्यास को छोड़ दिया जाता है क्योंकि यह मूल में था, अंत में, वाक्यविन्यास चीनी कुछ भी हो सकता है, यह सार को नहीं बदलता है।

तो, चबा ऑपरेटर के होते हैं

एक हेडर जिसमें आउटपुट फ़ील्ड्स और उनके प्रकारों की एक सूची होती है।
प्रत्येक आउटपुट (और इनपुट) फ़ील्ड एक स्थानीय चर है।
Ex: "chew {" var1 "फ्लोट," var2 "पूर्णांक}" का अर्थ है कि आउटपुट स्ट्रीम में दो कॉलम होंगे - एक फ्लोटिंग पॉइंट और एक पूर्णांक
निकायों - घटनाओं की कॉलबैक की एक सूची, इस समय - धारा की शुरुआत, धारा का अंत, रेखा। सिंटैक्स द्वारा, फ़ंक्शन PL / SQL के करीब हैं। पूर्वनिर्धारित फ़ंक्शन __interrupt () PIPE का एक एनालॉग है, यह आउटपुट कॉलम के अनुरूप चर से मान लेता है और इसे आउटपुट स्ट्रीम में रखता है। यदि आउटपुट स्ट्रीम का बफर ओवरफ्लो हो जाता है, तो हैंडलर का काम रुक जाएगा और स्ट्रीम के प्राप्त पक्ष का काम शुरू हो जाएगा।
Ex: "हुक" init "{var1: = 0; var2: = -1; } "

उदाहरण दिखाने का सबसे आसान तरीका।

कुल फ़ंक्शन SUM का एक एनालॉग।
```
 --  'select sum(val) from samples' -- select * from samples chew {“sum(val)” float} --    hook “init” { “sum(val)” := 0; --      } hook “row” { if (not isnull("val")) then "sum(val)" := "sum(val)" + "val"; end if; } hook “finit” { call __interrupt(); --  PIPE } 
```
यह भारी लग रहा है, लेकिन यह सिर्फ एक उदाहरण है,
कुछ संख्याओं को जोड़ने के लिए C प्रोग्राम लिखना आवश्यक नहीं है।

सुम + एवीजी

 --  'select sum(val), avg(val) from samples' -- select * from samples chew { “sum(val)” float, “avg(val)” float --       } hook “init” { “sum(val)” := 0; “avg(val)” := 0; var num integer; num := 0; --    ,       } hook “row” { if (not isnull("val")) then "sum(val)" := "sum(val)" + "val"; num := num + 1; end if; } hook “finit” { if (num > 0) then “avg(val)” := “sum(val)” / num; end if; call __interrupt(); }

यहां हम इस तथ्य पर ध्यान आकर्षित करते हैं कि योग केवल एक बार होता है।

सोम + ग्रुप द्वारा

 --  'select sum(val) from samples group by type' -- select * from --     ( samples val, type from samples order by type ) chew { “sum(val)” float } hook “init” { “sum(val)” := 0; var gtype integer; gtype := NULL; var num integer; --   num := 0; } hook “row” { if (gtype <> “type”) then __interrupt(); “gtype” := type; "sum(val)" := 0; num := 0; end if; if (not isnull("val")) then "sum(val)" := "sum(val)" + "val"; num := num + 1; end if; } hook “finit” { if (num > 0) then call __interrupt(); end if; }

ROW_NUMBER () OVER ()

 -- select row_number() over() as num, * from samples -- select * from samples chew { “num” integer, * --        --   '* except val1, ...valX',   TTM } hook “init” { num := 0; } hook “row” { num := num + 1; call __interrupt(); }

क्या यह एक उदाहरण प्रस्तुत करना संभव है जिस पर यह दृष्टिकोण सामान्य तरीके से मौलिक रूप से अप्राप्य होने वाले परिणाम देता है? हमारे पास हैं।

कभी-कभी ऐसा होता है कि डेटा लगभग सॉर्ट किया जाता है। वे पूरी तरह से क्रमबद्ध हो सकते हैं, लेकिन यह निश्चित रूप से ज्ञात नहीं है।

मान लीजिए कि ऊपर दिए गए उदाहरण में (डेटा स्ट्रीम कम्प्रेशन) डेटा विभिन्न स्रोतों से आता है और विभिन्न कारणों से, थोड़ा मिश्रित हो सकता है। यानीएक समय स्टैम्प T1 के साथ एक स्रोत से एक लाइन समय T2 के साथ किसी अन्य स्रोत से एक लाइन के बाद डेटाबेस में हो सकती है, जबकि T1 <2।

यहां तक कि अगर हम गारंटी देते हैं कि T1 और T2 के बीच का अंतर कभी भी एक निश्चित (कम) से अधिक नहीं होगा, तो हम यहां (पारंपरिक तरीके से) छांटे बिना नहीं कर सकते।

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

यहां एक बहुत महत्वपूर्ण बिंदु है।

केवल हम जानते हैं कि डेटा लगभग सॉर्ट किया गया है।

केवल हम उस स्थिरांक का मान जानते हैं।

यह निरंतरता केवल इस समस्या के लिए विशेषता है, और शायद केवल इस प्रयोग के लिए।
और हम इस हैक का उपयोग छँटाई से बचने के लिए अपनी जिम्मेदारी पर करते हैं।

कार्य का हमारा मानक ज्ञान SQL प्रोसेसर को बताने के लिए एक मानक तरीके से मौजूद नहीं है, और यह कल्पना करना मुश्किल है।

और लैम्ब्डा फंक्शंस का उपयोग करने से SQL प्रोसेसर को मजबूर करने का एक सार्वभौमिक तरीका मिलता है कि हमें ठीक उसी तरह की ज़रूरत है जो हमें इसकी आवश्यकता है।

निष्कर्ष

प्रस्तावित डिजाइन को लागू करने में बहुत मुश्किल नहीं लगती है।

किसी भी स्थिति में, मान्य PL / SQL के साथ।

यह विचार अपने आप में सरल और सहज है और भाषा में नई संस्थाओं को नहीं जोड़ता है।

यह एक एकल इकाई है, जो यदि आवश्यक हो, समग्र और विंडो फ़ंक्शन, ग्रुप बाय की जगह लेती है।

एक ऐसा तंत्र जो आपको बिना छांटे के करने की अनुमति देता है जहां पारंपरिक SQL प्रोसेसर के साथ कोई रास्ता नहीं है।

लेकिन सबसे महत्वपूर्ण बात, यह एक ऐसा तंत्र है जो आपको डेटा के साथ सबसे जरूरी तरीके से जो कुछ भी करने की स्वतंत्रता देता है।

पुनश्च: लेख की तैयारी में भाग लेने के लिए डोरोफी प्रोलेकोवस्की को धन्यवाद।

SQL में लैम्ब्डा फंक्शन्स ... आइए सोचते हैं

कस्टम सकल कार्य

विंडो फ़ंक्शन

रिकॉर्ड-रिटर्निंग फ़ंक्शंस

और क्या

निष्कर्ष

More articles: