Tarantool DBMS-ൽ ഉയർന്ന തലത്തിലുള്ള പകർപ്പ്

ഹലോ, ഞാൻ DBMS-നായി ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുകയാണ് ടാരന്റൂൾ Mail.ru ഗ്രൂപ്പ് വികസിപ്പിച്ച ഒരു പ്ലാറ്റ്‌ഫോമാണ്, അത് ഉയർന്ന പ്രകടനമുള്ള DBMS ഉം Lua ഭാഷയിലുള്ള ഒരു ആപ്ലിക്കേഷൻ സെർവറും സംയോജിപ്പിക്കുന്നു. ടാരന്റൂളിനെ അടിസ്ഥാനമാക്കിയുള്ള പരിഹാരങ്ങളുടെ ഉയർന്ന വേഗത കൈവരിക്കുന്നത്, പ്രത്യേകിച്ചും, DBMS-ന്റെ ഇൻ-മെമ്മറി മോഡിനുള്ള പിന്തുണയും ഡാറ്റയ്‌ക്കൊപ്പം ഒരൊറ്റ വിലാസ സ്ഥലത്ത് ആപ്ലിക്കേഷൻ ബിസിനസ് ലോജിക് എക്‌സിക്യൂട്ട് ചെയ്യാനുള്ള കഴിവും കാരണം. അതേ സമയം, ACID ഇടപാടുകൾ ഉപയോഗിച്ച് ഡാറ്റ സ്ഥിരത ഉറപ്പാക്കുന്നു (ഡിസ്കിൽ ഒരു WAL ലോഗ് പരിപാലിക്കപ്പെടുന്നു). ടാരന്റൂളിന് റെപ്ലിക്കേഷനും ഷാർഡിംഗിനും ബിൽറ്റ്-ഇൻ പിന്തുണയുണ്ട്. പതിപ്പ് 2.1 മുതൽ, SQL ഭാഷയിലുള്ള അന്വേഷണങ്ങൾ പിന്തുണയ്ക്കുന്നു. ടാരന്റൂൾ ഓപ്പൺ സോഴ്‌സാണ്, ലളിതമാക്കിയ ബിഎസ്‌ഡി ലൈസൻസിന് കീഴിൽ ലൈസൻസുള്ളതാണ്. ഒരു വാണിജ്യ എന്റർപ്രൈസ് പതിപ്പും ഉണ്ട്.

ശക്തി അനുഭവിക്കുക! (...അല്ലെങ്കിൽ പ്രകടനം ആസ്വദിക്കുക)

മുകളിൽ പറഞ്ഞവയെല്ലാം ഡാറ്റാബേസുകളിൽ പ്രവർത്തിക്കുന്ന ഉയർന്ന ലോഡ് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ആകർഷകമായ പ്ലാറ്റ്‌ഫോമായി ടാരന്റൂളിനെ മാറ്റുന്നു. അത്തരം പ്രയോഗങ്ങളിൽ, പലപ്പോഴും ഡാറ്റ പകർപ്പെടുക്കൽ ആവശ്യമാണ്.

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ടാരന്റൂളിന് ബിൽറ്റ്-ഇൻ ഡാറ്റ റെപ്ലിക്കേഷൻ ഉണ്ട്. മാസ്റ്റർ ലോഗിൽ (WAL) അടങ്ങിയിരിക്കുന്ന എല്ലാ ഇടപാടുകളും പകർപ്പുകളിൽ തുടർച്ചയായി നടപ്പിലാക്കുക എന്നതാണ് അതിന്റെ പ്രവർത്തനത്തിന്റെ തത്വം. സാധാരണയായി അത്തരം പകർപ്പുകൾ (ഞങ്ങൾ അതിനെ കൂടുതൽ വിളിക്കും താഴ്ന്ന നില) ആപ്ലിക്കേഷൻ തെറ്റ് സഹിഷ്ണുത ഉറപ്പാക്കാനും കൂടാതെ/അല്ലെങ്കിൽ ക്ലസ്റ്റർ നോഡുകൾക്കിടയിൽ റീഡിംഗ് ലോഡ് വിതരണം ചെയ്യാനും ഉപയോഗിക്കുന്നു.

അരി. 1. ഒരു ക്ലസ്റ്ററിനുള്ളിലെ പകർപ്പ്

ഒരു ഡാറ്റാബേസിൽ സൃഷ്ടിച്ച ഡാറ്റ മറ്റൊരു ഡാറ്റാബേസിലേക്ക് പ്രോസസ്സ് ചെയ്യുന്നതിനും നിരീക്ഷിക്കുന്നതിനുമായി കൈമാറുന്നതാണ് ഇതര സാഹചര്യത്തിന്റെ ഉദാഹരണം. പിന്നീടുള്ള സാഹചര്യത്തിൽ, കൂടുതൽ സൗകര്യപ്രദമായ ഒരു പരിഹാരം ഉപയോഗിക്കാം ഉയർന്ന തലം റെപ്ലിക്കേഷൻ - ആപ്ലിക്കേഷൻ ബിസിനസ് ലോജിക് തലത്തിലുള്ള ഡാറ്റ റെപ്ലിക്കേഷൻ. ആ. ഞങ്ങൾ DBMS-ൽ നിർമ്മിച്ച ഒരു റെഡിമെയ്ഡ് സൊല്യൂഷൻ ഉപയോഗിക്കുന്നില്ല, എന്നാൽ ഞങ്ങൾ വികസിപ്പിച്ചെടുക്കുന്ന ആപ്ലിക്കേഷനിൽ സ്വന്തം പകർപ്പ് നടപ്പിലാക്കുക. ഈ സമീപനത്തിന് ഗുണങ്ങളും ദോഷങ്ങളുമുണ്ട്. നമുക്ക് നേട്ടങ്ങൾ പട്ടികപ്പെടുത്താം.

1. ട്രാഫിക് സേവിംഗ്സ്:

• നിങ്ങൾക്ക് എല്ലാ ഡാറ്റയും കൈമാറാൻ കഴിയില്ല, പക്ഷേ അതിന്റെ ഒരു ഭാഗം മാത്രം (ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ചില പട്ടികകൾ, അവയുടെ ചില നിരകൾ അല്ലെങ്കിൽ ഒരു നിശ്ചിത മാനദണ്ഡം പാലിക്കുന്ന റെക്കോർഡുകൾ എന്നിവ മാത്രമേ കൈമാറാൻ കഴിയൂ);
• അസിൻക്രണസ് (ടരന്റൂളിന്റെ നിലവിലെ പതിപ്പ് - 1.10-ൽ നടപ്പിലാക്കിയിരിക്കുന്നത്) അല്ലെങ്കിൽ സിൻക്രണസ് (ടരന്റൂളിന്റെ തുടർന്നുള്ള പതിപ്പുകളിൽ നടപ്പിലാക്കാൻ) മോഡിൽ തുടർച്ചയായി നടത്തുന്ന ലോ-ലെവൽ റെപ്ലിക്കേഷനിൽ നിന്ന് വ്യത്യസ്തമായി, സെഷനുകളിൽ ഉയർന്ന ലെവൽ റെപ്ലിക്കേഷൻ നടത്താം (അതായത്, ആപ്ലിക്കേഷൻ ആദ്യം ഡാറ്റയെ സമന്വയിപ്പിക്കുന്നു - ഒരു എക്സ്ചേഞ്ച് സെഷൻ ഡാറ്റ, തുടർന്ന് റെപ്ലിക്കേഷനിൽ ഒരു താൽക്കാലിക വിരാമമുണ്ട്, അതിനുശേഷം അടുത്ത എക്സ്ചേഞ്ച് സെഷൻ സംഭവിക്കുന്നു, മുതലായവ);
• ഒരു റെക്കോർഡ് നിരവധി തവണ മാറിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അതിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് മാത്രമേ കൈമാറാൻ കഴിയൂ (ലോ-ലെവൽ റെപ്ലിക്കേഷനിൽ നിന്ന് വ്യത്യസ്തമായി, മാസ്റ്ററിൽ വരുത്തിയ എല്ലാ മാറ്റങ്ങളും പകർപ്പുകളിൽ തുടർച്ചയായി പ്ലേ ചെയ്യും).

2. വിദൂര ഡാറ്റാബേസുകൾ സമന്വയിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന HTTP എക്സ്ചേഞ്ച് നടപ്പിലാക്കുന്നതിൽ ബുദ്ധിമുട്ടുകൾ ഒന്നുമില്ല.

അരി. 2. HTTP-യിലൂടെയുള്ള പകർപ്പ്

3. ഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഡാറ്റാബേസ് ഘടനകൾ ഒന്നായിരിക്കണമെന്നില്ല (കൂടാതെ, പൊതുവായ സാഹചര്യത്തിൽ, വ്യത്യസ്ത DBMS-കൾ, പ്രോഗ്രാമിംഗ് ഭാഷകൾ, പ്ലാറ്റ്‌ഫോമുകൾ മുതലായവ ഉപയോഗിക്കാൻ പോലും സാധിക്കും).

അരി. 3. വൈവിധ്യമാർന്ന സംവിധാനങ്ങളിലെ അനുകരണം

പോരായ്മ എന്തെന്നാൽ, ശരാശരി, പ്രോഗ്രാമിംഗ് കോൺഫിഗറേഷനേക്കാൾ ബുദ്ധിമുട്ടാണ് / ചെലവേറിയതാണ്, ബിൽറ്റ്-ഇൻ പ്രവർത്തനം ഇഷ്ടാനുസൃതമാക്കുന്നതിനുപകരം, നിങ്ങളുടേത് നടപ്പിലാക്കേണ്ടിവരും.

നിങ്ങളുടെ സാഹചര്യത്തിൽ മേൽപ്പറഞ്ഞ ഗുണങ്ങൾ നിർണായകമാണെങ്കിൽ (അല്ലെങ്കിൽ അവശ്യമായ ഒരു വ്യവസ്ഥയാണ്), ഉയർന്ന തലത്തിലുള്ള പകർപ്പ് ഉപയോഗിക്കുന്നത് അർത്ഥമാക്കുന്നു. Tarantool DBMS-ൽ ഹൈ-ലെവൽ ഡാറ്റ റെപ്ലിക്കേഷൻ നടപ്പിലാക്കുന്നതിനുള്ള നിരവധി വഴികൾ നോക്കാം.

ട്രാഫിക് കുറയ്ക്കൽ

അതിനാൽ, ഉയർന്ന തലത്തിലുള്ള റെപ്ലിക്കേഷന്റെ ഗുണങ്ങളിലൊന്ന് ട്രാഫിക് ലാഭമാണ്. ഈ നേട്ടം പൂർണ്ണമായി സാക്ഷാത്കരിക്കുന്നതിന്, ഓരോ എക്സ്ചേഞ്ച് സെഷനിലും കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഡാറ്റയുടെ അളവ് കുറയ്ക്കേണ്ടത് ആവശ്യമാണ്. തീർച്ചയായും, സെഷന്റെ അവസാനം, ഡാറ്റ റിസീവർ ഉറവിടവുമായി സമന്വയിപ്പിക്കണം (കുറഞ്ഞത് പകർപ്പെടുക്കലിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ഡാറ്റയുടെ ആ ഭാഗത്തിനെങ്കിലും) എന്നത് നാം മറക്കരുത്.

ഉയർന്ന തലത്തിലുള്ള പകർപ്പെടുക്കൽ സമയത്ത് കൈമാറുന്ന ഡാറ്റയുടെ അളവ് എങ്ങനെ കുറയ്ക്കാം? തീയതിയും സമയവും അനുസരിച്ച് ഡാറ്റ തിരഞ്ഞെടുക്കുന്നതാണ് നേരായ പരിഹാരം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് പട്ടികയിൽ ഇതിനകം നിലവിലുള്ള തീയതി-സമയ ഫീൽഡ് ഉപയോഗിക്കാം (അത് നിലവിലുണ്ടെങ്കിൽ). ഉദാഹരണത്തിന്, ഒരു "ഓർഡർ" പ്രമാണത്തിന് "ആവശ്യമായ ഓർഡർ എക്സിക്യൂഷൻ സമയം" എന്ന ഫീൽഡ് ഉണ്ടായിരിക്കാം - delivery_time. ഈ പരിഹാരത്തിന്റെ പ്രശ്നം, ഈ ഫീൽഡിലെ മൂല്യങ്ങൾ ഓർഡറുകൾ സൃഷ്ടിക്കുന്ന ക്രമത്തിൽ ആയിരിക്കണമെന്നില്ല എന്നതാണ്. അതിനാൽ നമുക്ക് പരമാവധി ഫീൽഡ് മൂല്യം ഓർക്കാൻ കഴിയില്ല delivery_time, മുമ്പത്തെ എക്‌സ്‌ചേഞ്ച് സെഷനിൽ ട്രാൻസ്മിറ്റ് ചെയ്‌തു, അടുത്ത എക്‌സ്‌ചേഞ്ച് സെഷനിൽ ഉയർന്ന ഫീൽഡ് മൂല്യമുള്ള എല്ലാ റെക്കോർഡുകളും തിരഞ്ഞെടുക്കുക delivery_time. എക്സ്ചേഞ്ച് സെഷനുകൾക്കിടയിൽ കുറഞ്ഞ ഫീൽഡ് മൂല്യമുള്ള റെക്കോർഡുകൾ ചേർത്തിരിക്കാം delivery_time. കൂടാതെ, ഓർഡറിൽ മാറ്റങ്ങൾ വരുത്താമായിരുന്നു, എന്നിരുന്നാലും അത് ഫീൽഡിനെ ബാധിച്ചില്ല delivery_time. രണ്ട് സാഹചര്യങ്ങളിലും, മാറ്റങ്ങൾ ഉറവിടത്തിൽ നിന്ന് ലക്ഷ്യസ്ഥാനത്തേക്ക് മാറ്റില്ല. ഈ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ, ഞങ്ങൾ ഡാറ്റ "ഓവർലാപ്പിംഗ്" കൈമാറേണ്ടതുണ്ട്. ആ. ഓരോ എക്സ്ചേഞ്ച് സെഷനിലും ഞങ്ങൾ എല്ലാ ഡാറ്റയും ഫീൽഡ് മൂല്യം ഉപയോഗിച്ച് കൈമാറും delivery_time, ഭൂതകാലത്തിലെ ചില പോയിന്റുകൾ കവിയുന്നു (ഉദാഹരണത്തിന്, നിലവിലെ നിമിഷത്തിൽ നിന്ന് N മണിക്കൂർ). എന്നിരുന്നാലും, വലിയ സിസ്റ്റങ്ങൾക്ക് ഈ സമീപനം വളരെ അനാവശ്യമാണെന്നും ഞങ്ങൾ പരിശ്രമിക്കുന്ന ട്രാഫിക് ലാഭം കുറയ്ക്കാൻ കഴിയുമെന്നും വ്യക്തമാണ്. കൂടാതെ, കൈമാറുന്ന പട്ടികയിൽ തീയതി-സമയവുമായി ബന്ധപ്പെട്ട ഒരു ഫീൽഡ് ഉണ്ടാകണമെന്നില്ല.

നടപ്പാക്കലിന്റെ കാര്യത്തിൽ കൂടുതൽ സങ്കീർണ്ണമായ മറ്റൊരു പരിഹാരം, ഡാറ്റയുടെ രസീത് അംഗീകരിക്കുക എന്നതാണ്. ഈ സാഹചര്യത്തിൽ, ഓരോ എക്സ്ചേഞ്ച് സെഷനിലും, എല്ലാ ഡാറ്റയും കൈമാറ്റം ചെയ്യപ്പെടുന്നു, അതിന്റെ രസീത് സ്വീകർത്താവ് സ്ഥിരീകരിച്ചിട്ടില്ല. ഇത് നടപ്പിലാക്കാൻ, നിങ്ങൾ ഉറവിട പട്ടികയിലേക്ക് ഒരു ബൂളിയൻ കോളം ചേർക്കേണ്ടതുണ്ട് (ഉദാഹരണത്തിന്, is_transferred). റിസീവർ റെക്കോർഡിന്റെ രസീത് അംഗീകരിക്കുകയാണെങ്കിൽ, അനുബന്ധ ഫീൽഡ് മൂല്യം എടുക്കുന്നു true, അതിനുശേഷം പ്രവേശനം എക്സ്ചേഞ്ചുകളിൽ ഉൾപ്പെടുന്നില്ല. ഈ നടപ്പാക്കൽ ഓപ്ഷന് ഇനിപ്പറയുന്ന ദോഷങ്ങളുമുണ്ട്. ആദ്യം, കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഓരോ റെക്കോർഡിനും, ഒരു അംഗീകാരം ജനറേറ്റ് ചെയ്യുകയും അയയ്ക്കുകയും വേണം. ഏകദേശം പറഞ്ഞാൽ, ഇത് കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഡാറ്റയുടെ അളവ് ഇരട്ടിയാക്കുന്നതും റൗണ്ട് ട്രിപ്പുകളുടെ എണ്ണം ഇരട്ടിയാക്കുന്നതിലേക്ക് നയിക്കുന്നതുമായി താരതമ്യപ്പെടുത്താവുന്നതാണ്. രണ്ടാമതായി, ഒരേ റെക്കോർഡ് നിരവധി റിസീവറുകൾക്ക് അയയ്‌ക്കാനുള്ള സാധ്യതയില്ല (സ്വീകരിക്കുന്ന ആദ്യ റിസീവർ തനിക്കും മറ്റുള്ളവർക്കും രസീത് സ്ഥിരീകരിക്കും).

മുകളിൽ നൽകിയിരിക്കുന്ന പോരായ്മകളില്ലാത്ത ഒരു രീതി, കൈമാറ്റം ചെയ്ത പട്ടികയിലേക്ക് അതിന്റെ വരികളിലെ മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നതിന് ഒരു കോളം ചേർക്കുക എന്നതാണ്. അത്തരമൊരു കോളം തീയതി-സമയ തരത്തിലാകാം, ഓരോ തവണയും റെക്കോർഡുകൾ ചേർക്കുമ്പോൾ/മാറ്റുമ്പോൾ (അണുവിൽ കൂട്ടിച്ചേർക്കൽ/മാറ്റത്തിനൊപ്പം) നിലവിലെ സമയത്തേക്ക് ആപ്ലിക്കേഷൻ സജ്ജീകരിക്കണം/അപ്‌ഡേറ്റ് ചെയ്യണം. ഉദാഹരണമായി, നമുക്ക് കോളം എന്ന് വിളിക്കാം update_time. കൈമാറ്റം ചെയ്ത റെക്കോർഡുകൾക്കായി ഈ കോളത്തിന്റെ പരമാവധി ഫീൽഡ് മൂല്യം സംരക്ഷിക്കുന്നതിലൂടെ, ഈ മൂല്യം ഉപയോഗിച്ച് നമുക്ക് അടുത്ത എക്സ്ചേഞ്ച് സെഷൻ ആരംഭിക്കാം (ഫീൽഡ് മൂല്യമുള്ള റെക്കോർഡുകൾ തിരഞ്ഞെടുക്കുക update_time, മുമ്പ് സംഭരിച്ച മൂല്യത്തേക്കാൾ കൂടുതലാണ്). പിന്നീടുള്ള സമീപനത്തിലെ പ്രശ്നം ബാച്ചുകളിൽ ഡാറ്റ മാറ്റങ്ങൾ സംഭവിക്കാം എന്നതാണ്. കോളത്തിലെ ഫീൽഡ് മൂല്യങ്ങളുടെ ഫലമായി update_time അതുല്യമായിരിക്കില്ല. അതിനാൽ, ഈ കോളം ഭാഗികമായ (പേജ്-ബൈ-പേജ്) ഡാറ്റ ഔട്ട്പുട്ടിനായി ഉപയോഗിക്കാൻ കഴിയില്ല. പേജ് തോറും ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിന്, വളരെ കുറഞ്ഞ കാര്യക്ഷമതയുള്ള അധിക മെക്കാനിസങ്ങൾ നിങ്ങൾ കണ്ടുപിടിക്കേണ്ടതുണ്ട് (ഉദാഹരണത്തിന്, മൂല്യമുള്ള എല്ലാ റെക്കോർഡുകളും ഡാറ്റാബേസിൽ നിന്ന് വീണ്ടെടുക്കുക update_time തന്നിരിക്കുന്നതിനേക്കാൾ ഉയർന്നതും ഒരു നിശ്ചിത എണ്ണം റെക്കോർഡുകൾ നിർമ്മിക്കുന്നതും, സാമ്പിളിന്റെ തുടക്കം മുതൽ ഒരു നിശ്ചിത ഓഫ്‌സെറ്റിൽ നിന്ന് ആരംഭിക്കുന്നു).

മുമ്പത്തെ സമീപനം ചെറുതായി മെച്ചപ്പെടുത്തുന്നതിലൂടെ നിങ്ങൾക്ക് ഡാറ്റ കൈമാറ്റത്തിന്റെ കാര്യക്ഷമത മെച്ചപ്പെടുത്താൻ കഴിയും. ഇത് ചെയ്യുന്നതിന്, മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നതിനുള്ള കോളം ഫീൽഡ് മൂല്യങ്ങളായി ഞങ്ങൾ പൂർണ്ണസംഖ്യ തരം (നീണ്ട പൂർണ്ണസംഖ്യ) ഉപയോഗിക്കും. കോളത്തിന് പേരിടാം row_ver. ഓരോ തവണ റെക്കോർഡ് സൃഷ്‌ടിക്കുമ്പോഴും/പരിഷ്‌ക്കരിക്കപ്പെടുമ്പോഴും ഈ കോളത്തിന്റെ ഫീൽഡ് മൂല്യം സജ്ജീകരിച്ചിരിക്കണം/അപ്‌ഡേറ്റ് ചെയ്യണം. എന്നാൽ ഈ സാഹചര്യത്തിൽ, ഫീൽഡിന് നിലവിലെ തീയതി-സമയം നൽകില്ല, എന്നാൽ ചില കൗണ്ടറിന്റെ മൂല്യം ഒന്നായി വർദ്ധിപ്പിച്ചു. തത്ഫലമായി, കോളം row_ver അദ്വിതീയ മൂല്യങ്ങൾ അടങ്ങിയിരിക്കും കൂടാതെ "ഡെൽറ്റ" ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിന് മാത്രമല്ല (മുമ്പത്തെ എക്‌സ്‌ചേഞ്ച് സെഷന്റെ അവസാനം മുതൽ ഡാറ്റ ചേർത്തത്/മാറ്റിയത്) മാത്രമല്ല, അതിനെ ലളിതമായും ഫലപ്രദമായും പേജുകളായി വിഭജിക്കാനും ഇത് ഉപയോഗിക്കാം.

ഉയർന്ന തലത്തിലുള്ള ആവർത്തനത്തിന്റെ ചട്ടക്കൂടിനുള്ളിൽ കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഡാറ്റയുടെ അളവ് കുറയ്ക്കുന്നതിനുള്ള അവസാനമായി നിർദ്ദേശിച്ച രീതി എനിക്ക് ഏറ്റവും അനുയോജ്യവും സാർവത്രികവുമായി തോന്നുന്നു. നമുക്ക് അത് കൂടുതൽ വിശദമായി നോക്കാം.

ഒരു റോ പതിപ്പ് കൗണ്ടർ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു

സെർവർ/മാസ്റ്റർ ഭാഗം നടപ്പിലാക്കൽ

MS SQL സെർവറിൽ, ഈ സമീപനം നടപ്പിലാക്കാൻ ഒരു പ്രത്യേക കോളം തരം ഉണ്ട് - rowversion. ഓരോ ഡാറ്റാബേസിനും ഒരു കൗണ്ടർ ഉണ്ട്, ഓരോ തവണയും ഒരു റെക്കോർഡ് ചേർക്കുമ്പോൾ/മാറ്റുമ്പോൾ അത് പോലെ ഒരു കോളം ഉള്ള പട്ടികയിൽ rowversion. ഈ കൗണ്ടറിന്റെ മൂല്യം, ചേർത്ത/മാറ്റപ്പെട്ട റെക്കോർഡിലെ ഈ കോളത്തിന്റെ ഫീൽഡിലേക്ക് സ്വയമേവ അസൈൻ ചെയ്യപ്പെടും. Tarantool DBMS-ന് സമാനമായ ഒരു ബിൽറ്റ്-ഇൻ മെക്കാനിസം ഇല്ല. എന്നിരുന്നാലും, ടാരന്തൂളിൽ ഇത് സ്വമേധയാ നടപ്പിലാക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല. ഇത് എങ്ങനെ ചെയ്യുന്നുവെന്ന് നോക്കാം.

ആദ്യം, ഒരു ചെറിയ പദാവലി: ടാരന്റൂളിലെ പട്ടികകളെ സ്‌പെയ്‌സ് എന്നും റെക്കോർഡുകളെ ട്യൂപ്പിൾസ് എന്നും വിളിക്കുന്നു. Tarantool ൽ നിങ്ങൾക്ക് സീക്വൻസുകൾ സൃഷ്ടിക്കാൻ കഴിയും. ക്രമീകരിച്ച പൂർണ്ണസംഖ്യ മൂല്യങ്ങളുടെ പേരുള്ള ജനറേറ്ററുകളല്ലാതെ മറ്റൊന്നുമല്ല സീക്വൻസുകൾ. ആ. ഇതാണ് ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് വേണ്ടത്. ചുവടെ ഞങ്ങൾ അത്തരമൊരു ശ്രേണി സൃഷ്ടിക്കും.

Tarantool-ൽ ഏതെങ്കിലും ഡാറ്റാബേസ് പ്രവർത്തനം നടത്തുന്നതിന് മുമ്പ്, നിങ്ങൾ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്:

box.cfg{}

തൽഫലമായി, നിലവിലെ ഡയറക്‌ടറിയിലേക്ക് ഡാറ്റാബേസ് സ്‌നാപ്പ്‌ഷോട്ടുകളും ഇടപാട് ലോഗുകളും ടാരന്റൂൾ എഴുതാൻ തുടങ്ങും.

നമുക്ക് ഒരു ക്രമം ഉണ്ടാക്കാം 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), ഫീൽഡ് നാമങ്ങളും അവയുടെ തരങ്ങളും.

ടരന്റൂളിലെ ഓട്ടോ-ഇൻക്രിമെന്റിംഗ് ഫീൽഡുകളും സീക്വൻസുകൾ ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചിരിക്കുന്നത്. ഫീൽഡ് പ്രകാരം സ്വയമേവ വർദ്ധിപ്പിക്കുന്ന ഒരു പ്രാഥമിക കീ സൃഷ്ടിക്കാം 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 പുതിയ റെക്കോർഡുകൾ ചേർക്കുമ്പോൾ മാത്രമല്ല, നിലവിലുള്ളവ മാറ്റുമ്പോഴും ഒന്നായി വർദ്ധിക്കണം. ഇതിനായി നിങ്ങൾക്ക് ട്രിഗറുകൾ ഉപയോഗിക്കാം. ടാരന്റൂളിന് രണ്ട് തരം സ്പേസ് ട്രിഗറുകൾ ഉണ്ട്: before_replace и on_replace. സ്‌പെയ്‌സിലെ ഡാറ്റ മാറുമ്പോഴെല്ലാം ട്രിഗറുകൾ ഫയർ ചെയ്യപ്പെടുന്നു (മാറ്റങ്ങളാൽ ബാധിക്കുന്ന ഓരോ ട്യൂപ്പിളിനും, ഒരു ട്രിഗർ ഫംഗ്‌ഷൻ സമാരംഭിക്കും). വ്യത്യസ്തമായി on_replace, before_replaceട്രിഗർ എക്സിക്യൂട്ട് ചെയ്ത ട്യൂപ്പിളിന്റെ ഡാറ്റ പരിഷ്കരിക്കാൻ -ട്രിഗറുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. അതനുസരിച്ച്, അവസാന തരം ട്രിഗറുകൾ നമുക്ക് അനുയോജ്യമാണ്.

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 ക്രമത്തിന്റെ അടുത്ത മൂല്യത്തിലേക്ക് ട്യൂപ്പിൾ സംഭരിച്ചു 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 കടന്നുപോകുന്നു. അടുത്ത മൂല്യം ടാരന്റൂൾ സ്വയമേവ മാറ്റിസ്ഥാപിക്കും. അതുപോലെ, കോളം ഫീൽഡുകളുടെ മൂല്യം പോലെ 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, മാറ്റങ്ങൾ അൺലോഡ് ചെയ്യേണ്ടത് ആവശ്യമുള്ളതിൽ നിന്ന് ആരംഭിച്ച്, മാറ്റിയ ഡാറ്റയുടെ ഒരു ഭാഗം തിരികെ നൽകുന്നു.

ടാരന്റൂളിലെ ഡാറ്റ സാമ്പിൾ ഇൻഡെക്സുകളിലൂടെയാണ് ചെയ്യുന്നത്. ഫംഗ്ഷൻ get_goods സൂചിക പ്രകാരം ഒരു ഇറ്ററേറ്റർ ഉപയോഗിക്കുന്നു row_ver മാറിയ ഡാറ്റ സ്വീകരിക്കാൻ. ഇറ്ററേറ്റർ തരം GT ആണ് (ഗ്രേറ്റർ അധികം, വലിയതിനേക്കാൾ). പാസാക്കിയ കീയിൽ നിന്ന് (ഫീൽഡ് മൂല്യം) ആരംഭിക്കുന്ന സൂചിക മൂല്യങ്ങളിൽ ഇറ്ററേറ്റർ തുടർച്ചയായി സഞ്ചരിക്കും എന്നാണ് ഇതിനർത്ഥം. row_ver).

ഇറ്ററേറ്റർ ട്യൂപ്പിൾസ് തിരികെ നൽകുന്നു. പിന്നീട് HTTP വഴി ഡാറ്റ കൈമാറാൻ കഴിയുന്നതിന്, തുടർന്നുള്ള സീരിയലൈസേഷന് സൗകര്യപ്രദമായ ഒരു ഘടനയിലേക്ക് tuples പരിവർത്തനം ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഉദാഹരണം ഇതിനായി സ്റ്റാൻഡേർഡ് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു 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. ഒരു യഥാർത്ഥ പ്രോഗ്രാമിൽ, പേജിന്റെ വലുപ്പം സാധാരണയായി കൂടുതൽ പ്രധാനമാണ്. ഇത് സ്പേസ് ട്യൂപ്പിളിന്റെ ശരാശരി വലുപ്പത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ഡാറ്റാ കൈമാറ്റ സമയം അളക്കുന്നതിലൂടെ ഒപ്റ്റിമൽ പേജ് വലുപ്പം അനുഭവപരമായി നിർണ്ണയിക്കാനാകും. പേജ് വലുപ്പം കൂടുന്തോറും അയയ്‌ക്കുന്നതിനും സ്വീകരിക്കുന്നതിനും ഇടയിലുള്ള റൗണ്ട്‌ട്രിപ്പുകളുടെ എണ്ണം കുറയും. ഇതുവഴി നിങ്ങൾക്ക് മാറ്റങ്ങൾ ഡൗൺലോഡ് ചെയ്യുന്നതിനുള്ള മൊത്തത്തിലുള്ള സമയം കുറയ്ക്കാനാകും. എന്നിരുന്നാലും, പേജ് വലുപ്പം വളരെ വലുതാണെങ്കിൽ, സാമ്പിൾ സീരിയലൈസ് ചെയ്യാൻ ഞങ്ങൾ സെർവറിൽ കൂടുതൽ സമയം ചെലവഴിക്കും. തൽഫലമായി, സെർവറിലേക്ക് വരുന്ന മറ്റ് അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് കാലതാമസം ഉണ്ടായേക്കാം. പരാമീറ്റർ 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 അതിന്റെ അവസാന കോളിന് ശേഷം മാറിയ ഡാറ്റ സ്വീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് പരിഗണനയിലുള്ള പകർപ്പെടുക്കൽ രീതിയുടെ അടിസ്ഥാനമാണ്.

JSON എന്ന രൂപത്തിൽ HTTP വഴിയുള്ള ഫലങ്ങൾ ഈ ലേഖനത്തിന്റെ പരിധിക്ക് പുറത്ത് ഞങ്ങൾ വിടും. ഇതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ഇവിടെ വായിക്കാം: 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 ഡീരിയലൈസേഷനായി ഞങ്ങൾക്ക് ഒരു ലൈബ്രറിയും ആവശ്യമാണ്:

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

ഫംഗ്ഷൻ url വിലാസത്തിലേക്ക് ഒരു HTTP അഭ്യർത്ഥന നടപ്പിലാക്കുകയും അത് അയയ്ക്കുകയും ചെയ്യുന്നു row_ver ഒരു പാരാമീറ്ററായി അഭ്യർത്ഥനയുടെ ഡീസിയലൈസ് ചെയ്ത ഫലം നൽകുന്നു.

ലഭിച്ച ഡാറ്റ സംരക്ഷിക്കുന്നതിനുള്ള പ്രവർത്തനം ഇതുപോലെ കാണപ്പെടുന്നു:

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