Ubuntu Online, Fedora Online, Windows online emulator അല്ലെങ്കിൽ MAC OS ഓൺലൈൻ എമുലേറ്റർ എന്നിങ്ങനെയുള്ള ഞങ്ങളുടെ ഒന്നിലധികം സൗജന്യ ഓൺലൈൻ വർക്ക്‌സ്റ്റേഷനുകളിലൊന്ന് ഉപയോഗിച്ച് OnWorks സൗജന്യ ഹോസ്റ്റിംഗ് ദാതാവിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന pt-table-checksump കമാൻഡ് ഇതാണ്.
പട്ടിക:
NAME
pt-table-checksum - MySQL റെപ്ലിക്കേഷൻ ഇന്റഗ്രിറ്റി പരിശോധിക്കുക.
സിനോപ്സിസ്
ഉപയോഗം: pt-table-checksum [OPTIONS] [DSN]
pt-table-checksum ചെക്ക്സം നടപ്പിലാക്കുന്നതിലൂടെ ഒരു ഓൺലൈൻ റെപ്ലിക്കേഷൻ സ്ഥിരത പരിശോധന നടത്തുന്നു
പൊരുത്തമില്ലാത്ത പകർപ്പുകളിൽ വ്യത്യസ്ത ഫലങ്ങൾ സൃഷ്‌ടിക്കുന്ന മാസ്റ്ററെക്കുറിച്ചുള്ള അന്വേഷണങ്ങൾ
യജമാനനൊപ്പം. ഓപ്ഷണൽ DSN മാസ്റ്റർ ഹോസ്റ്റിനെ വ്യക്തമാക്കുന്നു. ടൂളിന്റെ "എക്സിറ്റ് സ്റ്റാറ്റസ്" ആണ്
എന്തെങ്കിലും വ്യത്യാസങ്ങൾ കണ്ടെത്തിയാൽ, അല്ലെങ്കിൽ എന്തെങ്കിലും മുന്നറിയിപ്പുകളോ പിശകുകളോ സംഭവിച്ചാൽ പൂജ്യമല്ല.
ഇനിപ്പറയുന്ന കമാൻഡ് ലോക്കൽഹോസ്റ്റിലെ റെപ്ലിക്കേഷൻ മാസ്റ്ററുമായി ബന്ധിപ്പിക്കും, ഓരോന്നിനും ചെക്ക്സം
പട്ടിക, കണ്ടെത്തുന്ന എല്ലാ പകർപ്പുകളിലും ഫലങ്ങൾ റിപ്പോർട്ടുചെയ്യുക:
pt-table-checksum
ഡാറ്റ വ്യത്യാസങ്ങൾ കാര്യക്ഷമമായി കണ്ടെത്തുന്നതിൽ ഈ ഉപകരണം ശ്രദ്ധ കേന്ദ്രീകരിച്ചിരിക്കുന്നു. ഏതെങ്കിലും ഡാറ്റ വ്യത്യസ്തമാണെങ്കിൽ,
pt-table-sync ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രശ്നം പരിഹരിക്കാൻ കഴിയും.
അപകടസാധ്യതകൾ
പെർക്കോണ ടൂൾകിറ്റ് പ്രായപൂർത്തിയായതും യഥാർത്ഥ ലോകത്ത് തെളിയിക്കപ്പെട്ടതും നന്നായി പരീക്ഷിച്ചതും എന്നാൽ എല്ലാ ഡാറ്റാബേസും ആണ്
ടൂളുകൾ സിസ്റ്റത്തിനും ഡാറ്റാബേസ് സെർവറിനും അപകടമുണ്ടാക്കും. ഈ ഉപകരണം ഉപയോഗിക്കുന്നതിന് മുമ്പ്,
ദയവായി:
· ടൂളിന്റെ ഡോക്യുമെന്റേഷൻ വായിക്കുക
· ടൂളിന്റെ അറിയപ്പെടുന്ന "ബഗ്ഗുകൾ" അവലോകനം ചെയ്യുക
· ഒരു നോൺ-പ്രൊഡക്ഷൻ സെർവറിൽ ഉപകരണം പരിശോധിക്കുക
· നിങ്ങളുടെ പ്രൊഡക്ഷൻ സെർവർ ബാക്കപ്പ് ചെയ്യുകയും ബാക്കപ്പുകൾ പരിശോധിക്കുകയും ചെയ്യുക
"പരിമിതികൾ" എന്നതും കാണുക.
വിവരണം
pt-table-checksum മിക്കവാറും എല്ലാ സാഹചര്യങ്ങളിലും സ്ഥിരസ്ഥിതിയായി ശരിയായ കാര്യം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. എപ്പോൾ
സംശയമുണ്ടെങ്കിൽ, ടൂൾ എങ്ങനെ ഒരു പട്ടിക പരിശോധിക്കുമെന്ന് കാണാൻ "--explain" ഉപയോഗിക്കുക. ഇനിപ്പറയുന്നത് എ
ഉപകരണം എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഉയർന്ന തലത്തിലുള്ള അവലോകനം.
pt-table-checksum-ന്റെ പഴയ പതിപ്പുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഈ ടൂൾ ഒരൊറ്റ കേന്ദ്രീകൃതമാണ്
ഉദ്ദേശ്യം, കൂടാതെ ധാരാളം സങ്കീർണ്ണതകളോ വ്യത്യസ്തമായ ചെക്ക്സംമ്മിംഗ് പിന്തുണയോ ഇല്ല
വിദ്യകൾ. ഇത് ഒരു സെർവറിൽ മാത്രം ചെക്ക്സം അന്വേഷണങ്ങൾ നടപ്പിലാക്കുന്നു, അവയിലൂടെ ഒഴുകുന്നു
പകർപ്പുകളിൽ വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യാനുള്ള പകർപ്പ്. നിങ്ങൾക്ക് പഴയ സ്വഭാവം വേണമെങ്കിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം
പെർക്കോണ ടൂൾകിറ്റ് പതിപ്പ് 1.0.
pt-table-checksum നിങ്ങൾ വ്യക്തമാക്കിയ സെർവറുമായി ബന്ധിപ്പിക്കുകയും ഡാറ്റാബേസുകളും പട്ടികകളും കണ്ടെത്തുകയും ചെയ്യുന്നു
നിങ്ങൾ വ്യക്തമാക്കിയ ഫിൽട്ടറുകളുമായി പൊരുത്തപ്പെടുത്തുക (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ). ഇത് ഒരു സമയം ഒരു ടേബിൾ പ്രവർത്തിക്കുന്നു, അതിനാൽ അത് പ്രവർത്തിക്കുന്നില്ല
വലിയ അളവിലുള്ള മെമ്മറി ശേഖരിക്കുക അല്ലെങ്കിൽ ചെക്ക്സം ആരംഭിക്കുന്നതിന് മുമ്പ് ധാരാളം ജോലികൾ ചെയ്യുക. ഈ
ഇത് വളരെ വലിയ സെർവറുകളിൽ ഉപയോഗയോഗ്യമാക്കുന്നു. നൂറുകണക്കിന് സെർവറുകളിൽ ഞങ്ങൾ ഇത് ഉപയോഗിച്ചു
ആയിരക്കണക്കിന് ഡാറ്റാബേസുകളും പട്ടികകളും ട്രില്യൺ കണക്കിന് വരികളും. എത്ര വലിയ സെർവർ ആണെങ്കിലും
ആണ്, pt-table-checksum ഒരുപോലെ നന്നായി പ്രവർത്തിക്കുന്നു.
വളരെ വലിയ ടേബിളുകളിൽ ഇത് പ്രവർത്തിക്കാനുള്ള ഒരു കാരണം, അത് ഓരോ ടേബിളും കഷണങ്ങളായി വിഭജിക്കുന്നു എന്നതാണ്
വരികൾ, ഓരോ ചങ്കിനും ഒരൊറ്റ റീപ്ലേസ് ഉപയോഗിച്ച് ചെക്ക്സം ചെയ്യുന്നു.. ചോദ്യം തിരഞ്ഞെടുക്കുക. ഇത് ചങ്ക് വ്യത്യാസപ്പെടുന്നു
ചെക്ക്സം അന്വേഷണങ്ങൾ ആവശ്യമുള്ള സമയത്ത് പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള വലുപ്പം. ചങ്കിംഗ് ലക്ഷ്യം
ടേബിളുകൾ, ഓരോ ടേബിളും ഒരു വലിയ ചോദ്യം ചെയ്യുന്നതിനുപകരം, അത് ഉറപ്പാക്കുക എന്നതാണ്
ചെക്ക്സം അപ്രസക്തമാണ്, മാത്രമല്ല സെർവറിൽ വളരെയധികം റെപ്ലിക്കേഷൻ ലാഗ് അല്ലെങ്കിൽ ലോഡിന് കാരണമാകരുത്.
അതുകൊണ്ടാണ് ഓരോ ചങ്കിന്റെയും ലക്ഷ്യ സമയം ഡിഫോൾട്ടായി 0.5 സെക്കൻഡ്.
സെർവറിന് എത്ര വേഗത്തിൽ ചോദ്യങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുമെന്ന് ഉപകരണം ട്രാക്ക് ചെയ്യുന്നു, ഒപ്പം ക്രമീകരിക്കുകയും ചെയ്യുന്നു
സെർവറിന്റെ പ്രകടനത്തെക്കുറിച്ച് കൂടുതൽ പഠിക്കുമ്പോൾ ചങ്കുകൾ. ഇത് എക്‌സ്‌പോണൻഷ്യലായി ഉപയോഗിക്കുന്നു
ചങ്കിന്റെ വലിപ്പം സ്ഥിരമായി നിലനിർത്താൻ, ഭാരമുള്ള ശരാശരി, എന്നിട്ടും പ്രതികരണശേഷി നിലനിർത്തുക
ഏതെങ്കിലും കാരണത്താൽ ചെക്ക്സമ്മിംഗ് സമയത്ത് സെർവറിന്റെ പ്രകടനം മാറുന്നു. ഉപകരണം എന്നാണ് ഇതിനർത്ഥം
ഒരു ട്രാഫിക്ക് സ്‌പൈക്കിൽ നിങ്ങളുടെ സെർവർ അമിതമായി ലോഡുചെയ്യുകയാണെങ്കിൽ അത് പെട്ടെന്ന് തന്നെ ത്രോട്ടിലാകും
അല്ലെങ്കിൽ ഒരു പശ്ചാത്തല ടാസ്ക്, ഉദാഹരണത്തിന്.
മറ്റ് ഉപകരണങ്ങളിൽ ഞങ്ങൾ "നിബ്ലിംഗ്" എന്ന് വിളിച്ചിരുന്ന ഒരു സാങ്കേതികതയിലൂടെയാണ് ചങ്കിംഗ് നടപ്പിലാക്കുന്നത്
പെർകോണ ടൂൾകിറ്റ്. ഉദാഹരണത്തിന്, pt-archiver-ന് ഉപയോഗിക്കുന്ന അതേ സാങ്കേതികതയാണിത്. പാരമ്പര്യം
pt-table-checksum-ന്റെ പഴയ പതിപ്പുകളിൽ ഉപയോഗിച്ചിരുന്ന ചങ്കിംഗ് അൽഗോരിതങ്ങൾ നീക്കം ചെയ്യുന്നു, കാരണം അവ
പ്രവചനാതീതമായ വലിപ്പമുള്ള കഷണങ്ങൾക്ക് കാരണമായില്ല, കൂടാതെ പല ടേബിളുകളിലും നന്നായി പ്രവർത്തിച്ചില്ല. എല്ലാം
ഒരു പട്ടികയെ കഷണങ്ങളായി വിഭജിക്കേണ്ടത് ഏതെങ്കിലും തരത്തിലുള്ള ഒരു സൂചികയാണ് (വെയിലത്ത് പ്രാഥമികം
കീ അല്ലെങ്കിൽ അദ്വിതീയ സൂചിക). ഒരു സൂചികയും ഇല്ലെങ്കിൽ, പട്ടികയിൽ അനുയോജ്യമായ ഒരു ചെറിയ അടങ്ങിയിരിക്കുന്നു
വരികളുടെ എണ്ണം, ടൂൾ ഒറ്റ ചങ്കിൽ പട്ടിക പരിശോധിക്കും.
pt-table-checksum അത് തടസ്സപ്പെടുത്തുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ മറ്റ് നിരവധി സുരക്ഷാ മാർഗങ്ങളുണ്ട്.
പകർപ്പുകൾ ഉൾപ്പെടെ സെർവറിന്റെ പ്രവർത്തനം. ഇത് ചെയ്യുന്നതിന്, pt-table-checksum കണ്ടുപിടിക്കുന്നു
പകർപ്പുകളും അവയുമായി യാന്ത്രികമായി ബന്ധിപ്പിക്കുന്നു. (ഇത് പരാജയപ്പെടുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു സൂചന നൽകാം
"--റിക്കർഷൻ-രീതി" ഓപ്ഷൻ.)
ഉപകരണം തുടർച്ചയായി പകർപ്പുകൾ നിരീക്ഷിക്കുന്നു. ഏതെങ്കിലും പകർപ്പ് വളരെ പിന്നിലാണെങ്കിൽ
റെപ്ലിക്കേഷൻ, pt-table-checksum അത് പിടിക്കാൻ അനുവദിക്കുന്നതിന് താൽക്കാലികമായി നിർത്തുന്നു. ഏതെങ്കിലും പകർപ്പ് ഉണ്ടെങ്കിൽ
പിശക്, അല്ലെങ്കിൽ പകർപ്പ് നിർത്തുന്നു, pt-table-checksum താൽക്കാലികമായി നിർത്തി കാത്തിരിക്കുന്നു. കൂടാതെ, pt-table-
ചെക്ക്സം, റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾ പോലുള്ള പ്രശ്‌നങ്ങളുടെ പൊതുവായ കാരണങ്ങൾ അന്വേഷിക്കുകയും നിരസിക്കുകയും ചെയ്യുന്നു
നിങ്ങൾ നിർബന്ധിക്കുന്നില്ലെങ്കിൽ പ്രവർത്തിക്കുക. റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾ അപകടകരമാണ്, കാരണം ചോദ്യങ്ങൾ
pt-table-checksum എക്സിക്യൂട്ടുകൾ അവയുമായി വൈരുദ്ധ്യമുണ്ടാക്കുകയും അനുകരണത്തിന് കാരണമാവുകയും ചെയ്യും
പരാജയപ്പെടാൻ.
pt-table-checksum സുരക്ഷിതമായി ചെക്ക്സം ചെയ്യാൻ കഴിയുന്നത്ര വലുതല്ലെന്ന് പരിശോധിക്കുന്നു. അത് നിർവഹിക്കുന്നു
ഓരോ ചങ്കിലും ഒരു വിശദീകരണ ചോദ്യം, ആവശ്യമുള്ളതിനേക്കാൾ വലുതായേക്കാവുന്ന ഭാഗങ്ങൾ ഒഴിവാക്കുക
വരികളുടെ എണ്ണം. ഈ സംരക്ഷണത്തിന്റെ സംവേദനക്ഷമത നിങ്ങൾക്ക് കോൺഫിഗർ ചെയ്യാൻ കഴിയും
"--ചങ്ക്-സൈസ്-ലിമിറ്റ്" ഓപ്ഷൻ. ഒരു ടേബിൾ ഒറ്റ ചങ്കിൽ ചെക്ക്സംമ് ചെയ്താൽ അത് കാരണം
ഒരു ചെറിയ എണ്ണം വരികൾ ഉണ്ട്, തുടർന്ന് pt-table-checksum അധികമായി പട്ടിക പരിശോധിക്കുന്നു
പകർപ്പുകളിൽ വലുതാക്കിയിട്ടില്ല. ഇത് ഇനിപ്പറയുന്ന സാഹചര്യം ഒഴിവാക്കുന്നു: ഒരു പട്ടിക ശൂന്യമാണ്
മാസ്റ്റർ എന്നാൽ ഒരു പകർപ്പിൽ വളരെ വലുതാണ്, കൂടാതെ ഒരൊറ്റ വലിയ അന്വേഷണത്തിൽ പരിശോധിക്കുന്നു
അനുകരണത്തിൽ വളരെ നീണ്ട കാലതാമസത്തിന് കാരണമാകുന്നു.
മറ്റ് നിരവധി സുരക്ഷാ സംവിധാനങ്ങളുണ്ട്. ഉദാഹരണത്തിന്, pt-table-checksum അതിന്റെ സെഷൻ-ലെവൽ സജ്ജമാക്കുന്നു
innodb_lock_wait_timeout 1 second, അങ്ങനെ ഒരു ലോക്ക് വെയിറ്റ് ഉണ്ടെങ്കിൽ, അത്
മറ്റ് ചോദ്യങ്ങൾക്ക് സമയപരിധി നൽകുന്നതിന് പകരം ഇര. മറ്റൊരു സുരക്ഷാ സംവിധാനം ലോഡ് പരിശോധിക്കുന്നു
ഡാറ്റാബേസ് സെർവർ, ലോഡ് വളരെ കൂടുതലാണെങ്കിൽ താൽക്കാലികമായി നിർത്തുന്നു. ഒരൊറ്റ ശരിയായ ഉത്തരമില്ല
ഇത് എങ്ങനെ ചെയ്യാം എന്നതിന്, എന്നാൽ സ്ഥിരസ്ഥിതിയായി pt-table-checksum 25-ൽ കൂടുതൽ ഉണ്ടെങ്കിൽ താൽക്കാലികമായി നിർത്തും
ഒരേസമയം അന്വേഷണങ്ങൾ നടപ്പിലാക്കുന്നു. നിങ്ങളുടെ സെർവറിനായി നിങ്ങൾ ഒരു നല്ല മൂല്യം സജ്ജീകരിക്കണം
"--max-load" ഓപ്ഷൻ.
ചെക്ക്സംമിംഗ് സാധാരണയായി സെർവറിലെ മറ്റ് ജോലികൾക്ക് വഴങ്ങുന്ന കുറഞ്ഞ മുൻഗണനയുള്ള ഒരു ജോലിയാണ്.
എന്നിരുന്നാലും, നിരന്തരം പുനരാരംഭിക്കേണ്ട ഒരു ഉപകരണം ഉപയോഗിക്കാൻ പ്രയാസമാണ്. അങ്ങനെ, pt-table-
ചെക്ക്സം പിശകുകളെ വളരെ പ്രതിരോധിക്കും. ഉദാഹരണത്തിന്, ഡാറ്റാബേസ് അഡ്മിനിസ്ട്രേറ്റർക്ക് ആവശ്യമുണ്ടെങ്കിൽ
ഏതെങ്കിലും കാരണത്താൽ pt-table-checksum-ന്റെ ചോദ്യങ്ങൾ ഇല്ലാതാക്കുക, അതൊരു മാരകമായ പിശകല്ല. ഉപയോക്താക്കൾ പലപ്പോഴും
ദീർഘകാലമായി പ്രവർത്തിക്കുന്ന ഏതെങ്കിലും ചെക്ക്സം അന്വേഷണങ്ങൾ ഇല്ലാതാക്കാൻ pt-kill പ്രവർത്തിപ്പിക്കുക. ഉപകരണം ഒരു കൊലപ്പെടുത്തിയ ചോദ്യം വീണ്ടും ശ്രമിക്കും
ഒരിക്കൽ, അത് വീണ്ടും പരാജയപ്പെടുകയാണെങ്കിൽ, അത് ആ മേശയുടെ അടുത്ത ഭാഗത്തേക്ക് നീങ്ങും. അതുതന്നെ
ലോക്ക് കാത്തിരിപ്പ് കാലഹരണപ്പെട്ടാൽ പെരുമാറ്റം ബാധകമാണ്. അങ്ങനെയെങ്കിൽ ഉപകരണം ഒരു മുന്നറിയിപ്പ് പ്രിന്റ് ചെയ്യും
ഒരു പിശക് സംഭവിക്കുന്നു, പക്ഷേ ഒരു ടേബിളിൽ ഒരിക്കൽ മാത്രം. ഏതെങ്കിലും സെർവറിലേക്കുള്ള കണക്ഷൻ പരാജയപ്പെടുകയാണെങ്കിൽ, pt-
table-checksum വീണ്ടും കണക്റ്റുചെയ്യാനും പ്രവർത്തിക്കുന്നത് തുടരാനും ശ്രമിക്കും.
pt-table-checksum പൂർണ്ണമായി നിർത്തുന്നതിന് കാരണമാകുന്ന ഒരു അവസ്ഥ നേരിടുന്നുണ്ടെങ്കിൽ, അത് എളുപ്പമാണ്
"--resume" ഓപ്ഷൻ ഉപയോഗിച്ച് ഇത് പുനരാരംഭിക്കുന്നതിന്. അവസാനത്തെ അവസാന ഭാഗത്തിൽ നിന്ന് ഇത് ആരംഭിക്കും
അത് പ്രോസസ്സ് ചെയ്ത പട്ടിക. CTRL-C ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഉപകരണം സുരക്ഷിതമായി നിർത്താനും കഴിയും. അത് അവസാനിക്കും
നിലവിൽ പ്രോസസ്സ് ചെയ്യുന്ന ഭാഗം, തുടർന്ന് പുറത്തുകടക്കുക. നിങ്ങൾക്ക് ഇത് പതിവുപോലെ പുനരാരംഭിക്കാം
അതിനുശേഷം.
pt-table-checksum ഒരു ടേബിളിലെ എല്ലാ ചങ്കുകളും പരിശോധിച്ച് പൂർത്തിയാക്കിയ ശേഷം, അത് താൽക്കാലികമായി നിർത്തുന്നു
ചെക്ക്സം അന്വേഷണങ്ങൾ നടപ്പിലാക്കുന്നത് പൂർത്തിയാക്കാൻ കണ്ടെത്തിയ എല്ലാ പകർപ്പുകളും കാത്തിരിക്കുന്നു. ഒരിക്കൽ അത്
പൂർത്തിയായി, എല്ലാ പകർപ്പുകളും അവയ്ക്ക് മാസ്റ്ററിന് സമാനമായ ഡാറ്റ ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു,
തുടർന്ന് ഫലങ്ങളോടൊപ്പം ഔട്ട്പുട്ടിന്റെ ഒരു ലൈൻ പ്രിന്റ് ചെയ്യുന്നു. അതിന്റെ ഔട്ട്പുട്ടിന്റെ ഒരു സാമ്പിൾ നിങ്ങൾക്ക് കാണാം
പിന്നീട് ഈ ഡോക്യുമെന്റേഷനിൽ.
സമയം-ദഹിപ്പിക്കുന്ന പ്രവർത്തനങ്ങളിൽ ടൂൾ പുരോഗതി സൂചകങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു. ഇത് പ്രിന്റ് ചെയ്യുന്നു a
ഓരോ പട്ടികയും പരിശോധിക്കുമ്പോൾ പുരോഗതി സൂചകം. പുരോഗതി കണക്കാക്കുന്നത്
പട്ടികയിലെ കണക്കാക്കിയ വരികളുടെ എണ്ണം. ഇത് താൽക്കാലികമായി നിർത്തുമ്പോൾ ഒരു പുരോഗതി റിപ്പോർട്ടും പ്രിന്റ് ചെയ്യും
റെപ്ലിക്കേഷൻ പിടിക്കാൻ കാത്തിരിക്കുക, ഒപ്പം പകർപ്പുകൾ പരിശോധിക്കാൻ കാത്തിരിക്കുമ്പോൾ
മാസ്റ്ററിൽ നിന്നുള്ള വ്യത്യാസങ്ങൾ. "--നിശബ്ദത" ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഔട്ട്പുട്ട് കുറച്ച് വാചാലമാക്കാം
ഓപ്ഷൻ.
നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഏതൊക്കെ പട്ടികകളുടെ റിപ്പോർട്ട് ലഭിക്കാൻ നിങ്ങൾക്ക് ചെക്ക്സം ടേബിളുകൾ സ്വമേധയാ അന്വേഷിക്കാവുന്നതാണ്
കഷണങ്ങൾക്ക് യജമാനനിൽ നിന്ന് വ്യത്യാസമുണ്ട്. ഇനിപ്പറയുന്ന ചോദ്യം ഓരോന്നും റിപ്പോർട്ട് ചെയ്യും
വ്യത്യാസങ്ങളുള്ള ഡാറ്റാബേസും പട്ടികയും, ചങ്കുകളുടെയും വരികളുടെയും എണ്ണത്തിന്റെ സംഗ്രഹം സഹിതം
ബാധിച്ചേക്കാം:
db, tbl, SUM(this_cnt) AS മൊത്തം_വരികൾ, COUNT(*) AS ഭാഗങ്ങൾ എന്നിവ തിരഞ്ഞെടുക്കുക
percona.checksums-ൽ നിന്ന്
എവിടെ (
master_cnt <> this_cnt
അല്ലെങ്കിൽ master_crc <> this_crc
OR ISNULL(master_crc) <> ISNULL(this_crc))
ഗ്രൂപ്പ് പ്രകാരം db, tbl;
ആ അന്വേഷണത്തിൽ പരാമർശിച്ചിരിക്കുന്ന പട്ടിക ചെക്ക്സം ടേബിൾ ആണ്, അവിടെ ചെക്ക്സം സംഭരിച്ചിരിക്കുന്നു.
പട്ടികയിലെ ഓരോ വരിയിലും ചില പട്ടികയിൽ നിന്നുള്ള ഒരു ഡാറ്റയുടെ ചെക്ക്സം അടങ്ങിയിരിക്കുന്നു
സെർവർ.
pt-table-checksum-ന്റെ പതിപ്പ് 2.0, pt-table-sync പതിപ്പിന് പിന്നിലേക്ക് അനുയോജ്യമല്ല
1.0 ചില സന്ദർഭങ്ങളിൽ ഇത് ഗുരുതരമായ പ്രശ്നമല്ല. എന്നതിലേക്ക് ഒരു "അതിർത്തി" കോളം ചേർക്കുന്നു
പട്ടിക, തുടർന്ന് സ്വമേധയാ ജനറേറ്റുചെയ്‌ത WHERE ക്ലോസ് ഉപയോഗിച്ച് അത് അപ്ഡേറ്റ് ചെയ്യുന്നത് pt- അനുവദിച്ചാൽ മതിയാകും.
പട്ടിക-സമന്വയ പതിപ്പ് 1.0 pt-table-checksum പതിപ്പ് 2.0-മായി പ്രവർത്തിക്കുന്നു. ഒരു അനുമാനിക്കുന്നു
'id' എന്ന് പേരിട്ടിരിക്കുന്ന പൂർണ്ണസംഖ്യ പ്രാഥമിക കീ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നത് പോലെ ഒന്ന് ശ്രമിക്കാവുന്നതാണ്:
ആൾട്ടർ ടേബിൾ ചെക്ക്സം ബൗണ്ടറികൾ ചേർക്കുക വർചാർ(500);
ചെക്ക്സം അപ്ഡേറ്റ് ചെയ്യുക
സെറ്റ് ബൗണ്ടറികൾ = COALESCE(CONCAT('id BETWEEN ', lower_boundary,
' ഒപ്പം ', അപ്പർ_ബൗണ്ടറി), '1=1');
പരിമിതികൾ
വരി അടിസ്ഥാനമാക്കിയുള്ള പകർപ്പ് ഉപയോഗിക്കുന്ന പകർപ്പുകൾ
pt-table-checksum-ന് സ്റ്റേറ്റ്മെന്റ് അടിസ്ഥാനമാക്കിയുള്ള പകർപ്പ് ആവശ്യമാണ്, അത് സജ്ജമാക്കുന്നു
മാസ്റ്ററിൽ "binlog_format=STATEMENT", പക്ഷേ MySQL പരിമിതി കാരണം പകർപ്പുകൾ ഇല്ല
ഈ മാറ്റത്തെ ബഹുമാനിക്കുക. അതിനാൽ, ചെക്ക്സംസ് ഉപയോഗിച്ചുള്ള ഏതെങ്കിലും പകർപ്പുകൾ ആവർത്തിക്കില്ല
തുടർന്നുള്ള പകർപ്പുകൾക്കുള്ള മാസ്റ്ററായ വരി അടിസ്ഥാനമാക്കിയുള്ള പകർപ്പ്.
ഉപകരണം എല്ലാ സെർവറുകളിലും "binlog_format" സ്വയമേവ പരിശോധിക്കുന്നു. കാണുക
"--[no]check-binlog-format" .
(ബഗ് 899415 )
സ്കീമ, പട്ടിക വ്യത്യാസങ്ങൾ
മാസ്റ്ററിലും എല്ലാത്തിലും സ്കീമകളും ടേബിളുകളും ഒരുപോലെയാണെന്ന് ടൂൾ അനുമാനിക്കുന്നു
പകർപ്പുകൾ. ഉദാഹരണത്തിന്, ഒരു പകർപ്പിന് ഒരു സ്കീമ ഇല്ലെങ്കിൽ, പകർപ്പ് തകരും
അത് മാസ്റ്ററിൽ നിലവിലുണ്ട് (ആ സ്കീമ ചെക്ക്സംമ്ഡ് ആണ്), അല്ലെങ്കിൽ a യുടെ ഘടന ആണെങ്കിൽ
ഒരു പകർപ്പിലെ മേശ മാസ്റ്ററിൽ നിന്ന് വ്യത്യസ്തമാണ്.
പെർകോണ എക്‌സ്ട്രാഡിബി ക്ലസ്റ്റർ
pt-table-checksum Percona XtraDB Cluster (PXC) 5.5.28-23.7-ഉം പുതിയതും പ്രവർത്തിക്കുന്നു. ദി
സാധ്യമായ Percona XtraDB ക്ലസ്റ്റർ സജ്ജീകരണങ്ങളുടെ എണ്ണം വളരെ വലുതാണ്, അത് ഉപയോഗിക്കാൻ കഴിയും
പതിവ് അനുകരണവും. അതിനാൽ, താഴെ ലിസ്റ്റ് ചെയ്‌തിരിക്കുന്ന സജ്ജീകരണങ്ങൾ മാത്രമേ പിന്തുണയ്‌ക്കുകയുള്ളൂ
പ്രവർത്തിക്കാൻ അറിയപ്പെടുന്നു. ക്ലസ്റ്റർ ടു ക്ലസ്റ്റർ പോലെയുള്ള മറ്റ് സജ്ജീകരണങ്ങൾ പിന്തുണയ്ക്കുന്നില്ല, ഒരുപക്ഷേ അങ്ങനെ ചെയ്യില്ല
ജോലി.
സൂചിപ്പിച്ചിരിക്കുന്നതൊഴികെ, ഇനിപ്പറയുന്ന പിന്തുണയുള്ള എല്ലാ സജ്ജീകരണങ്ങൾക്കും നിങ്ങൾ "dsn" ഉപയോഗിക്കേണ്ടതുണ്ട്
ക്ലസ്റ്റർ നോഡുകൾ വ്യക്തമാക്കുന്നതിനുള്ള "--റിക്കർഷൻ-രീതി" എന്നതിനായുള്ള രീതി. കൂടാതെ, കാലതാമസം പരിശോധന (കാണുക
"REPLICA CHECKS") ക്ലസ്റ്റർ നോഡുകൾക്കായി നടപ്പിലാക്കില്ല.
സിംഗിൾ ക്ലസ്റ്റർ
ഏറ്റവും ലളിതമായ PXC സജ്ജീകരണം ഒരൊറ്റ ക്ലസ്റ്ററാണ്: എല്ലാ സെർവറുകളും ക്ലസ്റ്റർ നോഡുകളാണ്
സാധാരണ പകർപ്പുകളല്ല. എല്ലാ നോഡുകളും DSN പട്ടികയിൽ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ (കാണുക
"--recursion-method"), തുടർന്ന് നിങ്ങൾക്ക് ഏത് നോഡിലും ഏത് വ്യത്യാസത്തിലും ഉപകരണം പ്രവർത്തിപ്പിക്കാം
മറ്റ് നോഡുകൾ കണ്ടെത്തും.
എല്ലാ നോഡുകളും ഒരേ ക്ലസ്റ്ററിലായിരിക്കണം (ഒരേ "wsrep_cluster_name" മൂല്യം ഉണ്ടായിരിക്കണം), അല്ലാത്തപക്ഷം
ഉപകരണം ഒരു പിശകോടെ പുറത്തുകടക്കുന്നു. വ്യത്യസ്ത ക്ലസ്റ്ററുകൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ടെങ്കിലും
അതേ പേര്, ഇത് ചെയ്യാൻ പാടില്ല, പിന്തുണയ്ക്കുന്നില്ല. ഇത് എല്ലാവർക്കും ബാധകമാണ്
പിന്തുണയ്ക്കുന്ന സജ്ജീകരണങ്ങൾ.
തനിപ്പകർപ്പുകളുള്ള ഒറ്റ ക്ലസ്റ്റർ
ക്ലസ്റ്റർ നോഡുകൾക്ക് റെഗുലർ മാസ്റ്ററുകളാകാനും സാധാരണ പകർപ്പുകളിലേക്ക് പകർത്താനും കഴിയും. എന്നിരുന്നാലും,
പകർപ്പിന്റെ "മാസ്റ്റർ നോഡിൽ" പ്രവർത്തിച്ചാൽ മാത്രമേ ഉപകരണത്തിന് ഒരു പകർപ്പിലെ വ്യത്യാസങ്ങൾ കണ്ടെത്താനാകൂ.
ഉദാഹരണത്തിന്, ക്ലസ്റ്റർ സെറ്റപ്പ് ആണെങ്കിൽ,
node1 <-> node2 <-> node3
| |
| +-> പകർപ്പ്3
+-> പകർപ്പ്2
node3-ൽ ടൂൾ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് replica3-ൽ വ്യത്യാസങ്ങൾ കണ്ടെത്താനാകും, എന്നാൽ വ്യത്യാസങ്ങൾ കണ്ടെത്തുന്നതിന്
replica2 നിങ്ങൾ node2-ൽ ടൂൾ വീണ്ടും പ്രവർത്തിപ്പിക്കണം. നിങ്ങൾ node1-ൽ ഉപകരണം പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് ചെയ്യും
ഒരു പകർപ്പിലെയും വ്യത്യാസങ്ങൾ കണ്ടെത്തുന്നില്ല.
നിലവിൽ, ഉപകരണം ഈ സജ്ജീകരണം കണ്ടെത്തുന്നില്ല അല്ലെങ്കിൽ സാധ്യമാകാത്ത പകർപ്പുകളെ കുറിച്ച് മുന്നറിയിപ്പ് നൽകുന്നില്ല
പരിശോധിച്ചു (ഉദാ. replica2 node3-ൽ പ്രവർത്തിക്കുമ്പോൾ).
ഈ സജ്ജീകരണത്തിലെ പകർപ്പുകൾ ഇപ്പോഴും "--[no]check-binlog-format"-ന് വിധേയമാണ്.
സിംഗിൾ ക്ലസ്റ്ററിലേക്ക് മാസ്റ്റർ
ഒരു സാധാരണ മാസ്റ്ററിന് ഒരു ക്ലസ്റ്ററിലേക്ക് പകർത്തുന്നത് സാധ്യമാണ്, ക്ലസ്റ്റർ പോലെ
ഒരു ലോജിക്കൽ അടിമ, പോലെ:
master -> node1 <-> node2 <-> node3
ടൂൾ ഈ സജ്ജീകരണത്തെ പിന്തുണയ്ക്കുന്നു, എന്നാൽ മാസ്റ്ററിൽ പ്രവർത്തിക്കുകയും എല്ലാ നോഡുകളും ആണെങ്കിൽ മാത്രം
ക്ലസ്റ്റർ "ഡയറക്ട് റെപ്ലിക്ക" (ഈ ഉദാഹരണത്തിലെ നോഡ്1) യുമായി പൊരുത്തപ്പെടുന്നു
മാസ്റ്റർ. ഉദാഹരണത്തിന്, എല്ലാ നോഡുകൾക്കും വരി 1 ന് "foo" മൂല്യമുണ്ടെങ്കിൽ, മാസ്റ്ററിന് മൂല്യമുണ്ട്
ഒരേ വരിയുടെ "ബാർ", ഈ വ്യത്യാസം കണ്ടെത്തും. അല്ലെങ്കിൽ node1-ൽ മാത്രമേ ഈ വ്യത്യാസമുണ്ടെങ്കിൽ,
അതും കണ്ടുപിടിക്കപ്പെടും. എന്നാൽ node2 അല്ലെങ്കിൽ node3 എന്നിവയിൽ മാത്രമേ ഈ വ്യത്യാസം ഉള്ളൂവെങ്കിൽ, അത് ഉണ്ടാകില്ല
കണ്ടെത്തി. അതിനാൽ, മാസ്റ്ററും ക്ലസ്റ്ററും a ആയി പരിശോധിക്കാൻ ഈ സജ്ജീകരണം ഉപയോഗിക്കുന്നു
എല്ലാം സ്ഥിരതയുള്ളതാണ്.
ഈ സജ്ജീകരണത്തിൽ, പ്രവർത്തിപ്പിക്കുമ്പോൾ ടൂളിന് "ഡയറക്ട് റെപ്ലിക്ക" (node1) സ്വയമേവ കണ്ടെത്താനാകും
മാസ്റ്ററിൽ, അതിനാൽ "--recursion-method" എന്നതിനായി നിങ്ങൾ "dsn" രീതി ഉപയോഗിക്കേണ്ടതില്ല
കാരണം node1 മുഴുവൻ ക്ലസ്റ്ററിനെയും പ്രതിനിധീകരിക്കും, അതിനാലാണ് മറ്റെല്ലാ നോഡുകളും ഉണ്ടായിരിക്കേണ്ടത്
അതുമായി പൊരുത്തപ്പെടുന്നു.
ഉപയോഗിക്കുമ്പോൾ മാത്രമേ ഇത് പ്രവർത്തിക്കൂ എന്ന് നിങ്ങളെ ഓർമ്മിപ്പിക്കുന്നതിന് ഈ സജ്ജീകരണം കണ്ടെത്തുമ്പോൾ ഉപകരണം മുന്നറിയിപ്പ് നൽകുന്നു
മുകളിൽ വിവരിച്ചതുപോലെ. ഈ മുന്നറിയിപ്പുകൾ ഉപകരണത്തിന്റെ എക്സിറ്റ് നിലയെ ബാധിക്കില്ല; അവർ
തെറ്റായ പോസിറ്റീവ് ഫലങ്ങൾ ഒഴിവാക്കാൻ സഹായിക്കുന്ന ഓർമ്മപ്പെടുത്തലുകൾ മാത്രം.
ഔട്ട്പ്
ടൂൾ ടാബുലാർ ഫലങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു, ഒരു ടേബിളിന് ഒരു വരി:
ടിഎസ് പിശകുകൾ വ്യത്യാസങ്ങൾ വരികൾ കഷണങ്ങൾ ഒഴിവാക്കി ടൈം ടേബിൾ
10-20T08:36:50 0 0 200 1 0 0.005 db1.tbl1
10-20T08:36:50 0 0 603 7 0 0.035 db1.tbl2
10-20T08:36:50 0 0 16 1 0 0.003 db2.tbl3
10-20T08:36:50 0 0 600 6 0 0.024 db2.tbl4
പിശകുകൾ, മുന്നറിയിപ്പുകൾ, പുരോഗതി റിപ്പോർട്ടുകൾ എന്നിവ സ്റ്റാൻഡേർഡ് പിശകിലേക്ക് പ്രിന്റ് ചെയ്യുന്നു. "--ശാന്തം" എന്നതും കാണുക.
ടൂൾ ടേബിൾ പരിശോധിക്കുമ്പോൾ ഓരോ പട്ടികയുടെയും ഫലങ്ങൾ പ്രിന്റ് ചെയ്യപ്പെടും. ദി
നിരകൾ ഇപ്രകാരമാണ്:
TS ടൂൾ ടേബിൾ പരിശോധിച്ച് പൂർത്തിയാക്കിയ സമയ സ്റ്റാമ്പ് (വർഷമില്ലാതെ).
പിശകുകൾ
പട്ടിക പരിശോധിക്കുമ്പോൾ സംഭവിച്ച പിശകുകളുടെയും മുന്നറിയിപ്പുകളുടെയും എണ്ണം. പിശകുകൾ
പട്ടിക പുരോഗമിക്കുമ്പോൾ മുന്നറിയിപ്പുകൾ സ്റ്റാൻഡേർഡ് പിശകിലേക്ക് അച്ചടിക്കുന്നു.
DIFFS
ഒന്നോ അതിലധികമോ പകർപ്പുകളിൽ മാസ്റ്ററിൽ നിന്ന് വ്യത്യസ്തമായ ചങ്കുകളുടെ എണ്ണം. എങ്കിൽ
"--no-replicate-check" വ്യക്തമാക്കിയിരിക്കുന്നു, ഈ നിരയിൽ എപ്പോഴും പൂജ്യങ്ങൾ ഉണ്ടായിരിക്കും. എങ്കിൽ
"--replicate-check-only" വ്യക്തമാക്കിയിട്ടുണ്ട്, തുടർന്ന് വ്യത്യാസങ്ങളുള്ള പട്ടികകൾ മാത്രമേ അച്ചടിക്കുകയുള്ളൂ.
വരികൾ
പട്ടികയിൽ നിന്ന് തിരഞ്ഞെടുത്ത വരികളുടെ എണ്ണം പരിശോധിക്കുക. അത് വ്യത്യസ്തമായിരിക്കാം
നിങ്ങൾ --where ഓപ്ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ പട്ടികയിലെ വരികളുടെ എണ്ണത്തിൽ നിന്ന്.
ചങ്കുകൾ
പട്ടിക വിഭജിച്ചിരിക്കുന്ന കഷണങ്ങളുടെ എണ്ണം.
ഒഴിവാക്കി
ഈ ഒന്നോ അതിലധികമോ പ്രശ്നങ്ങൾ കാരണം ഒഴിവാക്കിയ ചങ്കുകളുടെ എണ്ണം:
* MySQL --chunk-index ഉപയോഗിക്കുന്നില്ല
* MySQL ഫുൾ ചങ്ക് ഇൻഡക്സ് ഉപയോഗിക്കുന്നില്ല (--[ഇല്ല] ചെക്ക്-പ്ലാൻ)
* ചങ്കിന്റെ വലുപ്പം --ചങ്ക്-സൈസ് * --ചങ്ക്-സൈസ്-ലിമിറ്റിനേക്കാൾ കൂടുതലാണ്
* ലോക്ക് കാത്തിരിപ്പ് സമയം കഴിഞ്ഞു (--വീണ്ടും ശ്രമിക്കുന്നു)
* ചെക്ക്സം ചോദ്യം നശിച്ചു (--വീണ്ടും ശ്രമിക്കുന്നു)
pt-table-checksum 2.2.5 പോലെ, ഒഴിവാക്കിയ ചങ്കുകൾ പൂജ്യമല്ലാത്ത "എക്സിറ്റ് സ്റ്റാറ്റസ്" ഉണ്ടാക്കുന്നു.
TIME,
ടേബിൾ പരിശോധിക്കുന്നതിനിടയിൽ സമയം കടന്നുപോയി.
മേശ
പരിശോധിച്ച ഡാറ്റാബേസും പട്ടികയും.
"--replicate-check-only" എന്ന് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, കണ്ടെത്തിയ പകർപ്പുകളിലെ ചെക്ക്സം വ്യത്യാസങ്ങൾ മാത്രം
അച്ചടിച്ചവയാണ്. ഔട്ട്പുട്ട് വ്യത്യസ്തമാണ്: ഓരോ പകർപ്പിനും ഒരു ഖണ്ഡിക, ഒരു ചെക്ക്സം വ്യത്യാസം
ഓരോ വരിയിലും, മൂല്യങ്ങളെ സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കുന്നു:
h=127.0.0.1,P=12346 എന്നതിലെ വ്യത്യാസങ്ങൾ
പട്ടിക CHUNK CNT_DIFF CRC_DIFF CHUNK_INDEX LOWER_BOUNDARY UPPER_BOUNDARY
db1.tbl1 1 0 1 പ്രാഥമികം 1 100
db1.tbl1 6 0 1 പ്രാഥമികം 501 600
h=127.0.0.1,P=12347 എന്നതിലെ വ്യത്യാസങ്ങൾ
പട്ടിക CHUNK CNT_DIFF CRC_DIFF CHUNK_INDEX LOWER_BOUNDARY UPPER_BOUNDARY
db1.tbl1 1 0 1 പ്രാഥമികം 1 100
db2.tbl2 9 5 0 പ്രാഥമികം 101 200
ഒരു ഖണ്ഡികയുടെ ആദ്യ വരി വ്യത്യാസങ്ങളുള്ള പകർപ്പിനെ സൂചിപ്പിക്കുന്നു. ഈ ഉദാഹരണത്തിൽ
രണ്ടെണ്ണം ഉണ്ട്: h=127.0.0.1,P=12346, h=127.0.0.1,P=12347. നിരകൾ ഇപ്രകാരമാണ്:
മേശ
മാസ്റ്ററിൽ നിന്ന് വ്യത്യസ്തമായ ഡാറ്റാബേസും പട്ടികയും.
ചങ്ക്
മാസ്റ്ററിൽ നിന്ന് വ്യത്യസ്തമായ പട്ടികയുടെ ചങ്ക് നമ്പർ.
CNT_DIFF
റെപ്ലിക്കയിലെ ചങ്ക് വരികളുടെ എണ്ണം മാസ്റ്ററിലെ ചങ്ക് വരികളുടെ എണ്ണം മൈനസ്.
CRC_DIFF
1, പകർപ്പിലെ ചങ്കിന്റെ CRC യിൽ നിന്ന് വ്യത്യസ്തമാണെങ്കിൽ
മാസ്റ്റർ, അല്ലെങ്കിൽ 0.
CHUNK_INDEX
പട്ടിക ചങ്ക് ചെയ്യാൻ ഉപയോഗിക്കുന്ന സൂചിക.
LOWER_BOUNDARY
ചങ്കിന്റെ താഴത്തെ അതിർത്തി നിർവചിക്കുന്ന സൂചിക മൂല്യങ്ങൾ.
UPPER_BOUNDARY
ചങ്കിന്റെ മുകളിലെ അതിർത്തി നിർവചിക്കുന്ന സൂചിക മൂല്യങ്ങൾ.
പുറത്ത് പദവി
pt-table-checksum-ന് മൂന്ന് എക്സിറ്റ് സ്റ്റാറ്റസുകൾ ഉണ്ട്: പൂജ്യം, 255, മറ്റേതെങ്കിലും മൂല്യം a
വ്യത്യസ്ത പ്രശ്‌നങ്ങൾക്കുള്ള പതാകകളുള്ള ബിറ്റ്മാസ്ക്.
ഒരു സീറോ എക്സിറ്റ് സ്റ്റാറ്റസ് പിശകുകളോ മുന്നറിയിപ്പുകളോ ചെക്ക്സം വ്യത്യാസങ്ങളോ ഇല്ലെന്ന് സൂചിപ്പിക്കുന്നു, അല്ലെങ്കിൽ ഒഴിവാക്കിയിരിക്കുന്നു
കഷണങ്ങൾ അല്ലെങ്കിൽ മേശകൾ.
255 എക്സിറ്റ് സ്റ്റാറ്റസ് ഒരു മാരകമായ പിശകിനെ സൂചിപ്പിക്കുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ: ഉപകരണം മരിച്ചു അല്ലെങ്കിൽ തകർന്നു. ദി
പിശക് "STDERR" എന്ന് അച്ചടിച്ചു.
എക്സിറ്റ് സ്റ്റാറ്റസ് പൂജ്യം അല്ലെങ്കിൽ 255 അല്ലെങ്കിൽ, അതിന്റെ മൂല്യം ഇവ ഉപയോഗിച്ച് ഒരു ബിറ്റ്മാസ്ക് ആയി പ്രവർത്തിക്കുന്നു
പതാകകൾ:
ഫ്ലാഗ് ബിറ്റ് മൂല്യത്തിന്റെ അർത്ഥം
==================================================== =================
പിശക് 1 മാരകമല്ലാത്ത ഒരു പിശക് സംഭവിച്ചു
ALREADY_RUNNING 2 --pid ഫയൽ നിലവിലുണ്ട്, PID പ്രവർത്തിക്കുന്നു
CAUGHT_SIGNAL 4 പിടികൂടി SIGHUP, SIGINT, SIGPIPE അല്ലെങ്കിൽ SIGTERM
NO_SLAVES_FOUND 8 പകർപ്പുകളോ ക്ലസ്റ്റർ നോഡുകളോ കണ്ടെത്തിയില്ല
TABLE_DIFF 16 കുറഞ്ഞത് ഒരു വ്യത്യാസമെങ്കിലും കണ്ടെത്തി
SKIP_CHUNK 32 ഒരു ചങ്ക് എങ്കിലും ഒഴിവാക്കി
SKIP_TABLE 64 ഒരു ടേബിളെങ്കിലും ഒഴിവാക്കി
ഏതെങ്കിലും ഫ്ലാഗ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, എക്സിറ്റ് സ്റ്റാറ്റസ് പൂജ്യമല്ല. ഇതിനായി ബിറ്റ്‌വൈസ് "AND" പ്രവർത്തനം ഉപയോഗിക്കുക
ഒരു പ്രത്യേക പതാക പരിശോധിക്കുക. ഉദാഹരണത്തിന്, "$exit_status & 16" ശരിയാണെങ്കിൽ, കുറഞ്ഞത്
ഒരു വ്യത്യാസം കണ്ടെത്തി.
pt-table-checksum 2.2.5 പോലെ, ഒഴിവാക്കിയ ചങ്കുകൾ പൂജ്യമല്ലാത്ത എക്സിറ്റ് നിലയ്ക്ക് കാരണമാകുന്നു. ഒരു എക്സിറ്റ്
പൂജ്യം അല്ലെങ്കിൽ 32 എന്ന നില, മുമ്പത്തേതിൽ ഒഴിവാക്കിയ കഷണങ്ങളുള്ള പൂജ്യം എക്സിറ്റ് സ്റ്റാറ്റസിന് തുല്യമാണ്
ഉപകരണത്തിന്റെ പതിപ്പുകൾ.
ഓപ്ഷനുകൾ
ഈ ടൂൾ അധിക കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ സ്വീകരിക്കുന്നു. "സിനോപ്സിസും" ഉപയോഗവും കാണുക
വിശദാംശങ്ങൾക്ക് വിവരങ്ങൾ.
--ചോദിക്കുക-പാസ്
ഗ്രൂപ്പ്: കണക്ഷൻ
MySQL-ലേക്ക് കണക്‌റ്റ് ചെയ്യുമ്പോൾ ഒരു പാസ്‌വേഡ് ആവശ്യപ്പെടുക.
--[no]check-binlog-format
സ്ഥിരസ്ഥിതി: അതെ
എല്ലാ സെർവറുകളിലും "binlog_format" ഒന്നുതന്നെയാണോ എന്ന് പരിശോധിക്കുക.
"പരിമിതികൾ" എന്നതിന് താഴെയുള്ള "വരികൾ അടിസ്ഥാനമാക്കിയുള്ള പകർപ്പുകൾ ഉപയോഗിക്കുന്ന പകർപ്പുകൾ" കാണുക.
--ബൈനറി-സൂചിക
ഈ ഓപ്ഷൻ "--ക്രിയേറ്റ്-റെപ്ലിക്കേറ്റ്-ടേബിളിന്റെ" സ്വഭാവം പരിഷ്‌ക്കരിക്കുന്നു
പകർപ്പ് പട്ടികയുടെ മുകളിലും താഴെയുമുള്ള അതിർത്തി നിരകൾ BLOB ഡാറ്റ ഉപയോഗിച്ച് സൃഷ്‌ടിച്ചതാണ്
തരം. കീകൾ ഉപയോഗിച്ച് പട്ടികകൾ പരിശോധിക്കുന്നതിൽ നിങ്ങൾക്ക് പ്രശ്‌നമുള്ള സന്ദർഭങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാണ്
അതിൽ ഒരു ബൈനറി ഡാറ്റ തരം ഉൾപ്പെടുന്നു അല്ലെങ്കിൽ നിലവാരമില്ലാത്ത പ്രതീക സെറ്റുകൾ ഉണ്ട്. കാണുക
"--പകർപ്പ്".
--ചെക്ക്-ഇന്റർവെൽ
തരം: സമയം; സ്ഥിരസ്ഥിതി: 1; ഗ്രൂപ്പ്: ത്രോട്ടിൽ
"--max-lag" എന്നതിനായുള്ള പരിശോധനകൾക്കിടയിലുള്ള ഉറക്ക സമയം.
--[ഇല്ല] ചെക്ക്-പ്ലാൻ
സ്ഥിരസ്ഥിതി: അതെ
സുരക്ഷയ്ക്കായി ക്വറി എക്സിക്യൂഷൻ പ്ലാനുകൾ പരിശോധിക്കുക. സ്ഥിരസ്ഥിതിയായി, ഈ ഓപ്ഷൻ pt-table- ന് കാരണമാകുന്നു.
ഒരു ചെറിയ തുക ആക്സസ് ചെയ്യാൻ ഉദ്ദേശിച്ചുള്ള അന്വേഷണങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് EXPLAIN റൺ ചെയ്യുന്നതിനായി checksum
ഡാറ്റയുടെ, എന്നാൽ MySQL ഒരു മോശം എക്സിക്യൂഷൻ പ്ലാൻ തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ നിരവധി വരികൾ ആക്സസ് ചെയ്യാൻ കഴിയും. ഇവ
ചങ്ക് അതിരുകൾ നിർണ്ണയിക്കുന്നതിനുള്ള അന്വേഷണങ്ങളും ചങ്ക് അന്വേഷണങ്ങളും ഉൾപ്പെടുത്തുക. എങ്കിൽ
MySQL ഒരു മോശം ക്വറി എക്സിക്യൂഷൻ പ്ലാൻ ഉപയോഗിക്കുമെന്ന് തോന്നുന്നു, ടൂൾ ഒഴിവാക്കും
മേശയുടെ ഭാഗം.
ഒരു എക്സിക്യൂഷൻ പ്ലാൻ മോശമാണോ എന്ന് നിർണ്ണയിക്കാൻ ടൂൾ നിരവധി ഹ്യൂറിസ്റ്റിക്സ് ഉപയോഗിക്കുന്നു. ദി
ആദ്യത്തേത്, MySQL ആക്സസ് ചെയ്യുന്നതിന് ആവശ്യമുള്ള സൂചിക ഉപയോഗിക്കാൻ ഉദ്ദേശിക്കുന്നു എന്ന് EXPLAIN റിപ്പോർട്ടുചെയ്യുന്നുണ്ടോ എന്നതാണ്
വരികൾ. MySQL മറ്റൊരു സൂചിക തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, ഉപകരണം സുരക്ഷിതമല്ലെന്ന് കരുതുന്നു.
MySQL സൂചികയിൽ എത്രത്തോളം അത് ഉപയോഗിക്കുമെന്ന് ടൂൾ പരിശോധിക്കുന്നു
ചോദ്യം. EXPLAIN ഔട്ട്പുട്ട്, key_len കോളത്തിൽ ഇത് കാണിക്കുന്നു. ഉപകരണം ഓർമ്മിക്കുന്നു
ഏറ്റവും വലിയ key_len കണ്ടു, കൂടാതെ MySQL അത് ചെറുതായി ഉപയോഗിക്കുമെന്ന് റിപ്പോർട്ട് ചെയ്യുന്ന ഭാഗങ്ങൾ ഒഴിവാക്കുന്നു
സൂചികയുടെ പ്രിഫിക്സ്. ഈ ഹ്യൂറിസ്റ്റിക് എന്നത് ഒരു ഉള്ള കഷണങ്ങൾ ഒഴിവാക്കുന്നതായി മനസ്സിലാക്കാം
മറ്റ് ഭാഗങ്ങളേക്കാൾ മോശമായ നിർവ്വഹണ പദ്ധതി.
മോശം നിർവ്വഹണം കാരണം ഒരു ചങ്ക് ആദ്യമായി ഒഴിവാക്കപ്പെടുമ്പോൾ ഉപകരണം ഒരു മുന്നറിയിപ്പ് പ്രിന്റ് ചെയ്യുന്നു
ഓരോ ടേബിളിലും പ്ലാൻ ചെയ്യുക. നിങ്ങൾക്ക് കാണാൻ കഴിയുമെങ്കിലും തുടർന്നുള്ള ഭാഗങ്ങൾ നിശബ്ദമായി ഒഴിവാക്കപ്പെടുന്നു
ടൂളിന്റെ ഔട്ട്‌പുട്ടിലെ ഒഴിവാക്കിയ കോളത്തിൽ ഒഴിവാക്കിയ ചങ്കുകളുടെ എണ്ണം.
ഈ ഓപ്ഷൻ ഓരോ ടേബിളിലേക്കും ചങ്കിലേക്കും ചില സജ്ജീകരണ പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു. ജോലി ഇല്ലെങ്കിലും
MySQL-നുള്ള നുഴഞ്ഞുകയറ്റം, ഇത് സെർവറിലേക്ക് കൂടുതൽ റൗണ്ട് ട്രിപ്പുകൾ ഉണ്ടാക്കുന്നു, അത് ഉപഭോഗം ചെയ്യുന്നു
സമയം. കഷണങ്ങൾ വളരെ ചെറുതാക്കുന്നത് ഓവർഹെഡ് താരതമ്യേന വലുതാകാൻ ഇടയാക്കും. അത്
അതിനാൽ കഷണങ്ങൾ വളരെ ചെറുതാക്കരുതെന്ന് ശുപാർശ ചെയ്യുന്നു, കാരണം ഉപകരണം എടുത്തേക്കാം
നിങ്ങൾ ചെയ്യുകയാണെങ്കിൽ പൂർത്തിയാക്കാൻ വളരെ നീണ്ട സമയം.
--[ഇല്ല] ചെക്ക്-റെപ്ലിക്കേഷൻ-ഫിൽട്ടറുകൾ
സ്ഥിരസ്ഥിതി: അതെ; ഗ്രൂപ്പ്: സുരക്ഷ
ഏതെങ്കിലും പകർപ്പുകളിൽ ഏതെങ്കിലും റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ ചെക്ക്സം ചെയ്യരുത്. ഉപകരണം കാണപ്പെടുന്നു
binlog_ignore_db പോലെയുള്ള റെപ്ലിക്കേഷൻ ഫിൽട്ടർ ചെയ്യുന്ന സെർവർ ഓപ്ഷനുകൾക്കായി
replicate_do_db. അത്തരത്തിലുള്ള ഏതെങ്കിലും ഫിൽട്ടറുകൾ കണ്ടെത്തിയാൽ, അത് ഒരു പിശകിനാൽ നിർത്തലാക്കും.
ഏതെങ്കിലും ഫിൽട്ടറിംഗ് ഓപ്ഷനുകൾ ഉപയോഗിച്ച് പകർപ്പുകൾ കോൺഫിഗർ ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ശ്രദ്ധിക്കണം
മാസ്റ്ററിൽ നിലവിലുള്ള ഏതെങ്കിലും ഡാറ്റാബേസുകളോ ടേബിളുകളോ പരിശോധിക്കുന്നതിന്, പകർപ്പുകളല്ല.
ഇത്തരം ടേബിളുകളിലെ മാറ്റങ്ങൾ സാധാരണഗതിയിൽ പകർപ്പുകളിൽ ഒഴിവാക്കിയേക്കാം
ഫിൽട്ടറിംഗ് ഓപ്ഷനുകൾ, പക്ഷേ ചെക്ക്സം അന്വേഷണങ്ങൾ പട്ടികയിലെ ഉള്ളടക്കം പരിഷ്‌ക്കരിക്കുന്നു
ചെക്ക്സം സംഭരിക്കുന്നു, നിങ്ങൾ ചെക്ക്സംമിംഗ് ചെയ്യുന്ന ഡാറ്റയുടെ പട്ടികകളല്ല. അതുകൊണ്ടു,
ഈ അന്വേഷണങ്ങൾ റെപ്ലിക്കയിലും നിങ്ങൾ പട്ടികയിലോ ഡാറ്റാബേസിലോ ആണെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യും
ചെക്ക്സമ്മിംഗ് നിലവിലില്ല, ചോദ്യങ്ങൾ പകർപ്പെടുക്കൽ പരാജയപ്പെടാൻ ഇടയാക്കും. കൂടുതൽ
റെപ്ലിക്കേഷൻ നിയമങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ, കാണുക
<http://dev.mysql.com/doc/en/replication-rules.html>.
ചെക്ക്സം അന്വേഷണങ്ങൾ നടക്കില്ലെന്ന് ഉറപ്പ് വരുത്തുന്നത് റെപ്ലിക്കേഷൻ ഫിൽട്ടറിംഗ് അസാധ്യമാക്കുന്നു
ബ്രേക്ക് റെപ്ലിക്കേഷൻ (അല്ലെങ്കിൽ പകർത്തുന്നതിൽ പരാജയപ്പെടുക). ഓടുന്നത് ശരിയാണെന്ന് ഉറപ്പുണ്ടെങ്കിൽ
ചെക്ക്സം അന്വേഷണങ്ങൾ, ചെക്കുകൾ പ്രവർത്തനരഹിതമാക്കുന്നതിന് നിങ്ങൾക്ക് ഈ ഓപ്ഷൻ നിരാകരിക്കാവുന്നതാണ്. ഇതും കാണുക
"--replicate-database".
"റെപ്ലിക്ക ചെക്കുകൾ" എന്നതും കാണുക.
--ചെക്ക്-സ്ലേവ്-ലാഗ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ത്രോട്ടിൽ
ഈ പകർപ്പിന്റെ ലാഗ് "--max-lag"-ൽ കുറവാകുന്നത് വരെ ചെക്ക്സമ്മിംഗ് താൽക്കാലികമായി നിർത്തുക. മൂല്യം എ
മാസ്റ്റർ ഹോസ്റ്റിൽ നിന്നും കണക്ഷൻ ഓപ്ഷനുകളിൽ നിന്നും പ്രോപ്പർട്ടികൾ അവകാശമാക്കുന്ന DSN
("--പോർട്ട്", "--ഉപയോക്താവ്" മുതലായവ). ഡിഫോൾട്ടായി, pt-table-checksum മോണിറ്ററുകൾ എല്ലാത്തിലും ലാഗ് ചെയ്യുന്നു
കണക്റ്റുചെയ്‌ത പകർപ്പുകൾ, എന്നാൽ ഈ ഓപ്ഷൻ ലാഗ് മോണിറ്ററിംഗ് നിർദ്ദിഷ്ട പകർപ്പിലേക്ക് പരിമിതപ്പെടുത്തുന്നു.
ചില പകർപ്പുകൾ മനഃപൂർവ്വം ലാഗ് ചെയ്താൽ ഇത് ഉപയോഗപ്രദമാണ് (പിടി-സ്ലേവ്-ഡിലേയ്‌ക്കായി
ഉദാഹരണം), ഈ സാഹചര്യത്തിൽ നിരീക്ഷിക്കാൻ നിങ്ങൾക്ക് ഒരു സാധാരണ പകർപ്പ് വ്യക്തമാക്കാൻ കഴിയും.
"റെപ്ലിക്ക ചെക്കുകൾ" എന്നതും കാണുക.
--[ഇല്ല] ചെക്ക്-സ്ലേവ്-ടേബിളുകൾ
സ്ഥിരസ്ഥിതി: അതെ; ഗ്രൂപ്പ്: സുരക്ഷ
അടിമകളെക്കുറിച്ചുള്ള പട്ടികകൾ നിലവിലുണ്ടോയെന്നും എല്ലാ ചെക്ക്സം "--കോളങ്ങളും" ഉണ്ടെന്നും പരിശോധിക്കുന്നു. പട്ടികകൾ
അടിമകളെ കാണുന്നില്ല അല്ലെങ്കിൽ എല്ലാ ചെക്ക്സം "--കോളങ്ങളും" ഇല്ലാത്തത് ടൂളിന് കാരണമാകാം
വ്യത്യാസങ്ങൾ പരിശോധിക്കാൻ ശ്രമിക്കുമ്പോൾ പകർപ്പ് തകർക്കുക. എങ്കിൽ മാത്രം ഈ പരിശോധന പ്രവർത്തനരഹിതമാക്കുക
അപകടസാധ്യതകളെക്കുറിച്ച് നിങ്ങൾക്ക് ബോധമുണ്ട്, കൂടാതെ എല്ലാ അടിമകളുടെയും എല്ലാ പട്ടികകളും നിലവിലുണ്ടെന്നും ഉണ്ടെന്നും നിങ്ങൾക്ക് ഉറപ്പുണ്ട്
മാസ്റ്ററിന് സമാനമായത്.
--ചങ്ക്-ഇൻഡക്സ്
തരം: സ്ട്രിംഗ്
ചങ്കിംഗ് ടേബിളുകൾക്ക് ഈ സൂചിക തിരഞ്ഞെടുക്കുക. സ്ഥിരസ്ഥിതിയായി, pt-table-checksum ഏറ്റവും കൂടുതൽ തിരഞ്ഞെടുക്കുന്നു
ചങ്കിംഗിന് അനുയോജ്യമായ സൂചിക. നിങ്ങളുടേതായ സൂചിക വ്യക്തമാക്കാൻ ഈ ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു
മുൻഗണന. സൂചിക നിലവിലില്ലെങ്കിൽ, pt-table-checksum അതിലേക്ക് മടങ്ങും
ഒരു സൂചിക തിരഞ്ഞെടുക്കുന്നതിന്റെ ഡിഫോൾട്ട് സ്വഭാവം. pt-table-checksum എന്നതിലേക്ക് സൂചിക ചേർക്കുന്നു
"FORCE INDEX" ക്ലോസിലുള്ള checksum SQL പ്രസ്താവനകൾ. ഈ ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ ശ്രദ്ധിക്കുക;
സൂചികയുടെ മോശം തിരഞ്ഞെടുപ്പ് മോശം പ്രകടനത്തിന് കാരണമാകും. ഇത് എപ്പോൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്
നിങ്ങൾ ഒരു ടേബിൾ മാത്രമാണ് ചെക്ക്സം ചെയ്യുന്നത്, മുഴുവൻ സെർവറും അല്ല.
--ചങ്ക്-ഇൻഡക്സ്-നിരകൾ
തരം: int
ഒരു "--ചങ്ക്-ഇൻഡക്‌സിന്റെ" ഇടതുവശത്തുള്ള ഇത്രയും നിരകൾ മാത്രം ഉപയോഗിക്കുക. ഇത് വേണ്ടി മാത്രം പ്രവർത്തിക്കുന്നു
സംയുക്ത സൂചികകൾ, കൂടാതെ MySQL ക്വറി ഒപ്റ്റിമൈസറിലെ ബഗ് ഉള്ള സന്ദർഭങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാണ്
(പ്ലാനർ) സൂചിക കണ്ടെത്തുന്നതിന് പകരം വരികളുടെ ഒരു വലിയ ശ്രേണി സ്കാൻ ചെയ്യാൻ ഇത് കാരണമാകുന്നു
ആരംഭിക്കുന്നതും അവസാനിക്കുന്നതുമായ പോയിന്റുകൾ കൃത്യമായി. ഈ പ്രശ്നം ചിലപ്പോൾ സൂചികകളിൽ സംഭവിക്കുന്നു
നാലോ അതിലധികമോ പോലുള്ള നിരവധി നിരകൾ. ഇത് സംഭവിക്കുകയാണെങ്കിൽ, ഉപകരണം ഒരു മുന്നറിയിപ്പ് അച്ചടിച്ചേക്കാം
"--[നോ]ചെക്ക്-പ്ലാൻ" ഓപ്ഷനുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ആദ്യത്തേത് മാത്രം ഉപയോഗിക്കാൻ ടൂളിനോട് നിർദ്ദേശിക്കുന്നു
ചില സന്ദർഭങ്ങളിൽ ബഗിനുള്ള ഒരു പരിഹാരമാണ് സൂചികയുടെ N നിരകൾ.
--ചങ്ക് വലിപ്പം
തരം: വലിപ്പം; സ്ഥിരസ്ഥിതി: 1000
ഓരോ ചെക്ക്സം അന്വേഷണത്തിനും തിരഞ്ഞെടുക്കേണ്ട വരികളുടെ എണ്ണം. അനുവദനീയമായ പ്രത്യയങ്ങൾ k, M, G എന്നിവയാണ്.
മിക്ക കേസുകളിലും നിങ്ങൾ ഈ ഓപ്ഷൻ ഉപയോഗിക്കരുത്; പകരം "--ചങ്ക്-ടൈം" തിരഞ്ഞെടുക്കുക.
ഈ ഓപ്ഷന് ഡിഫോൾട്ട് സ്വഭാവത്തെ അസാധുവാക്കാൻ കഴിയും, അതായത് ചങ്ക് സൈസ് ക്രമീകരിക്കുക
കൃത്യമായ "--ചങ്ക്-ടൈം" സെക്കന്റുകൾക്കുള്ളിൽ ചങ്കുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് ചലനാത്മകമായി ശ്രമിക്കുക. ഇത് എപ്പോൾ
ഓപ്ഷൻ വ്യക്തമായി സജ്ജീകരിച്ചിട്ടില്ല, അതിന്റെ ഡിഫോൾട്ട് മൂല്യം ഒരു ആരംഭ പോയിന്റായി ഉപയോഗിക്കുന്നു, പക്ഷേ അതിനുശേഷം
അതായത്, ഉപകരണം ഈ ഓപ്ഷന്റെ മൂല്യം അവഗണിക്കുന്നു. നിങ്ങൾ ഈ ഓപ്ഷൻ വ്യക്തമായി സജ്ജീകരിക്കുകയാണെങ്കിൽ,
എന്നിരുന്നാലും, അത് ചലനാത്മക ക്രമീകരണ സ്വഭാവം പ്രവർത്തനരഹിതമാക്കുകയും എല്ലാ ഭാഗങ്ങളും ഉണ്ടാക്കാൻ ശ്രമിക്കുകയും ചെയ്യുന്നു
കൃത്യമായി പറഞ്ഞിരിക്കുന്ന വരികളുടെ എണ്ണം.
ഒരു സൂക്ഷ്മതയുണ്ട്: ചങ്ക് സൂചിക അദ്വിതീയമല്ലെങ്കിൽ, അത് ചങ്ക് ആകാൻ സാധ്യതയുണ്ട്
ആഗ്രഹിച്ചതിലും വലുതായിരിക്കും. ഉദാഹരണത്തിന്, ഒരു ടേബിളിനെ ഒരു സൂചിക കൊണ്ട് അരിഞ്ഞാൽ
നൽകിയിരിക്കുന്ന മൂല്യത്തിന്റെ 10,000 അടങ്ങിയിരിക്കുന്നു, പൊരുത്തപ്പെടുന്ന ഒരു ക്ലോസ് എഴുതാൻ ഒരു മാർഗവുമില്ല
മൂല്യങ്ങളുടെ 1,000 മാത്രം, ആ ഭാഗം കുറഞ്ഞത് 10,000 വരികൾ വലുതായിരിക്കും. അത്തരം എ
"--ചങ്ക്-സൈസ്-ലിമിറ്റ്" കാരണം ചങ്ക് ഒഴിവാക്കിയേക്കാം.
ഒരു ചെറിയ ചങ്ക് വലുപ്പം തിരഞ്ഞെടുക്കുന്നത്, ഭാഗികമായി ഉപകരണം വളരെ മന്ദഗതിയിലാക്കാൻ ഇടയാക്കും
"--[നോ]ചെക്ക്-പ്ലാൻ" എന്നതിന് ആവശ്യമായ സജ്ജീകരണ ജോലികൾ കാരണം.
--ചങ്ക്-വലിപ്പം-പരിധി
തരം: ഫ്ലോട്ട്; സ്ഥിരസ്ഥിതി: 2.0; ഗ്രൂപ്പ്: സുരക്ഷ
ആവശ്യമുള്ള ചങ്ക് വലുപ്പത്തേക്കാൾ വളരെ വലുത് ചെക്ക്സം കഷണങ്ങൾ ചെയ്യരുത്.
ഒരു ടേബിളിന് അദ്വിതീയ സൂചികകൾ ഇല്ലെങ്കിൽ, ചങ്ക് വലുപ്പങ്ങൾ കൃത്യമല്ലായിരിക്കാം. ഈ ഓപ്ഷൻ
കൃത്യതയില്ലായ്മയ്ക്ക് സഹിക്കാവുന്ന പരമാവധി പരിധി വ്യക്തമാക്കുന്നു. ഉപകരണം ഉപയോഗിക്കുന്നു വരെ
ചങ്കിൽ എത്ര വരികൾ ഉണ്ടെന്ന് കണക്കാക്കുക. ആ എസ്റ്റിമേറ്റ് ആവശ്യമുള്ള ചങ്ക് കവിയുന്നുവെങ്കിൽ
വലുപ്പം പരിധിയുടെ ഇരട്ടിയായി (ഇരട്ടി വലുത്, സ്ഥിരസ്ഥിതിയായി), തുടർന്ന് ഉപകരണം ചങ്ക് ഒഴിവാക്കുന്നു.
ഈ ഓപ്ഷന്റെ ഏറ്റവും കുറഞ്ഞ മൂല്യം 1 ആണ്, അതിനർത്ഥം ഒരു ചങ്കും ഇതിലും വലുതായിരിക്കില്ല എന്നാണ്
"--ചങ്ക്-സൈസ്". വരികൾ റിപ്പോർട്ട് ചെയ്‌തതിനാൽ, 1 വ്യക്തമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല
എസ്റ്റിമേറ്റുകളാണ് വിശദീകരിക്കുക, ഇത് വരികളുടെ യഥാർത്ഥ എണ്ണത്തിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കും
ചങ്ക്. വലിപ്പം കൂടിയതിനാൽ ടൂൾ വളരെയധികം കഷണങ്ങൾ ഒഴിവാക്കുകയാണെങ്കിൽ, നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
2 ന്റെ സ്ഥിരസ്ഥിതിയേക്കാൾ വലിയ മൂല്യം വ്യക്തമാക്കാൻ.
0 ന്റെ മൂല്യം വ്യക്തമാക്കിയുകൊണ്ട് നിങ്ങൾക്ക് വലിയ അളവിലുള്ള ചങ്ക് പരിശോധന പ്രവർത്തനരഹിതമാക്കാം.
--ചങ്ക്-ടൈം
തരം: ഫ്ലോട്ട്; സ്ഥിരസ്ഥിതി: 0.5
ഓരോ ചെക്ക്സം അന്വേഷണവും എക്സിക്യൂട്ട് ചെയ്യാൻ ഇത്രയും സമയമെടുക്കുന്ന തരത്തിൽ ചങ്ക് സൈസ് ഡൈനാമിക് ആയി ക്രമീകരിക്കുക.
ടൂൾ എല്ലാ പട്ടികകൾക്കും ഓരോ ടേബിളിനുമുള്ള ചെക്ക്സം നിരക്ക് (സെക്കൻഡിലെ വരികൾ) ട്രാക്ക് ചെയ്യുന്നു
വ്യക്തിഗതമായി. ഓരോ ചെക്ക്സം അന്വേഷണത്തിനുശേഷവും ചങ്ക് വലുപ്പം ക്രമീകരിക്കാൻ ഇത് ഈ നിരക്കുകൾ ഉപയോഗിക്കുന്നു,
അതിനാൽ അടുത്ത ചെക്ക്സം ചോദ്യം എക്സിക്യൂട്ട് ചെയ്യാൻ ഇത്രയും സമയമെടുക്കും (സെക്കൻഡിൽ).
അൽഗോരിതം ഇപ്രകാരമാണ്: ഓരോ ടേബിളിന്റെയും തുടക്കത്തിൽ, ചങ്ക് വലുപ്പം
ഉപകരണം പ്രവർത്തിക്കാൻ തുടങ്ങിയത് മുതൽ സെക്കൻഡിൽ മൊത്തത്തിലുള്ള ശരാശരി വരികളിൽ നിന്ന് ആരംഭിച്ചത്, അല്ലെങ്കിൽ
ഉപകരണം ഇതുവരെ പ്രവർത്തിക്കാൻ തുടങ്ങിയിട്ടില്ലെങ്കിൽ "--ചങ്ക്-സൈസ്" എന്നതിന്റെ മൂല്യം. ഓരോന്നിനും
ഒരു മേശയുടെ തുടർന്നുള്ള ഭാഗം, ടൂൾ ചോദ്യങ്ങൾ ഉണ്ടാക്കാൻ ശ്രമിക്കുന്നതിനായി ചങ്കിന്റെ വലുപ്പം ക്രമീകരിക്കുന്നു
ആവശ്യമുള്ള സമയത്ത് ഓടുക. ഇത് ജീർണിച്ചുകൊണ്ടിരിക്കുന്ന ചലിക്കുന്ന ശരാശരി നിലനിർത്തുന്നു
സെർവറിലെ മാറ്റങ്ങൾ കാരണം സെർവറിന്റെ പ്രകടനം മാറുകയാണെങ്കിൽ സെക്കൻഡിൽ ചോദ്യങ്ങൾ
സെർവർ ലോഡ്, ഉപകരണം വേഗത്തിൽ പൊരുത്തപ്പെടുന്നു. ഇത് ഉപകരണത്തെ പ്രവചനാതീതമായി നേടാൻ അനുവദിക്കുന്നു
ഓരോ ടേബിളിനും മൊത്തത്തിലുള്ള സെർവറിനുമുള്ള സമയബന്ധിതമായ അന്വേഷണങ്ങൾ.
ഈ ഓപ്ഷൻ പൂജ്യമായി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ചങ്ക് വലുപ്പം സ്വയമേവ ക്രമീകരിക്കില്ല, അതിനാൽ ചെക്ക്സം അന്വേഷിക്കുക
സമയം വ്യത്യാസപ്പെടും, പക്ഷേ ചെക്ക്സം വലുപ്പങ്ങൾ അന്വേഷിക്കില്ല. അതേ കാര്യം ചെയ്യാനുള്ള മറ്റൊരു വഴി
"--ചങ്ക്-സൈസ്" എന്നതിനുള്ള ഒരു മൂല്യം വ്യക്തമായി വ്യക്തമാക്കുക, പകരം അത്
സ്ഥിരസ്ഥിതിയായി.
--നിരകൾ
ഹ്രസ്വ രൂപം: -c; തരം: അറേ; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ കോമയാൽ വേർതിരിച്ച നിരകളുടെ ലിസ്റ്റ് മാത്രം ചെക്ക്സം ചെയ്യുക. ഒരു ടേബിളിൽ ഒന്നുമില്ലെങ്കിൽ
നിർദ്ദിഷ്ട നിരകൾ അത് ഒഴിവാക്കും.
ഈ ഓപ്ഷൻ എല്ലാ പട്ടികകൾക്കും ബാധകമാണ്, അതിനാൽ ഒരെണ്ണം പരിശോധിക്കുമ്പോൾ മാത്രമേ ഇത് ശരിക്കും അർത്ഥമാക്കൂ
പട്ടികകൾക്ക് ഒരു പൊതു നിരകൾ ഇല്ലെങ്കിൽ പട്ടിക.
--config
തരം: അറേ; ഗ്രൂപ്പ്: കോൺഫിഗറേഷൻ
കോൺഫിഗറേഷൻ ഫയലുകളുടെ കോമയാൽ വേർതിരിച്ച ഈ ലിസ്റ്റ് വായിക്കുക; വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഇത് ആദ്യത്തേതായിരിക്കണം
കമാൻഡ് ലൈനിലെ ഓപ്ഷൻ.
ഡിഫോൾട്ട് കോൺഫിഗറേഷൻ ഫയലുകളുടെ ഒരു ലിസ്റ്റിനായി "--help" ഔട്ട്പുട്ട് കാണുക.
--[ഇല്ല]പട്ടിക സൃഷ്ടിക്കുക
സ്ഥിരസ്ഥിതി: അതെ
"--replicate" ഡാറ്റാബേസും പട്ടികയും ഇല്ലെങ്കിൽ സൃഷ്ടിക്കുക. യുടെ ഘടന
"--replicate" എന്നതിൽ സൂചിപ്പിച്ചിരിക്കുന്ന നിർദ്ദേശിത പട്ടികയ്ക്ക് സമാനമാണ് പകർപ്പ് പട്ടിക.
--ഡാറ്റാബേസുകൾ
ഹ്രസ്വ രൂപം: -d; തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
കോമയാൽ വേർതിരിച്ച ഈ ഡാറ്റാബേസുകളുടെ ലിസ്റ്റ് മാത്രം ചെക്ക്സം ചെയ്യുക.
--databases-regex
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ Perl regex-ന്റെ പേരുകളുമായി പൊരുത്തപ്പെടുന്ന ചെക്ക്സം ഡാറ്റാബേസുകൾ മാത്രം.
--defaults-file
ഹ്രസ്വ രൂപം: -F; തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: കണക്ഷൻ
നൽകിയിരിക്കുന്ന ഫയലിൽ നിന്ന് mysql ഓപ്ഷനുകൾ മാത്രം വായിക്കുക. നിങ്ങൾ ഒരു സമ്പൂർണ്ണ പാതയുടെ പേര് നൽകണം.
--[ഇല്ല] ശൂന്യമായ-റെപ്ലിക്കേറ്റ്-ടേബിൾ
സ്ഥിരസ്ഥിതി: അതെ
പട്ടിക പരിശോധിക്കുന്നതിന് മുമ്പ് ഓരോ ടേബിളിനും മുമ്പുള്ള ചെക്ക്സം ഇല്ലാതാക്കുക. ഈ ഓപ്ഷൻ
മുഴുവൻ ടേബിളും വെട്ടിച്ചുരുക്കുന്നില്ല, അത് ഓരോ ടേബിളിനും വേണ്ടിയുള്ള വരികൾ (ചെക്ക്സം) മാത്രം ഇല്ലാതാക്കുന്നു
പട്ടിക പരിശോധിക്കുന്നതിന് തൊട്ടുമുമ്പ്. അതിനാൽ, ചെക്ക്സമ്മിംഗ് അകാലത്തിൽ നിർത്തുകയാണെങ്കിൽ ഒപ്പം
നേരത്തെയുള്ള ഡാറ്റ ഉണ്ടായിരുന്നു, അല്ലാത്ത പട്ടികകൾക്കായി ഇനിയും വരികൾ ഉണ്ടാകും
ഉപകരണം നിർത്തുന്നതിന് മുമ്പ് പരിശോധന നടത്തി.
നിങ്ങൾ മുമ്പത്തെ ചെക്ക്സം റണ്ണിൽ നിന്ന് പുനരാരംഭിക്കുകയാണെങ്കിൽ, ചെക്ക്സം രേഖകൾക്കായി രേഖപ്പെടുത്തുന്നു
ടൂൾ പുനരാരംഭിക്കുന്ന പട്ടിക ശൂന്യമാകില്ല.
മുഴുവൻ റെപ്ലിക്കേറ്റ് ടേബിളും ശൂന്യമാക്കാൻ, നിങ്ങൾ മുമ്പ് "TRUNCATE TABLE" സ്വമേധയാ എക്സിക്യൂട്ട് ചെയ്യണം
ഉപകരണം പ്രവർത്തിപ്പിക്കുന്നു.
--എഞ്ചിനുകൾ
ഹ്രസ്വ രൂപം: -ഇ; തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ സ്റ്റോറേജ് എഞ്ചിനുകൾ ഉപയോഗിക്കുന്ന ചെക്ക്സം ടേബിളുകൾ മാത്രം.
--വിശദീകരിക്കാൻ
സഞ്ചിത: അതെ; സ്ഥിരസ്ഥിതി: 0; ഗ്രൂപ്പ്: ഔട്ട്പുട്ട്
കാണിക്കുക, എന്നാൽ എക്സിക്യൂട്ട് ചെയ്യരുത്, ചെക്ക്സം അന്വേഷണങ്ങൾ ("--[no]empty-replicate-table" പ്രവർത്തനരഹിതമാക്കുന്നു).
രണ്ടുതവണ വ്യക്തമാക്കിയാൽ, ഉപകരണം യഥാർത്ഥത്തിൽ ചങ്കിംഗ് അൽഗോരിതം വഴി ആവർത്തിക്കുന്നു,
ഓരോ ചങ്കിനും മുകളിലും താഴെയുമുള്ള അതിർത്തി മൂല്യങ്ങൾ അച്ചടിക്കുന്നു, പക്ഷേ എക്സിക്യൂട്ട് ചെയ്യുന്നില്ല
ചെക്ക്സം അന്വേഷണങ്ങൾ.
--ഫ്ലോട്ട്-പ്രിസിഷൻ
തരം: int
ഫ്ലോട്ട്, ഡബിൾ നമ്പർ-ടു-സ്ട്രിംഗ് പരിവർത്തനത്തിനുള്ള കൃത്യത. ഫ്ലോട്ടിനും ഇരട്ടിക്കും കാരണമാകുന്നു
ദശാംശ ബിന്ദുവിന് ശേഷം നിശ്ചിത അക്കങ്ങളുടെ സംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യേണ്ട മൂല്യങ്ങൾ
The റൗണ്ട്() MySQL-ൽ പ്രവർത്തനം. കാരണം ചെക്ക്സം പൊരുത്തക്കേടുകൾ ഒഴിവാക്കാൻ ഇത് സഹായിക്കും
വ്യത്യസ്ത MySQL-ൽ ഒരേ മൂല്യങ്ങളുടെ വ്യത്യസ്ത ഫ്ലോട്ടിംഗ് പോയിന്റ് പ്രാതിനിധ്യങ്ങൾ
പതിപ്പുകളും ഹാർഡ്‌വെയറും. സ്ഥിരസ്ഥിതി റൗണ്ടിംഗ് ഇല്ല; മൂല്യങ്ങൾ പരിവർത്തനം ചെയ്യപ്പെടുന്നു
ചരടുകൾ വഴി CONCAT() ഫംഗ്ഷൻ, കൂടാതെ MySQL സ്ട്രിംഗ് പ്രാതിനിധ്യം തിരഞ്ഞെടുക്കുന്നു. നിങ്ങൾ എങ്കിൽ
2 ന്റെ മൂല്യം വ്യക്തമാക്കുക, ഉദാഹരണത്തിന്, 1.008, 1.009 എന്നീ മൂല്യങ്ങൾ റൗണ്ട് ചെയ്യപ്പെടും
1.01, കൂടാതെ ചെക്ക്സം തുല്യമായിരിക്കും.
--പ്രവർത്തനം
തരം: സ്ട്രിംഗ്
ചെക്ക്സം (FNV1A_64, MURMUR_HASH, SHA1, MD5, CRC32, മുതലായവ) ഹാഷ് ഫംഗ്ഷൻ.
സ്ഥിരസ്ഥിതി ഉപയോഗിക്കുക എന്നതാണ് CRC32(), പക്ഷേ MD5() ഒപ്പം SHA1() പ്രവർത്തിക്കുകയും ചെയ്യുക, നിങ്ങൾക്ക് നിങ്ങളുടെ ഉപയോഗിക്കാൻ കഴിയും
നിങ്ങൾക്ക് വേണമെങ്കിൽ സമാഹരിച്ച UDF പോലുള്ള സ്വന്തം പ്രവർത്തനം. നിങ്ങൾ വ്യക്തമാക്കിയ ഫംഗ്ഷൻ പ്രവർത്തിക്കുന്നു
SQL, Perl-ൽ അല്ല, അതിനാൽ ഇത് MySQL-ന് ലഭ്യമായിരിക്കണം.
MySQL-ന് വേഗതയേറിയ ബിൽറ്റ്-ഇൻ ഹാഷ് ഫംഗ്‌ഷനുകൾ ഇല്ല. CRC32() വളരെ സാധ്യതയുള്ളതാണ്
ഹാഷ് കൂട്ടിയിടികളിലേക്ക്, ഒപ്പം MD5() ഒപ്പം SHA1() വളരെ CPU-ഇന്റൻസീവ് ആണ്. ദി FNV1A_64() യുഡിഎഫ്
പെർക്കോണ സെർവറിനൊപ്പം വിതരണം ചെയ്യുന്നത് വേഗതയേറിയ ബദലാണ്. ഇത് വളരെ ലളിതമാണ്
കംപൈൽ ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക; നിർദ്ദേശങ്ങൾക്കായി സോഴ്സ് കോഡിലെ തലക്കെട്ട് നോക്കുക. അങ്ങനെ എങ്കിൽ
ഇൻസ്റ്റാൾ ചെയ്തു, അത് മുൻഗണന നൽകുന്നു MD5(). നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം MURMUR_HASH() എങ്കിൽ പ്രവർത്തിക്കുക
നിങ്ങൾ അത് ഒരു UDF ആയി കംപൈൽ ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക; ഉറവിടം പെർക്കോണയോടൊപ്പം വിതരണം ചെയ്യപ്പെടുന്നു
സെർവർ, അതിലും മികച്ചതായിരിക്കാം FNV1A_64().
--സഹായിക്കൂ
ഗ്രൂപ്പ്: സഹായം
സഹായം കാണിച്ച് പുറത്തുകടക്കുക.
--ഹോസ്റ്റ്
ഹ്രസ്വ രൂപം: -h; തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: ലോക്കൽഹോസ്റ്റ്; ഗ്രൂപ്പ്: കണക്ഷൻ
ബന്ധിപ്പിക്കാൻ ഹോസ്റ്റ്.
--നിരകൾ അവഗണിക്കുക
തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ചെക്ക്സം കണക്കാക്കുമ്പോൾ ഈ കോമയാൽ വേർതിരിച്ച നിരകളുടെ ലിസ്റ്റ് അവഗണിക്കുക. ഒരു മേശ ആണെങ്കിൽ
അതിന്റെ എല്ലാ കോളങ്ങളും --ignore-columns ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്തിട്ടുണ്ടോ, അത് ഒഴിവാക്കപ്പെടും.
ഡാറ്റാബേസുകളെ അവഗണിക്കുക
തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ കോമയാൽ വേർതിരിച്ച ഡാറ്റാബേസുകളുടെ പട്ടിക അവഗണിക്കുക.
--ignore-databases-regex
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ പേൾ റീജക്സുമായി പൊരുത്തപ്പെടുന്ന പേരുകളുള്ള ഡാറ്റാബേസുകൾ അവഗണിക്കുക.
--അവഗണിക്കുക-എഞ്ചിനുകൾ
തരം: ഹാഷ്; സ്ഥിരസ്ഥിതി: FEDERATED,MRG_MyISAM; ഗ്രൂപ്പ്: ഫിൽട്ടർ
കോമയാൽ വേർതിരിച്ച സ്റ്റോറേജ് എഞ്ചിനുകളുടെ ഈ ലിസ്റ്റ് അവഗണിക്കുക.
--പട്ടികകൾ അവഗണിക്കുക
തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ കോമയാൽ വേർതിരിച്ച പട്ടികകളുടെ പട്ടിക അവഗണിക്കുക. പട്ടികയുടെ പേരുകൾ ഇതിനൊപ്പം യോഗ്യത നേടിയേക്കാം
ഡാറ്റാബേസ് നാമം. "--replicate" പട്ടിക എപ്പോഴും സ്വയമേവ അവഗണിക്കപ്പെടും.
--ignore-tables-regex
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
പേരുകൾ പേൾ റീജക്സുമായി പൊരുത്തപ്പെടുന്ന പട്ടികകൾ അവഗണിക്കുക.
--max-lag
തരം: സമയം; സ്ഥിരസ്ഥിതി: 1സെ; ഗ്രൂപ്പ്: ത്രോട്ടിൽ
എല്ലാ പകർപ്പുകളുടെയും ലാഗ് ഈ മൂല്യത്തേക്കാൾ കുറവാകുന്നതുവരെ ചെക്ക്സമ്മിംഗ് താൽക്കാലികമായി നിർത്തുക. ഓരോന്നിനും ശേഷം
ചെക്ക്സം അന്വേഷണം (ഓരോ ഭാഗവും), pt-table-checksum എല്ലാത്തിന്റെയും പകർപ്പെടുക്കൽ ലാഗ് നോക്കുന്നു
Seconds_Behind_Master ഉപയോഗിച്ച് അത് ബന്ധിപ്പിക്കുന്ന പകർപ്പുകൾ. ഏതെങ്കിലും പകർപ്പ് പിന്നിലാണെങ്കിൽ
ഈ ഓപ്ഷന്റെ മൂല്യത്തേക്കാൾ കൂടുതൽ, അപ്പോൾ pt-table-checksum ഉറങ്ങും
"--ചെക്ക്-ഇന്റർവൽ" സെക്കൻഡുകൾ, തുടർന്ന് എല്ലാ പകർപ്പുകളും വീണ്ടും പരിശോധിക്കുക. നിങ്ങൾ വ്യക്തമാക്കിയാൽ
"--ചെക്ക്-സ്ലേവ്-ലാഗ്", തുടർന്ന് ടൂൾ ആ സെർവർ ലാഗിനായി പരിശോധിക്കുന്നു, എല്ലാ സെർവറുകളും അല്ല.
പകർപ്പുകൾ ലാഗ് ചെയ്യുന്നത് നിർത്താൻ ഉപകരണം എന്നേക്കും കാത്തിരിക്കുന്നു. ഏതെങ്കിലും പകർപ്പ് നിർത്തിയാൽ, ദി
പകർപ്പ് ആരംഭിക്കുന്നത് വരെ ഉപകരണം എന്നേക്കും കാത്തിരിക്കുന്നു. എല്ലാം ഒരിക്കൽ ചെക്ക്സംമിംഗ് തുടരുന്നു
പകർപ്പുകൾ പ്രവർത്തിക്കുന്നു, വളരെ പിന്നിലല്ല.
കാത്തിരിക്കുമ്പോൾ ടൂൾ പുരോഗതി റിപ്പോർട്ടുകൾ പ്രിന്റ് ചെയ്യുന്നു. ഒരു പകർപ്പ് നിർത്തിയാൽ, അത് അച്ചടിക്കുന്നു a
പുരോഗതി റിപ്പോർട്ട് ഉടനടി, തുടർന്ന് ഓരോ പുരോഗതി റിപ്പോർട്ട് ഇടവേളയിലും.
"റെപ്ലിക്ക ചെക്കുകൾ" എന്നതും കാണുക.
--max-load
തരം: അറേ; സ്ഥിരസ്ഥിതി: Threads_running=25; ഗ്രൂപ്പ്: ത്രോട്ടിൽ
ഓരോ ചങ്കിനും ശേഷം ഷോ ഗ്ലോബൽ സ്റ്റാറ്റസ് പരിശോധിക്കുക, എന്തെങ്കിലും സ്റ്റാറ്റസ് വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ താൽക്കാലികമായി നിർത്തുക
ഉമ്മരപ്പടിയെക്കാൾ ഉയർന്നത്. ഈ ഓപ്ഷൻ MySQL സ്റ്റാറ്റസിന്റെ കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് സ്വീകരിക്കുന്നു
ഒരു പരിധി പരിശോധിക്കുന്നതിനുള്ള വേരിയബിളുകൾ. ഒരു ഓപ്ഷണൽ "=MAX_VALUE" (അല്ലെങ്കിൽ ":MAX_VALUE") കഴിയും
ഓരോ വേരിയബിളും പിന്തുടരുക. നൽകിയിട്ടില്ലെങ്കിൽ, ഉപകരണം പരിശോധിച്ചുകൊണ്ട് ഒരു പരിധി നിശ്ചയിക്കുന്നു
നിലവിലെ മൂല്യം 20% വർദ്ധിപ്പിക്കുന്നു.
ഉദാഹരണത്തിന്, Threads_connected വളരെ ഉയർന്നതായിരിക്കുമ്പോൾ ടൂൾ താൽക്കാലികമായി നിർത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ
"Threads_connected" എന്ന് വ്യക്തമാക്കാൻ കഴിയും, ഉപകരണം നിലവിലുള്ള മൂല്യം പരിശോധിക്കും
പ്രവർത്തിക്കാൻ തുടങ്ങുകയും ആ മൂല്യത്തിലേക്ക് 20% ചേർക്കുകയും ചെയ്യുന്നു. നിലവിലെ മൂല്യം 100 ആണെങ്കിൽ, ഉപകരണം
Threads_connected 120 കവിയുമ്പോൾ താൽക്കാലികമായി നിർത്തുകയും 120-ൽ താഴെയാകുമ്പോൾ പ്രവർത്തനം പുനരാരംഭിക്കുകയും ചെയ്യും
വീണ്ടും. നിങ്ങൾക്ക് 110 പോലെ വ്യക്തമായ ഒരു പരിധി വ്യക്തമാക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഒന്നുകിൽ ഉപയോഗിക്കാം
"Threads_connected:110" അല്ലെങ്കിൽ "Threads_connected=110".
ഈ ഓപ്ഷന്റെ ഉദ്ദേശം, ടൂളിലേക്ക് വളരെയധികം ലോഡ് ചേർക്കുന്നത് തടയുക എന്നതാണ്
സെർവർ. ചെക്ക്സം അന്വേഷണങ്ങൾ നുഴഞ്ഞുകയറുന്നതോ ലോക്ക് കാത്തിരിപ്പിന് കാരണമാകുന്നതോ ആണെങ്കിൽ, മറ്റുള്ളവ
സെർവറിലെ അന്വേഷണങ്ങൾ തടയാനും ക്യൂ നിൽക്കാനും പ്രവണത കാണിക്കും. ഇത് സാധാരണയായി കാരണമാകും
വർദ്ധിപ്പിക്കാൻ Threads_running, SHOW GLOBAL പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ ടൂളിന് അത് കണ്ടെത്താനാകും
ഓരോ ചെക്ക്സം അന്വേഷണവും പൂർത്തിയായ ഉടൻ തന്നെ STATUS. ഇതിനായി നിങ്ങൾ ഒരു പരിധി വ്യക്തമാക്കിയാൽ
ഈ വേരിയബിൾ, തുടർന്ന് അന്വേഷണങ്ങൾ പ്രവർത്തിക്കുന്നത് വരെ കാത്തിരിക്കാൻ നിങ്ങൾക്ക് ടൂളിനോട് നിർദ്ദേശിക്കാവുന്നതാണ്
സാധാരണ വീണ്ടും. എന്നിരുന്നാലും, ഇത് ക്യൂവിനെ തടയില്ല; അത് സെർവറിന് മാത്രമേ നൽകൂ
ക്യൂവിൽ നിന്ന് കരകയറാനുള്ള അവസരം. ക്യൂ നിൽക്കുന്നത് ശ്രദ്ധയിൽപ്പെട്ടാൽ കുറയ്ക്കുന്നതാണ് നല്ലത്
ചങ്ക് സമയം.
--password
ഹ്രസ്വ രൂപം: -p; തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: കണക്ഷൻ
ബന്ധിപ്പിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട പാസ്‌വേഡ്. പാസ്‌വേഡിൽ കോമകളുണ്ടെങ്കിൽ അവ രക്ഷപ്പെടണം
ഒരു ബാക്ക്സ്ലാഷ് ഉപയോഗിച്ച്: "പരീക്ഷ\,ple"
--pid
തരം: സ്ട്രിംഗ്
നൽകിയിരിക്കുന്ന PID ഫയൽ സൃഷ്ടിക്കുക. PID ഫയൽ നിലവിലുണ്ടെങ്കിൽ ടൂൾ ആരംഭിക്കില്ല
അതിൽ അടങ്ങിയിരിക്കുന്ന PID നിലവിലെ PID-യിൽ നിന്ന് വ്യത്യസ്തമാണ്. എന്നിരുന്നാലും, PID ഫയൽ ആണെങ്കിൽ
നിലവിലുണ്ട്, അതിൽ അടങ്ങിയിരിക്കുന്ന PID ഇനി പ്രവർത്തിക്കില്ല, ഉപകരണം PID പുനരാലേഖനം ചെയ്യും
നിലവിലെ PID ഉള്ള ഫയൽ. ടൂൾ പുറത്തുകടക്കുമ്പോൾ PID ഫയൽ സ്വയമേവ നീക്കം ചെയ്യപ്പെടും.
--പ്ലഗിൻ
തരം: സ്ട്രിംഗ്
ഒരു "pt_table_checksum_plugin" ക്ലാസ് നിർവചിക്കുന്ന Perl മൊഡ്യൂൾ ഫയൽ. ഒരു പ്ലഗിൻ നിങ്ങളെ അനുവദിക്കുന്നു
pt-table-checksum-ന്റെ പല ഭാഗങ്ങളിലേക്കും ഹുക്ക് ചെയ്യാൻ കഴിയുന്ന ഒരു Perl മൊഡ്യൂൾ എഴുതാൻ. ഈ
അതിനപ്പുറമുള്ള Perl, Percona ടൂൾകിറ്റ് കൺവെൻഷനുകളെ കുറിച്ച് നല്ല അറിവ് ആവശ്യമാണ്
ഈ ഡോക്യുമെന്റേഷന്റെ ഈ വ്യാപ്തി. നിങ്ങൾക്ക് എന്തെങ്കിലും ചോദ്യങ്ങളുണ്ടെങ്കിൽ അല്ലെങ്കിൽ പെർകോണയുമായി ബന്ധപ്പെടുക
സഹായം ആവശ്യമുണ്ട്.
കൂടുതൽ വിവരങ്ങൾക്ക് "പ്ലഗിൻ" കാണുക.
--പോർട്ട്
ഹ്രസ്വ രൂപം: -പി; തരം: int; ഗ്രൂപ്പ്: കണക്ഷൻ
കണക്ഷനായി ഉപയോഗിക്കേണ്ട പോർട്ട് നമ്പർ.
--പുരോഗതി
തരം: അറേ; സ്ഥിരസ്ഥിതി: സമയം,30
STDERR-ലേക്ക് പുരോഗതി റിപ്പോർട്ടുകൾ അച്ചടിക്കുക.
മൂല്യം രണ്ട് ഭാഗങ്ങളുള്ള കോമയാൽ വേർതിരിച്ച ലിസ്റ്റാണ്. ആദ്യ ഭാഗം ശതമാനം ആകാം,
സമയം, അല്ലെങ്കിൽ ആവർത്തനങ്ങൾ; ഒരു അപ്ഡേറ്റ് എത്ര തവണ പ്രിന്റ് ചെയ്യണമെന്ന് രണ്ടാം ഭാഗം വ്യക്തമാക്കുന്നു,
ശതമാനം, സെക്കൻഡുകൾ അല്ലെങ്കിൽ ആവർത്തനങ്ങളുടെ എണ്ണത്തിൽ. ടൂൾ പുരോഗതി റിപ്പോർട്ടുകൾ പ്രിന്റ് ചെയ്യുന്നു
സമയമെടുക്കുന്ന വൈവിധ്യമാർന്ന പ്രവർത്തനങ്ങൾ, പകർപ്പുകൾ ലഭിക്കാൻ കാത്തിരിക്കുന്നത് ഉൾപ്പെടെ
അവർ മന്ദഗതിയിലാകുന്നു.
--നിശബ്ദമായി
ഹ്രസ്വ രൂപം: -q; സഞ്ചിത: അതെ; സ്ഥിരസ്ഥിതി: 0
ഏറ്റവും പ്രധാനപ്പെട്ട വിവരങ്ങൾ മാത്രം പ്രിന്റ് ചെയ്യുക ("--പ്രോഗ്രസ്സ്" പ്രവർത്തനരഹിതമാക്കുന്നു). ഇത് വ്യക്തമാക്കുന്നത്
ഒരിക്കൽ ഓപ്ഷൻ പിശകുകൾ, മുന്നറിയിപ്പുകൾ, പട്ടികകൾ എന്നിവ മാത്രം പ്രിന്റ് ചെയ്യാൻ ടൂളിനെ പ്രേരിപ്പിക്കുന്നു
ചെക്ക്സം വ്യത്യാസങ്ങൾ.
ഈ ഓപ്ഷൻ രണ്ടുതവണ വ്യക്തമാക്കുന്നത് ടൂളിൽ പിശകുകൾ മാത്രം പ്രിന്റ് ചെയ്യാൻ കാരണമാകുന്നു. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ
എന്തെങ്കിലും മുന്നറിയിപ്പുകളോ ചെക്ക്‌സമോ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ ഉപകരണത്തിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് ഉപയോഗിക്കാം
വ്യത്യാസങ്ങൾ.
--ആവർത്തനം
തരം: int
പകർപ്പുകൾ കണ്ടെത്തുമ്പോൾ ശ്രേണിയിൽ ആവർത്തിക്കേണ്ട ലെവലുകളുടെ എണ്ണം. സ്ഥിരസ്ഥിതിയാണ്
അനന്തമായ. "--റിക്കർഷൻ-രീതി", "റെപ്ലിക്ക ചെക്കുകൾ" എന്നിവയും കാണുക.
--ആവർത്തന-രീതി
തരം: അറേ; സ്ഥിരസ്ഥിതി: പ്രോസസ്സ്ലിസ്റ്റ്, ഹോസ്റ്റുകൾ
പകർപ്പുകൾ കണ്ടെത്തുന്നതിന് തിരഞ്ഞെടുത്ത ആവർത്തന രീതി. pt-table-checksum നിർവഹിക്കുന്നു
പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പും പ്രവർത്തിക്കുമ്പോഴും നിരവധി "റെപ്ലിക്ക ചെക്കുകൾ".
pt-table-checksum പ്രവർത്തിപ്പിക്കുന്നതിന് പകർപ്പുകൾ ആവശ്യമില്ലെങ്കിലും, ടൂളിന് കണ്ടെത്താൻ കഴിയില്ല
അത് കണ്ടെത്താൻ കഴിയാത്ത അടിമകളിൽ വ്യത്യാസമുണ്ട്. അതിനാൽ, ഒരു മുന്നറിയിപ്പ് അച്ചടിച്ചിരിക്കുന്നു
പകർപ്പുകളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ "എക്സിറ്റ് സ്റ്റാറ്റസ്" പൂജ്യമല്ല, രീതി "ഒന്നുമില്ല" അല്ല. എങ്കിൽ
ഇത് സംഭവിക്കുന്നു, മറ്റൊരു ആവർത്തന രീതി പരീക്ഷിക്കുക, അല്ലെങ്കിൽ വ്യക്തമാക്കുന്നതിന് "dsn" രീതി ഉപയോഗിക്കുക
പരിശോധിക്കാനുള്ള പകർപ്പുകൾ.
സാധ്യമായ രീതികൾ ഇവയാണ്:
രീതി ഉപയോഗങ്ങൾ
===================================================== ======
പ്രോസസ്സ്ലിസ്റ്റ് പ്രോസസ്സ്ലിസ്റ്റ് കാണിക്കുക
ഹോസ്റ്റുകൾ സ്ലേവ് ഹോസ്റ്റുകൾ കാണിക്കുന്നു
'wsrep\_incoming\_addresses' പോലെയുള്ള ക്ലസ്റ്റർ സ്റ്റാറ്റസ് കാണിക്കുക
dsn=ഒരു ടേബിളിൽ നിന്നുള്ള DSN DSN-കൾ
ആരും അടിമകളെ കണ്ടെത്തരുത്
"പ്രോസസ്‌ലിസ്റ്റ്" രീതി ഡിഫോൾട്ടാണ്, കാരണം "സ്ലേവ് ഹോസ്റ്റുകൾ കാണിക്കുക" എന്നത് വിശ്വസനീയമല്ല.
എന്നിരുന്നാലും, സെർവർ ഒരു നോൺ-സ്റ്റാൻഡേർഡ് പോർട്ട് ഉപയോഗിക്കുന്നുവെങ്കിൽ (3306 അല്ല), പിന്നെ "ഹോസ്റ്റുകൾ" രീതി
ഈ സാഹചര്യത്തിൽ ഇത് മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നതിനാൽ ഡിഫോൾട്ടായി മാറുന്നു.
"hosts" രീതിക്ക് "report_host" ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്യേണ്ട പകർപ്പുകൾ ആവശ്യമാണ്,
"report_port" മുതലായവ.
"ക്ലസ്റ്റർ" രീതിക്ക് Galera 23.7.3 അല്ലെങ്കിൽ പുതിയത് അടിസ്ഥാനമാക്കിയുള്ള ഒരു ക്ലസ്റ്റർ ആവശ്യമാണ്.
Percona XtraDB ക്ലസ്റ്റർ പതിപ്പുകൾ 5.5.29-ഉം അതിനുമുകളിലും. ഇത് a-യിലെ നോഡുകൾ സ്വയമേവ കണ്ടെത്തും
"wsrep\_incoming\_addresses' പോലെയുള്ള സ്റ്റാറ്റസ് കാണിക്കുക" ഉപയോഗിക്കുന്ന ക്ലസ്റ്റർ. നിങ്ങൾക്ക് സംയോജിപ്പിക്കാം
ക്ലസ്റ്റർ നോഡുകളും പകർപ്പുകളും സ്വയമേവ കണ്ടെത്തുന്നതിന് "പ്രോസസ്‌ലിസ്റ്റും" "ഹോസ്റ്റുകളും" ഉള്ള "ക്ലസ്റ്റർ",
എന്നാൽ ഈ പ്രവർത്തനം പരീക്ഷണാത്മകമാണ്.
"dsn" രീതി സവിശേഷമാണ്: തനിയെ പകർപ്പുകൾ കണ്ടെത്തുന്നതിനുപകരം, ഇത്
രീതി DSN-കളുള്ള ഒരു പട്ടിക വ്യക്തമാക്കുന്നു. ഉപകരണം ഇവയുമായി മാത്രമേ ബന്ധിപ്പിക്കുകയുള്ളൂ
പകർപ്പുകൾ. ഒരേ MySQL ഉപയോക്തൃനാമം അല്ലെങ്കിൽ പകർപ്പുകൾ ഉപയോഗിക്കാത്തപ്പോൾ ഈ രീതി നന്നായി പ്രവർത്തിക്കുന്നു
മാസ്റ്ററായി പാസ്‌വേഡ്, അല്ലെങ്കിൽ ഉപകരണം കണക്റ്റുചെയ്യുന്നതിൽ നിന്ന് തടയാൻ നിങ്ങൾ താൽപ്പര്യപ്പെടുമ്പോൾ
ചില പകർപ്പുകൾ. "dsn" രീതി ഇതുപോലെ വ്യക്തമാക്കിയിരിക്കുന്നു: "--recursion-method
dsn=h=host,D=percona,t=dsns". നിർദ്ദിഷ്ട DSN-ന് D, t ഭാഗങ്ങൾ ഉണ്ടായിരിക്കണം, അല്ലെങ്കിൽ ഒരു
DSN പട്ടിക വ്യക്തമാക്കുന്ന ഡാറ്റാബേസ്-യോഗ്യതയുള്ള t ഭാഗം. DSN പട്ടികയിൽ ഉണ്ടായിരിക്കണം
ഇനിപ്പറയുന്ന ഘടന:
പട്ടിക സൃഷ്ടിക്കുക `dsns` (
`id` int(11) ശൂന്യമായ ഓട്ടോ_ഇൻക്രിമെന്റ് അല്ല,
`രക്ഷാകർതൃ_ഐഡി` int(11) ഡിഫോൾട്ട് NULL,
`dsn` varchar(255) ശൂന്യമല്ല,
പ്രൈമറി കീ (`ഐഡി`)
);
DSN-കൾ ഓർഡർ ചെയ്തിരിക്കുന്നത് "id" ആണ്, എന്നാൽ "id", "parent_id" എന്നിവ അവഗണിക്കപ്പെടും. "ഡിഎസ്എൻ"
കോളത്തിൽ കമാൻഡ് ലൈനിൽ നൽകിയിരിക്കുന്നത് പോലെ ഒരു പകർപ്പ് DSN അടങ്ങിയിരിക്കുന്നു, ഉദാഹരണത്തിന്:
"h=replica_host,u=repl_user,p=repl_pass".
"ഒന്നുമില്ല" രീതി ടൂളിനെ എല്ലാ സ്ലേവുകളേയും ക്ലസ്റ്റർ നോഡുകളേയും അവഗണിക്കുന്നു. ഈ രീതി
ഇത് "REPLICA ചെക്കുകൾ" ഫലപ്രദമായി പ്രവർത്തനരഹിതമാക്കുന്നതിനാൽ ശുപാർശ ചെയ്തിട്ടില്ല
വ്യത്യാസങ്ങൾ കണ്ടെത്താൻ കഴിയും. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ചെക്ക്സം മാത്രം എഴുതണമെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്
മാസ്റ്ററിലോ ഒരൊറ്റ ക്ലസ്റ്റർ നോഡിലോ. സുരക്ഷിതമായ ബദലാണ്
"--no-replicate-check": ടൂൾ പകർപ്പുകളും ക്ലസ്റ്റർ നോഡുകളും കണ്ടെത്തുന്നു,
"REPLICA ചെക്കുകൾ", എന്നാൽ വ്യത്യാസങ്ങൾ പരിശോധിക്കുന്നില്ല. "--[no]replicate-check" കാണുക.
--പ്രതികരിക്കുക
തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: percona.checksums
ഈ പട്ടികയിലേക്ക് ചെക്ക്സം ഫലങ്ങൾ എഴുതുക. പകർപ്പ് പട്ടികയിൽ ഈ ഘടന ഉണ്ടായിരിക്കണം
(MAGIC_create_replicate):
ടേബിൾ ചെക്ക്സം സൃഷ്ടിക്കുക (
db ടാങ്ക്(64) ശൂന്യമല്ല,
ടിബിഎൽ ടാങ്ക്(64) ശൂന്യമല്ല,
ചങ്ക് INT ശൂന്യമല്ല,
chunk_time FLOAT NULL,
ചങ്ക്_ഇൻഡക്സ് വർചാർ(200) NULL,
ലോവർ_ബൗണ്ടറി വാചകം NULL,
മുകളിലെ_അതിർത്തി വാചകം NULL,
ഇത്_crc ടാങ്ക്(40) ശൂന്യമല്ല,
this_cnt INT NULL അല്ല,
master_crc ടാങ്ക്(40) NULL,
master_cnt INT NULL,
ts TIMESTAMP അസാധുവായ ഡിഫോൾട്ട് CURRENT_TIMESTAMP അപ്ഡേറ്റിൽ CURRENT_TIMESTAMP,
പ്രൈമറി കീ (db, tbl, ചങ്ക്),
INDEX ts_db_tbl (ts, db, tbl)
) എഞ്ചിൻ=InnoDB;
ശ്രദ്ധിക്കുക: ലോവർ_ബൗണ്ടറി, അപ്പർ_ബൗണ്ടറി ഡാറ്റ തരം BLOB ആകാം. "--ബൈനറി-ഇൻഡക്സ്" കാണുക.
സ്ഥിരസ്ഥിതിയായി, "--[no]replicate-table" എന്നത് ശരിയാണ്, അതിനാൽ ഡാറ്റാബേസും പട്ടികയും
ഈ ഓപ്ഷൻ വ്യക്തമാക്കിയവ നിലവിലില്ലെങ്കിൽ സ്വയമേവ സൃഷ്‌ടിക്കപ്പെടും.
റെപ്ലിക്കേറ്റ് ടേബിളിന് അനുയോജ്യമായ ഒരു സ്റ്റോറേജ് എഞ്ചിൻ തിരഞ്ഞെടുക്കുന്നത് ഉറപ്പാക്കുക. നിങ്ങളാണെങ്കിൽ
InnoDB ടേബിളുകൾ പരിശോധിക്കുന്നു, നിങ്ങൾ ഈ ടേബിളിനായി MyISAM ഉപയോഗിക്കുന്നു, ഒരു ഡെഡ്‌ലോക്ക് തകരും
അനുകരണം, കാരണം ഇടപാട്, ഇടപാട് ഇതര പട്ടികകളുടെ മിശ്രിതം
ചെക്ക്സം സ്റ്റേറ്റ്‌മെന്റുകൾ അത് ബിൻലോഗിൽ എഴുതാൻ ഇടയാക്കും
പിശക്. അത് പിന്നീട് പകർപ്പുകളിൽ ഒരു തടസ്സവുമില്ലാതെ വീണ്ടും പ്ലേ ചെയ്യും, കൂടാതെ പകർപ്പ് തകർക്കും
"യജമാനന്റെയും അടിമയുടെയും വ്യത്യസ്ത പിശക്" ഉപയോഗിച്ച്. ഇത് pt-table-ന്റെ പ്രശ്നമല്ല-
ചെക്ക്സം; ഇത് MySQL റെപ്ലിക്കേഷനിലെ ഒരു പ്രശ്നമാണ്, നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാൻ കഴിയും
MySQL മാനുവൽ.
പകർപ്പ് പട്ടിക ഒരിക്കലും പരിശോധിക്കില്ല (ഉപകരണം ഈ പട്ടികയിലേക്ക് സ്വയമേവ ചേർക്കുന്നു
"--പട്ടികകൾ അവഗണിക്കുക").
--[ഇല്ല]റെപ്ലിക്കേറ്റ്-ചെക്ക്
സ്ഥിരസ്ഥിതി: അതെ
ഓരോ ടേബിളും പൂർത്തിയാക്കിയ ശേഷം ഡാറ്റ വ്യത്യാസങ്ങൾക്കായി പകർപ്പുകൾ പരിശോധിക്കുക. ഉപകരണം കണ്ടെത്തുന്നു
കണ്ടെത്തിയ എല്ലാ പകർപ്പുകളിലും ഒരു ലളിതമായ SELECT പ്രസ്താവന നടപ്പിലാക്കുന്നതിലൂടെ വ്യത്യാസങ്ങൾ. ദി
ചോദ്യം റെപ്ലിക്കയുടെ ചെക്ക്സം ഫലങ്ങളെ മാസ്റ്ററുടെ ചെക്ക്സം ഫലങ്ങളുമായി താരതമ്യം ചെയ്യുന്നു. അത്
ഔട്ട്പുട്ടിന്റെ DIFFS നിരയിലെ വ്യത്യാസങ്ങൾ റിപ്പോർട്ടുചെയ്യുന്നു.
--replicate-check-only
ചെക്ക്സം അന്വേഷണങ്ങൾ നടത്താതെ തന്നെ സ്ഥിരതയ്ക്കായി പകർപ്പുകൾ പരിശോധിക്കുക. ഈ ഓപ്ഷൻ ആണ്
"--[no]replicate-check" ഉപയോഗിച്ച് മാത്രം ഉപയോഗിക്കുന്നു. വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, pt-table-checksum ഇല്ല
ഏതെങ്കിലും പട്ടികകൾ പരിശോധിക്കുക. മുമ്പ് കണ്ടെത്തിയ വ്യത്യാസങ്ങൾക്കായി ഇത് പകർപ്പുകൾ പരിശോധിക്കുന്നു
ചെക്ക്സമ്മിംഗ്, തുടർന്ന് പുറത്തുകടക്കുന്നു. നിങ്ങൾ pt-table-checksum നിശബ്ദമായി പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ അത് ഉപയോഗപ്രദമായിരിക്കും
ഒരു ക്രോൺ ജോലിയിൽ, ഉദാഹരണത്തിന്, ക്രോൺ ജോലിയുടെ ഫലങ്ങളെക്കുറിച്ച് പിന്നീട് ഒരു റിപ്പോർട്ട് വേണം,
ഒരുപക്ഷേ ഒരു നാഗിയോസ് പരിശോധന നടപ്പിലാക്കാൻ.
--replicate-check-retriries
തരം: int; സ്ഥിരസ്ഥിതി: 1
ഒരു വ്യത്യാസം നേരിടുമ്പോൾ, ചെക്ക്സം താരതമ്യം ചെയ്യാൻ വീണ്ടും ശ്രമിക്കുക. അപ്പോൾ മാത്രം
ഈ ചെക്കുകളുടെ എണ്ണം സാധുതയുള്ളതായി കണക്കാക്കിയതിന് ശേഷവും ഒരു വ്യത്യാസം നിലനിൽക്കുന്നു. ഇത് ഉപയോഗിച്ച്
രണ്ടോ അതിലധികമോ മൂല്യമുള്ള ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ ഉണ്ടാകുന്ന വ്യാജ വ്യത്യാസങ്ങൾ ലഘൂകരിക്കുന്നു
--resume ഓപ്ഷൻ.
--replicate-database
തരം: സ്ട്രിംഗ്
ഈ ഡാറ്റാബേസ് മാത്രം ഉപയോഗിക്കുക. സ്ഥിരസ്ഥിതിയായി, pt-table-checksum എന്നത് തിരഞ്ഞെടുക്കാൻ USE എക്സിക്യൂട്ട് ചെയ്യുന്നു
നിലവിൽ പ്രവർത്തിക്കുന്ന പട്ടിക അടങ്ങുന്ന ഡാറ്റാബേസ്. ഇതൊരു മികച്ച ശ്രമമാണ്
binlog_ignore_db പോലുള്ള റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകളിലെ പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ
replicate_ignore_db. എന്നിരുന്നാലും, റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾക്ക് അവിടെ ഒരു സാഹചര്യം സൃഷ്ടിക്കാൻ കഴിയും
കാര്യങ്ങൾ ചെയ്യാൻ ആരും ശരിയായ മാർഗമല്ല. ചില പ്രസ്താവനകൾ ആവർത്തിക്കാനിടയില്ല, കൂടാതെ
മറ്റുള്ളവ അനുകരണം പരാജയപ്പെടാൻ കാരണമായേക്കാം. അത്തരം സന്ദർഭങ്ങളിൽ, നിങ്ങൾക്ക് ഈ ഓപ്ഷൻ ഉപയോഗിക്കാം
USE-നൊപ്പം pt-table-checksum തിരഞ്ഞെടുക്കുന്ന, ഒരിക്കലും മാറാത്ത ഒരു സ്ഥിരസ്ഥിതി ഡാറ്റാബേസ് വ്യക്തമാക്കുക.
"--[no]check-replication-filters" എന്നതും കാണുക.
--പുനരാരംഭിക്കുക
അവസാനം പൂർത്തിയാക്കിയ ചങ്കിൽ നിന്ന് ചെക്ക്സംമിംഗ് പുനരാരംഭിക്കുക (അപ്രാപ്തമാക്കുന്നു
"--[ഇല്ല]ശൂന്യമായ-പകർപ്പ്-പട്ടിക"). എല്ലാ പട്ടികകളും പരിശോധിക്കുന്നതിന് മുമ്പ് ഉപകരണം നിർത്തിയാൽ,
ഈ ഓപ്ഷൻ അവസാന പട്ടികയുടെ അവസാന ഭാഗത്തിൽ നിന്ന് ചെക്ക്സംമിംഗ് പുനരാരംഭിക്കുന്നു
പൂർത്തിയായി.
--വീണ്ടും ശ്രമിക്കുന്നു
തരം: int; സ്ഥിരസ്ഥിതി: 2
മാരകമല്ലാത്ത ഒരു പിശക് ഉണ്ടാകുമ്പോൾ ഇത് പലതവണ വീണ്ടും ശ്രമിക്കുക. മാരകമല്ലാത്ത പിശകുകളാണ്
ലോക്ക് കാത്തിരിപ്പ് സമയപരിധി അല്ലെങ്കിൽ ചോദ്യം നശിപ്പിക്കപ്പെടുന്നത് പോലുള്ള പ്രശ്നങ്ങൾ.
--റൺ-ടൈം
തരം: സമയം
എത്ര നേരം ഓടണം. എല്ലാ ടേബിളുകളും പരിശോധിക്കുന്നത് വരെ പ്രവർത്തിക്കുന്നതാണ് ഡിഫോൾട്ട്. ഇവ
സമയ മൂല്യ സഫിക്സുകൾ അനുവദനീയമാണ്: s (സെക്കൻഡ്), m (മിനിറ്റ്), h (മണിക്കൂറുകൾ), d (ദിവസങ്ങൾ).
ഈ ഓപ്ഷൻ "--resume" എന്നതുമായി സംയോജിപ്പിച്ച് ഒരു അനുവദിച്ചിട്ടുള്ള അത്രയും ടേബിളുകൾ ചെക്ക്സം ചെയ്യുക
സമയം, അടുത്ത തവണ പ്രവർത്തിപ്പിക്കുമ്പോൾ ഉപകരണം നിർത്തിയിടത്ത് നിന്ന് പുനരാരംഭിക്കുന്നു.
--സെപ്പറേറ്റർ
തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: #
ഇതിനായി ഉപയോഗിക്കുന്ന സെപ്പറേറ്റർ പ്രതീകം CONCAT_WS(). ചേരാൻ ഈ പ്രതീകം ഉപയോഗിക്കുന്നു
ചെക്ക്സമ്മിംഗ് ചെയ്യുമ്പോൾ നിരകളുടെ മൂല്യങ്ങൾ.
--set-vars
തരം: അറേ; ഗ്രൂപ്പ്: കണക്ഷൻ
"വേരിയബിൾ=മൂല്യം" ജോഡികളുടെ കോമയാൽ വേർതിരിച്ച ഈ ലിസ്റ്റിൽ MySQL വേരിയബിളുകൾ സജ്ജമാക്കുക.
സ്ഥിരസ്ഥിതിയായി, ഉപകരണം സജ്ജമാക്കുന്നു:
wait_timeout=10000
innodb_lock_wait_timeout=1
കമാൻഡ് ലൈനിൽ വ്യക്തമാക്കിയിരിക്കുന്ന വേരിയബിളുകൾ ഈ ഡിഫോൾട്ടുകളെ അസാധുവാക്കുന്നു. ഉദാഹരണത്തിന്,
"--set-vars wait_timeout=500" വ്യക്തമാക്കുന്നത് 10000-ന്റെ സ്ഥിര മൂല്യത്തെ മറികടക്കുന്നു.
ഉപകരണം ഒരു മുന്നറിയിപ്പ് പ്രിന്റ് ചെയ്യുകയും ഒരു വേരിയബിൾ സജ്ജമാക്കാൻ കഴിയുന്നില്ലെങ്കിൽ തുടരുകയും ചെയ്യുന്നു.
--സോക്കറ്റ്
ചെറു വാക്കുകൾ; തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: കണക്ഷൻ
കണക്ഷനായി ഉപയോഗിക്കേണ്ട സോക്കറ്റ് ഫയൽ.
--പട്ടികകൾ
ഹ്രസ്വ രൂപം: -t; തരം: ഹാഷ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ കോമയാൽ വേർതിരിച്ച പട്ടികകളുടെ പട്ടിക മാത്രം ചെക്ക്സം ചെയ്യുക. പട്ടികയുടെ പേരുകൾക്ക് യോഗ്യത ഉണ്ടായിരിക്കാം
ഡാറ്റാബേസ് നാമം.
--tables-regex
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ഫിൽട്ടർ
ഈ Perl regex-ന്റെ പേരുകളുമായി പൊരുത്തപ്പെടുന്ന പട്ടികകൾ മാത്രം ചെക്ക്സം.
--ട്രിം
ചേർക്കുക TRIM() VARCHAR നിരകളിലേക്ക് (4.1 മുതൽ >= 5.0 വരെ താരതമ്യം ചെയ്യുമ്പോൾ സഹായിക്കുന്നു). ഇത് ഉപയോഗപ്രദമാണ്
MySQL പതിപ്പുകൾക്കിടയിലുള്ള സ്പേസ് വ്യത്യാസങ്ങൾ നിങ്ങൾ ശ്രദ്ധിക്കുന്നില്ല
ട്രെയിലിംഗ് ഇടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിൽ വ്യത്യാസമുണ്ട്. MySQL 5.0 ഉം പിന്നീടുള്ളവയും ട്രെയിലിംഗ് നിലനിർത്തുന്നു
VARCHAR-ലെ സ്‌പെയ്‌സുകൾ, മുമ്പത്തെ പതിപ്പുകൾ അവ നീക്കം ചെയ്യും. ഈ വ്യത്യാസങ്ങൾ ചെയ്യും
തെറ്റായ ചെക്ക്സം വ്യത്യാസങ്ങൾ ഉണ്ടാക്കുക.
--ഉപയോക്താവ്
ഹ്രസ്വ രൂപം: -u; തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: കണക്ഷൻ
നിലവിലെ ഉപയോക്താവല്ലെങ്കിൽ ലോഗിൻ ചെയ്യാനുള്ള ഉപയോക്താവ്.
--പതിപ്പ്
ഗ്രൂപ്പ്: സഹായം
പതിപ്പ് കാണിച്ച് പുറത്തുകടക്കുക.
--[ഇല്ല]പതിപ്പ്-പരിശോധന
സ്ഥിരസ്ഥിതി: അതെ
Percona Toolkit, MySQL, മറ്റ് പ്രോഗ്രാമുകൾ എന്നിവയുടെ ഏറ്റവും പുതിയ പതിപ്പിനായി പരിശോധിക്കുക.
ഇത് ഒരു സ്റ്റാൻഡേർഡ് "അപ്ഡേറ്റുകൾക്കായി യാന്ത്രികമായി പരിശോധിക്കുക" സവിശേഷതയാണ്, കൂടാതെ രണ്ട് അധികവും
ഫീച്ചറുകൾ. ആദ്യം, ടൂൾ ലോക്കൽ സിസ്റ്റത്തിലെ മറ്റ് പ്രോഗ്രാമുകളുടെ പതിപ്പ് പരിശോധിക്കുന്നു
സ്വന്തം പതിപ്പിന് പുറമേ. ഉദാഹരണത്തിന്, ഇത് എല്ലാ MySQL സെർവറിന്റെയും പതിപ്പ് പരിശോധിക്കുന്നു
ഇത് Perl, Perl മൊഡ്യൂൾ DBD::mysql എന്നിവയുമായി ബന്ധിപ്പിക്കുന്നു. രണ്ടാമതായി, അത് പരിശോധിക്കുകയും മുന്നറിയിപ്പ് നൽകുകയും ചെയ്യുന്നു
അറിയപ്പെടുന്ന പ്രശ്നങ്ങളുള്ള പതിപ്പുകളെക്കുറിച്ച്. ഉദാഹരണത്തിന്, MySQL 5.5.25-ന് ഒരു നിർണായക ബഗ് ഉണ്ടായിരുന്നു
5.5.25a ആയി വീണ്ടും റിലീസ് ചെയ്തു.
ഏതെങ്കിലും അപ്‌ഡേറ്റുകളോ അറിയപ്പെടുന്ന പ്രശ്‌നങ്ങളോ ടൂളിന്റെ സാധാരണ ഔട്ട്‌പുട്ടിന് മുമ്പ് STDOUT-ലേക്ക് പ്രിന്റ് ചെയ്യപ്പെടും.
ഈ സവിശേഷത ഒരിക്കലും ഉപകരണത്തിന്റെ സാധാരണ പ്രവർത്തനത്തെ തടസ്സപ്പെടുത്തരുത്.
കൂടുതൽ വിവരങ്ങൾക്ക്, സന്ദർശിക്കുക .
--എവിടെ
തരം: സ്ട്രിംഗ്
ഈ WHERE ക്ലോസുമായി പൊരുത്തപ്പെടുന്ന വരികൾ മാത്രം ചെയ്യുക. പരിമിതപ്പെടുത്താൻ നിങ്ങൾക്ക് ഈ ഓപ്ഷൻ ഉപയോഗിക്കാം
പട്ടികയുടെ ഒരു ഭാഗത്തേക്ക് മാത്രം ചെക്ക്സം. നിങ്ങൾക്ക് അനുബന്ധം ഉണ്ടെങ്കിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്-
പട്ടികകൾ മാത്രം, എല്ലാ വരികളും നിരന്തരം വീണ്ടും പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നില്ല; നിങ്ങൾക്ക് ദൈനംദിന ജോലി നടത്താം
ഉദാഹരണത്തിന്, ഇന്നലത്തെ വരികൾ പരിശോധിക്കാൻ.
mysqldump-ലേക്കുള്ള -w ഓപ്ഷൻ പോലെയാണ് ഈ ഓപ്ഷൻ. എവിടെയാണെന്ന് വ്യക്തമാക്കരുത്
കീവേഡ്. നിങ്ങൾ മൂല്യം ഉദ്ധരിക്കേണ്ടി വന്നേക്കാം. ഒരു ഉദാഹരണം ഇതാ:
pt-table-checksum --എവിടെ "ts > CURRENT_DATE - INTERVAL 1 ദിവസം"
റെപ്ലിക്ക ചെക്കുകൾ
സ്ഥിരസ്ഥിതിയായി, pt-table-checksum കണക്റ്റുചെയ്‌തിരിക്കുന്ന എല്ലാ പകർപ്പുകളും കണ്ടെത്താനും കണക്‌റ്റ് ചെയ്യാനും ശ്രമിക്കുന്നു
മാസ്റ്റർ ഹോസ്റ്റ്. ഈ യാന്ത്രിക പ്രക്രിയയെ "സ്ലേവ് റിക്കർഷൻ" എന്ന് വിളിക്കുന്നു, ഇത് നിയന്ത്രിക്കുന്നത്
"--recursion-method", "--recurse" എന്നീ ഓപ്ഷനുകൾ. ഉപകരണം എല്ലാവരിലും ഈ പരിശോധനകൾ നടത്തുന്നു
പകർപ്പുകൾ:
1. "--[ഇല്ല] ചെക്ക്-റെപ്ലിക്കേഷൻ-ഫിൽട്ടറുകൾ"
pt-table-checksum എല്ലാ പകർപ്പുകളിലും റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾക്കായി പരിശോധിക്കുന്നു, കാരണം അവർക്ക് കഴിയും
ചെക്ക്സം പ്രക്രിയ സങ്കീർണ്ണമാക്കുക അല്ലെങ്കിൽ തകർക്കുക. ഡിഫോൾട്ടായി, ടൂൾ എന്തെങ്കിലും ഉണ്ടെങ്കിൽ പുറത്തുകടക്കും
റെപ്ലിക്കേഷൻ ഫിൽട്ടറുകൾ കണ്ടെത്തി, എന്നാൽ ഈ ചെക്ക് വ്യക്തമാക്കുന്നതിലൂടെ പ്രവർത്തനരഹിതമാക്കാം
"--നോ-ചെക്ക്-റെപ്ലിക്കേഷൻ-ഫിൽട്ടറുകൾ".
2. "--replicate" പട്ടിക
pt-table-checksum എല്ലാ പകർപ്പുകളിലും "--replicate" പട്ടിക നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കുന്നു.
മാസ്റ്റർ റെപ്ലിക്കേറ്റിലെ ടേബിളിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ ചെക്ക്‌സമ്മിംഗിന് റെപ്ലിക്കേഷൻ തകർക്കാൻ കഴിയും
മേശയില്ലാത്ത ഒരു പകർപ്പിലേക്ക്. ഈ പരിശോധനയും ഉപകരണവും പ്രവർത്തനരഹിതമാക്കാൻ കഴിയില്ല
"--പ്രോഗ്രസ്" സന്ദേശങ്ങൾ അച്ചടിച്ച് എല്ലാ പകർപ്പുകളിലും പട്ടിക നിലനിൽക്കുന്നതുവരെ എന്നേക്കും കാത്തിരിക്കുന്നു
അത് കാത്തിരിക്കുമ്പോൾ.
3. ഒറ്റ ചങ്ക് വലിപ്പം
ഒരു ടേബിൾ മാസ്റ്ററിൽ ഒരൊറ്റ ചങ്കിൽ ചെക്ക്സംമ് ചെയ്യാൻ കഴിയുമെങ്കിൽ, pt-table-checksum ചെയ്യും
എല്ലാ പകർപ്പുകളിലെയും പട്ടികയുടെ വലുപ്പം "--ചങ്ക്-സൈസ്" എന്നതിനേക്കാൾ കുറവാണോ എന്ന് പരിശോധിക്കുക *
"--ചങ്ക്-സൈസ്-ലിമിറ്റ്". ഇത് മാസ്റ്ററിലെ ടേബിൾ ഉള്ള ഒരു അപൂർവ പ്രശ്നത്തെ തടയുന്നു
ശൂന്യമോ ചെറുതോ, എന്നാൽ ഒരു പകർപ്പിൽ അത് വളരെ വലുതാണ്. ഈ സാഹചര്യത്തിൽ, ഒറ്റ ചങ്ക്
മാസ്റ്ററിലെ ചെക്ക്സം പകർപ്പ് ഓവർലോഡ് ചെയ്യും.
ഒരു പകർപ്പിലെ പട്ടികയുടെ വലുപ്പം അടുത്തായിരിക്കുമ്പോൾ മറ്റൊരു അപൂർവ പ്രശ്നം സംഭവിക്കുന്നു
"--ചങ്ക്-സൈസ്" * "--ചങ്ക്-സൈസ്-ലിമിറ്റ്". അത്തരം സന്ദർഭങ്ങളിൽ, മേശ കൂടുതലായിരിക്കും
ഒറ്റ ചങ്കിൽ ചെക്ക്സം സുരക്ഷിതമാണെങ്കിലും ഒഴിവാക്കി. കാരണം ഇത് സംഭവിക്കുന്നു
പട്ടികയുടെ വലുപ്പങ്ങൾ ഏകദേശ കണക്കുകളാണ്. ആ എസ്റ്റിമേറ്റുകളും "--ചങ്ക്-സൈസ്"* എപ്പോൾ
"--ചങ്ക്-സൈസ്-ലിമിറ്റ്" ഏതാണ്ട് തുല്യമാണ്, ഈ പരിശോധന കൂടുതൽ സെൻസിറ്റീവ് ആയി മാറുന്നു
ടേബിൾ വലുപ്പങ്ങളിലെ യഥാർത്ഥ കാര്യമായ വ്യത്യാസങ്ങളേക്കാൾ പിശകിന്റെ മാർജിൻ കണക്കാക്കുന്നു.
"--chunk-size-limit" എന്നതിനായി ഒരു വലിയ മൂല്യം വ്യക്തമാക്കുന്നത് ഈ പ്രശ്നം ഒഴിവാക്കാൻ സഹായിക്കുന്നു.
ഈ പരിശോധന പ്രവർത്തനരഹിതമാക്കാൻ കഴിയില്ല.
4. ലാഗ്
ഓരോ ചങ്കിനും ശേഷം, pt-table-checksum എല്ലാ പകർപ്പുകളിലെയും കാലതാമസം പരിശോധിക്കുന്നു, അല്ലെങ്കിൽ
"--ചെക്ക്-സ്ലേവ്-ലാഗ്" വ്യക്തമാക്കിയ പകർപ്പ്. ഓവർലോഡ് ചെയ്യാതിരിക്കാൻ ഇത് ഉപകരണത്തെ സഹായിക്കുന്നു
ചെക്ക്സം ഡാറ്റയുള്ള പകർപ്പുകൾ. ഈ പരിശോധന പ്രവർത്തനരഹിതമാക്കാൻ ഒരു മാർഗവുമില്ല, എന്നാൽ നിങ്ങൾക്ക് കഴിയും
"--ചെക്ക്-സ്ലേവ്-ലാഗ്" ഉപയോഗിച്ച് പരിശോധിക്കാൻ ഒരൊറ്റ പകർപ്പ് വ്യക്തമാക്കുക, ആ പകർപ്പ് ആണെങ്കിൽ
ഏറ്റവും വേഗതയേറിയത്, പകർപ്പ് കാലതാമസം കുറയുന്നതിന് ഉപകരണം കൂടുതൽ സമയം കാത്തിരിക്കുന്നത് തടയാൻ ഇത് സഹായിക്കും.
5. ചെക്ക്സം കഷണങ്ങൾ
pt-table-checksum ഒരു ടേബിൾ ചെക്ക്സമ്മിംഗ് പൂർത്തിയാക്കുമ്പോൾ, അത് അവസാന ചെക്ക്സത്തിനായി കാത്തിരിക്കുന്നു
എല്ലാ പകർപ്പുകളിലേക്കും പകർത്താൻ ചങ്ക്, അതിനാൽ ഇതിന് "--[ഇല്ല] റെപ്ലിക്കേറ്റ്-ചെക്ക്" ചെയ്യാൻ കഴിയും.
--no-replicate-check വ്യക്തമാക്കുന്നതിലൂടെ ആ ഓപ്ഷൻ പ്രവർത്തനരഹിതമാക്കുന്നത് ഈ പരിശോധന പ്രവർത്തനരഹിതമാക്കുന്നു, പക്ഷേ ഇത്
ചെക്ക്സം വ്യത്യാസങ്ങൾ ഉടനടി റിപ്പോർട്ടുചെയ്യുന്നതും പ്രവർത്തനരഹിതമാക്കുന്നു, അതുവഴി ഒരു സെക്കന്റ് ആവശ്യമാണ്
ചെക്ക്സം വ്യത്യാസങ്ങൾ കണ്ടെത്താനും പ്രിന്റ് ചെയ്യാനും "--replicate-check-only" ഉപയോഗിച്ച് ടൂൾ പ്രവർത്തിപ്പിക്കുക.
പ്ലഗിൻ
"--പ്ലഗിൻ" വ്യക്തമാക്കിയ ഫയൽ, വിളിക്കപ്പെടുന്ന ഒരു ക്ലാസ് (അതായത് ഒരു പാക്കേജ്) നിർവ്വചിക്കണം
"pt_table_checksum_plugin" ഒരു "പുതിയ()" സബ്റൂട്ടീനോടുകൂടിയാണ്. ഉപകരണം ഒരു ഉദാഹരണം സൃഷ്ടിക്കും
ഈ ക്ലാസ് കൂടാതെ അത് നിർവചിക്കുന്ന ഏതെങ്കിലും കൊളുത്തുകൾ വിളിക്കുക. കൊളുത്തുകളൊന്നും ആവശ്യമില്ല, എന്നാൽ ഒരു പ്ലഗിൻ ആവശ്യമില്ല
അവയില്ലാതെ വളരെ ഉപയോഗപ്രദമാണ്.
ഈ ഹുക്കുകൾ, ഈ ക്രമത്തിൽ, നിർവചിച്ചാൽ വിളിക്കപ്പെടുന്നു:
ഇവയെ
മുമ്പ്_replicate_check
after_replicate_check
ഗെറ്റ്_സ്ലേവ്_ലാഗ്
മുമ്പ്_ചെക്ക്സം_ടേബിൾ
after_checksum_table
ഓരോ കൊളുത്തും വ്യത്യസ്ത വാദങ്ങൾ പാസാക്കുന്നു. ഏതൊക്കെ വാദങ്ങളാണ് ഒരു ഹുക്കിലേക്ക് കൈമാറുന്നതെന്ന് കാണാൻ,
ടൂളിന്റെ സോഴ്സ് കോഡിൽ ഹുക്കിന്റെ പേര് തിരയുക:
# --പ്ലഗിൻ ഹുക്ക്
എങ്കിൽ ( $plugin && $plugin->('init') ) {
$plugin->init(
അടിമകൾ => $അടിമകൾ,
slave_lag_cxns => $slave_lag_cxns,
repl_table => $repl_table,
);
}
എല്ലാ ഹുക്ക് കോളിനും മുമ്പായി "# --പ്ലഗിൻ ഹുക്ക്" എന്ന അഭിപ്രായം ഉണ്ട്.
നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിലോ സഹായം ആവശ്യമുണ്ടെങ്കിലോ ദയവായി പെർകോണയുമായി ബന്ധപ്പെടുക.
ഡിഎസ്എൻ ഓപ്ഷനുകൾ
ഒരു DSN സൃഷ്ടിക്കാൻ ഈ DSN ഓപ്ഷനുകൾ ഉപയോഗിക്കുന്നു. ഓരോ ഓപ്ഷനും "option=value" പോലെ നൽകിയിരിക്കുന്നു.
ഓപ്ഷനുകൾ കേസ് സെൻസിറ്റീവ് ആയതിനാൽ പിയും പിയും ഒരേ ഓപ്ഷനല്ല. ഉണ്ടാകാൻ കഴിയില്ല
"=" എന്നതിന് മുമ്പോ ശേഷമോ വൈറ്റ്‌സ്‌പെയ്‌സ്, മൂല്യത്തിൽ വൈറ്റ്‌സ്‌പെയ്‌സ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ അത് ഉദ്ധരിക്കണം.
DSN ഓപ്ഷനുകൾ കോമയാൽ വേർതിരിച്ചിരിക്കുന്നു. പൂർണ്ണമായ വിശദാംശങ്ങൾക്ക് പെർകോണ-ടൂൾകിറ്റ് മാൻപേജ് കാണുക.
· എ
dsn: charset; പകർത്തുക: അതെ
ഡിഫോൾട്ട് പ്രതീക സെറ്റ്.
· ഡി
പകർത്തുക: ഇല്ല
DSN പട്ടിക ഡാറ്റാബേസ്.
· എഫ്
dsn: mysql_read_default_file; പകർത്തുക: അതെ
കണക്ഷൻ മൂല്യങ്ങൾക്കായുള്ള ഡിഫോൾട്ട് ഫയൽ.
. H.
dsn: ഹോസ്റ്റ്; പകർത്തുക: അതെ
ഹോസ്റ്റിലേക്ക് കണക്റ്റുചെയ്യുക.
· പി
dsn: രഹസ്യവാക്ക്; പകർത്തുക: അതെ
ബന്ധിപ്പിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട പാസ്‌വേഡ്. പാസ്‌വേഡിൽ കോമകളുണ്ടെങ്കിൽ അവ രക്ഷപ്പെടണം
ഒരു ബാക്ക്സ്ലാഷ് ഉപയോഗിച്ച്: "പരീക്ഷ\,ple"
· പി
dsn: പോർട്ട്; പകർത്തുക: അതെ
കണക്ഷനായി ഉപയോഗിക്കേണ്ട പോർട്ട് നമ്പർ.
. എസ്
dsn: mysql_socket; പകർത്തുക: ഇല്ല
കണക്ഷനായി ഉപയോഗിക്കേണ്ട സോക്കറ്റ് ഫയൽ.
· ടി
പകർത്തുക: ഇല്ല
DSN പട്ടിക പട്ടിക.
· യു
dsn: ഉപയോക്താവ്; പകർത്തുക: അതെ
നിലവിലെ ഉപയോക്താവല്ലെങ്കിൽ ലോഗിൻ ചെയ്യാനുള്ള ഉപയോക്താവ്.
ENVIRONMENT
പരിസ്ഥിതി വേരിയബിൾ "PTDEBUG" STDERR-ലേക്ക് വെർബോസ് ഡീബഗ്ഗിംഗ് ഔട്ട്പുട്ട് പ്രാപ്തമാക്കുന്നു. പ്രാപ്തമാക്കാൻ
ഡീബഗ്ഗ് ചെയ്ത് ഒരു ഫയലിലേക്ക് എല്ലാ ഔട്ട്‌പുട്ടും ക്യാപ്‌ചർ ചെയ്യുക, ടൂൾ പ്രവർത്തിപ്പിക്കുക:
PTDEBUG=1 pt-table-checksum ... > FILE 2>&1
ശ്രദ്ധിക്കുക: ഡീബഗ്ഗിംഗ് ഔട്ട്പുട്ട് വളരെ വലുതാണ് കൂടാതെ നിരവധി മെഗാബൈറ്റ് ഔട്ട്പുട്ട് സൃഷ്ടിക്കാൻ കഴിയും.
സിസ്റം ആവശ്യകതകൾ
നിങ്ങൾക്ക് Perl, DBI, DBD::mysql, കൂടാതെ ഏതെങ്കിലും ഒന്നിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ട ചില കോർ പാക്കേജുകളും ആവശ്യമാണ്.
Perl-ന്റെ ന്യായമായ പുതിയ പതിപ്പ്.
onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് pt-table-checksump ഓൺലൈനായി ഉപയോഗിക്കുക
