ການຂຽນໂມດູນຫມົດອາຍຸ capped ຂອງພວກເຮົາສໍາລັບ tarantool

ບາງຄັ້ງກ່ອນຫນ້ານີ້ພວກເຮົາໄດ້ປະເຊີນກັບບັນຫາຂອງການທໍາຄວາມສະອາດ tuples ໃນສະຖານທີ່ ທາລັນທູ. ການທໍາຄວາມສະອາດຈະຕ້ອງເລີ່ມຕົ້ນບໍ່ແມ່ນໃນເວລາທີ່ tarantool ກໍາລັງຫມົດຄວາມຊົງຈໍາ, ແຕ່ລ່ວງຫນ້າແລະຄວາມຖີ່ທີ່ແນ່ນອນ. ສໍາລັບວຽກງານນີ້, tarantool ມີໂມດູນທີ່ຂຽນໃນ Lua ເອີ້ນວ່າ ໝົດອາຍຸ. ຫຼັງຈາກໃຊ້ໂມດູນນີ້ເປັນເວລາສັ້ນໆ, ພວກເຮົາຮູ້ວ່າມັນບໍ່ເຫມາະສົມສໍາລັບພວກເຮົາ: ເນື່ອງຈາກການເຮັດຄວາມສະອາດຢ່າງຕໍ່ເນື່ອງຂອງຂໍ້ມູນຈໍານວນຫລາຍ, Lua ແຂວນຢູ່ໃນ GC. ດັ່ງນັ້ນ, ພວກເຮົາຄິດກ່ຽວກັບການພັດທະນາໂມດູນທີ່ຫມົດອາຍຸ capped ຂອງພວກເຮົາເອງ, ຫວັງວ່າລະຫັດທີ່ຂຽນເປັນພາສາການຂຽນໂປຼແກຼມພື້ນເມືອງຈະແກ້ໄຂບັນຫາຂອງພວກເຮົາໃນທາງທີ່ດີທີ່ສຸດ.

ຕົວຢ່າງທີ່ດີສໍາລັບພວກເຮົາແມ່ນໂມດູນ tarantool ທີ່ເອີ້ນວ່າ memcached. ວິທີການທີ່ໃຊ້ໃນມັນແມ່ນອີງໃສ່ຄວາມຈິງທີ່ວ່າພາກສະຫນາມແຍກຕ່າງຫາກແມ່ນຖືກສ້າງຂຶ້ນໃນຊ່ອງ, ເຊິ່ງຊີ້ໃຫ້ເຫັນເຖິງອາຍຸຂອງ tuple, ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ttl. ໂມດູນໃນພື້ນຫລັງສະແກນພື້ນທີ່, ປຽບທຽບ TTL ກັບເວລາປະຈຸບັນແລະຕັດສິນໃຈວ່າຈະລຶບ tuple ຫຼືບໍ່. ລະຫັດໂມດູນ memcached ແມ່ນງ່າຍດາຍແລະສະຫງ່າງາມ, ແຕ່ທົ່ວໄປເກີນໄປ. ຫນ້າທໍາອິດ, ມັນບໍ່ໄດ້ຄໍານຶງເຖິງປະເພດຂອງດັດຊະນີທີ່ກໍາລັງກວາດລ້າງແລະລຶບ. ອັນທີສອງ, ໃນແຕ່ລະຜ່ານ tuples ທັງຫມົດໄດ້ຖືກສະແກນ, ຈໍານວນທີ່ສາມາດຂ້ອນຂ້າງໃຫຍ່. ແລະຖ້າຢູ່ໃນໂມດູນຫມົດອາຍຸ, ບັນຫາທໍາອິດໄດ້ຖືກແກ້ໄຂ (ດັດສະນີຕົ້ນໄມ້ຖືກແຍກອອກເປັນຊັ້ນແຍກຕ່າງຫາກ), ຫຼັງຈາກນັ້ນ, ທີສອງຍັງບໍ່ໄດ້ຮັບການເອົາໃຈໃສ່. ສາມຈຸດເຫຼົ່ານີ້ໄດ້ກໍານົດທາງເລືອກໃນເງື່ອນໄຂຂອງການຂຽນລະຫັດຂອງຂ້ອຍເອງ.

ລາຍ​ລະ​ອຽດ

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

ໃຫ້ເລີ່ມຕົ້ນຈາກໄລຍະໄກແລະເບິ່ງວ່າໂມດູນຫມົດອາຍຸທີ່ມີ capped ມີລັກສະນະແນວໃດຈາກພາຍນອກ:

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)

ສໍາລັບຄວາມງ່າຍດາຍ, ພວກເຮົາເປີດຕົວ tarantool ໃນໄດເລກະທໍລີທີ່ຫ້ອງສະຫມຸດ libcapped-expirationd.so ຂອງພວກເຮົາຕັ້ງຢູ່. ສອງຫນ້າທີ່ຖືກສົ່ງອອກຈາກຫ້ອງສະຫມຸດ: ເລີ່ມຕົ້ນແລະຂ້າ. ຂັ້ນຕອນທໍາອິດແມ່ນເພື່ອເຮັດໃຫ້ຫນ້າທີ່ເຫຼົ່ານີ້ສາມາດໃຊ້ໄດ້ຈາກ Lua ໂດຍໃຊ້ box.schema.func.create ແລະ box.schema.user.grant. ຫຼັງຈາກນັ້ນ, ສ້າງຊ່ອງທີ່ 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. ການໂຕ້ຖຽງທໍາອິດກັບຟັງຊັນເລີ່ມຕົ້ນແມ່ນຊື່ທີ່ເປັນເອກະລັກຂອງຫນ້າວຽກ. ອັນທີສອງແມ່ນຕົວລະບຸຊ່ອງ. ອັນທີສາມແມ່ນດັດຊະນີທີ່ເປັນເອກະລັກທີ່ tuples ຈະຖືກລຶບ. ສີ່ແມ່ນດັດຊະນີທີ່ tuples ຈະຖືກຂ້າມຜ່ານ. ທີຫ້າແມ່ນຕົວເລກຂອງພາກສະຫນາມ tuple ຕະຫຼອດຊີວິດ (ຕົວເລກເລີ່ມຕົ້ນຈາກ 1, ບໍ່ແມ່ນ 0!). ຄັ້ງທີ VI ແລະທີ 1024 ແມ່ນການຕັ້ງຄ່າການສະແກນ. 3600 ແມ່ນຈໍານວນສູງສຸດຂອງ tuples ທີ່ສາມາດເບິ່ງໄດ້ໃນທຸລະກໍາດຽວ. XNUMX — ເວລາສະແກນເຕັມໃນວິນາທີ.

ໃຫ້ສັງເກດວ່າຕົວຢ່າງໃຊ້ດັດສະນີດຽວກັນສໍາລັບການລວບລວມຂໍ້ມູນແລະການລຶບ. ຖ້ານີ້ແມ່ນດັດຊະນີຕົ້ນໄມ້, ຫຼັງຈາກນັ້ນ, ເສັ້ນທາງຜ່ານແມ່ນດໍາເນີນຈາກຄີຂະຫນາດນ້ອຍໄປຫາຂະຫນາດໃຫຍ່ກວ່າ. ຖ້າມີບາງອັນອື່ນ, ສໍາລັບການຍົກຕົວຢ່າງ, ດັດຊະນີ hash, ຫຼັງຈາກນັ້ນ traversal ແມ່ນດໍາເນີນ, ຕາມກົດລະບຽບ, ໃນຄໍາສັ່ງສຸ່ມ. ຊ່ອງຫວ່າງທັງໝົດຖືກສະແກນໃນສະແກນດຽວ.

ໃຫ້ໃສ່ tuples ຫຼາຍໆອັນເຂົ້າໄປໃນຊ່ອງທີ່ມີຊີວິດ 60 ວິນາທີ:

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 ໄດ້ດໍາເນີນການແລ້ວ:

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

ໃຫ້ພວກເຮົາໃສ່ tuples ຫຼາຍອັນເຂົ້າໄປໃນຊ່ອງອີກເທື່ອຫນຶ່ງໂດຍຕະຫຼອດຊີວິດຂອງ 60 ວິນາທີ:

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 ໄດ້ດໍາເນີນການແລ້ວ:

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

ຍັງມີບາງ tuples ເຫຼືອຢູ່ໃນຊ່ອງທີ່ຈະມີປະມານ 30 ວິນາທີເພີ່ມເຕີມເພື່ອດໍາລົງຊີວິດ. ຍິ່ງໄປກວ່ານັ້ນ, ການສະແກນຢຸດເມື່ອຍ້າຍຈາກ tuple ທີ່ມີ ID ຂອງ 2 ແລະຕະຫຼອດຊີວິດຂອງ 1576421257 ກັບ tuple ທີ່ມີ ID ຂອງ 3 ແລະຕະຫຼອດຊີວິດຂອງ 1576421287. Tuples ທີ່ມີຊີວິດຂອງ 1576421287 ຫຼືຫຼາຍກວ່ານັ້ນບໍ່ໄດ້ຖືກສະແກນເນື່ອງຈາກການສັ່ງຊື້ຂອງ ກະແຈ exp index. ນີ້ແມ່ນເງິນຝາກປະຢັດທີ່ພວກເຮົາຕ້ອງການບັນລຸໃນຕອນເລີ່ມຕົ້ນ.

ໃຫ້ຢຸດເຊົາວຽກງານ:

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

Реализация

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

arguments ທີ່ພວກເຮົາຜ່ານໄປຫາວິທີການເລີ່ມຕົ້ນແມ່ນເກັບໄວ້ໃນໂຄງສ້າງທີ່ເອີ້ນວ່າ 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;
};

ຄຸນລັກສະນະຂອງຊື່ແມ່ນຊື່ຂອງວຽກງານ. ຄຸນລັກສະນະ space_id ແມ່ນຕົວລະບຸພື້ນທີ່. ຄຸນລັກສະນະ rm_index_id ແມ່ນຕົວລະບຸຂອງດັດຊະນີທີ່ເປັນເອກະລັກທີ່ tuples ຈະຖືກລຶບ. ຄຸນລັກສະນະ it_index_id ແມ່ນຕົວລະບຸຂອງດັດຊະນີທີ່ tuples ຈະຖືກຂ້າມຜ່ານ. ຄຸນລັກສະນະ it_index_type ແມ່ນປະເພດຂອງດັດຊະນີທີ່ tuples ຈະຖືກຂ້າມຜ່ານ. ຄຸນລັກສະນະ filed_no ແມ່ນຕົວເລກຂອງຊ່ອງ tuple ຕະຫຼອດຊີວິດ. ຄຸນລັກສະນະ scan_size ແມ່ນຈໍານວນສູງສຸດຂອງ tuples ທີ່ຖືກສະແກນໃນຫນຶ່ງທຸລະກໍາ. ຄຸນລັກສະນະ scan_time ແມ່ນເວລາສະແກນເຕັມເປັນວິນາທີ.

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

ຕອນນີ້ໃຫ້ເຮົາກ້າວໄປສູ່ສິ່ງທີ່ສໍາຄັນທີ່ສຸດ - ເຫດຜົນຂອງການຂ້າມຊ່ອງແລະການລຶບ tuples. ແຕ່ລະທ່ອນຂອງ tuples ທີ່ບໍ່ໃຫຍ່ກວ່າ scan_size ແມ່ນໄດ້ຖືກສະແກນ ແລະດັດແກ້ພາຍໃຕ້ທຸລະກໍາດຽວ. ຖ້າປະສົບຜົນສໍາເລັດ, ການເຮັດທຸລະກໍານີ້ແມ່ນຫມັ້ນສັນຍາ; ຖ້າຂໍ້ຜິດພາດເກີດຂື້ນ, ມັນຈະຖືກກັບຄືນ. ການໂຕ້ຖຽງສຸດທ້າຍຕໍ່ກັບຟັງຊັນ expirationd_iterate ແມ່ນຕົວຊີ້ໄປຫາ iterator ທີ່ການສະແກນເລີ່ມຕົ້ນ ຫຼືສືບຕໍ່. iterator ນີ້​ແມ່ນ​ເພີ່ມ​ຂຶ້ນ​ພາຍ​ໃນ​ຈົນ​ກ​່​ວາ​ຄວາມ​ຜິດ​ພາດ​ເກີດ​ຂຶ້ນ​, ຊ່ອງ​ທີ່​ຫມົດ​, ຫຼື​ມັນ​ເປັນ​ໄປ​ໄດ້​ທີ່​ຈະ​ຢຸດ​ເຊົາ​ຂະ​ບວນ​ການ​ລ່ວງ​ຫນ້າ​. ຟັງຊັນ expirationd_expired ກວດເບິ່ງອາຍຸຂອງ tuple, expirationd_delete ລົບ tuple, ການກວດສອບການຫມົດອາຍຸ d_breakable ວ່າພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ດໍາເນີນການຕໍ່ໄປ.

ລະຫັດຟັງຊັນ 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;
}

ລະຫັດຟັງຊັນ expirationd_expired:

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:

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

Application

ທ່ານສາມາດເບິ່ງລະຫັດແຫຼ່ງທີ່ ທີ່ນີ້!

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