ഒരു തത്സമയ സേവനത്തിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് Q, KDB+ ഭാഷകളുടെ സവിശേഷതകൾ

KDB+ ബേസ്, Q പ്രോഗ്രാമിംഗ് ഭാഷ എന്താണെന്നും അവയുടെ ശക്തിയും ബലഹീനതകളും എന്താണെന്നും എന്റെ മുമ്പത്തെതിൽ നിങ്ങൾക്ക് വായിക്കാം ലേഖനം ആമുഖത്തിൽ സംക്ഷിപ്തമായി. ലേഖനത്തിൽ, ഇൻകമിംഗ് ഡാറ്റാ സ്ട്രീം പ്രോസസ്സ് ചെയ്യുന്ന ഒരു സേവനം ഞങ്ങൾ Q-ൽ നടപ്പിലാക്കും, കൂടാതെ "റിയൽ ടൈം" മോഡിൽ ഓരോ മിനിറ്റിലും വിവിധ അഗ്രഗേഷൻ ഫംഗ്ഷനുകൾ കണക്കാക്കുകയും ചെയ്യും (അതായത്, ഡാറ്റയുടെ അടുത്ത ഭാഗത്തിന് മുമ്പ് എല്ലാം കണക്കാക്കാൻ സമയമുണ്ടാകും). ഒറ്റ ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിച്ചല്ല, അവയുടെ അറേകൾ, അറേകളുടെ അറേകൾ, മറ്റ് സങ്കീർണ്ണ വസ്തുക്കൾ എന്നിവ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന വെക്റ്റർ ഭാഷയാണ് ക്യൂവിന്റെ പ്രധാന സവിശേഷത. ക്യു, അതിന്റെ ബന്ധുക്കളായ കെ, ജെ, എപിഎൽ തുടങ്ങിയ ഭാഷകൾ അവയുടെ സംക്ഷിപ്‌തതയ്ക്ക് പ്രസിദ്ധമാണ്. മിക്കപ്പോഴും, ജാവ പോലുള്ള പരിചിതമായ ഭാഷയിൽ കോഡിന്റെ നിരവധി സ്‌ക്രീനുകൾ എടുക്കുന്ന ഒരു പ്രോഗ്രാം അവയിൽ കുറച്ച് വരികളിൽ എഴുതാം. ഇതാണ് ഈ ലേഖനത്തിൽ ഞാൻ പ്രകടിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നത്.

ആമുഖം

KDB+ എന്നത് ഒരു പ്രത്യേക രീതിയിൽ (പ്രാഥമികമായി സമയം അനുസരിച്ച്) ക്രമീകരിച്ചിരിക്കുന്ന, വളരെ വലിയ അളവിലുള്ള ഡാറ്റയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന ഒരു കോളം ഡാറ്റാബേസാണ്. ഇത് പ്രാഥമികമായി ധനകാര്യ സ്ഥാപനങ്ങളിൽ ഉപയോഗിക്കുന്നു - ബാങ്കുകൾ, നിക്ഷേപ ഫണ്ടുകൾ, ഇൻഷുറൻസ് കമ്പനികൾ. ഈ ഡാറ്റ ഉപയോഗിച്ച് ഫലപ്രദമായി പ്രവർത്തിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന KDB+ ന്റെ ആന്തരിക ഭാഷയാണ് Q ഭാഷ. Q പ്രത്യയശാസ്ത്രം സംക്ഷിപ്തതയും കാര്യക്ഷമതയും ആണ്, അതേസമയം വ്യക്തത ബലികഴിക്കപ്പെടുന്നു. ഏത് സാഹചര്യത്തിലും വെക്റ്റർ ഭാഷ മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടാണ് എന്ന വസ്തുത ഇത് ന്യായീകരിക്കുന്നു, കൂടാതെ റെക്കോർഡിംഗിന്റെ സംക്ഷിപ്തതയും സമ്പന്നതയും പ്രോഗ്രാമിന്റെ വലിയൊരു ഭാഗം ഒരു സ്ക്രീനിൽ കാണാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് ആത്യന്തികമായി മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കുന്നു.

ഈ ലേഖനത്തിൽ ഞങ്ങൾ Q-ൽ ഒരു പൂർണ്ണമായ പ്രോഗ്രാം നടപ്പിലാക്കുന്നു, നിങ്ങൾ അത് പരീക്ഷിച്ചുനോക്കാൻ ആഗ്രഹിച്ചേക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് യഥാർത്ഥ Q ആവശ്യമാണ്. kx കമ്പനി വെബ്സൈറ്റിൽ നിങ്ങൾക്ക് സൗജന്യ 32-ബിറ്റ് പതിപ്പ് ഡൗൺലോഡ് ചെയ്യാം - www.kx.com. അവിടെ, നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, Q എന്ന പുസ്തകത്തെക്കുറിച്ചുള്ള റഫറൻസ് വിവരങ്ങൾ നിങ്ങൾ കണ്ടെത്തും ക്യു ഫോർ മോർട്ടൽസ് ഈ വിഷയത്തിൽ വിവിധ ലേഖനങ്ങളും.

പ്രശ്ന പ്രസ്താവന

ഓരോ 25 മില്ലിസെക്കൻഡിലും ഡാറ്റയുള്ള ഒരു പട്ടിക അയയ്ക്കുന്ന ഒരു ഉറവിടമുണ്ട്. KDB+ പ്രാഥമികമായി ധനകാര്യത്തിൽ ഉപയോഗിക്കുന്നതിനാൽ, ഇത് ഇടപാടുകളുടെ (ട്രേഡുകൾ) ഒരു പട്ടികയാണെന്ന് ഞങ്ങൾ അനുമാനിക്കും, അതിൽ ഇനിപ്പറയുന്ന നിരകളാണുള്ളത്: സമയം (സമയം മില്ലിസെക്കൻഡിൽ), സിം (സ്റ്റോക്ക് എക്സ്ചേഞ്ചിലെ കമ്പനി പദവി - ഐബിഎം, AAPL,...), വില (ഷെയറുകൾ വാങ്ങിയ വില), വലിപ്പം (ഇടപാടിന്റെ വലിപ്പം). 25 മില്ലിസെക്കൻഡ് ഇടവേള ഏകപക്ഷീയമാണ്, വളരെ ചെറുതല്ല, ദൈർഘ്യമേറിയതുമല്ല. അതിന്റെ സാന്നിധ്യം അർത്ഥമാക്കുന്നത് ഡാറ്റ ഇതിനകം ബഫർ ചെയ്ത സേവനത്തിലേക്ക് വരുന്നു എന്നാണ്. നിലവിലെ ലോഡിനെ ആശ്രയിച്ച് ഡൈനാമിക് ബഫറിംഗ് ഉൾപ്പെടെ, സേവന ഭാഗത്ത് ബഫറിംഗ് നടപ്പിലാക്കുന്നത് എളുപ്പമായിരിക്കും, എന്നാൽ ലാളിത്യത്തിനായി, ഞങ്ങൾ ഒരു നിശ്ചിത ഇടവേളയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

സിം കോളത്തിൽ നിന്നുള്ള ഓരോ ഇൻകമിംഗ് ചിഹ്നത്തിനും ഒരു കൂട്ടം ഫംഗ്‌ഷനുകൾ - പരമാവധി വില, ശരാശരി വില, തുകയുടെ വലുപ്പം മുതലായവ ഈ സേവനം ഓരോ മിനിറ്റിലും കണക്കാക്കണം. ഉപകാരപ്രദമായ വിവരം. ലാളിത്യത്തിനായി, എല്ലാ ഫംഗ്ഷനുകളും വർദ്ധിപ്പിച്ച് കണക്കാക്കാൻ കഴിയുമെന്ന് ഞങ്ങൾ അനുമാനിക്കും, അതായത്. ഒരു പുതിയ മൂല്യം ലഭിക്കുന്നതിന്, രണ്ട് സംഖ്യകൾ അറിഞ്ഞാൽ മതി - പഴയതും ഇൻകമിംഗ് മൂല്യങ്ങളും. ഉദാഹരണത്തിന്, പരമാവധി, ശരാശരി, തുക എന്നീ ഫംഗ്‌ഷനുകൾക്ക് ഈ ഗുണമുണ്ട്, എന്നാൽ മീഡിയൻ ഫംഗ്‌ഷനില്ല.

ഇൻകമിംഗ് ഡാറ്റ സ്ട്രീം സമയം ക്രമീകരിച്ചതാണെന്നും ഞങ്ങൾ അനുമാനിക്കും. ഇത് അവസാന നിമിഷം കൊണ്ട് മാത്രം പ്രവർത്തിക്കാനുള്ള അവസരം നൽകും. പ്രായോഗികമായി, ചില അപ്‌ഡേറ്റുകൾ വൈകിയാൽ നിലവിലുള്ളതും മുമ്പത്തെതുമായ മിനിറ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കാൻ കഴിഞ്ഞാൽ മതി. ലാളിത്യത്തിനായി, ഞങ്ങൾ ഈ കേസ് പരിഗണിക്കില്ല.

അഗ്രഗേഷൻ പ്രവർത്തനങ്ങൾ

ആവശ്യമായ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകൾ ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു. സേവനത്തിലെ ലോഡ് വർദ്ധിപ്പിക്കുന്നതിന് ഞാൻ അവയിൽ പരമാവധി എടുത്തു:

• ഉയർന്ന - പരമാവധി വില - മിനിറ്റിന് പരമാവധി വില.
• കുറഞ്ഞ - മിനിറ്റ് വില - മിനിറ്റിന് കുറഞ്ഞ വില.
• ആദ്യവില - ആദ്യ വില - മിനിറ്റിന് ആദ്യ വില.
• അവസാന വില - അവസാന വില - മിനിറ്റിലെ അവസാന വില.
• ആദ്യ വലുപ്പം - ആദ്യ വലുപ്പം - മിനിറ്റിൽ ആദ്യ വ്യാപാര വലുപ്പം.
• lastSize - അവസാന വലുപ്പം - ഒരു മിനിറ്റിനുള്ളിൽ അവസാന വ്യാപാര വലുപ്പം.
• numTrades - കൗണ്ട് i - മിനിറ്റിലെ ട്രേഡുകളുടെ എണ്ണം.
• വോളിയം - ആകെ വലുപ്പം - മിനിറ്റിലെ വ്യാപാര വലുപ്പങ്ങളുടെ ആകെത്തുക.
• pvolume - തുകയുടെ വില - ഒരു മിനിറ്റിലെ വിലകളുടെ ആകെത്തുക, ശരാശരി വിലയ്ക്ക് ആവശ്യമാണ്.
• - തുക വിറ്റുവരവ് വില* വലുപ്പം - ഒരു മിനിറ്റിലെ ഇടപാടുകളുടെ ആകെ അളവ്.
• ശരാശരി വില - pvolume%numTrades - മിനിറ്റിന് ശരാശരി വില.
• ശരാശരി വലുപ്പം - വോളിയം% numTrades - മിനിറ്റിൽ ശരാശരി വ്യാപാര വലുപ്പം.
• vwap - വിറ്റുവരവ്% വോളിയം - ഇടപാടിന്റെ വലുപ്പം അനുസരിച്ച് മിനിറ്റിന് ശരാശരി വില.
• cumVolume - സം വോളിയം - മുഴുവൻ സമയവും ഇടപാടുകളുടെ സഞ്ചിത വലുപ്പം.

വ്യക്തമല്ലാത്ത ഒരു പോയിന്റ് നമുക്ക് ഉടൻ ചർച്ച ചെയ്യാം - ഈ കോളങ്ങൾ ആദ്യമായി എങ്ങനെ ആരംഭിക്കാം, തുടർന്നുള്ള ഓരോ മിനിറ്റിലും. ഓരോ തവണയും അസാധുവാക്കാൻ ഫസ്റ്റ് പ്രൈസ് തരത്തിന്റെ ചില കോളങ്ങൾ ആരംഭിക്കണം; അവയുടെ മൂല്യം നിർവചിച്ചിട്ടില്ല. മറ്റ് വോളിയം തരങ്ങൾ എല്ലായ്‌പ്പോഴും 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;
…

എന്നാൽ നമുക്ക് കൂടുതൽ മുന്നോട്ട് പോകാം, ക്യുവിന് അദ്വിതീയവും അതിശക്തവുമായ ഒരു ഓപ്പറേറ്റർ ഉണ്ട് - സാമാന്യവൽക്കരിച്ച അസൈൻമെന്റ് ഓപ്പറേറ്റർ. സൂചികകൾ, ഫംഗ്‌ഷനുകൾ, ആർഗ്യുമെന്റുകൾ എന്നിവയുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിച്ച് സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനയിൽ ഒരു കൂട്ടം മൂല്യങ്ങൾ മാറ്റാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

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-ൽ, ഒരു ലിസ്റ്റ് സൃഷ്‌ടിക്കുന്നത് ഒരു ഫംഗ്‌ഷനാണെന്നും ലിസ്റ്റുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്നതിന് ഓരോ(മാപ്പ്) ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് നമുക്ക് അതിനെ വിളിക്കാമെന്നും ശ്രദ്ധിക്കുക.

കണക്കാക്കിയ നിരകളുടെ സെറ്റ് ഉറപ്പിച്ചിട്ടില്ലെന്ന് ഉറപ്പാക്കാൻ, മുകളിൽ പറഞ്ഞ പദപ്രയോഗം ഞങ്ങൾ ചലനാത്മകമായി സൃഷ്ടിക്കും. സമാഹരിച്ചതും ഇൻപുട്ട് ഡാറ്റയും റഫർ ചെയ്യുന്നതിന് വരിയും ഇൻപ് വേരിയബിളുകളും ഉപയോഗിച്ച് ഓരോ നിരയും കണക്കാക്കുന്നതിനുള്ള ഫംഗ്ഷനുകൾ നമുക്ക് ആദ്യം നിർവചിക്കാം:

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 ന് ഒരു തിരഞ്ഞെടുത്ത ഫംഗ്‌ഷൻ ഉണ്ട് - ?[ബൂളിയൻ ലിസ്റ്റ്;list1;list2] - ഇത് ആദ്യ ആർഗ്യുമെന്റിലെ വ്യവസ്ഥയെ ആശ്രയിച്ച് പട്ടിക 1 അല്ലെങ്കിൽ 2 ൽ നിന്ന് ഒരു മൂല്യം തിരഞ്ഞെടുക്കുന്നു:

// high -> ?[isFirst;inp`high;row[`high]|inp`high]
// @ - тоже обобщенное присваивание для случая когда индекс неглубокий
@[`aggExpression;specialCols;{[x;y]"?[isFirst;inp`",y,";",x,"]"};string specialCols];

ഇവിടെ ഞാൻ എന്റെ ഫംഗ്‌ഷനുള്ള ഒരു സാമാന്യവൽക്കരിച്ച അസൈൻമെന്റിനെ വിളിച്ചു (ചുരുണ്ട ബ്രേസുകളിലെ ഒരു പദപ്രയോഗം). ഇതിന് നിലവിലെ മൂല്യവും (ആദ്യത്തെ ആർഗ്യുമെന്റ്) ഒരു അധിക ആർഗ്യുമെന്റും ലഭിക്കുന്നു, അത് ഞാൻ നാലാമത്തെ പാരാമീറ്ററിൽ പാസ്സാക്കുന്നു.

ബാറ്ററി സ്പീക്കറുകൾ വെവ്വേറെ ചേർക്കാം, കാരണം അവയ്‌ക്കുള്ള പ്രവർത്തനം സമാനമാണ്:

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

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:{[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 ദശലക്ഷം വരികൾ) വളരെ വലുതാണ്; അത്തരം സന്ദർഭങ്ങളിൽ, സേവനത്തിന്റെ നിരവധി ക്ലോണുകൾ (അല്ലെങ്കിൽ ഡസൻ കണക്കിന് ക്ലോണുകൾ പോലും) സമാരംഭിക്കുന്നത് സാധാരണമാണ്, അവയിൽ ഓരോന്നും പ്രതീകങ്ങളുടെ ഒരു ഭാഗം മാത്രം പ്രോസസ്സ് ചെയ്യുന്നു. എന്നിരുന്നാലും, പ്രാഥമികമായി ഡാറ്റ സംഭരണത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന ഒരു വ്യാഖ്യാന ഭാഷയ്ക്ക് ഫലം ശ്രദ്ധേയമാണ്.

എന്തുകൊണ്ടാണ് ഓരോ അപ്‌ഡേറ്റിന്റെയും വലുപ്പത്തിനൊപ്പം സമയം രേഖീയമല്ലാത്ത രീതിയിൽ വളരുന്നത് എന്ന ചോദ്യം ഉയർന്നേക്കാം. കാരണം, ഷ്രിങ്ക് ഫംഗ്‌ഷൻ യഥാർത്ഥത്തിൽ ഒരു C ഫംഗ്‌ഷനാണ്, ഇത് updateAgg-നേക്കാൾ വളരെ കാര്യക്ഷമമാണ്. ഒരു നിശ്ചിത അപ്‌ഡേറ്റ് വലുപ്പത്തിൽ നിന്ന് (ഏകദേശം 10.000) ആരംഭിച്ച്, updateAgg അതിന്റെ പരിധിയിൽ എത്തുന്നു, തുടർന്ന് അതിന്റെ എക്‌സിക്യൂഷൻ സമയം അപ്‌ഡേറ്റ് വലുപ്പത്തെ ആശ്രയിക്കുന്നില്ല. പ്രിലിമിനറി സ്റ്റെപ്പ് ക്യു കാരണമാണ് അത്തരം ഡാറ്റയുടെ അളവുകൾ ദഹിപ്പിക്കാൻ സേവനത്തിന് കഴിയുന്നത്. വലിയ ഡാറ്റയുമായി പ്രവർത്തിക്കുമ്പോൾ ശരിയായ അൽഗോരിതം തിരഞ്ഞെടുക്കുന്നത് എത്ര പ്രധാനമാണെന്ന് ഇത് എടുത്തുകാണിക്കുന്നു. മെമ്മറിയിലെ ഡാറ്റയുടെ ശരിയായ സംഭരണമാണ് മറ്റൊരു പോയിന്റ്. ഡാറ്റ നിരയായി സംഭരിച്ചിട്ടില്ലെങ്കിലോ സമയത്തിനനുസരിച്ച് ഓർഡർ ചെയ്തിട്ടില്ലെങ്കിലോ, TLB കാഷെ മിസ് പോലുള്ള ഒരു കാര്യം ഞങ്ങൾ പരിചിതരാകും - പ്രോസസ്സർ വിലാസ കാഷെയിൽ മെമ്മറി പേജ് വിലാസത്തിന്റെ അഭാവം. ഒരു വിലാസം തിരയുന്നത് വിജയിച്ചില്ലെങ്കിൽ ഏകദേശം 30 മടങ്ങ് കൂടുതൽ സമയമെടുക്കും, കൂടാതെ ഡാറ്റ ചിതറിക്കിടക്കുകയാണെങ്കിൽ, അത് നിരവധി തവണ സേവനം മന്ദഗതിയിലാക്കാം.

തീരുമാനം

ഈ ലേഖനത്തിൽ, KDB+, Q ഡാറ്റാബേസ് വലിയ ഡാറ്റ സംഭരിക്കുന്നതിനും തിരഞ്ഞെടുക്കുന്നതിലൂടെ എളുപ്പത്തിൽ ആക്‌സസ് ചെയ്യുന്നതിനും മാത്രമല്ല, ദശലക്ഷക്കണക്കിന് വരികൾ/ജിഗാബൈറ്റ് ഡാറ്റ ദഹിപ്പിക്കാൻ കഴിവുള്ള ഡാറ്റ പ്രോസസ്സിംഗ് സേവനങ്ങൾ സൃഷ്ടിക്കുന്നതിനും അനുയോജ്യമാണെന്ന് ഞാൻ കാണിച്ചു. ഒരൊറ്റ Q പ്രക്രിയ. ക്യു ഭാഷ തന്നെ അതിന്റെ വെക്റ്റർ സ്വഭാവം, അന്തർനിർമ്മിത SQL ഡയലക്റ്റ് ഇന്റർപ്രെറ്റർ, വളരെ വിജയകരമായ ലൈബ്രറി ഫംഗ്ഷനുകൾ എന്നിവ കാരണം ഡാറ്റ പ്രോസസ്സിംഗുമായി ബന്ധപ്പെട്ട അൽഗോരിതങ്ങൾ വളരെ സംക്ഷിപ്തവും കാര്യക്ഷമവുമായ നടപ്പിലാക്കാൻ അനുവദിക്കുന്നു.

ക്യുവിന് ചെയ്യാൻ കഴിയുന്നതിന്റെ ഒരു ഭാഗം മാത്രമാണ് മുകളിൽ പറഞ്ഞിരിക്കുന്നതെന്ന് ഞാൻ ശ്രദ്ധിക്കും, ഇതിന് മറ്റ് സവിശേഷ സവിശേഷതകളും ഉണ്ട്. ഉദാഹരണത്തിന്, വളരെ ലളിതമായ ഒരു IPC പ്രോട്ടോക്കോൾ വ്യക്തിഗത ക്യു പ്രോസസുകൾ തമ്മിലുള്ള അതിർത്തി മായ്‌ക്കുകയും ലോകത്തിന്റെ വിവിധ ഭാഗങ്ങളിൽ ഡസൻ കണക്കിന് സെർവറുകളിൽ സ്ഥിതി ചെയ്യുന്ന ഒരൊറ്റ നെറ്റ്‌വർക്കിലേക്ക് നൂറുകണക്കിന് ഈ പ്രക്രിയകൾ സംയോജിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു.

അവലംബം: www.habr.com