tarantool အတွက်ကျွန်ုပ်တို့၏ကိုယ်ပိုင် capped သက်တမ်းကုန်ဆုံးနေသော module ကိုရေးပါ။

မကြာသေးမီက ကျွန်ုပ်တို့သည် နေရာလွတ်များတွင် tuples များကို သန့်ရှင်းရေးလုပ်သည့် ပြဿနာနှင့် ရင်ဆိုင်ခဲ့ရသည်။ တားရန်တူးလ်. tarantool သည် မှတ်ဉာဏ်ကုန်သွားသောအခါတွင်မဟုတ်ဘဲ ကြိုတင်၍ သတ်မှတ်ထားသော ကြိမ်နှုန်းဖြင့် သန့်ရှင်းရေးကို စတင်ရပါမည်။ ဤလုပ်ငန်းဆောင်တာအတွက်၊ tarantool တွင် Lua ဟုခေါ်သော မော်ဂျူးတစ်ခုရှိသည်။ သက်တမ်းကုန်ဆုံး. ဤ module ကို အချိန်တိုအတွင်း အသုံးပြုပြီးနောက်၊ ၎င်းသည် ကျွန်ုပ်တို့အတွက် မသင့်လျော်ကြောင်း ကျွန်ုပ်တို့ သဘောပေါက်လိုက်သည်- ဒေတာအများအပြားကို အဆက်မပြတ်ရှင်းလင်းခြင်းကြောင့် Lua သည် GC တွင် ချိတ်ဆွဲထားသည်။ ထို့ကြောင့်၊ ကျွန်ုပ်တို့သည် မူရင်းပရိုဂရမ်းမင်းဘာသာစကားဖြင့် ရေးသားထားသော ကုဒ်သည် ကျွန်ုပ်တို့၏ပြဿနာများကို ဖြစ်နိုင်သမျှ အကောင်းဆုံးနည်းဖြင့် ဖြေရှင်းပေးမည်ဟု မျှော်လင့်ထားသော ကျွန်ုပ်တို့၏ကိုယ်ပိုင်သက်တမ်းကုန်ဆုံးထားသော module ကို တီထွင်ရန် စဉ်းစားခဲ့ပါသည်။

ကျွန်ုပ်တို့အတွက် နမူနာကောင်းတစ်ခုမှာ tarantool ဟုခေါ်သော မော်ဂျူးဖြစ်သည်။ memcache. ၎င်းတွင်အသုံးပြုသောချဉ်းကပ်မှုသည် tuple ၏သက်တမ်းကိုညွှန်ပြသည့်အာကာသအတွင်းသီးခြားအကွက်တစ်ခုကိုဖန်တီးသည်ဟူသောအချက်အပေါ်အခြေခံသည်။ နောက်ခံရှိ မော်ဂျူးသည် အာကာသကို စကင်န်ဖတ်ပြီး TTL ကို လက်ရှိအချိန်နှင့် နှိုင်းယှဉ်ကာ tuple ကို ဖျက်ရန် ရှိ၊ မရှိ ဆုံးဖြတ်သည်။ memcached module code သည် ရိုးရှင်းပြီး ပြေပြစ်သော်လည်း ယေဘုယျဆန်လွန်းသည်။ ပထမဦးစွာ၊ ကောက်ယူပြီး ဖျက်လိုက်သော အညွှန်းအမျိုးအစားကို ထည့်သွင်းစဉ်းစားမည်မဟုတ်ပါ။ ဒုတိယအနေဖြင့်၊ ဖြတ်သန်းမှုတစ်ခုစီတွင် tuples အားလုံးကိုစကင်န်ဖတ်ထားပြီး၊ အရေအတွက်အတော်လေးကြီးမားနိုင်သည်။ အကယ်၍ သက်တမ်းကုန်ဆုံးသွားသော module တွင် ပထမပြဿနာကို ဖြေရှင်းပြီးပါက (သစ်ပင်ညွှန်းကိန်းကို သီးခြားအတန်းတစ်ခုအဖြစ် ခွဲခြားထားသည်)၊ ထို့နောက် ဒုတိယတစ်ခုသည် မည်သည့်အာရုံကိုမျှ မရရှိခဲ့ပါ။ ဤအချက်သုံးချက်သည် ကျွန်ုပ်၏ကိုယ်ပိုင်ကုဒ်ကို ရေးသားရာတွင် ရွေးချယ်မှုအား ကြိုတင်သတ်မှတ်ထားသည်။

ဖေါ်ပြချက်

tarantool အတွက် စာရွက်စာတမ်းသည် အလွန်ကောင်းမွန်သည်။ ကျူတိုရီရယ် C တွင် သိမ်းဆည်းထားသော လုပ်ထုံးလုပ်နည်းများကို မည်သို့ရေးရမည်နည်းနှင့် ပတ်သက်၍ ပထမဦးစွာ၊ အောက်ဖော်ပြပါအတိုင်း ပေါ်လာမည့် command များနှင့် ကုဒ်များပါသော ထည့်သွင်းမှုများကို နားလည်ရန်အတွက် ၎င်းနှင့် ရင်းနှီးအောင် လုပ်ဖို့ အကြံပြုအပ်ပါသည်။ အဲဒါကိုလည်း သတိထားရကျိုးနပ်ပါတယ်။ အကိုးအကား သင်၏ကိုယ်ပိုင် capped module ကိုရေးသောအခါတွင်ရရှိနိုင်သည့်အရာဝတ္ထုများဆီသို့၊ ဆိုလိုသည်မှာ သေတ္တာ, အမှငျြ, အညွှန်းကိန်း и txn.

အဝေးကနေ စပြီး ထုပ်ထားတဲ့ သက်တမ်းကုန်ဆုံးသွားတဲ့ မော်ဂျူးကို အပြင်ကနေ ဘယ်လိုပုံစံနဲ့ ကြည့်ကြည့်ရအောင်။

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
capped_connection = net_box:new(3300)

ရိုးရှင်းရန်အတွက် ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ libcapped-expirationd.so စာကြည့်တိုက်တည်ရှိရာ လမ်းညွှန်တွင် tarantool ကိုဖွင့်လိုက်ပါ။ လုပ်ဆောင်ချက်နှစ်ခုကို ဒစ်ဂျစ်တိုက်မှ တင်ပို့သည်- စတင်ခြင်းနှင့် သတ်ပစ်ခြင်း။ ပထမအဆင့်မှာ box.schema.func.create နှင့် box.schema.user.grant ကို အသုံးပြု၍ Lua မှ ဤလုပ်ဆောင်ချက်များကို ရရှိနိုင်စေရန်ဖြစ်သည်။ ထို့နောက် tuples တွင် အကွက်သုံးခုသာပါဝင်မည့် နေရာတစ်ခုကို ဖန်တီးပါ- ပထမတစ်ခုသည် ထူးခြားသောသတ်မှတ်မှုဖြစ်ပြီး ဒုတိယမှာ အီးမေးလ်ဖြစ်ပြီး တတိယမှာ tuple ၏သက်တမ်းဖြစ်သည်။ ကျွန်ုပ်တို့သည် ပထမအကွက်၏ထိပ်တွင် သစ်ပင်အညွှန်းတစ်ခုကို တည်ဆောက်ပြီး ၎င်းကို မူလတန်းဟုခေါ်သည်။ ထို့နောက် ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ မူလစာကြည့်တိုက်သို့ ချိတ်ဆက်မှုအရာဝတ္ထုကို ရယူပါသည်။

ကြိုတင်ပြင်ဆင်မှုအပြီးတွင်၊ စတင်သည့်လုပ်ဆောင်ချက်ကို လုပ်ဆောင်ပါ။

capped_connection:call('libcapped-expirationd.start', {'non-indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.primary, 3, 1024, 3600})

ဤဥပမာသည် Lua တွင်ရေးထားသည့် သက်တမ်းကုန်ဆုံးနေသော module နှင့် အတိအကျတူညီသောစကင်န်ဖတ်နေစဉ်အတွင်း အလုပ်လုပ်မည်ဖြစ်သည်။ start function အတွက် ပထမဆုံး argument သည် task ၏ ထူးခြားသော အမည်ဖြစ်ပါသည်။ ဒုတိယမှာ space identifier ဖြစ်သည်။ တတိယသည် tuple များကိုဖျက်မည့်ထူးခြားသောအညွှန်းတစ်ခုဖြစ်သည်။ စတုတ္ထသည် tuples များကိုဖြတ်သန်းမည့်အညွှန်းကိန်းဖြစ်သည်။ ပဉ္စမသည် တစ်သက်တာနှင့်အတူ tuple အကွက်၏နံပါတ်ဖြစ်သည် (နံပါတ်သည် 1 မှစတင်သည်၊ 0 မဟုတ်ပါ။!) ဆဋ္ဌမနှင့် သတ္တမတို့သည် စကင်ဖတ်ခြင်း ဆက်တင်များဖြစ်သည်။ 1024 သည် ငွေပေးငွေယူတစ်ခုတည်းတွင် ကြည့်ရှုနိုင်သည့် tuple အရေအတွက် အများဆုံးဖြစ်သည်။ 3600 — စက္ကန့်ပိုင်းအတွင်း စကင်ဖတ်ချိန်အပြည့်။

ဥပမာသည် ကူးယူခြင်းနှင့် ဖျက်ခြင်းအတွက် တူညီသောအညွှန်းကို အသုံးပြုကြောင်း သတိပြုပါ။ ၎င်းသည် သစ်ပင်အညွှန်းဖြစ်ပါက၊ သေးငယ်သောသော့မှ ပိုကြီးသည့်အထိ ဖြတ်သွားခြင်းကို လုပ်ဆောင်သည်။ ဥပမာအားဖြင့် hash index အချို့ရှိပါက၊ စည်းကမ်းအတိုင်း၊ ကျပန်းအစီအစဥ်ဖြင့် ဖြတ်သန်းခြင်းကို လုပ်ဆောင်သည်။ အာကာသ tuple အားလုံးကို စကင်န်တစ်ခုတွင် စကင်န်ဖတ်သည်။

တစ်သက်တာ စက္ကန့် 60 ဖြင့် အာကာသထဲသို့ tuple များစွာကို ထည့်သွင်းကြပါစို့။

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

ထည့်သွင်းမှု အောင်မြင်ကြောင်း စစ်ဆေးကြည့်ကြပါစို့။

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576418976]
  - [1, '[email protected]', 1576418976]
  - [2, '[email protected]', 1576418976]
...

60+ စက္ကန့်အကြာတွင် ရွေးချယ်မှုကို ပြန်လုပ်ကြည့်ရအောင် (ပထမ tuple ၏အစတွင် ထည့်သွင်းခြင်းအစမှ ရေတွက်ခြင်း) နှင့် capped သက်တမ်းကုန်ဆုံးသွားသော module သည် လုပ်ဆောင်ပြီးဖြစ်သည်ကို ကြည့်ကြပါစို့။

tarantool> box.space.tester.index.primary:select()
---
  - []
...

တာဝန်ကို ရပ်လိုက်ကြရအောင်။

capped_connection:call('libcapped-expirationd.kill', {'non-indexed'})

ကူးယူခြင်းအတွက် သီးခြားအညွှန်းကို အသုံးပြုသည့် ဒုတိယဥပမာကို ကြည့်ကြပါစို့။

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
box.space.tester:create_index('exp', {unique = false, parts = {3, 'unsigned'}})
capped_connection = net_box:new(3300)

ဤနေရာတွင် အရာအားလုံးသည် ခြွင်းချက်အနည်းငယ်ဖြင့် ပထမဥပမာတွင် တူညီပါသည်။ ကျွန်ုပ်တို့သည် တတိယအကွက်၏ထိပ်တွင် သစ်ပင်အညွှန်းတစ်ခုကို တည်ဆောက်ပြီး exp ဟုခေါ်သည်။ ဤအညွှန်းသည် မူလဟုခေါ်သော အညွှန်းနှင့်မတူဘဲ ထူးခြားနေရန် မလိုအပ်ပါ။ အကူးအပြောင်းကို exp အညွှန်းဖြင့် လုပ်ဆောင်မည်ဖြစ်ပြီး၊ အဓိကအားဖြင့် ဖျက်ခြင်းကို လုပ်ဆောင်မည်ဖြစ်သည်။ ယခင်က နှစ်ခုစလုံးကို မူလအညွှန်းကို အသုံးပြု၍ လုပ်ဆောင်ခဲ့ကြောင်း ကျွန်ုပ်တို့ သတိရမိသည်။

ကြိုတင်ပြင်ဆင်မှုအပြီးတွင်၊ ကျွန်ုပ်တို့သည် အကြောင်းပြချက်အသစ်များဖြင့် စတင်သည့်လုပ်ဆောင်ချက်ကို လုပ်ဆောင်သည်-

capped_connection:call('libcapped-expirationd.start', {'indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.exp, 3, 1024, 3600})

တစ်သက်တာ စက္ကန့် 60 ဖြင့် အာကာသထဲသို့ tuple များစွာကို ထပ်ထည့်ကြပါစို့။

box.space.tester:insert{0, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, '[email protected]', math.floor(fiber.time()) + 60}

စက္ကန့် 30 ကြာပြီးနောက်၊ ဥပမာအားဖြင့်၊ ကျွန်ုပ်တို့သည် နောက်ထပ် tuples အနည်းငယ်ကို ထပ်ထည့်ပါမည်။

box.space.tester:insert{3, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{4, '[email protected]', math.floor(fiber.time()) + 60}
box.space.tester:insert{5, '[email protected]', math.floor(fiber.time()) + 60}

ထည့်သွင်းမှု အောင်မြင်ကြောင်း စစ်ဆေးကြည့်ကြပါစို့။

tarantool> box.space.tester.index.primary:select()
---
- - [0, '[email protected]', 1576421257]
  - [1, '[email protected]', 1576421257]
  - [2, '[email protected]', 1576421257]
  - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

60+ စက္ကန့်အကြာတွင် ရွေးချယ်မှုကို ပြန်လုပ်ကြည့်ရအောင် (ပထမ tuple ၏အစတွင် ထည့်သွင်းခြင်းအစမှ ရေတွက်ခြင်း) နှင့် capped သက်တမ်းကုန်ဆုံးသွားသော module သည် လုပ်ဆောင်ပြီးဖြစ်သည်ကို ကြည့်ကြပါစို့။

tarantool> box.space.tester.index.primary:select()
---
- - [3, '[email protected]', 1576421287]
  - [4, '[email protected]', 1576421287]
  - [5, '[email protected]', 1576421287]
...

အသက်ရှင်ရန် စက္ကန့် 30 ခန့်သာ ကျန်ရှိတော့သည့် အာကာသထဲတွင် ကျူပလီအချို့ ကျန်နေသေးသည်။ ထို့အပြင်၊ ID 2 ရှိသော tuple မှ 1576421257 နှင့် 3 ID ရှိသော tuple နှင့် တစ်သက်တာ 1576421287 သို့ ရွေ့လျားသည့်အခါ စကင်န်ရပ်တန့်သွားပါသည်။ 1576421287 သို့မဟုတ် တစ်သက်တာ XNUMX သို့မဟုတ် ထို့ထက်ပိုသော tuple များကို စကင်န်မဖတ်နိုင်ပါ။ exp အညွှန်းကီးများ။ ဒါက အစမှာ လိုချင်တဲ့ စုဆောင်းငွေပါ။

တာဝန်ကို ရပ်လိုက်ကြရအောင်။

capped_connection:call('libcapped-expirationd.kill', {'indexed'})

အကောင်အထည်ဖော်မှု

ပရောဂျက်တစ်ခု၏ အင်္ဂါရပ်များအားလုံးကို ပြောပြရန် အကောင်းဆုံးနည်းလမ်းမှာ ၎င်း၏မူရင်းရင်းမြစ်ဖြစ်သည်။ ကုဒ်! ထုတ်ဝေမှု၏ တစ်စိတ်တစ်ပိုင်းအနေဖြင့်၊ ကျွန်ုပ်တို့သည် အရေးကြီးဆုံးအချက်များဖြစ်သည့် အာကာသရှောင်ကွင်း အယ်လဂိုရီသမ်များကိုသာ အာရုံစိုက်ပါမည်။

စတင်နည်းလမ်းသို့ ကျွန်ုပ်တို့ပေးပို့သော အကြောင်းပြချက်များကို expirationd_task ဟုခေါ်သော ဖွဲ့စည်းပုံတွင် သိမ်းဆည်းထားသည်။

struct expirationd_task
{
  char name[256];
  uint32_t space_id;
  uint32_t rm_index_id;
  uint32_t it_index_id;
  uint32_t it_index_type; 
  uint32_t field_no;
  uint32_t scan_size;
  uint32_t scan_time;
};

name attribute သည် အလုပ်၏အမည်ဖြစ်သည်။ space_id ရည်ညွှန်းချက်သည် space identifier ဖြစ်သည်။ rm_index_id ရည်ညွှန်းချက်သည် tuples များကို ဖျက်ပစ်မည့် သီးခြားအညွှန်းကိန်း၏ အထောက်အထားဖြစ်သည်။ it_index_id ရည်ညွှန်းချက်သည် tuples ကိုဖြတ်သွားမည့် အညွှန်းကိန်း၏ identifier ဖြစ်သည်။ it_index_type ရည်ညွှန်းချက်သည် tuples ကိုဖြတ်သွားမည့် အညွှန်းအမျိုးအစားဖြစ်သည်။ filed_no ရည်ညွှန်းချက်သည် တစ်သက်တာနှင့်အတူ tuple အကွက်၏ နံပါတ်ဖြစ်သည်။ scan_size ရည်ညွှန်းချက်သည် ငွေပေးငွေယူတစ်ခုတွင် စကင်န်ဖတ်ထားသော tuples အများဆုံးအရေအတွက်ဖြစ်သည်။ scan_time ရည်ညွှန်းချက်သည် စက္ကန့်ပိုင်းအတွင်း အပြည့်အဝ စကင်ဖတ်ချိန်ဖြစ်သည်။

အငြင်းအခုံများကို ပိုင်းခြားစဉ်းစားမည်မဟုတ်ပါ။ စာကြည့်တိုက်သည် သင့်အား ကူညီပေးမည့် ဝီရိယရှိသော်လည်း ရိုးရှင်းသောအလုပ်ဖြစ်သည်။ msgpuck. mp_map အမျိုးအစားနှင့်အတူ ရှုပ်ထွေးသောဒေတာဖွဲ့စည်းပုံအဖြစ် Lua မှဖြတ်သန်းသွားသော အညွှန်းကိန်းများနှင့်သာ ရိုးရှင်းသောအမျိုးအစားများဖြစ်သော mp_bool၊ mp_double၊ mp_int၊ mp_uint နှင့် mp_array တို့ကို အသုံးမပြုဘဲ ဖြစ်ပေါ်လာနိုင်သည်။ သို့သော် အညွှန်းတစ်ခုလုံးကို ခွဲခြမ်းစိတ်ဖြာရန် မလိုအပ်ပါ။ ၎င်း၏ထူးခြားမှုကို စစ်ဆေးရန်၊ အမျိုးအစားကို တွက်ချက်ပြီး ခွဲခြားသတ်မှတ်မှုကို ထုတ်ယူရန်သာ လိုအပ်သည်။

ကျွန်ုပ်တို့သည် ခွဲခြမ်းစိတ်ဖြာရန်အတွက် အသုံးပြုသည့် လုပ်ဆောင်ချက်အားလုံး၏ ရှေ့ပြေးပုံစံများကို စာရင်းပြုစုထားပါသည်။

bool expirationd_parse_name(struct expirationd_task *task, const char **pos);
bool expirationd_parse_space_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_unique(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_type(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_field_no(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_size(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_time(struct expirationd_task *task, const char **pos);

အခု အရေးကြီးဆုံးအရာ - space ကိုကျော်ဖြတ်ပြီး tuples တွေကို ဖျက်ခြင်းရဲ့ ယုတ္တိကို ဆက်ကြည့်ရအောင်။ scan_size ထက်မကြီးသော tuple တုံးတစ်ခုစီကို အရောင်းအ၀ယ်တစ်ခုတည်းအောက်တွင် စကန်ဖတ်ပြီး ပြုပြင်မွမ်းမံထားသည်။ အောင်မြင်ပါက၊ ဤငွေပေးငွေယူကို ကတိပြုထားပြီး၊ အမှားအယွင်းဖြစ်ပါက၊ ၎င်းကို ပြန်လည်ရုပ်သိမ်းမည်ဖြစ်သည်။ expirationd_iterate လုပ်ဆောင်ချက်အတွက် နောက်ဆုံးအငြင်းအခုံသည် စကင်ဖတ်စစ်ဆေးခြင်း စတင်သည် သို့မဟုတ် ဆက်လက်လုပ်ဆောင်သည့် iterator အား ညွှန်ပြချက်ဖြစ်သည်။ အမှားအယွင်းတစ်ခုဖြစ်ပွားခြင်း၊ နေရာလွတ်ကုန်သွားသည်အထိ သို့မဟုတ် လုပ်ငန်းစဉ်ကိုကြိုတင်ရပ်တန့်ရန်မဖြစ်နိုင်မချင်း ဤထပ်တင်ကိရိယာကို အတွင်းပိုင်းအတွင်း တိုးထားသည်။ လုပ်ဆောင်ချက် expirationd_expired သည် tuple တစ်ခု၏ သက်တမ်းကို စစ်ဆေးသည်၊ expirationd_delete သည် tuple တစ်ခုကို ဖျက်သည်၊ expirationd_breakable checks သည် ကျွန်ုပ်တို့ ရှေ့ဆက်ရန် လိုအပ်ခြင်း ရှိမရှိ စစ်ဆေးသည်။

Expirationd_iterate လုပ်ဆောင်ချက်ကုဒ်-

static bool
expirationd_iterate(struct expirationd_task *task, box_iterator_t **iterp)
{
  box_iterator_t *iter = *iterp;
  box_txn_begin();
  for (uint32_t i = 0; i < task->scan_size; ++i) {
    box_tuple_t *tuple = NULL;
    if (box_iterator_next(iter, &tuple) < 0) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_rollback();
      return false;
    }
    if (!tuple) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_commit();
      return true;
    }
    if (expirationd_expired(task, tuple))
      expirationd_delete(task, tuple);
    else if (expirationd_breakable(task))
      break;
  }
  box_txn_commit();
  return true;
}

လုပ်ဆောင်ချက်ကုဒ် သက်တမ်းကုန်ဆုံးသည်_သက်တမ်းကုန်သွားသည်-

static bool
expirationd_expired(struct expirationd_task *task, box_tuple_t *tuple)
{
  const char *buf = box_tuple_field(tuple, task->field_no - 1);
  if (!buf || mp_typeof(*buf) != MP_UINT)
    return false;
  uint64_t val = mp_decode_uint(&buf);
  if (val > fiber_time64() / 1000000)
    return false;
  return true;
}

Expirationd_delete လုပ်ဆောင်ချက်ကုဒ်-

static void
expirationd_delete(struct expirationd_task *task, box_tuple_t *tuple)
{
  uint32_t len;
  const char *str = box_tuple_extract_key(tuple, task->space_id, task->rm_index_id, &len);
  box_delete(task->space_id, task->rm_index_id, str, str + len, NULL);
}

Expirationd_breakable function code-

static bool
expirationd_breakable(struct expirationd_task *task)
{
  return task->it_index_id != task->rm_index_id && task->it_index_type == ITER_GT;
}

လြှောကျလှာ

source code ကို မှာ ကြည့်ရှုနိုင်ပါတယ်။ ဒီမှာ!

source: www.habr.com