👩‍👦 👩🏼‍🍳 ↔️ वास्तविक समय सेवा के उदाहरण पर क्यू और केडीबी + की विशेषताएं 🐆 🍦 ⛹🏼

केडीबी + क्या है, क्यू प्रोग्रामिंग भाषा, उनकी ताकत और कमजोरियां क्या हैं, मेरे पिछले लेख में और संक्षेप में परिचय में पाया जा सकता है। लेख में, हम क्यू पर एक सेवा को लागू करते हैं जो आने वाले डेटा स्ट्रीम को संसाधित करेगा और प्रति मिनट "वास्तविक समय" मोड में विभिन्न एकत्रित कार्यों की गणना करेगा (अर्थात, यह डेटा के अगले टुकड़े तक सब कुछ गिनने का प्रबंधन करेगा)। क्यू की मुख्य विशेषता यह है कि यह एक सदिश भाषा है जो आपको एकल वस्तुओं के साथ नहीं, बल्कि उनके सरणियों, सरणियों और अन्य जटिल वस्तुओं के साथ संचालित करने की अनुमति देती है। Q और उसके संबंधित K, J, APL जैसी भाषाएँ अपनी संक्षिप्तता के लिए प्रसिद्ध हैं। अक्सर एक प्रोग्राम जो एक परिचित भाषा में कोड के कई स्क्रीन को फैलाता है जैसे कि जावा उन पर कई लाइनों में लिखा जा सकता है। यह वास्तव में मैं इस लेख में प्रदर्शित करना चाहता हूं।

परिचय

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

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

समस्या का बयान

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

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

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

अलग कार्य

नीचे सूचीबद्ध आवश्यक कार्य हैं। मैंने उन्हें सेवा पर भार बढ़ाने के लिए जितना संभव हो उतना लिया:

उच्च - अधिकतम मूल्य - प्रति मिनट अधिकतम मूल्य।
कम - न्यूनतम मूल्य - प्रति मिनट न्यूनतम मूल्य।
FirstPrice - पहली कीमत - प्रति मिनट पहली कीमत।
lastPrice - अंतिम मूल्य - प्रति मिनट अंतिम मूल्य।
पहला आकार - पहला आकार - एक मिनट में पहला सौदा आकार।
lastSize - अंतिम आकार - एक मिनट में अंतिम सौदा आकार।
numTrades - गणना i - प्रति मिनट लेनदेन की संख्या।
मात्रा - योग आकार - प्रति मिनट लेनदेन आकार का योग।
pvolume - योग मूल्य - प्रति मिनट कीमतों का योग, avgPrice के लिए आवश्यक।
कारोबार - योग मूल्य * आकार - प्रति मिनट लेनदेन की कुल मात्रा।
avgPrice - pvolume% numTrades - औसत मूल्य प्रति मिनट।
avgSize - वॉल्यूम% संख्या - औसत सौदा प्रति मिनट आकार।
vwap - टर्नओवर% मात्रा - प्रति मिनट औसत मूल्य लेनदेन के आकार से भारित।
पूरे समय के लिए सह-आयतन - योग की मात्रा - संचित लेनदेन का आकार।

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

// list ! list –  , 0n – float null, 0N – long null, `sym –  , `sym1`sym2 –   initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0); aggCols:reverse key[initWith] except `sym`time; //    , reverse

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

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

पिछले एक से नए मिनट में कॉपी किए जाने वाले कॉलम, सुविधा के लिए जोड़ा गया कॉलम:

 rollColumns:`sym`cumVolume;

अब हम कॉलम को समूहों में विभाजित करते हैं कि उन्हें कैसे अद्यतन किया जाना चाहिए। तीन प्रकारों को प्रतिष्ठित किया जा सकता है:

बैटरी (वॉल्यूम, टर्नओवर, ..) - हमें पिछले वाले में इनपुट वैल्यू जोड़ना चाहिए।
एक विशेष बिंदु (उच्च, निम्न, ..) के साथ - एक मिनट में पहला मूल्य इनपुट डेटा से लिया जाता है, बाकी को फ़ंक्शन का उपयोग करके गिना जाता है।
बाकी। हमेशा एक फ़ंक्शन का उपयोग करके गिना जाता है।

इन वर्गों के लिए चर परिभाषित करें:

 accumulatorCols:`numTrades`volume`pvolume`turnover; specialCols:`high`low`firstPrice`firstSize;

गणना क्रम

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

 select high:max price, low:min price … by sym,time.minute from table

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

 ?[table;whereClause;byClause;selectClause]

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

 selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size"); // each   map  Q    preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

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

दूसरा चरण कुल तालिका को अद्यतन कर रहा है। सबसे पहले, हम एल्गोरिथ्म को pseudocode में लिखते हैं:

 for each sym in inputTable idx: row index in agg table for sym+currentTime; aggTable[idx;`high]: aggTable[idx;`high] | inputTable[sym;`high]; aggTable[idx;`volume]: aggTable[idx;`volume] + inputTable[sym;`volume]; …

क्यू में, छोरों के बजाय, यह मानचित्र का उपयोग करने / कार्यों को कम करने के लिए प्रथागत है। लेकिन क्यू चूंकि एक सदिश भाषा है और सभी ऑपरेशन हम सुरक्षित रूप से एक बार में सभी प्रतीकों पर लागू कर सकते हैं, तो पहले सन्निकटन के रूप में हम एक चक्र के बिना कर सकते हैं, एक बार में सभी प्रतीकों के साथ संचालन कर रहे हैं:

 idx:calcIdx inputTable; row:aggTable idx; aggTable[idx;`high]: row[`high] | inputTable`high; aggTable[idx;`volume]: row[`volume] + inputTable`volume; …

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

 idx:calcIdx inputTable; rows:aggTable idx; // .[target;(idx0;idx1;..);function;argument] ~ target[idx 0;idx 1;…]: function[target[idx 0;idx 1;…];argument],     –   .[aggTable;(idx;aggCols);:;flip (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

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

 .[aggTable;;:;]'[(idx;)each aggCols; (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

हम फिर से प्रक्षेपण समारोह का उपयोग करते हैं। यह भी ध्यान दें कि क्यू में, एक सूची बनाना भी एक फ़ंक्शन है और हम सूचियों की सूची प्राप्त करने के लिए प्रत्येक (मैप) फ़ंक्शन का उपयोग करके इसे कॉल कर सकते हैं।

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

 aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume! ("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");

कुछ कॉलम विशेष हैं, उनका पहला मान किसी फ़ंक्शन द्वारा गणना नहीं किया जाना चाहिए। हम यह निर्धारित कर सकते हैं कि यह स्तंभ पंक्ति में पहला है [`संख्या] - यदि इसमें 0 है, तो मान पहले है। Q का एक चयन कार्य है - [बूलियन सूची; सूची 1; सूची 2] - जो पहले तर्क में शर्त के आधार पर सूची 1 या 2 में से एक मान का चयन करती है:

 // high -> ?[isFirst;inp`high;row[`high]|inp`high] // @ -         @[`aggExpression;specialCols;{[x;y]"?[isFirst;inp`",y,";",x,"]"};string specialCols];

यहां मैंने अपने फ़ंक्शन (घुंघराले ब्रेस में अभिव्यक्ति) के साथ एक सामान्य असाइनमेंट कहा। वर्तमान मूल्य (पहला तर्क) और एक अतिरिक्त तर्क, जिसे मैं 4 वें पैरामीटर में पास करता हूं, इसे पास किया जाता है।

अलग-अलग, हम बैटरी स्पीकर जोड़ते हैं, क्योंकि उनके लिए फ़ंक्शन समान है:

 // volume -> row[`volume]+inp`volume aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;

यह क्यू के मानकों द्वारा एक सामान्य असाइनमेंट है, मैं केवल एक बार मूल्यों की एक सूची प्रदान करता हूं। अंत में, मुख्य कार्य बनाएँ:

 // ":",/:aggExprs ~ map[{":",x};aggExpr] => ":row[`high]|inp`high"    ,          // string[cols],'exprs ~ map[,;string[cols];exprs] => "high:row[`high]|inp`high"   . ,'   map[concat] // ";" sv exprs – String from Vector (sv),     “;”  updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst:0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}";

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

 {[aggTable;idx;inp] rows:aggTable idx; isFirst:0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols ;(cumVolume:row[`cumVolume]+inp`cumVolume;… ; high:?[isFirst;inp`high;row[`high]|inp`high])]}

स्तंभों की गणना का क्रम उलटा है, क्यू के गणना का क्रम दाईं से बाईं ओर है।

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

अंतिम चरण

हमारे पास प्रीप्रोसेस और अपडेटएग फ़ंक्शन हैं जो सभी काम करते हैं। लेकिन मिनटों में सही संक्रमण सुनिश्चित करने और एकत्रीकरण के लिए सूचकांकों की गणना करना अभी भी आवश्यक है। पहले हम init फ़ंक्शन को परिभाषित करते हैं:

 init:{ tradeAgg:: 0#enlist[initWith]; //    , enlist    ,  0#   0    currTime::00:00; //   0, :: ,      currSyms::`u#`symbol$(); // `u# -    ,     offset::0; //   tradeAgg,     rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg; //     roll ,    sym }

हम रोल फ़ंक्शन को भी परिभाषित करते हैं, जो वर्तमान मिनट को बदल देगा:

 roll:{[tm] if[currTime>tm; :init[]]; //    ,    init rollCache,::offset _ rollColumns#tradeAgg; //   –  roll   aggTable, ,   rollCache offset::count tradeAgg; currSyms::`u#`$(); }

हमें नए वर्ण जोड़ने के लिए एक फ़ंक्शन की आवश्यकता है:

 addSyms:{[syms] currSyms,::syms; //     //    sym, time  rollColumns   . //  ^      roll ,     . value flip table     . `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime), (initWith cols rc)^value flip rc:rollCache ([] sym: syms)]; }

और अंत में, अपडेट फ़ंक्शन (क्यू सेवाओं के लिए इस फ़ंक्शन का पारंपरिक नाम), जिसे क्लाइंट द्वारा डेटा जोड़ने के लिए कहा जाता है:

 upd:{[tblName;data] // tblName   ,       tm:exec distinct time from data:() xkey preprocess data; // preprocess & calc time updMinute[data] each tm; //      }; updMinute:{[data;tm] if[tm<>currTime; roll tm; currTime::tm]; //  ,   data:select from data where time=tm; //  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms]; //   updateAgg[`tradeAgg;offset+currSyms?syms;data]; //   .  ?        . };

वह सब है। यहाँ हमारी सेवा का पूरा कोड है, जैसा कि वादा किया गया है, बस कुछ पंक्तियाँ:

 initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0); aggCols:reverse key[initWith] except `sym`time; rollColumns:`sym`cumVolume; accumulatorCols:`numTrades`volume`pvolume`turnover; specialCols:`high`low`firstPrice`firstSize; selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size"); preprocess:?[;();`sym`time!`sym`time.minute;selExpression]; aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume"); @[`aggExpression;specialCols;{"?[isFirst;inp`",y,";",x,"]"};string specialCols]; aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols; updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst:0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}"; / ' init:{ tradeAgg::0#enlist[initWith]; currTime::00:00; currSyms::`u#`symbol$(); offset::0; rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg; }; roll:{[tm] if[currTime>tm; :init[]]; rollCache,::offset _ rollColumns#tradeAgg; offset::count tradeAgg; currSyms::`u#`$(); }; addSyms:{[syms] currSyms,::syms; `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime),(initWith cols rc)^value flip rc:rollCache ([] sym: syms)]; }; upd:{[tblName;data] updMinute[data] each exec distinct time from data:() xkey preprocess data}; updMinute:{[data;tm] if[tm<>currTime; roll tm; currTime::tm]; data:select from data where time=tm; if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms]; updateAgg[`tradeAgg;offset+currSyms?syms;data]; };

परीक्षण

सेवा के प्रदर्शन की जाँच करें। ऐसा करने के लिए, इसे एक अलग प्रक्रिया में चलाएं (कोड को service.q फ़ाइल में डालें) और init फ़ंक्शन को कॉल करें:

 q service.q –p 5566 q)init[]

दूसरे कंसोल में, दूसरी Q प्रक्रिया शुरू करें और पहले से कनेक्ट करें:

 h:hopen `:host:5566 h:hopen 5566 //

सबसे पहले, वर्णों की एक सूची बनाएं - 10,000 टुकड़े और एक यादृच्छिक तालिका बनाने के लिए एक फ़ंक्शन जोड़ें। दूसरे कंसोल में:

 syms:`IBM`AAPL`GOOG,-9997?`8 rnd:{[n;t] ([] sym:n?syms; time:t+asc n#til 25; price:n?10f; size:n?10)}

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

अब आप सेवा में डेटा भेजने का प्रयास कर सकते हैं (पहले दस घंटे जोड़ें):

 {h (`upd;`trade;rnd[10000;x])} each `time$00:00 + til 60*10

आप उस सेवा में देख सकते हैं जिसे तालिका अपडेट कर दी गई है:

 \c 25 200 select from tradeAgg where sym=`AAPL -20#select from tradeAgg where sym=`AAPL

परिणाम:

 sym|time|high|low|firstPrice|lastPrice|firstSize|lastSize|numTrades|volume|pvolume|turnover|avgPrice|avgSize|vwap|cumVolume --|--|--|--|--|-------------------------------- AAPL|09:27|9.258904|9.258904|9.258904|9.258904|8|8|1|8|9.258904|74.07123|9.258904|8|9.258904|2888 AAPL|09:28|9.068162|9.068162|9.068162|9.068162|7|7|1|7|9.068162|63.47713|9.068162|7|9.068162|2895 AAPL|09:31|4.680449|0.2011121|1.620827|0.2011121|1|5|4|14|9.569556|36.84342|2.392389|3.5|2.631673|2909 AAPL|09:33|2.812535|2.812535|2.812535|2.812535|6|6|1|6|2.812535|16.87521|2.812535|6|2.812535|2915 AAPL|09:34|5.099025|5.099025|5.099025|5.099025|4|4|1|4|5.099025|20.3961|5.099025|4|5.099025|2919

हम अब यह पता लगाने के लिए लोड परीक्षण करेंगे कि सेवा प्रति मिनट कितना डेटा संसाधित कर सकती है। मुझे आपको याद दिलाना है कि हम 25 मिलीसेकंड के अपडेट के लिए अंतराल सेट करते हैं। तदनुसार, एक सेवा को (औसतन) उपयोगकर्ताओं को डेटा का अनुरोध करने के लिए समय देने के लिए प्रति अपडेट कम से कम 20 मिलीसेकंड में फिट होना चाहिए। दूसरी प्रक्रिया में निम्नलिखित दर्ज करें:

 tm:10:00:00.000 stressTest:{[n] 1 string[tm]," "; times,::h ({st:.zT; upd[`trade;x]; .zT-st};rnd[n;tm]); tm+:25} start:{[n] times::(); do[4800;stressTest[n]]; -1 " "; `min`avg`med`max!(min times;avg times;med times;max times)}

4800 दो मिनट का है। आप हर 25 मिलीसेकंड में 1000 लाइनों के लिए पहले शुरू करने की कोशिश कर सकते हैं:

 start 1000

मेरे मामले में, परिणाम प्रति अपडेट मिलिसेकंड के एक जोड़े के आसपास है। इसलिए मैं तुरंत पंक्तियों की संख्या बढ़ाकर 10.000 करूंगा:

 start 10000

परिणाम:

 min| 00:00:00.004 avg| 9.191458 med| 9f max| 00:00:00.030

फिर, कुछ खास नहीं है, लेकिन यह 24 मिलियन लाइनें प्रति मिनट, 400 हजार प्रति सेकंड है। 25 मिलीसेकंड से अधिक के लिए, अपडेट केवल 5 बार धीमा हो गया, जाहिरा तौर पर मिनट बदलते समय। 100,000 तक बढ़ाएँ:

 start 100000

परिणाम:

 min| 00:00:00.013 avg| 25.11083 med| 24f max| 00:00:00.108 q)sum times 00:02:00.532

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

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

निष्कर्ष

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

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

वास्तविक समय सेवा के उदाहरण पर क्यू और केडीबी + की विशेषताएं

परिचय

समस्या का बयान

अलग कार्य

गणना क्रम

अंतिम चरण

परीक्षण

निष्कर्ष

More articles: