លក្ខណៈពិសេសនៃភាសា Q និង KDB+ ដោយប្រើឧទាហរណ៍នៃសេវាកម្មពេលវេលាជាក់ស្តែង

អ្នក​អាច​អាន​អំពី​អ្វី​ដែល​មូលដ្ឋាន KDB+ ភាសា​សរសេរ​កម្មវិធី Q អ្វី​ជា​ចំណុច​ខ្លាំង​និង​ចំណុច​ខ្សោយ​របស់​វា​នៅ​ក្នុង​កម្មវិធី​មុន​របស់​ខ្ញុំ អត្ថបទ ហើយដោយសង្ខេបនៅក្នុងការណែនាំ។ នៅក្នុងអត្ថបទ យើងនឹងអនុវត្តសេវាកម្មមួយនៅលើ Q ដែលនឹងដំណើរការស្ទ្រីមទិន្នន័យចូល និងគណនាមុខងារប្រមូលផ្តុំផ្សេងៗជារៀងរាល់នាទីក្នុងរបៀប "ពេលវេលាពិត" (ឧទាហរណ៍ វានឹងមានពេលវេលាដើម្បីគណនាអ្វីៗទាំងអស់មុននឹងផ្នែកបន្ទាប់នៃទិន្នន័យ)។ លក្ខណៈពិសេសចម្បងរបស់ Q គឺថាវាជាភាសាវ៉ិចទ័រដែលអនុញ្ញាតឱ្យអ្នកដំណើរការមិនមែនជាមួយវត្ថុតែមួយទេ ប៉ុន្តែជាមួយនឹងអារេរបស់ពួកគេ អារេនៃអារេ និងវត្ថុស្មុគស្មាញផ្សេងទៀត។ ភាសាដូចជា Q និងសាច់ញាតិរបស់វា K, J, APL មានភាពល្បីល្បាញដោយសារភាពខ្លីរបស់ពួកគេ។ ជាញឹកញយ កម្មវិធីដែលប្រើអេក្រង់កូដជាច្រើននៅក្នុងភាសាដែលធ្លាប់ស្គាល់ដូចជា Java អាចត្រូវបានសរសេរនៅលើពួកវាជាពីរជួរ។ នេះជាអ្វីដែលខ្ញុំចង់បង្ហាញនៅក្នុងអត្ថបទនេះ។

សេចក្តីណែនាំ

KDB+ គឺ​ជា​មូលដ្ឋាន​ទិន្នន័យ​ជួរ​ឈរ​ដែល​ផ្តោត​លើ​ចំនួន​ទិន្នន័យ​ដ៏​ច្រើន​ដែល​បាន​តម្រៀប​តាម​វិធី​ជាក់លាក់​មួយ (ជា​ចម្បង​តាម​ពេលវេលា)។ វាត្រូវបានប្រើជាចម្បងនៅក្នុងស្ថាប័នហិរញ្ញវត្ថុ - ធនាគារ មូលនិធិវិនិយោគ ក្រុមហ៊ុនធានារ៉ាប់រង។ ភាសា Q គឺជាភាសាផ្ទៃក្នុងរបស់ KDB+ ដែលអនុញ្ញាតឱ្យអ្នកធ្វើការជាមួយទិន្នន័យនេះប្រកបដោយប្រសិទ្ធភាព។ មនោគមវិជ្ជា Q មានភាពរហ័សរហួន និងប្រសិទ្ធភាព ខណៈពេលដែលភាពច្បាស់លាស់ត្រូវបានលះបង់។ នេះសមហេតុផលដោយការពិតដែលថាភាសាវ៉ិចទ័រនឹងពិបាកយល់ក្នុងករណីណាក៏ដោយ ហើយភាពរហ័សរហួន និងភាពសម្បូរបែបនៃការថតអនុញ្ញាតឱ្យអ្នកឃើញផ្នែកធំជាងនៃកម្មវិធីនៅលើអេក្រង់តែមួយ ដែលនៅទីបំផុតធ្វើឱ្យវាកាន់តែងាយស្រួលយល់។

នៅក្នុងអត្ថបទនេះ យើងអនុវត្តកម្មវិធីពេញលេញនៅក្នុង Q ហើយអ្នកប្រហែលជាចង់សាកល្បងវា។ ដើម្បីធ្វើដូចនេះអ្នកនឹងត្រូវការ Q ពិតប្រាកដ អ្នកអាចទាញយកកំណែ 32 ប៊ីតដោយឥតគិតថ្លៃនៅលើគេហទំព័ររបស់ក្រុមហ៊ុន kx - www.kx.com. នៅទីនោះ ប្រសិនបើអ្នកចាប់អារម្មណ៍ អ្នកនឹងរកឃើញព័ត៌មានយោងនៅលើ Q សៀវភៅនេះ។ Q សម្រាប់មនុស្សស្លាប់ និងអត្ថបទផ្សេងៗលើប្រធានបទនេះ។

ការបង្កើតបញ្ហា

មានប្រភពដែលផ្ញើតារាងជាមួយទិន្នន័យរៀងរាល់ 25 មីលីវិនាទី។ ដោយសារ KDB+ ត្រូវបានប្រើជាចម្បងក្នុងផ្នែកហិរញ្ញវត្ថុ យើងនឹងសន្មត់ថានេះជាតារាងប្រតិបត្តិការ (ពាណិជ្ជកម្ម) ដែលមានជួរដូចខាងក្រោមៈ ពេលវេលា (ពេលវេលាគិតជាមិល្លីវិនាទី) ស៊ីម (ការកំណត់ក្រុមហ៊ុននៅលើផ្សារហ៊ុន - ក្រុមហ៊ុន IBM, Apple បាន,…), តម្លៃ (តម្លៃដែលភាគហ៊ុនត្រូវបានទិញ), ទំហំ (ទំហំប្រតិបត្តិការ) ។ ចន្លោះពេល 25 មិល្លីវិនាទីគឺតាមអំពើចិត្ត មិនតូចពេក និងមិនយូរពេក។ វត្តមានរបស់វាមានន័យថា ទិន្នន័យមកដល់សេវាត្រូវបានរារាំងរួចហើយ។ វានឹងមានភាពងាយស្រួលក្នុងការអនុវត្ត buffering នៅលើផ្នែកសេវាកម្ម រួមទាំង dynamic buffering អាស្រ័យលើបន្ទុកបច្ចុប្បន្ន ប៉ុន្តែសម្រាប់ភាពសាមញ្ញ យើងនឹងផ្តោតលើចន្លោះពេលថេរ។

សេវាកម្មត្រូវតែរាប់រាល់នាទីសម្រាប់និមិត្តសញ្ញាចូលនីមួយៗពីជួរ sym សំណុំនៃមុខងារសរុប - តម្លៃអតិបរមា តម្លៃជាមធ្យម ទំហំបូក។ល។ ព័ត៌មានមានប្រយោជន៍។ សម្រាប់ភាពសាមញ្ញ យើងនឹងសន្មត់ថាមុខងារទាំងអស់អាចត្រូវបានគណនាជាបណ្តើរៗ i.e. ដើម្បីទទួលបានតម្លៃថ្មី វាគ្រប់គ្រាន់ដើម្បីដឹងចំនួនពីរ - តម្លៃចាស់ និងតម្លៃចូល។ ឧទាហរណ៍ អនុគមន៍អតិបរមា មធ្យម ផលបូកមានទ្រព្យសម្បត្តិនេះ ប៉ុន្តែអនុគមន៍មធ្យមមិនមានទេ។

យើង​ក៏​នឹង​សន្មត​ថា​ការ​ស្ទ្រីម​ទិន្នន័យ​ចូល​ត្រូវ​បាន​បញ្ជា​តាម​ពេល​វេលា។ នេះនឹងផ្តល់ឱ្យយើងនូវឱកាសដើម្បីធ្វើការតែជាមួយនាទីចុងក្រោយប៉ុណ្ណោះ។ នៅក្នុងការអនុវត្ត វាគ្រប់គ្រាន់ដើម្បីអាចធ្វើការជាមួយនាទីបច្ចុប្បន្ន និងមុន ក្នុងករណីដែលការអាប់ដេតខ្លះយឺត។ សម្រាប់ភាពសាមញ្ញយើងនឹងមិនពិចារណាករណីនេះទេ។

មុខងារនៃការប្រមូលផ្តុំ

មុខងារប្រមូលផ្តុំដែលត្រូវការត្រូវបានរាយខាងក្រោម។ ខ្ញុំបានយកវាឱ្យបានច្រើនតាមដែលអាចធ្វើទៅបាន ដើម្បីបង្កើនបន្ទុកលើសេវាកម្ម៖

• តម្លៃខ្ពស់ - តម្លៃអតិបរមា - តម្លៃអតិបរមាក្នុងមួយនាទី។
• តម្លៃទាប - តម្លៃអប្បបរមា - តម្លៃអប្បបរមាក្នុងមួយនាទី។
• FirstPrice - តម្លៃដំបូង - តម្លៃដំបូងក្នុងមួយនាទី។
• LastPrice - តម្លៃចុងក្រោយ - តម្លៃចុងក្រោយក្នុងមួយនាទី។
• ទំហំដំបូង - ទំហំដំបូង - ទំហំពាណិជ្ជកម្មដំបូងក្នុងមួយនាទី។
• LastSize - ទំហំចុងក្រោយ - ទំហំពាណិជ្ជកម្មចុងក្រោយក្នុងរយៈពេលមួយនាទី។
• numTrades - រាប់ i - ចំនួននៃការជួញដូរក្នុងមួយនាទី។
• បរិមាណ - ទំហំសរុប - ផលបូកនៃទំហំពាណិជ្ជកម្មក្នុងមួយនាទី។
• pvolume – sum price – ផលបូកនៃតម្លៃក្នុងមួយនាទី ទាមទារសម្រាប់ avgPrice ។
• - ផលបូកតម្លៃ * ទំហំ - បរិមាណសរុបនៃប្រតិបត្តិការក្នុងមួយនាទី។
• avgPrice – pvolume%numTrades – តម្លៃជាមធ្យមក្នុងមួយនាទី។
• avgSize – volume%numTrades – ទំហំពាណិជ្ជកម្មជាមធ្យមក្នុងមួយនាទី។
• vwap – turnover%volume – តម្លៃជាមធ្យមក្នុងមួយនាទីមានទម្ងន់តាមទំហំប្រតិបត្តិការ។
• 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 объяснен ниже

ខ្ញុំបានបន្ថែម sym និងពេលវេលាទៅវចនានុក្រមសម្រាប់ភាពងាយស្រួល ឥឡូវនេះ initWith គឺជាបន្ទាត់ដែលត្រៀមរួចជាស្រេចពីតារាងសរុបចុងក្រោយ ដែលវានៅសល់ដើម្បីកំណត់ sym និងពេលវេលាត្រឹមត្រូវ។ អ្នកអាចប្រើវាដើម្បីបន្ថែមជួរថ្មីទៅតារាង។

យើងនឹងត្រូវការ aggCols នៅពេលបង្កើតមុខងារប្រមូលផ្តុំ។ បញ្ជីត្រូវតែដាក់បញ្ច្រាសដោយសារតែលំដាប់ដែលកន្សោមនៅក្នុង Q ត្រូវបានវាយតម្លៃ (ពីស្តាំទៅឆ្វេង)។ គោលដៅគឺដើម្បីធានាថាការគណនាពីកម្រិតខ្ពស់ទៅ cumVolume ចាប់តាំងពីជួរឈរមួយចំនួនអាស្រ័យលើជួរមុន។

ជួរ​ឈរ​ដែល​ត្រូវ​ចម្លង​ទៅ​នាទី​ថ្មី​ពី​លើក​មុន ជួរ​ឈរ sym ត្រូវ​បាន​បន្ថែម​ដើម្បី​ងាយស្រួល៖

rollColumns:`sym`cumVolume;

ឥឡូវ​យើង​ចែក​ជួរ​ឈរ​ជា​ក្រុម​តាម​របៀប​ដែល​គេ​គួរ​ធ្វើ​បច្ចុប្បន្នភាព។ បីប្រភេទអាចត្រូវបានសម្គាល់:

1. Accumulators (volume, turnover,..) – យើងត្រូវបន្ថែមតម្លៃចូលទៅកាន់លេខមុន។
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 និងដែលត្រូវការនៅក្នុងមុខងារជ្រើសរើស។ សូមចំណាំផងដែរថាដំណើរការមុនត្រូវបានកំណត់ជាការព្យាករ (ឧ. មុខងារដែលមានអាគុយម៉ង់ដែលបានកំណត់ដោយផ្នែក) នៃអនុគមន៍ជ្រើសរើស អាគុយម៉ង់មួយ (តារាង) ត្រូវបានបាត់។ ប្រសិន​បើ​យើង​អនុវត្ត​ដំណើរការ​មុន​ទៅ​តារាង យើង​នឹង​ទទួល​បាន​តារាង​បង្ហាប់។

ដំណាក់កាលទីពីរគឺការធ្វើបច្ចុប្បន្នភាពតារាងសរុប។ ដំបូងយើងសរសេរ algorithm ក្នុង 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];
  …

នៅក្នុង Q វាជារឿងធម្មតាក្នុងការប្រើមុខងារផែនទី/កាត់បន្ថយជំនួសឱ្យរង្វិលជុំ។ ប៉ុន្តែដោយសារ 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 ការបង្កើតបញ្ជីក៏ជាមុខងារមួយដែរ ហើយយើងអាចហៅវាដោយប្រើមុខងារនីមួយៗ (ផែនទី) ដើម្បីទទួលបានបញ្ជីបញ្ជី។

ដើម្បីធានាថាសំណុំនៃជួរឈរដែលបានគណនាមិនត្រូវបានជួសជុល យើងនឹងបង្កើតកន្សោមខាងលើដោយថាមវន្ត។ ដំបូង​យើង​កំណត់​មុខងារ​ក្នុង​ការ​គណនា​ជួរ​ឈរ​នីមួយៗ ដោយ​ប្រើ​អថេរ​ជួរ​ដេក និង​បញ្ចូល​ដើម្បី​យោង​ទៅ​លើ​ទិន្នន័យ​ដែល​រួម​បញ្ចូល និង​បញ្ចូល៖

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 មានមុខងារជ្រើសរើស - ?[Boolean list;list1;list2] - ដែលជ្រើសរើសតម្លៃពីបញ្ជី 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 លំដាប់​វាយ​តម្លៃ​គឺ​ពី​ស្តាំ​ទៅ​ឆ្វេង។

ឥឡូវនេះយើងមានមុខងារសំខាន់ពីរដែលចាំបាច់សម្រាប់ការគណនា យើងគ្រាន់តែត្រូវការបន្ថែមហេដ្ឋារចនាសម្ព័ន្ធបន្តិចបន្តួច ហើយសេវាកម្មគឺរួចរាល់។

ជំហានចុងក្រោយ

យើងមានមុខងារ preprocess និង updateAgg ដែលធ្វើការងារទាំងអស់។ ប៉ុន្តែវានៅតែចាំបាច់ដើម្បីធានាឱ្យមានការផ្លាស់ប្តូរត្រឹមត្រូវតាមរយៈនាទី និងគណនាសន្ទស្សន៍សម្រាប់ការប្រមូលផ្តុំ។ ជាដំបូង ចូរយើងកំណត់មុខងារ 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 លានជួរក្នុងមួយនាទី) គឺធំខ្លាំងណាស់ នៅក្នុងករណីបែបនេះ វាជារឿងធម្មតាក្នុងការបើកដំណើរការក្លូនជាច្រើន (ឬសូម្បីតែក្លូនរាប់សិប) នៃសេវាកម្ម ដែលនីមួយៗដំណើរការតែផ្នែកនៃតួអក្សរប៉ុណ្ណោះ។ ទោះយ៉ាងណាក៏ដោយ លទ្ធផលគឺគួរឱ្យចាប់អារម្មណ៍សម្រាប់ភាសាដែលបានបកប្រែដែលផ្តោតលើការផ្ទុកទិន្នន័យជាចម្បង។

សំណួរអាចកើតឡើងថាហេតុអ្វីបានជាពេលវេលាកើនឡើងមិនស្មើគ្នាជាមួយនឹងទំហំនៃការធ្វើបច្ចុប្បន្នភាពនីមួយៗ។ ហេតុផលគឺថា មុខងាររួញ តាមពិតទៅមុខងារ C ដែលមានប្រសិទ្ធភាពជាង updateAgg ។ ចាប់ផ្តើមពីទំហំអាប់ដេតជាក់លាក់ (ប្រហែល 10.000) updateAgg ឈានដល់ពិដានរបស់វា ហើយបន្ទាប់មកពេលវេលាប្រតិបត្តិរបស់វាមិនអាស្រ័យលើទំហំអាប់ដេតនោះទេ។ វាកើតឡើងដោយសារជំហានបឋម Q ដែលសេវាកម្មអាចរំលាយបរិមាណទិន្នន័យបែបនេះ។ នេះបង្ហាញពីសារៈសំខាន់នៃការជ្រើសរើសក្បួនដោះស្រាយត្រឹមត្រូវនៅពេលធ្វើការជាមួយទិន្នន័យធំ។ ចំណុចមួយទៀតគឺការផ្ទុកទិន្នន័យក្នុងអង្គចងចាំត្រឹមត្រូវ។ ប្រសិនបើទិន្នន័យមិនត្រូវបានរក្សាទុកជាជួរ ឬមិនត្រូវបានបញ្ជាទិញតាមពេលវេលាទេ នោះយើងនឹងស៊ាំជាមួយរឿងដូចជា បាត់ឃ្លាំងសម្ងាត់ TLB - អវត្ដមាននៃអាសយដ្ឋានទំព័រអង្គចងចាំនៅក្នុងឃ្លាំងសម្ងាត់អាសយដ្ឋានដំណើរការ។ ការស្វែងរកអាសយដ្ឋានត្រូវចំណាយពេលយូរជាងនេះប្រហែល 30 ដង ប្រសិនបើមិនជោគជ័យ ហើយប្រសិនបើទិន្នន័យត្រូវបានខ្ចាត់ខ្ចាយ វាអាចបន្ថយសេវាកម្មជាច្រើនដង។

សេចក្តីសន្និដ្ឋាន

នៅក្នុងអត្ថបទនេះ ខ្ញុំបានបង្ហាញថា មូលដ្ឋានទិន្នន័យ KDB+ និង Q គឺសមរម្យមិនត្រឹមតែសម្រាប់រក្សាទុកទិន្នន័យធំ និងងាយស្រួលចូលប្រើវាតាមរយៈការជ្រើសរើសប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងសម្រាប់បង្កើតសេវាកម្មដំណើរការទិន្នន័យដែលមានសមត្ថភាពរំលាយទិន្នន័យរាប់រយលានជួរ/ជីហ្គាបៃសូម្បីតែនៅក្នុង ដំណើរការ Q តែមួយ។ ភាសា Q ខ្លួនវាអនុញ្ញាតឱ្យមានការអនុវត្តយ៉ាងសង្ខេប និងមានប្រសិទ្ធភាពនៃក្បួនដោះស្រាយទាក់ទងនឹងដំណើរការទិន្នន័យ ដោយសារលក្ខណៈវ៉ិចទ័ររបស់វា អ្នកបកប្រែភាសា SQL ដែលភ្ជាប់មកជាមួយ និងសំណុំមុខងារបណ្ណាល័យដ៏ជោគជ័យ។

ខ្ញុំនឹងកត់សម្គាល់ថាខាងលើគ្រាន់តែជាផ្នែកនៃអ្វីដែល Q អាចធ្វើបាន វាមានលក្ខណៈពិសេសប្លែកផ្សេងទៀតផងដែរ។ ឧទាហរណ៍ ពិធីការ IPC ដ៏សាមញ្ញបំផុតដែលលុបព្រំដែនរវាងដំណើរការ Q នីមួយៗ និងអនុញ្ញាតឱ្យអ្នកបញ្ចូលគ្នារាប់រយនៃដំណើរការទាំងនេះទៅក្នុងបណ្តាញតែមួយ ដែលអាចមានទីតាំងនៅលើម៉ាស៊ីនមេរាប់សិបនៅក្នុងផ្នែកផ្សេងៗនៃពិភពលោក។

ប្រភព: www.habr.com