ការចម្លងកម្រិតខ្ពស់នៅក្នុង Tarantool DBMS

សួស្តី ខ្ញុំកំពុងបង្កើតកម្មវិធីសម្រាប់ DBMS តារ៉ាន់ធូល។ គឺជាវេទិកាមួយដែលបង្កើតឡើងដោយ Mail.ru Group ដែលរួមបញ្ចូលគ្នានូវ DBMS ដែលដំណើរការខ្ពស់ និងម៉ាស៊ីនមេកម្មវិធីនៅក្នុងភាសា Lua ។ ល្បឿនខ្ពស់នៃដំណោះស្រាយផ្អែកលើ Tarantool ត្រូវបានសម្រេច ជាពិសេសដោយសារតែការគាំទ្រសម្រាប់របៀបក្នុងអង្គចងចាំរបស់ DBMS និងសមត្ថភាពក្នុងការប្រតិបត្តិតក្កវិជ្ជាអាជីវកម្មរបស់កម្មវិធីក្នុងចន្លោះអាសយដ្ឋានតែមួយជាមួយនឹងទិន្នន័យ។ ក្នុងពេលជាមួយគ្នានេះ ការបន្តទិន្នន័យត្រូវបានធានាដោយប្រើប្រតិបត្តិការ ACID (កំណត់ហេតុ WAL ត្រូវបានរក្សាទុកនៅលើថាស)។ Tarantool មានភ្ជាប់មកជាមួយនូវការគាំទ្រសម្រាប់ការចម្លង និងការបំបែក។ ចាប់ផ្តើមពីកំណែ 2.1 សំណួរជាភាសា SQL ត្រូវបានគាំទ្រ។ Tarantool គឺជាប្រភពបើកចំហ និងទទួលបានអាជ្ញាប័ណ្ណក្រោមអាជ្ញាបណ្ណ BSD សាមញ្ញ។ វាក៏មានកំណែសហគ្រាសពាណិជ្ជកម្មផងដែរ។

មានអារម្មណ៍ថាមានថាមពល! (…aka សូមរីករាយជាមួយការសម្តែង)

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

ដូចដែលបានរៀបរាប់ខាងលើ Tarantool មានភ្ជាប់មកជាមួយនូវការចម្លងទិន្នន័យ។ គោលការណ៍នៃប្រតិបត្តិការរបស់វាគឺដើម្បីប្រតិបត្តិតាមលំដាប់លំដោយលើការចម្លងប្រតិបត្តិការទាំងអស់ដែលមាននៅក្នុង master log (WAL) ។ ជាធម្មតាការចម្លងបែបនេះ (យើងនឹងហៅវាបន្ថែមទៀត កំរិត​ទាប) ត្រូវ​បាន​ប្រើ​ដើម្បី​ធានា​ពី​ការ​អត់ឱន​កំហុស​របស់​កម្មវិធី និង/ឬ​ដើម្បី​ចែកចាយ​ការ​អាន​រវាង​ថ្នាំង​ចង្កោម។

អង្ករ។ 1. ការចម្លងនៅក្នុងចង្កោមមួយ។

ឧទាហរណ៍នៃសេណារីយ៉ូជំនួសមួយនឹងត្រូវបានផ្ទេរទិន្នន័យដែលបានបង្កើតនៅក្នុងមូលដ្ឋានទិន្នន័យមួយទៅកាន់មូលដ្ឋានទិន្នន័យមួយផ្សេងទៀតសម្រាប់ដំណើរការ/ត្រួតពិនិត្យ។ ក្នុងករណីចុងក្រោយ ដំណោះស្រាយងាយស្រួលជាងនេះប្រហែលជាត្រូវប្រើ កម្រិតខ្ពស់ ការចម្លង - ការចម្លងទិន្នន័យនៅកម្រិតតក្កវិជ្ជាអាជីវកម្មកម្មវិធី។ ទាំងនោះ។ យើងមិនប្រើដំណោះស្រាយដែលត្រៀមរួចជាស្រេចដែលបានបង្កើតឡើងនៅក្នុង DBMS ទេ ប៉ុន្តែអនុវត្តការចម្លងដោយខ្លួនឯងនៅក្នុងកម្មវិធីដែលយើងកំពុងបង្កើត។ វិធីសាស្រ្តនេះមានទាំងគុណសម្បត្តិ និងគុណវិបត្តិ។ ចូររាយបញ្ជីគុណសម្បត្តិ។

1. ការសន្សំចរាចរណ៍៖

• អ្នក​មិន​អាច​ផ្ទេរ​ទិន្នន័យ​ទាំង​អស់​បាន​ទេ ប៉ុន្តែ​មាន​តែ​មួយ​ផ្នែក​ប៉ុណ្ណោះ (ឧទាហរណ៍ អ្នក​អាច​ផ្ទេរ​បាន​តែ​តារាង​ខ្លះ ជួរ​ឈរ​ខ្លះ ឬ​កំណត់ត្រា​របស់​វា​ដែល​ត្រូវ​នឹង​លក្ខណៈ​វិនិច្ឆ័យ​ជាក់លាក់​មួយ);
• មិនដូចការចម្លងកម្រិតទាប ដែលត្រូវបានអនុវត្តជាបន្តបន្ទាប់ក្នុងទម្រង់អសមកាល (អនុវត្តក្នុងកំណែបច្ចុប្បន្ននៃ Tarantool - 1.10) ឬធ្វើសមកាលកម្ម (ដើម្បីអនុវត្តនៅក្នុងកំណែបន្តបន្ទាប់នៃ Tarantool) របៀប ការចម្លងកម្រិតខ្ពស់អាចត្រូវបានអនុវត្តនៅក្នុងវគ្គ (ឧ។ កម្មវិធីដំបូងធ្វើសមកាលកម្មទិន្នន័យ - ទិន្នន័យសម័យផ្លាស់ប្តូរបន្ទាប់មកមានការផ្អាកក្នុងការចម្លងបន្ទាប់ពីនោះវគ្គផ្លាស់ប្តូរបន្ទាប់កើតឡើង។
• ប្រសិនបើកំណត់ត្រាបានផ្លាស់ប្តូរច្រើនដង អ្នកអាចផ្ទេរបានតែកំណែចុងក្រោយបំផុតរបស់វា (មិនដូចការចម្លងកម្រិតទាប ដែលការផ្លាស់ប្តូរទាំងអស់ដែលបានធ្វើឡើងនៅលើមេនឹងត្រូវបានចាក់ឡើងវិញជាបន្តបន្ទាប់នៅលើការចម្លង)។

2. មិនមានការលំបាកក្នុងការអនុវត្តការផ្លាស់ប្តូរ HTTP ដែលអនុញ្ញាតឱ្យអ្នកធ្វើសមកាលកម្មមូលដ្ឋានទិន្នន័យពីចម្ងាយ។

អង្ករ។ 2. ការចម្លងតាម HTTP

3. រចនាសម្ព័ន្ធមូលដ្ឋានទិន្នន័យរវាងទិន្នន័យដែលត្រូវបានផ្ទេរមិនត្រូវដូចគ្នាទេ (លើសពីនេះទៅទៀត នៅក្នុងករណីទូទៅ វាថែមទាំងអាចប្រើ DBMSs ផ្សេងគ្នា ភាសាសរសេរកម្មវិធី វេទិកា។ល។)។

អង្ករ។ 3. ការចម្លងនៅក្នុងប្រព័ន្ធតំណពូជ

គុណវិបត្តិគឺថាជាមធ្យម ការសរសេរកម្មវិធីគឺពិបាក/ចំណាយច្រើនជាងការកំណត់ ហើយជំនួសឱ្យការកំណត់មុខងារដែលភ្ជាប់មកជាមួយតាមបំណង អ្នកនឹងត្រូវអនុវត្តដោយខ្លួនឯង។

ប្រសិនបើនៅក្នុងស្ថានភាពរបស់អ្នក គុណសម្បត្តិខាងលើមានសារៈសំខាន់ (ឬជាលក្ខខណ្ឌចាំបាច់) នោះវាសមហេតុផលក្នុងការប្រើការចម្លងកម្រិតខ្ពស់។ សូមក្រឡេកមើលវិធីជាច្រើនដើម្បីអនុវត្តការចម្លងទិន្នន័យកម្រិតខ្ពស់នៅក្នុង Tarantool DBMS ។

ការកាត់បន្ថយចរាចរណ៍

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

តើធ្វើដូចម្តេចដើម្បីកាត់បន្ថយចំនួនទិន្នន័យដែលបានផ្ទេរកំឡុងពេលចម្លងកម្រិតខ្ពស់? ដំណោះស្រាយត្រង់មួយអាចជាការជ្រើសរើសទិន្នន័យតាមកាលបរិច្ឆេទ និងពេលវេលា។ ដើម្បីធ្វើដូចនេះអ្នកអាចប្រើវាលកាលបរិច្ឆេទដែលមានរួចហើយនៅក្នុងតារាង (ប្រសិនបើវាមាន) ។ ឧទាហរណ៍ ឯកសារ "បញ្ជាទិញ" អាចមានវាល "ពេលវេលាប្រតិបត្តិការបញ្ជាទិញដែលត្រូវការ" - delivery_time. បញ្ហាជាមួយនឹងដំណោះស្រាយនេះគឺថាតម្លៃនៅក្នុងវាលនេះមិនចាំបាច់នៅក្នុងលំដាប់ដែលត្រូវគ្នាទៅនឹងការបង្កើតការបញ្ជាទិញនោះទេ។ ដូច្នេះយើងមិនអាចចាំតម្លៃវាលអតិបរមាបានទេ។ delivery_timeបញ្ជូនក្នុងអំឡុងពេលវគ្គផ្លាស់ប្តូរមុន ហើយក្នុងអំឡុងពេលវគ្គផ្លាស់ប្តូរបន្ទាប់ សូមជ្រើសរើសកំណត់ត្រាទាំងអស់ជាមួយនឹងតម្លៃវាលខ្ពស់ជាង delivery_time. កំណត់ត្រាដែលមានតម្លៃវាលទាបជាងអាចត្រូវបានបន្ថែមរវាងវគ្គផ្លាស់ប្តូរ delivery_time. ដូចគ្នានេះផងដែរ ការបញ្ជាទិញអាចមានការផ្លាស់ប្ដូរ ដែលទោះជាយ៉ាងនេះក្ដី វាមិនប៉ះពាល់ដល់វិស័យនេះទេ។ delivery_time. ក្នុងករណីទាំងពីរ ការផ្លាស់ប្តូរនឹងមិនត្រូវបានផ្ទេរពីប្រភពទៅទិសដៅនោះទេ។ ដើម្បីដោះស្រាយបញ្ហាទាំងនេះយើងនឹងត្រូវការផ្ទេរទិន្នន័យ "ត្រួតស៊ីគ្នា" ។ ទាំងនោះ។ ក្នុងវគ្គផ្លាស់ប្តូរនីមួយៗ យើងនឹងផ្ទេរទិន្នន័យទាំងអស់ជាមួយនឹងតម្លៃវាល delivery_timeលើសពីចំណុចមួយចំនួនកាលពីអតីតកាល (ឧទាហរណ៍ N ម៉ោងចាប់ពីពេលបច្ចុប្បន្ន)។ ទោះជាយ៉ាងណាក៏ដោយ វាច្បាស់ណាស់ថាសម្រាប់ប្រព័ន្ធធំ វិធីសាស្រ្តនេះគឺមិនប្រើដដែលៗច្រើន ហើយអាចកាត់បន្ថយការសន្សំចរាចរណ៍ដែលយើងកំពុងព្យាយាមដើម្បីគ្មានអ្វីសោះ។ លើសពីនេះ តារាងដែលកំពុងផ្ទេរអាចមិនមានវាលដែលភ្ជាប់ជាមួយកាលបរិច្ឆេទ។

ដំណោះស្រាយមួយទៀតដែលស្មុគស្មាញជាងក្នុងលក្ខខណ្ឌនៃការអនុវត្តគឺការទទួលស្គាល់ការទទួលទិន្នន័យ។ ក្នុងករណីនេះក្នុងអំឡុងពេលនៃវគ្គផ្លាស់ប្តូរនីមួយៗ ទិន្នន័យទាំងអស់ត្រូវបានបញ្ជូន បង្កាន់ដៃដែលមិនត្រូវបានបញ្ជាក់ដោយអ្នកទទួល។ ដើម្បីអនុវត្តវា អ្នកនឹងត្រូវបន្ថែមជួរឈរ Boolean ទៅក្នុងតារាងប្រភព (ឧទាហរណ៍ is_transferred) ប្រសិនបើអ្នកទទួលទទួលស្គាល់ការទទួលកំណត់ត្រា វាលដែលត្រូវគ្នាយកតម្លៃ trueបន្ទាប់ពីនោះ ធាតុចូលលែងពាក់ព័ន្ធក្នុងការផ្លាស់ប្តូរ។ ជម្រើសនៃការអនុវត្តនេះមានគុណវិបត្តិដូចខាងក្រោម។ ជាដំបូង សម្រាប់ការផ្ទេរកំណត់ត្រានីមួយៗ ការទទួលស្គាល់ត្រូវតែបង្កើត និងផ្ញើ។ និយាយឱ្យចំទៅ នេះអាចប្រៀបធៀបទៅនឹងការកើនឡើងទ្វេដងនៃចំនួនទិន្នន័យដែលបានផ្ទេរ និងនាំឱ្យកើនឡើងទ្វេដងនៃចំនួនការធ្វើដំណើរទៅមក។ ទីពីរ គ្មានលទ្ធភាពនៃការផ្ញើកំណត់ត្រាដូចគ្នាទៅកាន់អ្នកទទួលមួយចំនួនទេ (អ្នកទទួលទីមួយដែលទទួលនឹងបញ្ជាក់ការទទួលដោយខ្លួនឯង និងសម្រាប់អ្នកផ្សេងទៀតទាំងអស់)។

វិធីសាស្រ្តដែលមិនមានគុណវិបត្តិដែលបានផ្តល់ឱ្យខាងលើគឺដើម្បីបន្ថែមជួរឈរមួយទៅតារាងដែលបានផ្ទេរដើម្បីតាមដានការផ្លាស់ប្តូរនៅក្នុងជួរដេករបស់វា។ ជួរឈរបែបនេះអាចជាប្រភេទកាលបរិច្ឆេទ ហើយត្រូវតែកំណត់/ធ្វើបច្ចុប្បន្នភាពដោយកម្មវិធីទៅពេលវេលាបច្ចុប្បន្ន រាល់ពេលដែលកំណត់ត្រាត្រូវបានបន្ថែម/ផ្លាស់ប្តូរ (អាតូមជាមួយការបន្ថែម/ការផ្លាស់ប្តូរ)។ ជាឧទាហរណ៍សូមហៅជួរឈរ update_time. ដោយរក្សាទុកតម្លៃវាលអតិបរមានៃជួរឈរនេះសម្រាប់កំណត់ត្រាដែលបានផ្ទេរ យើងអាចចាប់ផ្តើមវគ្គផ្លាស់ប្តូរបន្ទាប់ជាមួយនឹងតម្លៃនេះ (ជ្រើសរើសកំណត់ត្រាជាមួយនឹងតម្លៃវាល update_timeលើសពីតម្លៃដែលបានរក្សាទុកពីមុន)។ បញ្ហាជាមួយនឹងវិធីសាស្រ្តចុងក្រោយគឺថាការផ្លាស់ប្តូរទិន្នន័យអាចកើតឡើងជាបាច់។ ជាលទ្ធផលនៃតម្លៃវាលនៅក្នុងជួរឈរ update_time ប្រហែលជាមិនប្លែកទេ។ ដូច្នេះ ជួរ​ឈរ​នេះ​មិន​អាច​ត្រូវ​បាន​ប្រើ​សម្រាប់​លទ្ធផល​ទិន្នន័យ​ជា​ផ្នែក (មួយ​ទំព័រ​ដោយ​ទំព័រ) ទេ។ ដើម្បីបង្ហាញទិន្នន័យតាមទំព័រ អ្នកនឹងត្រូវបង្កើតយន្តការបន្ថែម ដែលទំនងជាមានប្រសិទ្ធភាពទាបបំផុត (ឧទាហរណ៍ ការទាញយកពីមូលដ្ឋានទិន្នន័យ រាល់កំណត់ត្រាជាមួយនឹងតម្លៃ update_time ខ្ពស់ជាងចំនួនដែលបានផ្តល់ឱ្យ និងផលិតចំនួនជាក់លាក់នៃកំណត់ត្រា ដោយចាប់ផ្តើមពីអុហ្វសិតជាក់លាក់មួយចាប់ពីដើមគំរូ)។

អ្នកអាចបង្កើនប្រសិទ្ធភាពនៃការផ្ទេរទិន្នន័យដោយធ្វើឱ្យប្រសើរឡើងបន្តិចនូវវិធីសាស្រ្តពីមុន។ ដើម្បីធ្វើដូចនេះយើងនឹងប្រើប្រភេទចំនួនគត់ (ចំនួនគត់វែង) ជាតម្លៃវាលជួរឈរសម្រាប់តាមដានការផ្លាស់ប្តូរ។ ចូរយើងដាក់ឈ្មោះជួរឈរ row_ver. តម្លៃវាលនៃជួរឈរនេះនៅតែត្រូវកំណត់/ធ្វើបច្ចុប្បន្នភាពរាល់ពេលដែលកំណត់ត្រាត្រូវបានបង្កើត/កែប្រែ។ ប៉ុន្តែក្នុងករណីនេះ វាលនឹងមិនត្រូវបានផ្តល់កាលបរិច្ឆេទ-ពេលវេលាបច្ចុប្បន្នទេ ប៉ុន្តែតម្លៃនៃការរាប់មួយចំនួនកើនឡើងដោយមួយ។ ជាលទ្ធផលជួរឈរ row_ver នឹងមានតម្លៃតែមួយគត់ ហើយអាចត្រូវបានប្រើមិនត្រឹមតែដើម្បីបង្ហាញទិន្នន័យ "ដីសណ្ត" (ទិន្នន័យបន្ថែម/ផ្លាស់ប្តូរចាប់តាំងពីចុងបញ្ចប់នៃវគ្គផ្លាស់ប្តូរមុន) ប៉ុន្តែថែមទាំងបំបែកវាទៅជាទំព័រយ៉ាងសាមញ្ញ និងមានប្រសិទ្ធភាពផងដែរ។

វិធីសាស្រ្តដែលបានស្នើចុងក្រោយនៃការបង្រួមអប្បបរមានៃទិន្នន័យដែលបានផ្ទេរក្នុងក្របខ័ណ្ឌនៃការចម្លងកម្រិតខ្ពស់ហាក់ដូចជាខ្ញុំល្អបំផុត និងជាសកលបំផុត។ សូមក្រឡេកមើលវាឱ្យកាន់តែលម្អិត។

ការបញ្ជូនទិន្នន័យដោយប្រើឧបករណ៍រាប់កំណែជួរ

ការអនុវត្តផ្នែកម៉ាស៊ីនមេ/មេ

នៅក្នុង MS SQL Server មានប្រភេទជួរឈរពិសេសដើម្បីអនុវត្តវិធីសាស្រ្តនេះ - rowversion. មូលដ្ឋានទិន្នន័យនីមួយៗមានបញ្ជរដែលកើនឡើងមួយរាល់ពេលដែលកំណត់ត្រាត្រូវបានបន្ថែម/ផ្លាស់ប្តូរនៅក្នុងតារាងដែលមានជួរឈរដូច rowversion. តម្លៃនៃការរាប់នេះត្រូវបានកំណត់ដោយស្វ័យប្រវត្តិទៅវាលនៃជួរឈរនេះនៅក្នុងកំណត់ត្រាបន្ថែម/ផ្លាស់ប្តូរ។ Tarantool DBMS មិនមានយន្តការបង្កើតស្រដៀងគ្នាទេ។ ទោះជាយ៉ាងណាក៏ដោយនៅក្នុង Tarantool វាមិនពិបាកក្នុងការអនុវត្តវាដោយដៃទេ។ សូមក្រឡេកមើលរបៀបដែលនេះត្រូវបានធ្វើ។

ទីមួយវាក្យស័ព្ទតូចមួយ៖ តារាងនៅក្នុង Tarantool ត្រូវបានគេហៅថាលំហ ហើយកំណត់ត្រាត្រូវបានគេហៅថា tuples ។ នៅក្នុង Tarantool អ្នកអាចបង្កើតលំដាប់។ លំដាប់គឺគ្មានអ្វីក្រៅពីឈ្មោះម៉ាស៊ីនបង្កើតតម្លៃនៃចំនួនគត់ដែលបានបញ្ជា។ ទាំងនោះ។ នេះគឺជាអ្វីដែលយើងត្រូវការសម្រាប់គោលបំណងរបស់យើង។ ខាងក្រោមនេះយើងនឹងបង្កើតលំដាប់បែបនេះ។

មុនពេលអនុវត្តប្រតិបត្តិការមូលដ្ឋានទិន្នន័យណាមួយនៅក្នុង Tarantool អ្នកត្រូវដំណើរការពាក្យបញ្ជាខាងក្រោម៖

box.cfg{}

ជាលទ្ធផល Tarantool នឹងចាប់ផ្តើមសរសេររូបថតនៃមូលដ្ឋានទិន្នន័យ និងកំណត់ហេតុប្រតិបត្តិការទៅកាន់ថតបច្ចុប្បន្ន។

តោះបង្កើតលំដាប់ row_version:

box.schema.sequence.create('row_version',
    { if_not_exists = true })

ជម្រើស if_not_exists អនុញ្ញាតឱ្យស្គ្រីបបង្កើតត្រូវបានប្រតិបត្តិច្រើនដង៖ ប្រសិនបើមានវត្ថុនោះ Tarantool នឹងមិនព្យាយាមបង្កើតវាម្តងទៀតទេ។ ជម្រើសនេះនឹងត្រូវបានប្រើនៅក្នុងពាក្យបញ្ជា DDL ជាបន្តបន្ទាប់ទាំងអស់។

ចូរយើងបង្កើតលំហជាឧទាហរណ៍។

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        },
        {
            name = 'row_ver',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

នៅទីនេះយើងកំណត់ឈ្មោះនៃលំហ (goods) ឈ្មោះវាល និងប្រភេទរបស់វា។

វាលបង្កើនដោយស្វ័យប្រវត្តិនៅក្នុង Tarantool ក៏ត្រូវបានបង្កើតដោយប្រើលំដាប់ផងដែរ។ តោះបង្កើតកូនសោចម្បងដែលបង្កើនដោយស្វ័យប្រវត្តិតាមវាល id:

box.schema.sequence.create('goods_id',
    { if_not_exists = true })
box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

Tarantool គាំទ្រប្រភេទសន្ទស្សន៍ជាច្រើន។ សន្ទស្សន៍ដែលប្រើជាទូទៅបំផុតគឺប្រភេទ TREE និង HASH ដែលផ្អែកលើរចនាសម្ព័ន្ធដែលត្រូវគ្នានឹងឈ្មោះ។ TREE គឺជាប្រភេទលិបិក្រមដែលអាចប្រើប្រាស់បានច្រើនបំផុត។ វាអនុញ្ញាតឱ្យអ្នកទាញយកទិន្នន័យតាមរបៀបរៀបចំ។ ប៉ុន្តែសម្រាប់ការជ្រើសរើសសមភាព HASH គឺសមរម្យជាង។ ដូច្នោះហើយ គួរប្រើ HASH សម្រាប់សោបឋម (ដែលជាអ្វីដែលយើងបានធ្វើ)។

ដើម្បីប្រើជួរឈរ row_ver ដើម្បីផ្ទេរទិន្នន័យដែលបានផ្លាស់ប្តូរ អ្នកត្រូវចងតម្លៃលំដាប់ទៅវាលនៃជួរឈរនេះ។ row_ver. ប៉ុន្តែ​មិន​ដូច​សោ​ចម្បង​ទេ តម្លៃ​វាល​ជួរ​ឈរ row_ver គួរតែកើនឡើងមួយមិនត្រឹមតែនៅពេលបន្ថែមកំណត់ត្រាថ្មីប៉ុណ្ណោះទេ ប៉ុន្តែក៏នៅពេលដែលផ្លាស់ប្តូរកំណត់ត្រាដែលមានស្រាប់ផងដែរ។ អ្នកអាចប្រើគន្លឹះសម្រាប់រឿងនេះ។ Tarantool មានពីរប្រភេទនៃកេះអវកាស៖ before_replace и on_replace. កេះត្រូវបានបាញ់នៅពេលណាដែលទិន្នន័យនៅក្នុងលំហផ្លាស់ប្តូរ (សម្រាប់ tuple នីមួយៗដែលរងផលប៉ះពាល់ដោយការផ្លាស់ប្តូរ មុខងារកេះត្រូវបានចាប់ផ្តើម)។ មិន​ដូច on_replace, before_replace-triggers អនុញ្ញាតឱ្យអ្នកកែប្រែទិន្នន័យនៃ tuple ដែល trigger ត្រូវបានប្រតិបត្តិ។ ដូច្នោះហើយ ប្រភេទចុងក្រោយនៃការកេះសាកសមនឹងយើង។

box.space.goods:before_replace(function(old, new)
    return box.tuple.new({new[1], new[2], new[3],
        box.sequence.row_version:next()})
end)

គន្លឹះខាងក្រោមជំនួសតម្លៃវាល row_ver ទុក tuple ទៅតម្លៃបន្ទាប់នៃលំដាប់ row_version.

ដើម្បីអាចទាញយកទិន្នន័យពីលំហ goods តាមជួរឈរ row_verតោះបង្កើតលិបិក្រម៖

box.space.goods:create_index('row_ver', {
    parts = { 'row_ver' },
    unique = true,
    type = 'TREE',
    if_not_exists = true
})

ប្រភេទសន្ទស្សន៍ - មែកធាង (TREE), ដោយសារតែ យើង​នឹង​ត្រូវ​ស្រង់​ទិន្នន័យ​តាម​លំដាប់​ឡើង​នៃ​តម្លៃ​ក្នុង​ជួរ​ឈរ row_ver.

តោះបន្ថែមទិន្នន័យមួយចំនួនទៅក្នុងលំហ៖

box.space.goods:insert{nil, 'pen', 123}
box.space.goods:insert{nil, 'pencil', 321}
box.space.goods:insert{nil, 'brush', 100}
box.space.goods:insert{nil, 'watercolour', 456}
box.space.goods:insert{nil, 'album', 101}
box.space.goods:insert{nil, 'notebook', 800}
box.space.goods:insert{nil, 'rubber', 531}
box.space.goods:insert{nil, 'ruler', 135}

ដោយសារតែ វាលទីមួយគឺជាបញ្ជរបង្កើនដោយស្វ័យប្រវត្តិ យើងហុច nil ជំនួសវិញ។ Tarantool នឹងជំនួសតម្លៃបន្ទាប់ដោយស្វ័យប្រវត្តិ។ ស្រដៀងគ្នានេះដែរ ជាតម្លៃនៃវាលជួរឈរ row_ver អ្នកអាចឆ្លងកាត់ Nil - ឬមិនបញ្ជាក់តម្លៃទាល់តែសោះ ពីព្រោះ ជួរឈរនេះកាន់កាប់ទីតាំងចុងក្រោយនៅក្នុងលំហ។

តោះពិនិត្យមើលលទ្ធផលបញ្ចូល៖

tarantool> box.space.goods:select()
---
- - [1, 'pen', 123, 1]
  - [2, 'pencil', 321, 2]
  - [3, 'brush', 100, 3]
  - [4, 'watercolour', 456, 4]
  - [5, 'album', 101, 5]
  - [6, 'notebook', 800, 6]
  - [7, 'rubber', 531, 7]
  - [8, 'ruler', 135, 8]
...

ដូចដែលអ្នកអាចឃើញ ប្រអប់ទីមួយ និងចុងក្រោយត្រូវបានបំពេញដោយស្វ័យប្រវត្តិ។ ឥឡូវនេះវានឹងមានភាពងាយស្រួលក្នុងការសរសេរមុខងារសម្រាប់ការផ្ទុកឡើងពីទំព័រមួយទៅទំព័រនៃការផ្លាស់ប្តូរទំហំ goods:

local page_size = 5
local function get_goods(row_ver)
    local index = box.space.goods.index.row_ver
    local goods = {}
    local counter = 0
    for _, tuple in index:pairs(row_ver, {
        iterator = 'GT' }) do
        local obj = tuple:tomap({ names_only = true })
        table.insert(goods, obj)
        counter = counter + 1
        if counter >= page_size then
            break
        end
    end
    return goods
end

មុខងារយកជាប៉ារ៉ាម៉ែត្រតម្លៃ row_verចាប់ផ្តើមពីពេលដែលវាចាំបាច់ដើម្បីដកការផ្លាស់ប្ដូរ ហើយត្រឡប់ផ្នែកនៃទិន្នន័យដែលបានផ្លាស់ប្តូរ។

ការយកគំរូទិន្នន័យនៅក្នុង Tarantool ធ្វើឡើងតាមរយៈលិបិក្រម។ មុខងារ get_goods ប្រើ​ឧបករណ៍​បំប្លែង​តាម​លិបិក្រម row_ver ដើម្បីទទួលទិន្នន័យដែលបានផ្លាស់ប្តូរ។ ប្រភេទ Iterator គឺ GT (ធំជាង ធំជាង)។ នេះ​មាន​ន័យ​ថា​អ្នក​ធ្វើ​ការ​ត្រួត​ពិនិត្យ​តាម​លំដាប់​លំដោយ​តម្លៃ​លិបិក្រម​ដែល​ចាប់​ផ្តើម​ពី​គ្រាប់​ចុច​ដែល​បាន​ឆ្លង (តម្លៃ​វាល row_ver).

ឧបករណ៍បំលែងចរន្តត្រឡប់ tuples ។ ដើម្បីអាចផ្ទេរទិន្នន័យជាបន្តបន្ទាប់តាមរយៈ HTTP វាចាំបាច់ក្នុងការបំប្លែង tuples ទៅជារចនាសម្ព័ន្ធដែលងាយស្រួលសម្រាប់ serialization ជាបន្តបន្ទាប់។ ឧទាហរណ៍ប្រើមុខងារស្តង់ដារសម្រាប់ការនេះ។ tomap. ជំនួសឱ្យការប្រើប្រាស់ tomap អ្នកអាចសរសេរមុខងារផ្ទាល់ខ្លួនរបស់អ្នក។ ជាឧទាហរណ៍ យើងប្រហែលជាចង់ប្តូរឈ្មោះវាលមួយ។ nameកុំឆ្លងកាត់វាល code និងបន្ថែមវាលមួយ។ comment:

local function unflatten_goods(tuple)
    local obj = {}
    obj.id = tuple.id
    obj.goods_name = tuple.name
    obj.comment = 'some comment'
    obj.row_ver = tuple.row_ver
    return obj
end

ទំហំទំព័រនៃទិន្នន័យលទ្ធផល (ចំនួនកំណត់ត្រាក្នុងផ្នែកមួយ) ត្រូវបានកំណត់ដោយអថេរ page_size. ក្នុងឧទាហរណ៍តម្លៃ page_size គឺ 5. នៅក្នុងកម្មវិធីពិត ទំហំទំព័រជាធម្មតាសំខាន់ជាង។ វាអាស្រ័យលើទំហំមធ្យមនៃ tuple អវកាស។ ទំហំទំព័រដ៏ប្រសើរបំផុតអាចត្រូវបានកំណត់ដោយជាក់ស្តែងដោយការវាស់វែងពេលវេលាផ្ទេរទិន្នន័យ។ ទំហំទំព័រកាន់តែធំ ចំនួនដំណើរទៅមកតូចជាងរវាងភាគីផ្ញើ និងទទួល។ វិធីនេះអ្នកអាចកាត់បន្ថយពេលវេលាទាំងមូលសម្រាប់ការទាញយកការផ្លាស់ប្តូរ។ ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើទំហំទំព័រធំពេក យើងនឹងចំណាយពេលយូរពេក លើម៉ាស៊ីនមេ ធ្វើស៊េរីគំរូ។ ជាលទ្ធផល វាអាចមានការពន្យារពេលក្នុងដំណើរការសំណើផ្សេងទៀតដែលមកដល់ម៉ាស៊ីនមេ។ ប៉ារ៉ាម៉ែត្រ page_size អាចត្រូវបានផ្ទុកពីឯកសារកំណត់រចនាសម្ព័ន្ធ។ សម្រាប់ចន្លោះបញ្ជូននីមួយៗ អ្នកអាចកំណត់តម្លៃរបស់វាផ្ទាល់។ ទោះយ៉ាងណាក៏ដោយ សម្រាប់ចន្លោះភាគច្រើន តម្លៃលំនាំដើម (ឧទាហរណ៍ 100) អាចសមរម្យ។

តោះអនុវត្តមុខងារ get_goods:

tarantool> get_goods(0)

---
- - row_ver: 1
    code: 123
    name: pen
    id: 1
  - row_ver: 2
    code: 321
    name: pencil
    id: 2
  - row_ver: 3
    code: 100
    name: brush
    id: 3
  - row_ver: 4
    code: 456
    name: watercolour
    id: 4
  - row_ver: 5
    code: 101
    name: album
    id: 5
...

ចូរយើងយកតម្លៃវាល row_ver ពីបន្ទាត់ចុងក្រោយ ហើយហៅមុខងារម្តងទៀត៖

tarantool> get_goods(5)

---
- - row_ver: 6
    code: 800
    name: notebook
    id: 6
  - row_ver: 7
    code: 531
    name: rubber
    id: 7
  - row_ver: 8
    code: 135
    name: ruler
    id: 8
...

ជា​ថ្មី​ម្តង​ទៀត:

tarantool> get_goods(8)
---
- []
...

ដូចដែលអ្នកអាចឃើញនៅពេលប្រើវិធីនេះ មុខងារត្រឡប់ទំព័រកំណត់ត្រាលំហទាំងអស់ដោយទំព័រ goods. ទំព័រចុងក្រោយត្រូវបានបន្តដោយការជ្រើសរើសទទេ។

តោះធ្វើការផ្លាស់ប្តូរលំហ៖

box.space.goods:update(4, {{'=', 6, 'copybook'}})
box.space.goods:insert{nil, 'clip', 234}
box.space.goods:insert{nil, 'folder', 432}

យើងបានផ្លាស់ប្តូរតម្លៃវាល name សម្រាប់ធាតុមួយ និងបានបន្ថែមធាតុថ្មីពីរ។

ចូរយើងធ្វើការហៅមុខងារចុងក្រោយម្តងទៀត៖

tarantool> get_goods(8)
---



- - row_ver: 9
    code: 800
    name: copybook
    id: 6
  - row_ver: 10
    code: 234
    name: clip
    id: 9
  - row_ver: 11
    code: 432
    name: folder
    id: 10
...

មុខងារបានត្រឡប់កំណត់ត្រាដែលបានផ្លាស់ប្តូរ និងបន្ថែម។ ដូច្នេះមុខងារ get_goods អនុញ្ញាតឱ្យអ្នកទទួលបានទិន្នន័យដែលបានផ្លាស់ប្តូរចាប់តាំងពីការហៅចុងក្រោយរបស់វា ដែលជាមូលដ្ឋាននៃវិធីសាស្ត្រចម្លងដែលកំពុងត្រូវបានពិចារណា។

យើងនឹងទុកការចេញលទ្ធផលតាមរយៈ HTTP ក្នុងទម្រង់ JSON នៅខាងក្រៅវិសាលភាពនៃអត្ថបទនេះ។ អ្នកអាចអានអំពីរឿងនេះនៅទីនេះ៖ https://habr.com/ru/company/mailru/blog/272141/

ការអនុវត្តផ្នែកអតិថិជន/ទាសករ

សូមក្រឡេកមើលថាតើការអនុវត្តរបស់ភាគីទទួលមើលទៅដូចម្ដេច។ តោះបង្កើតកន្លែងទំនេរនៅផ្នែកទទួល ដើម្បីរក្សាទុកទិន្នន័យដែលបានទាញយក៖

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

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

លើសពីនេះ យើងត្រូវការកន្លែងទំនេរដើម្បីរក្សាទុកតម្លៃ row_ver:

box.schema.space.create('row_ver', {
    format = {
        {
            name = 'space_name',
            type = 'string'

        },
        {
            name = 'value',
            type = 'string'

        }
    },
    if_not_exists = true
})

box.space.row_ver:create_index('primary', {
    parts = { 'space_name' },
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

សម្រាប់កន្លែងផ្ទុកនីមួយៗ (វាល space_name) យើងនឹងរក្សាទុកតម្លៃដែលបានផ្ទុកចុងក្រោយនៅទីនេះ row_ver (វាល value) ជួរឈរដើរតួនាទីជាគន្លឹះសំខាន់ space_name.

តោះបង្កើតមុខងារមួយដើម្បីផ្ទុកទិន្នន័យលំហ goods តាមរយៈ HTTP ។ ដើម្បីធ្វើដូច្នេះបាន យើងត្រូវការបណ្ណាល័យដែលអនុវត្តម៉ាស៊ីនភ្ញៀវ HTTP ។ បន្ទាត់ខាងក្រោមផ្ទុកបណ្ណាល័យ និងធ្វើឱ្យម៉ាស៊ីនភ្ញៀវ HTTP ភ្លាមៗ៖

local http_client = require('http.client').new()

យើងក៏ត្រូវការបណ្ណាល័យសម្រាប់ json deserialization៖

local json = require('json')

វាគ្រប់គ្រាន់ដើម្បីបង្កើតមុខងារផ្ទុកទិន្នន័យ៖

local function load_data(url, row_ver)
    local url = ('%s?rowVer=%s'):format(url,
        tostring(row_ver))
    local body = nil
    local data = http_client:request('GET', url, body, {
        keepalive_idle =  1,
        keepalive_interval = 1
    })
    return json.decode(data.body)
end

មុខងារអនុវត្តសំណើ HTTP ទៅអាសយដ្ឋាន url ហើយផ្ញើវា។ row_ver ជា​ប៉ារ៉ាម៉ែត្រ​មួយ ហើយ​ត្រឡប់​លទ្ធផល deserialized នៃ​សំណើ។

មុខងារសម្រាប់រក្សាទុកទិន្នន័យដែលបានទទួលមើលទៅដូចនេះ៖

local function save_goods(goods)
    local n = #goods
    box.atomic(function()
        for i = 1, n do
            local obj = goods[i]
            box.space.goods:put(
                obj.id, obj.name, obj.code)
        end
    end)
end

វដ្តនៃការរក្សាទុកទិន្នន័យទៅកាន់លំហ goods ដាក់ក្នុងប្រតិបត្តិការមួយ (មុខងារត្រូវបានប្រើសម្រាប់ការនេះ។ box.atomic) ដើម្បីកាត់បន្ថយចំនួនប្រតិបត្តិការថាស។

ទីបំផុតមុខងារធ្វើសមកាលកម្មលំហមូលដ្ឋាន goods ជាមួយនឹងប្រភព អ្នកអាចអនុវត្តវាដូចនេះ៖

local function sync_goods()
    local tuple = box.space.row_ver:get('goods')
    local row_ver = tuple and tuple.value or 0

    —— set your url here:
    local url = 'http://127.0.0.1:81/test/goods/list'

    while true do
        local goods = load_goods(url, row_ver)

        local count = #goods
        if count == 0 then
            return
        end

        save_goods(goods)

        row_ver = goods[count].rowVer
        box.space.row_ver:put({'goods', row_ver})
    end
end

ដំបូងយើងអានតម្លៃដែលបានរក្សាទុកពីមុន row_ver សម្រាប់លំហ goods. ប្រសិនបើវាបាត់ (វគ្គផ្លាស់ប្តូរដំបូង) បន្ទាប់មកយើងយកវាជា row_ver សូន្យ។ បន្ទាប់នៅក្នុងវដ្ត យើងអនុវត្តការទាញយកមួយទំព័រដោយទំព័រនៃទិន្នន័យដែលបានផ្លាស់ប្តូរពីប្រភពនៅ url ដែលបានបញ្ជាក់។ នៅពេលធ្វើម្តងទៀតនីមួយៗ យើងរក្សាទុកទិន្នន័យដែលទទួលបានទៅកន្លែងទំនេរក្នុងតំបន់សមស្រប ហើយធ្វើបច្ចុប្បន្នភាពតម្លៃ row_ver (នៅក្នុងលំហ row_ver និងនៅក្នុងអថេរ row_ver) - យកតម្លៃ row_ver ពីជួរចុងក្រោយនៃទិន្នន័យដែលបានផ្ទុក។

ដើម្បីការពារប្រឆាំងនឹងរង្វិលជុំដោយចៃដន្យ (ក្នុងករណីមានកំហុសក្នុងកម្មវិធី) រង្វិលជុំ while អាចត្រូវបានជំនួសដោយ for:

for _ = 1, max_req do ...

ជាលទ្ធផលនៃការអនុវត្តមុខងារ sync_goods លំហ goods អ្នកទទួលនឹងមានកំណែចុងក្រោយបំផុតនៃកំណត់ត្រាអវកាសទាំងអស់។ goods នៅក្នុងប្រភព។

ជាក់ស្តែង ការលុបទិន្នន័យមិនអាចផ្សាយតាមវិធីនេះបានទេ។ ប្រសិនបើមានតម្រូវការបែបនេះ អ្នកអាចប្រើសញ្ញាលុប។ បន្ថែមទៅកន្លែងទំនេរ goods វាលប៊ូលីន is_deleted ហើយជំនួសឱ្យការលុបកំណត់ត្រាជាក់ស្តែង យើងប្រើការលុបឡូជីខល - យើងកំណត់តម្លៃវាល is_deleted ចូលទៅក្នុងអត្ថន័យ true. ពេលខ្លះជំនួសឱ្យវាលប៊ូលីន is_deleted វាកាន់តែងាយស្រួលប្រើវាល deletedដែលរក្សាទុកកាលបរិច្ឆេទ-ពេលវេលានៃការលុបកំណត់ហេតុ។ បន្ទាប់ពីអនុវត្តការលុបឡូជីខល កំណត់ត្រាដែលបានសម្គាល់សម្រាប់ការលុបនឹងត្រូវបានផ្ទេរពីប្រភពទៅទិសដៅ (យោងទៅតាមតក្កវិជ្ជាដែលបានពិភាក្សាខាងលើ)។

លំដាប់លំដោយ row_ver អាចត្រូវបានប្រើដើម្បីបញ្ជូនទិន្នន័យពីចន្លោះផ្សេងទៀត៖ មិនចាំបាច់បង្កើតលំដាប់ដាច់ដោយឡែកសម្រាប់លំហបញ្ជូននីមួយៗទេ។

យើងបានពិនិត្យមើលវិធីដ៏មានប្រសិទ្ធភាពនៃការចម្លងទិន្នន័យកម្រិតខ្ពស់នៅក្នុងកម្មវិធីដោយប្រើ Tarantool DBMS ។

ការរកឃើញ

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

ប្រភព: www.habr.com