ຄຸນສົມບັດຂອງພາສາ Q ແລະ KDB+ ໂດຍໃຊ້ຕົວຢ່າງຂອງການບໍລິການແບບສົດໆ

ທ່ານສາມາດອ່ານກ່ຽວກັບພື້ນຖານຂອງ KDB+, ພາສາການຂຽນໂປລແກລມ Q ແມ່ນຫຍັງ, ຈຸດແຂງແລະຈຸດອ່ອນຂອງພວກເຂົາແມ່ນຫຍັງໃນອະດີດຂອງຂ້ອຍ ບົດຄວາມ ແລະໄລຍະສັ້ນໆໃນການແນະນໍາ. ໃນບົດຄວາມ, ພວກເຮົາຈະປະຕິບັດການບໍລິການກ່ຽວກັບ Q ທີ່ຈະປະມວນຜົນກະແສຂໍ້ມູນຂາເຂົ້າແລະຄິດໄລ່ຫນ້າທີ່ລວມຕ່າງໆໃນທຸກໆນາທີໃນຮູບແບບ "ເວລາຈິງ" (ເຊັ່ນ: ມັນຈະມີເວລາທີ່ຈະຄິດໄລ່ທຸກຢ່າງກ່ອນຂໍ້ມູນສ່ວນຕໍ່ໄປ). ລັກສະນະຕົ້ນຕໍຂອງ Q ແມ່ນວ່າມັນເປັນພາສາ vector ທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດດໍາເນີນການບໍ່ແມ່ນກັບວັດຖຸດຽວ, ແຕ່ກັບ arrays, array ຂອງ array ແລະວັດຖຸສະລັບສັບຊ້ອນອື່ນໆ. ພາສາເຊັ່ນ Q ແລະພີ່ນ້ອງຂອງມັນ K, J, APL ແມ່ນມີຊື່ສຽງສໍາລັບຄວາມຫຍໍ້ຂອງມັນ. ເລື້ອຍໆ, ໂປລແກລມທີ່ເອົາລະຫັດຫຼາຍຫນ້າຈໍໃນພາສາທີ່ຄຸ້ນເຄີຍເຊັ່ນ Java ສາມາດຖືກຂຽນໃສ່ພວກມັນໃນສອງສາມແຖວ. ນີ້ແມ່ນສິ່ງທີ່ຂ້ອຍຕ້ອງການສະແດງໃຫ້ເຫັນໃນບົດຄວາມນີ້.

ການນໍາສະເຫນີ

KDB+ ແມ່ນຖານຂໍ້ມູນຖັນທີ່ເນັ້ນໃສ່ຂໍ້ມູນຈໍານວນຫຼວງຫຼາຍ, ຈັດຮຽງຕາມແບບສະເພາະ (ຕົ້ນຕໍແມ່ນຕາມເວລາ). ມັນຖືກນໍາໃຊ້ຕົ້ນຕໍໃນສະຖາບັນການເງິນ - ທະນາຄານ, ກອງທຶນການລົງທຶນ, ບໍລິສັດປະກັນໄພ. ພາສາ Q ແມ່ນພາສາພາຍໃນຂອງ KDB+ ທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດເຮັດວຽກກັບຂໍ້ມູນນີ້ໄດ້ຢ່າງມີປະສິດທິພາບ. ອຸດົມການ Q ແມ່ນ brevity ແລະປະສິດທິພາບ, ໃນຂະນະທີ່ຄວາມຊັດເຈນແມ່ນການເສຍສະລະ. ນີ້ແມ່ນເຫດຜົນໂດຍຄວາມຈິງທີ່ວ່າພາສາ vector ຈະຍາກທີ່ຈະເຂົ້າໃຈໃນກໍລະນີໃດກໍ່ຕາມ, ແລະຄວາມອຸດົມສົມບູນຂອງການບັນທຶກຊ່ວຍໃຫ້ທ່ານເຫັນສ່ວນໃຫຍ່ກວ່າຂອງໂປແກມໃນຫນ້າຈໍດຽວ, ເຊິ່ງໃນທີ່ສຸດເຮັດໃຫ້ມັນງ່າຍຕໍ່ການເຂົ້າໃຈ.

ໃນບົດຄວາມນີ້ພວກເຮົາປະຕິບັດໂຄງການເຕັມຮູບແບບໃນ Q ແລະທ່ານອາດຈະຕ້ອງການລອງມັນອອກ. ເພື່ອເຮັດສິ່ງນີ້, ທ່ານຈະຕ້ອງການ Q. ຕົວຈິງ, ທ່ານສາມາດດາວໂຫລດເວີຊັນ 32-bit ໄດ້ຟຣີຢູ່ໃນເວັບໄຊທ໌ຂອງບໍລິສັດ kx - www.kx.com. ຢູ່ທີ່ນັ້ນ, ຖ້າທ່ານສົນໃຈ, ທ່ານຈະຊອກຫາຂໍ້ມູນອ້າງອີງກ່ຽວກັບ Q, ປື້ມ ຖາມສໍາລັບມະນຸດ ແລະບົດຄວາມຕ່າງໆກ່ຽວກັບຫົວຂໍ້ນີ້.

ການສ້າງບັນຫາ

ມີແຫຼ່ງທີ່ສົ່ງຕາຕະລາງທີ່ມີຂໍ້ມູນທຸກໆ 25 milliseconds. ເນື່ອງຈາກ KDB+ ຖືກນໍາໃຊ້ຕົ້ນຕໍໃນດ້ານການເງິນ, ພວກເຮົາຈະສົມມຸດວ່ານີ້ແມ່ນຕາຕະລາງການເຮັດທຸລະກໍາ (ການຄ້າ), ທີ່ມີຖັນຕໍ່ໄປນີ້: ເວລາ (ເວລາເປັນ milliseconds), sym (ການກໍານົດບໍລິສັດໃນຕະຫຼາດຫຼັກຊັບ -. IBM, AAPL,…), ລາຄາ (ລາຄາທີ່ຮຸ້ນໄດ້ຖືກຊື້), ຂະຫນາດ (ຂະຫນາດຂອງການເຮັດທຸລະກໍາ). ໄລຍະຫ່າງ 25 millisecond ແມ່ນຕາມໃຈມັກ, ບໍ່ນ້ອຍເກີນໄປ ແລະ ບໍ່ດົນເກີນໄປ. ການປະກົດຕົວຂອງມັນຫມາຍຄວາມວ່າຂໍ້ມູນມາຮອດການບໍລິການທີ່ຖືກ buffed ແລ້ວ. ມັນຈະເປັນການງ່າຍທີ່ຈະປະຕິບັດ buffering ໃນດ້ານການບໍລິການ, ລວມທັງ buffering ແບບເຄື່ອນໄຫວໂດຍອີງຕາມການໂຫຼດໃນປະຈຸບັນ, ແຕ່ສໍາລັບຄວາມງ່າຍດາຍ, ພວກເຮົາຈະສຸມໃສ່ໄລຍະເວລາຄົງທີ່.

ການບໍລິການຕ້ອງນັບທຸກໆນາທີສໍາລັບແຕ່ລະສັນຍາລັກຂາເຂົ້າຈາກຖັນ sym ຊຸດຂອງຟັງຊັນການລວບລວມ - ລາຄາສູງສຸດ, ລາຄາສະເລ່ຍ, ຂະຫນາດລວມ, ແລະອື່ນໆ. ຂໍ້ມູນທີ່ເປັນປະໂຫຍດ. ສໍາລັບຄວາມງ່າຍດາຍ, ພວກເຮົາຈະສົມມຸດວ່າຫນ້າທີ່ທັງຫມົດສາມາດໄດ້ຮັບການຄິດໄລ່ incrementally, i.e. ເພື່ອໃຫ້ໄດ້ມູນຄ່າໃຫມ່, ມັນພຽງພໍທີ່ຈະຮູ້ສອງຕົວເລກ - ຄ່າເກົ່າແລະມູນຄ່າຂາເຂົ້າ. ຕົວຢ່າງ, ຟັງຊັນ max, average, sum ມີຄຸນສົມບັດນີ້, ແຕ່ຟັງຊັນ median ບໍ່ມີ.

ພວກເຮົາຍັງຈະສົມມຸດວ່າການຖ່າຍທອດຂໍ້ມູນຂາເຂົ້າແມ່ນຄໍາສັ່ງເວລາ. ນີ້ຈະໃຫ້ພວກເຮົາມີໂອກາດທີ່ຈະເຮັດວຽກພຽງແຕ່ນາທີສຸດທ້າຍ. ໃນການປະຕິບັດ, ມັນພຽງພໍທີ່ຈະສາມາດເຮັດວຽກກັບນາທີໃນປະຈຸບັນແລະກ່ອນຫນ້າໃນກໍລະນີທີ່ການປັບປຸງບາງຢ່າງຊ້າ. ສໍາລັບຄວາມງ່າຍດາຍ, ພວກເຮົາຈະບໍ່ພິຈາລະນາກໍລະນີນີ້.

ຟັງຊັນການລວບລວມ

ຟັງຊັນການລວບລວມທີ່ຕ້ອງການແມ່ນລະບຸໄວ້ຂ້າງລຸ່ມນີ້. ຂ້ອຍເອົາພວກມັນຫຼາຍເທົ່າທີ່ເປັນໄປໄດ້ເພື່ອເພີ່ມການໂຫຼດໃນການບໍລິການ:

• high – ລາຄາສູງສຸດ – ລາຄາສູງສຸດຕໍ່ນາທີ.
• low – min price – ລາຄາຕໍາ່ສຸດຕໍ່ນາທີ.
• firstPrice – ລາຄາທໍາອິດ – ລາຄາທໍາອິດຕໍ່ນາທີ.
• LastPrice - ລາຄາສຸດທ້າຍ - ລາຄາສຸດທ້າຍຕໍ່ນາທີ.
• firstSize - ຂະຫນາດທໍາອິດ - ຂະຫນາດການຄ້າຄັ້ງທໍາອິດຕໍ່ນາທີ.
• LastSize - ຂະຫນາດສຸດທ້າຍ - ຂະຫນາດການຄ້າສຸດທ້າຍໃນຫນຶ່ງນາທີ.
• numTrades – ນັບ i – ຈໍານວນຂອງການຊື້ຂາຍຕໍ່ນາທີ.
• ປະລິມານ – ຂະຫນາດລວມ – ຜົນລວມຂອງຂະຫນາດການຄ້າຕໍ່ນາທີ.
• pvolume – ລາຄາລວມ – ຜົນລວມຂອງລາຄາຕໍ່ນາທີ, ຕ້ອງການສໍາລັບ avgPrice.
• – ລາຄາລວມຍອດເງິນ* ຂະໜາດ – ປະລິມານການເຮັດທຸລະກຳທັງໝົດຕໍ່ນາທີ.
• avgPrice – pvolume%numTrades – ລາຄາສະເລ່ຍຕໍ່ນາທີ.
• avgSize – ປະລິມານ%numTrades – ຂະຫນາດການຄ້າສະເລ່ຍຕໍ່ນາທີ.
• vwap – turnover%volume – ລາຄາສະເລ່ຍຕໍ່ນາທີ ນ້ຳໜັກຕາມຂະໜາດທຸລະກຳ.
• cumVolume – ປະ​ລິ​ມານ​ລວມ – ຂະ​ຫນາດ​ສະ​ສົມ​ຂອງ​ການ​ເຮັດ​ທຸ​ລະ​ກໍາ​ໃນ​ໄລ​ຍະ​ທັງ​ຫມົດ.

ໃຫ້ປຶກສາຫາລືທັນທີຫນຶ່ງຈຸດທີ່ບໍ່ຊັດເຈນ - ວິທີການເລີ່ມຕົ້ນຂອງຄໍລໍາເຫຼົ່ານີ້ຄັ້ງທໍາອິດແລະສໍາລັບແຕ່ລະນາທີຕໍ່ມາ. ບາງຖັນຂອງປະເພດ firstPrice ຈະຕ້ອງຖືກຕັ້ງຕົ້ນເປັນ null ແຕ່ລະເທື່ອ; ຄ່າຂອງພວກມັນບໍ່ໄດ້ຖືກກຳນົດ. ປະເພດປະລິມານອື່ນໆຕ້ອງຖືກຕັ້ງເປັນ 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. ຄັງສະສົມ (ປະລິມານ, ການຫັນປ່ຽນ, ..) – ພວກເຮົາຕ້ອງເພີ່ມມູນຄ່າຂາເຂົ້າກັບອັນກ່ອນໜ້າ.
2. ດ້ວຍຈຸດພິເສດ (ສູງ, ຕໍ່າ, ..) - ຄ່າທໍາອິດໃນນາທີແມ່ນເອົາມາຈາກຂໍ້ມູນຂາເຂົ້າ, ສ່ວນທີ່ເຫຼືອແມ່ນຄິດໄລ່ໂດຍໃຊ້ຟັງຊັນ.
3. ພັກຜ່ອນ. ຄິດໄລ່ສະເໝີໂດຍໃຊ້ຟັງຊັນ.

ໃຫ້ກໍານົດຕົວແປສໍາລັບຫ້ອງຮຽນເຫຼົ່ານີ້:

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

ຄໍາສັ່ງຄິດໄລ່

ພວກເຮົາຈະປັບປຸງຕາຕະລາງລວມໃນສອງຂັ້ນຕອນ. ເພື່ອປະສິດທິພາບ, ພວກເຮົາທໍາອິດຫຼຸດລົງຕາຕະລາງຂາເຂົ້າເພື່ອໃຫ້ມີພຽງແຕ່ຫນຶ່ງແຖວສໍາລັບແຕ່ລະຕົວອັກສອນແລະນາທີ. ຄວາມຈິງທີ່ວ່າຫນ້າທີ່ຂອງພວກເຮົາທັງຫມົດແມ່ນ incremental ແລະ associative ຮັບປະກັນວ່າຜົນໄດ້ຮັບຂອງຂັ້ນຕອນເພີ່ມເຕີມນີ້ຈະບໍ່ມີການປ່ຽນແປງ. ທ່ານສາມາດຫຍໍ້ຕາຕະລາງໂດຍການເລືອກ:

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

ວິທີການນີ້ມີຂໍ້ເສຍ - ຊຸດຂອງຄໍລໍາທີ່ຄິດໄລ່ແມ່ນຖືກກໍານົດໄວ້ລ່ວງຫນ້າ. ໂຊກດີ, ໃນ Q, ເລືອກຍັງຖືກປະຕິບັດເປັນຫນ້າທີ່ທີ່ທ່ານສາມາດທົດແທນການໂຕ້ຖຽງທີ່ສ້າງແບບເຄື່ອນໄຫວ:

?[table;whereClause;byClause;selectClause]

ຂ້າ​ພະ​ເຈົ້າ​ຈະ​ບໍ່​ອະ​ທິ​ບາຍ​ໃນ​ລາຍ​ລະ​ອຽດ​ຮູບ​ແບບ​ຂອງ​ການ​ໂຕ້​ຖຽງ; ໃນ​ກໍ​ລະ​ນີ​ຂອງ​ພວກ​ເຮົາ, ພຽງ​ແຕ່​ໂດຍ​ແລະ​ການ​ສະ​ແດງ​ອອກ​ທີ່​ຈະ​ເລືອກ​ທີ່​ຈະ​ເປັນ nontrivial ແລະ​ພວກ​ເຂົາ​ເຈົ້າ​ຄວນ​ຈະ​ເປັນ​ວັດ​ຈະ​ນາ​ນຸ​ກົມ​ຂອງ​ຖັນ​ຮູບ​ແບບ!expressions. ດັ່ງນັ້ນ, ຫນ້າທີ່ຫົດຕົວສາມາດຖືກກໍານົດດັ່ງຕໍ່ໄປນີ້:

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

ເພື່ອຄວາມຊັດເຈນ, ຂ້ອຍໄດ້ໃຊ້ຟັງຊັນ parse, ເຊິ່ງປ່ຽນສະຕຣິງທີ່ມີການສະແດງຜົນ Q ເຂົ້າໄປໃນຄ່າທີ່ສາມາດສົ່ງກັບຟັງຊັນ eval ແລະທີ່ຕ້ອງການໃນຫນ້າທີ່ເລືອກ. ໃຫ້ສັງເກດວ່າ preprocess ຖືກກໍານົດເປັນການຄາດຄະເນ (i.e., ຟັງຊັນທີ່ມີ arguments ທີ່ກໍານົດບາງສ່ວນ) ຂອງຟັງຊັນທີ່ເລືອກ, ຫນຶ່ງ argument (ຕາຕະລາງ) ຫາຍໄປ. ຖ້າພວກເຮົານໍາໃຊ້ preprocess ກັບຕາຕະລາງ, ພວກເຮົາຈະໄດ້ຮັບຕາຕະລາງ compressed.

ຂັ້ນຕອນທີສອງແມ່ນການປັບປຸງຕາຕະລາງລວມ. ທໍາອິດໃຫ້ຂຽນ 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, ມັນເປັນເລື່ອງທໍາມະດາທີ່ຈະໃຊ້ຫນ້າທີ່ແຜນທີ່ / ຫຼຸດຜ່ອນແທນທີ່ຈະເປັນ loops. ແຕ່ເນື່ອງຈາກວ່າ Q ເປັນພາສາ vector ແລະພວກເຮົາສາມາດປະຕິບັດການດໍາເນີນການທັງຫມົດໄດ້ຢ່າງງ່າຍດາຍກັບສັນຍາລັກທັງຫມົດໃນເວລາດຽວ, ຫຼັງຈາກນັ້ນເພື່ອປະມານທໍາອິດທີ່ພວກເຮົາສາມາດເຮັດໄດ້ໂດຍບໍ່ມີການ loop ທັງຫມົດ, ດໍາເນີນການກ່ຽວກັບສັນຍາລັກທັງຫມົດໃນເວລາດຽວກັນ:

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

ແຕ່ຫນ້າເສຍດາຍ, ເພື່ອກໍານົດຕາຕະລາງທ່ານຕ້ອງການບັນຊີລາຍຊື່ຂອງແຖວ, ບໍ່ແມ່ນຄໍລໍາ, ແລະທ່ານຕ້ອງ transpose matrix (ບັນຊີລາຍຊື່ຂອງຖັນໄປຫາບັນຊີລາຍຊື່ຂອງແຖວ) ໂດຍໃຊ້ຟັງຊັນ flip. ນີ້ແມ່ນລາຄາແພງສໍາລັບຕາຕະລາງຂະຫນາດໃຫຍ່, ດັ່ງນັ້ນ, ແທນທີ່ຈະພວກເຮົານໍາໃຊ້ການມອບຫມາຍທົ່ວໄປໃນແຕ່ລະຄໍລໍາແຍກຕ່າງຫາກ, ການນໍາໃຊ້ຫນ້າທີ່ແຜນທີ່ (ເຊິ່ງຄ້າຍຄື apostrophe):

.[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 ມີຟັງຊັນເລືອກ - ?[ບັນຊີລາຍຊື່ boolean;list1;list2] - ເຊິ່ງເລືອກຄ່າຈາກບັນຊີລາຍຊື່ 1 ຫຼື 2 ຂຶ້ນກັບເງື່ອນໄຂໃນການໂຕ້ຖຽງທໍາອິດ:

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

ໃນທີ່ນີ້ຂ້ອຍເອີ້ນວ່າການມອບຫມາຍໂດຍທົ່ວໄປກັບຫນ້າທີ່ຂອງຂ້ອຍ (ການສະແດງອອກໃນວົງເລັບ curly). ມັນໄດ້ຮັບມູນຄ່າປະຈຸບັນ (ການໂຕ້ຖຽງທໍາອິດ) ແລະການໂຕ້ຖຽງເພີ່ມເຕີມ, ທີ່ຂ້ອຍຜ່ານໃນພາລາມິເຕີທີ 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[]

ໃນ console ອື່ນ, ເລີ່ມຕົ້ນຂະບວນການ Q ທີສອງແລະເຊື່ອມຕໍ່ກັບຄັ້ງທໍາອິດ:

h:hopen `:host:5566
h:hopen 5566 // если оба на одном хосте

ທໍາອິດ, ໃຫ້ສ້າງບັນຊີລາຍຊື່ຂອງສັນຍາລັກ - 10000 ຊິ້ນແລະເພີ່ມຫນ້າທີ່ເພື່ອສ້າງຕາຕະລາງແບບສຸ່ມ. ໃນ console ທີສອງ:

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 milliseconds. ດັ່ງນັ້ນ, ການບໍລິການຕ້ອງ (ໂດຍສະເລ່ຍ) ເຫມາະຢ່າງຫນ້ອຍ 20 milliseconds ຕໍ່ການປັບປຸງເພື່ອໃຫ້ຜູ້ໃຊ້ໃຊ້ເວລາໃນການຮ້ອງຂໍຂໍ້ມູນ. ກະລຸນາໃສ່ຕໍ່ໄປນີ້ໃນຂະບວນການທີສອງ:

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 milliseconds​:

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 ລ້ານແຖວຕໍ່ນາທີ) ແມ່ນມີຂະຫນາດໃຫຍ່ທີ່ສຸດ; ໃນກໍລະນີດັ່ງກ່າວ, ມັນເປັນເລື່ອງປົກກະຕິທີ່ຈະເປີດຕົວ clones ຫຼາຍ (ຫຼືແມ້ກະທັ້ງຫຼາຍສິບ clones) ຂອງການບໍລິການ, ແຕ່ລະຂະບວນການພຽງແຕ່ບາງສ່ວນຂອງຕົວອັກສອນ. ຢ່າງໃດກໍຕາມ, ຜົນໄດ້ຮັບແມ່ນປະທັບໃຈສໍາລັບພາສາທີ່ຕີຄວາມຫມາຍທີ່ສຸມໃສ່ການເກັບຮັກສາຂໍ້ມູນຕົ້ນຕໍ.

ຄໍາຖາມອາດຈະເກີດຂື້ນວ່າເປັນຫຍັງເວລາເຕີບໂຕບໍ່ກົງກັບຂະຫນາດຂອງແຕ່ລະການປັບປຸງ. ເຫດຜົນແມ່ນວ່າຫນ້າທີ່ຫົດຕົວຕົວຈິງແມ່ນຫນ້າທີ່ C, ເຊິ່ງມີປະສິດທິພາບຫຼາຍກ່ວາ updateAgg. ເລີ່ມຕົ້ນຈາກຂະຫນາດການປັບປຸງທີ່ແນ່ນອນ (ປະມານ 10.000), updateAgg ຮອດເພດານຂອງມັນແລະຫຼັງຈາກນັ້ນເວລາປະຕິບັດຂອງມັນບໍ່ຂຶ້ນກັບຂະຫນາດການປັບປຸງ. ມັນແມ່ນຍ້ອນຂັ້ນຕອນເບື້ອງຕົ້ນ Q ທີ່ບໍລິການສາມາດຍ່ອຍປະລິມານຂໍ້ມູນດັ່ງກ່າວໄດ້. ນີ້ຊີ້ໃຫ້ເຫັນເຖິງຄວາມສໍາຄັນວ່າມັນມີຄວາມສໍາຄັນແນວໃດທີ່ຈະເລືອກເອົາສູດການຄິດໄລ່ທີ່ຖືກຕ້ອງໃນເວລາທີ່ເຮັດວຽກກັບຂໍ້ມູນໃຫຍ່. ອີກຈຸດຫນຶ່ງແມ່ນການເກັບຮັກສາຂໍ້ມູນທີ່ຖືກຕ້ອງໃນຫນ່ວຍຄວາມຈໍາ. ຖ້າຂໍ້ມູນບໍ່ໄດ້ຖືກເກັບໄວ້ໃນຖັນຫຼືບໍ່ໄດ້ຖືກຈັດລໍາດັບຕາມເວລາ, ຫຼັງຈາກນັ້ນພວກເຮົາຈະຄຸ້ນເຄີຍກັບສິ່ງດັ່ງກ່າວເປັນ TLB cache miss - ການຂາດທີ່ຢູ່ຫນ້າຫນ່ວຍຄວາມຈໍາໃນ cache ທີ່ຢູ່ processor. ການຊອກຫາທີ່ຢູ່ໃຊ້ເວລາປະມານ 30 ເທົ່າຖ້າບໍ່ສໍາເລັດ, ແລະຖ້າຂໍ້ມູນກະແຈກກະຈາຍ, ມັນສາມາດເຮັດໃຫ້ການບໍລິການຊ້າລົງຫຼາຍຄັ້ງ.

ສະຫລຸບ

ໃນບົດຄວາມນີ້, ຂ້າພະເຈົ້າໄດ້ສະແດງໃຫ້ເຫັນວ່າຖານຂໍ້ມູນ KDB + ແລະ Q ແມ່ນເຫມາະສົມບໍ່ພຽງແຕ່ສໍາລັບການເກັບຮັກສາຂໍ້ມູນຂະຫນາດໃຫຍ່ແລະເຂົ້າເຖິງໄດ້ງ່າຍໂດຍຜ່ານການເລືອກ, ແຕ່ຍັງສໍາລັບການສ້າງການບໍລິການປະມວນຜົນຂໍ້ມູນທີ່ສາມາດຍ່ອຍຫຼາຍຮ້ອຍລ້ານແຖວ / gigabyte ຂອງຂໍ້ມູນເຖິງແມ່ນວ່າໃນ. ຂະບວນການ Q ດຽວ. ພາສາ Q ຕົວຂອງມັນເອງອະນຸຍາດໃຫ້ປະຕິບັດຢ່າງງ່າຍດາຍແລະປະສິດທິພາບຂອງ algorithms ທີ່ກ່ຽວຂ້ອງກັບການປະມວນຜົນຂໍ້ມູນເນື່ອງຈາກລັກສະນະຂອງ vector ຂອງມັນ, ຕົວແປພາສາພາສາ SQL ແລະຊຸດທີ່ປະສົບຜົນສໍາເລັດຫຼາຍຂອງຫນ້າທີ່ຫ້ອງສະຫມຸດ.

ຂ້າພະເຈົ້າຈະສັງເກດວ່າຂ້າງເທິງນີ້ແມ່ນພຽງແຕ່ສ່ວນຫນຶ່ງຂອງສິ່ງທີ່ Q ສາມາດເຮັດໄດ້, ມັນມີລັກສະນະພິເສດອື່ນໆເຊັ່ນກັນ. ຕົວຢ່າງເຊັ່ນ, ໂປໂຕຄອນ IPC ທີ່ງ່າຍດາຍທີ່ສຸດທີ່ຈະລົບລ້າງຂອບເຂດລະຫວ່າງຂະບວນການ Q ສ່ວນບຸກຄົນແລະຊ່ວຍໃຫ້ທ່ານສາມາດລວມເອົາຫຼາຍຮ້ອຍຂະບວນການເຫຼົ່ານີ້ເຂົ້າໄປໃນເຄືອຂ່າຍດຽວ, ເຊິ່ງສາມາດຕັ້ງຢູ່ໃນເຄື່ອງແມ່ຂ່າຍຫຼາຍສິບຫນ່ວຍໃນສ່ວນຕ່າງໆຂອງໂລກ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com