રીઅલ-ટાઇમ સેવાના ઉદાહરણનો ઉપયોગ કરીને Q અને KDB+ ભાષાના લક્ષણો

તમે KDB+ આધાર, Q પ્રોગ્રામિંગ ભાષા શું છે, તેમની શક્તિઓ અને નબળાઈઓ શું છે તે વિશે વાંચી શકો છો. લેખ અને ટૂંકમાં પરિચયમાં. લેખમાં, અમે Q પર એક સેવાનો અમલ કરીશું જે આવનારા ડેટા સ્ટ્રીમ પર પ્રક્રિયા કરશે અને "રીઅલ ટાઇમ" મોડમાં દર મિનિટે વિવિધ એકત્રીકરણ કાર્યોની ગણતરી કરશે (એટલે ​​​​કે, તેની પાસે ડેટાના આગલા ભાગ પહેલાં દરેક વસ્તુની ગણતરી કરવાનો સમય હશે). Q ની મુખ્ય વિશેષતા એ છે કે તે એક વેક્ટર ભાષા છે જે તમને એક ઑબ્જેક્ટ સાથે નહીં, પરંતુ તેમના એરે, એરેના એરે અને અન્ય જટિલ ઑબ્જેક્ટ્સ સાથે ઑપરેટ કરવાની મંજૂરી આપે છે. Q અને તેના સંબંધીઓ K, ​​J, APL જેવી ભાષાઓ તેમના સંક્ષિપ્તતા માટે પ્રખ્યાત છે. ઘણીવાર, જાવા જેવી પરિચિત ભાષામાં કોડની ઘણી સ્ક્રીનો લેતો પ્રોગ્રામ તેના પર થોડી લીટીઓમાં લખી શકાય છે. આ તે છે જે હું આ લેખમાં દર્શાવવા માંગુ છું.

પરિચય

KDB+ એ સ્તંભાકાર ડેટાબેઝ છે જે ખૂબ મોટી માત્રામાં ડેટા પર ધ્યાન કેન્દ્રિત કરે છે, જે ચોક્કસ રીતે (મુખ્યત્વે સમય દ્વારા) ઓર્ડર કરવામાં આવે છે. તેનો ઉપયોગ મુખ્યત્વે નાણાકીય સંસ્થાઓ - બેંકો, રોકાણ ભંડોળ, વીમા કંપનીઓમાં થાય છે. Q ભાષા એ KDB+ ની આંતરિક ભાષા છે જે તમને આ ડેટા સાથે અસરકારક રીતે કાર્ય કરવાની મંજૂરી આપે છે. ક્યુ વિચારધારા સંક્ષિપ્તતા અને કાર્યક્ષમતા છે, જ્યારે સ્પષ્ટતાનું બલિદાન આપવામાં આવે છે. આ હકીકત દ્વારા વાજબી છે કે વેક્ટર ભાષાને કોઈ પણ સંજોગોમાં સમજવું મુશ્કેલ હશે, અને રેકોર્ડિંગની સંક્ષિપ્તતા અને સમૃદ્ધિ તમને એક સ્ક્રીન પર પ્રોગ્રામનો ઘણો મોટો ભાગ જોવાની મંજૂરી આપે છે, જે આખરે તેને સમજવામાં સરળ બનાવે છે.

આ લેખમાં અમે Q માં એક સંપૂર્ણ પ્રોગ્રામ અમલમાં મૂક્યો છે અને તમે તેને અજમાવી શકો છો. આ કરવા માટે, તમારે વાસ્તવિક Qની જરૂર પડશે. તમે kx કંપનીની વેબસાઇટ પર મફત 32-બીટ સંસ્કરણ ડાઉનલોડ કરી શકો છો – www.kx.com. ત્યાં, જો તમને રસ હોય, તો તમને Q, પુસ્તક પર સંદર્ભ માહિતી મળશે પ્રાણઘાતક લોકો માટે અને આ વિષય પર વિવિધ લેખો.

સમસ્યાની રચના

ત્યાં એક સ્રોત છે જે દર 25 મિલીસેકન્ડે ડેટા સાથે કોષ્ટક મોકલે છે. KDB+ નો ઉપયોગ મુખ્યત્વે ફાઇનાન્સમાં થતો હોવાથી, અમે ધારીશું કે આ વ્યવહારો (વેપાર) નું કોષ્ટક છે, જેમાં નીચેના કૉલમ છે: સમય (મિલિસેકન્ડમાં સમય), સિમ (સ્ટૉક એક્સચેન્જ પર કંપનીનો હોદ્દો - IBM, AAPL,…), કિંમત (જે ભાવે શેર ખરીદવામાં આવ્યા હતા), કદ (ટ્રાન્ઝેક્શનનું કદ). 25 મિલીસેકન્ડનો અંતરાલ મનસ્વી છે, બહુ નાનો નથી અને બહુ લાંબો પણ નથી. તેની હાજરીનો અર્થ એ છે કે ડેટા પહેલેથી બફર કરેલી સેવામાં આવે છે. વર્તમાન લોડના આધારે ગતિશીલ બફરિંગ સહિત, સેવા બાજુ પર બફરિંગ લાગુ કરવું સરળ હશે, પરંતુ સરળતા માટે, અમે નિશ્ચિત અંતરાલ પર ધ્યાન કેન્દ્રિત કરીશું.

સેવાએ સિમ કૉલમમાંથી દરેક ઇનકમિંગ સિમ્બોલ માટે દર મિનિટે એકંદર ફંક્શનના સમૂહની ગણતરી કરવી જોઈએ - મહત્તમ કિંમત, સરેરાશ કિંમત, સરવાળો કદ, વગેરે. ઉપયોગી માહિતી. સરળતા માટે, અમે ધારીશું કે તમામ કાર્યોની ગણતરી વધતી-ઓછી થઈ શકે છે, એટલે કે. નવું મૂલ્ય મેળવવા માટે, બે નંબરો જાણવા માટે પૂરતું છે - જૂના અને આવનારા મૂલ્યો. ઉદાહરણ તરીકે, મહત્તમ, સરેરાશ, સરવાળા ફંક્શનમાં આ ગુણધર્મ હોય છે, પરંતુ મધ્ય ફંક્શન એવું નથી.

અમે એ પણ ધારીશું કે આવનારા ડેટા સ્ટ્રીમનો સમય નક્કી કરવામાં આવ્યો છે. આનાથી અમને છેલ્લી ઘડીએ જ કામ કરવાની તક મળશે. વ્યવહારમાં, કેટલાક અપડેટ મોડું થાય તો વર્તમાન અને પાછલી મિનિટો સાથે કામ કરવા માટે સક્ષમ થવા માટે તે પૂરતું છે. સરળતા માટે, અમે આ કેસને ધ્યાનમાં લઈશું નહીં.

એકત્રીકરણ કાર્યો

જરૂરી એકત્રીકરણ કાર્યો નીચે સૂચિબદ્ધ છે. સેવા પરનો ભાર વધારવા માટે મેં તેમાંથી શક્ય તેટલા લીધા:

• ઉચ્ચ - મહત્તમ કિંમત - પ્રતિ મિનિટ મહત્તમ કિંમત.
• નીચી - ન્યૂનતમ કિંમત - ન્યૂનતમ કિંમત પ્રતિ મિનિટ.
• પ્રથમ કિંમત - પ્રથમ કિંમત - પ્રતિ મિનિટ પ્રથમ કિંમત.
• છેલ્લી કિંમત - છેલ્લી કિંમત - છેલ્લી કિંમત પ્રતિ મિનિટ.
• ફર્સ્ટસાઇઝ - પ્રથમ કદ - પ્રતિ મિનિટ પ્રથમ વેપાર કદ.
• લાસ્ટ સાઇઝ - છેલ્લું કદ - એક મિનિટમાં છેલ્લું વેપાર કદ.
• numTrades – કાઉન્ટ i – પ્રતિ મિનિટ સોદાની સંખ્યા.
• વોલ્યુમ - સરવાળો કદ - પ્રતિ મિનિટ વેપાર કદનો સરવાળો.
• pvolume – સરવાળો કિંમત – પ્રતિ મિનિટ કિંમતોનો સરવાળો, સરેરાશ કિંમત માટે જરૂરી છે.
• - સરવાળો ટર્નઓવર કિંમત*કદ - પ્રતિ મિનિટ વ્યવહારોનું કુલ વોલ્યુમ.
• avgPrice – pvolume%numTrades – સરેરાશ કિંમત પ્રતિ મિનિટ.
• avgSize – વોલ્યુમ%numTrades – સરેરાશ વેપાર કદ પ્રતિ મિનિટ.
• vwap - ટર્નઓવર% વોલ્યુમ - વ્યવહારના કદ દ્વારા વેઇટેડ પ્રતિ મિનિટ સરેરાશ કિંમત.
• કમવોલ્યુમ - સરવાળો વોલ્યુમ - સમગ્ર સમય દરમિયાન વ્યવહારોનું સંચિત કદ.

ચાલો તરત જ એક બિન-સ્પષ્ટ મુદ્દાની ચર્ચા કરીએ - આ કૉલમ્સને પ્રથમ વખત અને દરેક અનુગામી મિનિટ માટે કેવી રીતે શરૂ કરવી. ફર્સ્ટપ્રાઈસ પ્રકારની કેટલીક કૉલમ દરેક વખતે શૂન્ય કરવા માટે આરંભિત હોવી જોઈએ; તેમનું મૂલ્ય અવ્યાખ્યાયિત છે. અન્ય વોલ્યુમ પ્રકારો હંમેશા 0 પર સેટ હોવા જોઈએ. ત્યાં એવા કૉલમ્સ પણ છે કે જેને સંયુક્ત અભિગમની જરૂર હોય છે - ઉદાહરણ તરીકે, cumVolume ની અગાઉની મિનિટથી નકલ કરવી આવશ્યક છે, અને પ્રથમ એક માટે 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 ની જરૂર પડશે. Q માં અભિવ્યક્તિઓનું મૂલ્યાંકન (જમણેથી ડાબે) કરવામાં આવે છે તે ક્રમને કારણે સૂચિ ઊંધી હોવી આવશ્યક છે. ધ્યેય એ સુનિશ્ચિત કરવાનો છે કે ગણતરી ઉચ્ચથી કમ વોલ્યુમ સુધી જાય, કારણ કે કેટલીક કૉલમ પાછલી કૉલમ પર આધારિત છે.

કૉલમ કે જેને પાછલા એકમાંથી નવી મિનિટમાં કૉપિ કરવાની જરૂર છે, સુવિધા માટે સિમ કૉલમ ઉમેરવામાં આવે છે:

rollColumns:`sym`cumVolume;

ચાલો હવે કૉલમને કેવી રીતે અપડેટ કરવા જોઈએ તે પ્રમાણે જૂથોમાં વિભાજીત કરીએ. ત્રણ પ્રકારો ઓળખી શકાય છે:

1. સંચયકર્તાઓ (વોલ્યુમ, ટર્નઓવર,..) - આપણે આગલા મૂલ્યમાં ઇનકમિંગ મૂલ્ય ઉમેરવું જોઈએ.
2. વિશિષ્ટ બિંદુ સાથે (ઉચ્ચ, નીચું, ..) - મિનિટમાં પ્રથમ મૂલ્ય ઇનકમિંગ ડેટામાંથી લેવામાં આવે છે, બાકીની ગણતરી ફંક્શનનો ઉપયોગ કરીને કરવામાં આવે છે.
3. આરામ કરો. હંમેશા ફંક્શનનો ઉપયોગ કરીને ગણતરી કરવામાં આવે છે.

ચાલો આ વર્ગો માટે ચલોને વ્યાખ્યાયિત કરીએ:

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

ગણતરી ક્રમ

અમે એકીકૃત કોષ્ટકને બે તબક્કામાં અપડેટ કરીશું. કાર્યક્ષમતા માટે, અમે પ્રથમ ઇનકમિંગ કોષ્ટકને સંકોચાઈએ છીએ જેથી દરેક અક્ષર અને મિનિટ માટે માત્ર એક પંક્તિ હોય. હકીકત એ છે કે અમારા તમામ કાર્યો વૃદ્ધિશીલ અને સહયોગી છે તે ખાતરી આપે છે કે આ વધારાના પગલાનું પરિણામ બદલાશે નહીં. તમે સિલેક્ટનો ઉપયોગ કરીને ટેબલને સંકોચાઈ શકો છો:

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

આ પદ્ધતિમાં ગેરલાભ છે - ગણતરી કરેલ કૉલમનો સમૂહ પૂર્વવ્યાખ્યાયિત છે. સદનસીબે, Q માં, સિલેક્ટને ફંક્શન તરીકે પણ લાગુ કરવામાં આવે છે જ્યાં તમે ગતિશીલ રીતે બનાવેલ દલીલોને બદલી શકો છો:

?[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];

સ્પષ્ટતા માટે, મેં પાર્સ ફંક્શનનો ઉપયોગ કર્યો, જે Q અભિવ્યક્તિ સાથેની સ્ટ્રિંગને મૂલ્યમાં ફેરવે છે જે eval ફંક્શનમાં પાસ કરી શકાય છે અને જે ફંક્શન સિલેક્ટમાં જરૂરી છે. એ પણ નોંધ લો કે પ્રીપ્રોસેસ પસંદ ફંક્શનના પ્રોજેક્શન (એટલે ​​​​કે, આંશિક રીતે વ્યાખ્યાયિત દલીલો સાથેનું કાર્ય) તરીકે વ્યાખ્યાયિત થયેલ છે, એક દલીલ (કોષ્ટક) ખૂટે છે. જો આપણે ટેબલ પર પ્રીપ્રોસેસ લાગુ કરીએ, તો આપણને સંકુચિત ટેબલ મળશે.

બીજો તબક્કો એ એકીકૃત કોષ્ટકને અપડેટ કરવાનું છે. ચાલો પહેલા સ્યુડોકોડમાં અલ્ગોરિધમ લખીએ:

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];
  …

Q માં, લૂપ્સને બદલે નકશા/ઘટાડો ફંક્શનનો ઉપયોગ કરવો સામાન્ય છે. પરંતુ ક્યૂ એ વેક્ટર લેંગ્વેજ છે અને આપણે બધા સિમ્બોલ પર એક જ સમયે તમામ ઑપરેશન્સ સરળતાથી લાગુ કરી શકીએ છીએ, પછી પ્રથમ અંદાજમાં આપણે લૂપ વિના બિલકુલ કરી શકીએ છીએ, એક જ સમયે તમામ પ્રતીકો પર ઑપરેશન કરી શકીએ છીએ:

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

પરંતુ આપણે આગળ જઈ શકીએ છીએ, Q પાસે એક અનન્ય અને અત્યંત શક્તિશાળી ઓપરેટર છે - સામાન્ય અસાઇનમેન્ટ ઓપરેટર. તે તમને સૂચકાંકો, કાર્યો અને દલીલોની સૂચિનો ઉપયોગ કરીને જટિલ ડેટા માળખામાં મૂલ્યોના સમૂહને બદલવાની મંજૂરી આપે છે. અમારા કિસ્સામાં તે આના જેવું લાગે છે:

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;…)];

અમે ફરીથી ફંક્શન પ્રોજેક્શનનો ઉપયોગ કરીએ છીએ. એ પણ નોંધ લો કે Q માં, સૂચિ બનાવવી એ પણ એક કાર્ય છે અને અમે સૂચિની સૂચિ મેળવવા માટે દરેક(નકશા) ફંક્શનનો ઉપયોગ કરીને તેને કૉલ કરી શકીએ છીએ.

ગણતરી કરેલ કૉલમનો સમૂહ નિશ્ચિત નથી તેની ખાતરી કરવા માટે, અમે ઉપરોક્ત અભિવ્યક્તિ ગતિશીલ રીતે બનાવીશું. ચાલો દરેક કૉલમની ગણતરી કરવા માટે પ્રથમ ફંક્શનને વ્યાખ્યાયિત કરીએ, એકીકૃત અને ઇનપુટ ડેટાનો સંદર્ભ આપવા માટે પંક્તિ અને inp ચલોનો ઉપયોગ કરીને:

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");

કેટલીક કૉલમ વિશિષ્ટ હોય છે; તેમની પ્રથમ કિંમત ફંક્શન દ્વારા ગણવામાં આવવી જોઈએ નહીં. અમે નક્કી કરી શકીએ છીએ કે તે પંક્તિ [`numTrades] કૉલમ દ્વારા પ્રથમ છે - જો તેમાં 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;

આ Q ધોરણો દ્વારા સામાન્ય સોંપણી છે, પરંતુ હું એક જ સમયે મૂલ્યોની સૂચિ સોંપી રહ્યો છું. છેલ્લે, ચાલો મુખ્ય કાર્ય બનાવીએ:

// ":",/: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])]}

કૉલમ મૂલ્યાંકન ક્રમ ઊંધો છે કારણ કે Q માં મૂલ્યાંકન ક્રમ જમણેથી ડાબે છે.

હવે અમારી પાસે ગણતરીઓ માટે જરૂરી બે મુખ્ય કાર્યો છે, અમારે માત્ર થોડું ઇન્ફ્રાસ્ટ્રક્ચર ઉમેરવાની જરૂર છે અને સેવા તૈયાર છે.

અંતિમ પગલાં

અમારી પાસે પ્રીપ્રોસેસ અને અપડેટએગ ફંક્શન છે જે તમામ કામ કરે છે. પરંતુ તે હજી પણ મિનિટ દ્વારા યોગ્ય સંક્રમણની ખાતરી કરવા અને એકત્રીકરણ માટે અનુક્રમણિકાઓની ગણતરી કરવા માટે જરૂરી છે. સૌ પ્રથમ, ચાલો 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 ફંક્શન (Q સેવાઓ માટે આ ફંક્શનનું પરંપરાગત નામ), જેને ક્લાયંટ દ્વારા ડેટા ઉમેરવા માટે કહેવામાં આવે છે:

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 // если оба на одном хосте

પ્રથમ, ચાલો પ્રતીકોની સૂચિ બનાવીએ - 10000 ટુકડાઓ અને રેન્ડમ ટેબલ બનાવવા માટે ફંક્શન ઉમેરીએ. બીજા કન્સોલમાં:

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

મેં તેમને કોષ્ટકમાં જોવાનું સરળ બનાવવા માટે સૂચિમાં ત્રણ વાસ્તવિક પ્રતીકો ઉમેર્યા છે. rnd ફંક્શન 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:.z.T; upd[`trade;x]; .z.T-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 બે મિનિટ છે. તમે દર 1000 મિલીસેકન્ડે 25 પંક્તિઓ માટે પ્રથમ દોડવાનો પ્રયાસ કરી શકો છો:

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) થી શરૂ કરીને, અપડેટએગ તેની ટોચમર્યાદા સુધી પહોંચે છે અને પછી તેનો અમલ સમય અપડેટના કદ પર આધારિત નથી. તે પ્રારંભિક પગલા Q ને કારણે છે કે સેવા આવા જથ્થાના ડેટાને ડાયજેસ્ટ કરવામાં સક્ષમ છે. આ દર્શાવે છે કે મોટા ડેટા સાથે કામ કરતી વખતે યોગ્ય અલ્ગોરિધમ પસંદ કરવાનું કેટલું મહત્વનું છે. બીજો મુદ્દો મેમરીમાં ડેટાનો યોગ્ય સંગ્રહ છે. જો ડેટા સ્તંભાકીય રીતે સંગ્રહિત ન હોય અથવા સમયસર ઓર્ડર ન કરવામાં આવ્યો હોય, તો પછી આપણે TLB કેશ મિસ જેવી વસ્તુથી પરિચિત થઈશું - પ્રોસેસર એડ્રેસ કેશમાં મેમરી પૃષ્ઠ સરનામાંની ગેરહાજરી. સરનામું શોધવામાં લગભગ 30 ગણો વધુ સમય લાગે છે જો અસફળ હોય, અને જો ડેટા વેરવિખેર થઈ જાય, તો તે સેવાને ઘણી વખત ધીમું કરી શકે છે.

નિષ્કર્ષ

આ લેખમાં, મેં બતાવ્યું કે KDB+ અને Q ડેટાબેઝ માત્ર મોટા ડેટાને સંગ્રહિત કરવા અને તેને પસંદગી દ્વારા સરળતાથી ઍક્સેસ કરવા માટે જ નહીં, પણ ડેટા પ્રોસેસિંગ સેવાઓ બનાવવા માટે પણ યોગ્ય છે જે લાખો પંક્તિઓ/ગીગાબાઇટ્સ ડેટાને ડાયજેસ્ટ કરવામાં સક્ષમ છે. એક જ Q પ્રક્રિયા. Q ભાષા પોતે જ તેની વેક્ટર પ્રકૃતિ, બિલ્ટ-ઇન SQL બોલી દુભાષિયા અને લાઇબ્રેરી કાર્યોના ખૂબ જ સફળ સમૂહને કારણે ડેટા પ્રોસેસિંગ સંબંધિત અલ્ગોરિધમ્સના અત્યંત સંક્ષિપ્ત અને કાર્યક્ષમ અમલીકરણ માટે પરવાનગી આપે છે.

હું નોંધ કરીશ કે ઉપરોક્ત એ માત્ર Q શું કરી શકે છે તેનો એક ભાગ છે, તેમાં અન્ય વિશિષ્ટ સુવિધાઓ પણ છે. ઉદાહરણ તરીકે, એક અત્યંત સરળ IPC પ્રોટોકોલ જે વ્યક્તિગત Q પ્રક્રિયાઓ વચ્ચેની સીમાને ભૂંસી નાખે છે અને તમને આમાંથી સેંકડો પ્રક્રિયાઓને એક નેટવર્કમાં જોડવાની મંજૂરી આપે છે, જે વિશ્વના વિવિધ ભાગોમાં ડઝનેક સર્વર્સ પર સ્થિત હોઈ શકે છે.

સોર્સ: www.habr.com