pt-killp - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

pt-kill - ചില മാനദണ്ഡങ്ങളുമായി പൊരുത്തപ്പെടുന്ന MySQL അന്വേഷണങ്ങൾ ഇല്ലാതാക്കുക.

സിനോപ്സിസ്

ഉപയോഗം: pt-kill [OPTIONS] [DSN]

pt-kill MySQL കണക്ഷനുകളെ നശിപ്പിക്കുന്നു. pt-kill MySQL-ലേക്ക് ബന്ധിപ്പിക്കുകയും ഷോയിൽ നിന്ന് ചോദ്യങ്ങൾ നേടുകയും ചെയ്യുന്നു
ഫയലൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ, പ്രോസസ്സ്ലിസ്റ്റ്. അല്ലെങ്കിൽ, ഇത് ഒന്നോ അതിലധികമോ ഫയലുകളിൽ നിന്നുള്ള ചോദ്യങ്ങൾ വായിക്കുന്നു
SHOW PROCESSLIST ന്റെ ഔട്ട്പുട്ട് അടങ്ങിയിരിക്കുന്നു. FILE ആണെങ്കിൽ -, pt-kill STDIN-ൽ നിന്ന് വായിക്കുന്നു.

60-കളിൽ കൂടുതൽ ദൈർഘ്യമുള്ള ചോദ്യങ്ങൾ ഇല്ലാതാക്കുക:

pt-kill --തിരക്കേറിയ സമയം 60 --kill

പ്രിന്റ് ചെയ്യുക, കൊല്ലരുത്, 60-കളിൽ കൂടുതൽ ദൈർഘ്യമുള്ള അന്വേഷണങ്ങൾ:

pt-kill --തിരക്കേറിയ സമയം 60 --print

സ്ലീപ്പിംഗ് പ്രക്രിയകൾ പരിശോധിക്കുകയും ഓരോ 10 സെക്കൻഡിലും അവരെ കൊല്ലുകയും ചെയ്യുക:

pt-kill --match-command Sleep --kill --victims all --interval 10

എല്ലാ ലോഗിൻ പ്രക്രിയകളും പ്രിന്റ് ചെയ്യുക:

pt-kill --match-state login --print --victims all

ഇപ്പോൾ പ്രോസസ്സ് ലിസ്റ്റിലെ ഏതൊക്കെ ചോദ്യങ്ങളാണ് പൊരുത്തപ്പെടുന്നതെന്ന് കാണുക:

mysql -e "പ്രോസസ്‌ലിസ്റ്റ് കാണിക്കുക" > proclist.txt
pt-kill --test-matching proclist.txt --busy-time 60 --print

അപകടസാധ്യതകൾ

പെർക്കോണ ടൂൾകിറ്റ് പ്രായപൂർത്തിയായതും യഥാർത്ഥ ലോകത്ത് തെളിയിക്കപ്പെട്ടതും നന്നായി പരീക്ഷിച്ചതും എന്നാൽ എല്ലാ ഡാറ്റാബേസും ആണ്
ടൂളുകൾ സിസ്റ്റത്തിനും ഡാറ്റാബേസ് സെർവറിനും അപകടമുണ്ടാക്കും. ഈ ഉപകരണം ഉപയോഗിക്കുന്നതിന് മുമ്പ്,
ദയവായി:

· ടൂളിന്റെ ഡോക്യുമെന്റേഷൻ വായിക്കുക

· ടൂളിന്റെ അറിയപ്പെടുന്ന "ബഗ്ഗുകൾ" അവലോകനം ചെയ്യുക

· ഒരു നോൺ-പ്രൊഡക്ഷൻ സെർവറിൽ ഉപകരണം പരിശോധിക്കുക

· നിങ്ങളുടെ പ്രൊഡക്ഷൻ സെർവർ ബാക്കപ്പ് ചെയ്യുകയും ബാക്കപ്പുകൾ പരിശോധിക്കുകയും ചെയ്യുക

വിവരണം

pt-kill SHOW PROCESSLIST-ൽ നിന്നുള്ള ചോദ്യങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുന്നു, അവ ഫിൽട്ടർ ചെയ്യുന്നു, തുടർന്ന് ഒന്നുകിൽ കൊല്ലുന്നു അല്ലെങ്കിൽ
അവരെ പ്രിന്റ് ചെയ്യുന്നു. ചില സർക്കിളുകളിൽ ഇത് "സ്ലോ ക്വറി സ്നൈപ്പർ" എന്നും അറിയപ്പെടുന്നു. എന്നതാണ് ആശയം
വളരെയധികം വിഭവങ്ങൾ ഉപയോഗിച്ചേക്കാവുന്ന ചോദ്യങ്ങൾക്കായി കാണുക, അവരെ കൊല്ലുക.

സംക്ഷിപ്‌തതയ്‌ക്കായി, ഞങ്ങൾ ചോദ്യങ്ങളെ കൊല്ലുന്നതിനെക്കുറിച്ചാണ് സംസാരിക്കുന്നത്, പക്ഷേ അവ പ്രിന്റ് ചെയ്‌തേക്കാം (അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും
ഭാവിയിലെ പ്രവർത്തനം) എന്ത് ഓപ്ഷനുകൾ നൽകിയിരിക്കുന്നു എന്നതിനെ ആശ്രയിച്ച്.

SHOW PROCESSLIST-ൽ നിന്ന് ചോദ്യങ്ങൾ ലഭിക്കുന്നതിന് സാധാരണയായി pt-kill MySQL-ലേക്ക് കണക്ട് ചെയ്യുന്നു. പകരമായി,
ഫയലുകളിൽ നിന്നുള്ള ഷോ പ്രോസസ്‌ലിസ്റ്റ് ഔട്ട്‌പുട്ട് വായിക്കാൻ ഇതിന് കഴിയും. ഈ സാഹചര്യത്തിൽ, pt-kill-ലേക്ക് കണക്റ്റുചെയ്യുന്നില്ല
MySQL, "--kill" എന്നിവയ്ക്ക് യാതൊരു ഫലവുമില്ല. ഫയലുകൾ വായിക്കുമ്പോൾ പകരം "--print" ഉപയോഗിക്കണം.
"--ടെസ്റ്റ്-മാച്ചിംഗ്" ഉപയോഗിച്ച് ഒരു ഫയൽ വായിക്കാനുള്ള കഴിവ്, SHOW PROCESSLIST ക്യാപ്‌ചർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു
നിങ്ങളുടെ പൊരുത്തങ്ങൾ ശരിയായ അന്വേഷണങ്ങളെ ഇല്ലാതാക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ pt-kill ഉപയോഗിച്ച് പിന്നീട് ഇത് പരീക്ഷിക്കുക.
"പ്രതികരണ ത്രെഡുകളെ കൊല്ലരുത്" എന്നതുപോലുള്ള ധാരാളം പ്രത്യേക നിയമങ്ങൾ പാലിക്കേണ്ടതുണ്ട്
പ്രധാനപ്പെട്ട എന്തെങ്കിലും കൊല്ലാതിരിക്കാൻ ശ്രദ്ധിക്കുക!

"--തിരക്കേറിയ സമയം", "--ഇരകൾ" എന്നിവയാണ് അറിയേണ്ട രണ്ട് പ്രധാന ഓപ്ഷനുകൾ. ആദ്യം, അതേസമയം മിക്കതും
മാച്ച്/ഫിൽട്ടർ ഓപ്‌ഷനുകൾ ഷോ പ്രോസസ്‌ലിസ്റ്റിൽ നിന്ന് അവയുടെ അനുബന്ധ മൂല്യവുമായി പൊരുത്തപ്പെടുന്നു (ഉദാ
"--മാച്ച്-കമാൻഡ്" ഒരു അന്വേഷണത്തിന്റെ കമാൻഡ് മൂല്യവുമായി പൊരുത്തപ്പെടുന്നു), സമയ മൂല്യം പൊരുത്തപ്പെടുത്തുന്നു
"--തിരക്കേറിയ സമയം". "--ഇന്റർവെൽ" എന്നതും കാണുക.

രണ്ടാമതായി, "--ഇരകൾ" ഓരോ ക്ലാസിൽ നിന്നും ഏത് പൊരുത്തമുള്ള ചോദ്യങ്ങളാണ് കൊല്ലപ്പെടുന്നത് എന്നത് നിയന്ത്രിക്കുന്നു. എഴുതിയത്
സ്ഥിരസ്ഥിതിയായി, ഏറ്റവും ഉയർന്ന സമയ മൂല്യമുള്ള പൊരുത്തമുള്ള ചോദ്യം നശിപ്പിക്കപ്പെടുന്നു (ഏറ്റവും പഴയ ചോദ്യം). കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് "ഗ്രൂപ്പ്, മാച്ച് ആൻഡ് കിൽ" എന്ന അടുത്ത വിഭാഗം.

സാധാരണയായി നിങ്ങൾ ഒരു "--മാച്ച്" ഓപ്ഷനെങ്കിലും വ്യക്തമാക്കേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം ചോദ്യങ്ങളൊന്നും പൊരുത്തപ്പെടില്ല.
അല്ലെങ്കിൽ, അവഗണിക്കാത്ത എല്ലാ ചോദ്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നതിന് നിങ്ങൾക്ക് "--മാച്ച്-എല്ലാം" വ്യക്തമാക്കാൻ കഴിയും
"--അവഗണിക്കുക" ഓപ്ഷൻ.

ഗ്രൂപ്പ്, മത്സരം ഒപ്പം കൊല്ലുക

ഏതാണ് കൃത്യമായി കൊല്ലപ്പെടുക (അല്ലെങ്കിൽ
അച്ചടിച്ചത്--നിർദിഷ്ട പ്രവർത്തനം). ഈ ഘട്ടങ്ങൾ മനസ്സിലാക്കുന്നത് പൊരുത്തപ്പെടാൻ നിങ്ങളെ സഹായിക്കും
കൃത്യമായി നിങ്ങൾ ആഗ്രഹിക്കുന്ന ചോദ്യങ്ങൾ.

ചോദ്യങ്ങളെ ക്ലാസുകളായി തരംതിരിക്കുക എന്നതാണ് ആദ്യപടി. "--group-by" ഓപ്ഷൻ നിയന്ത്രിക്കുന്നു
ഗ്രൂപ്പിംഗ്. ഡിഫോൾട്ടായി, ഈ ഓപ്ഷന് മൂല്യമില്ല, അതിനാൽ എല്ലാ ചോദ്യങ്ങളും ഒന്നായി തരംതിരിച്ചിരിക്കുന്നു
സ്ഥിരസ്ഥിതി ക്ലാസ്. എല്ലാ തരത്തിലുമുള്ള പൊരുത്തപ്പെടുത്തലും ഫിൽട്ടറിംഗും (അടുത്ത ഘട്ടം) ഓരോ ക്ലാസിലും പ്രയോഗിക്കുന്നു.
അതിനാൽ, ചില ക്ലാസുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന്/ഫിൽട്ടർ ചെയ്യുന്നതിന് നിങ്ങൾ ചോദ്യങ്ങൾ ഗ്രൂപ്പ് ചെയ്യേണ്ടതുണ്ട്, പക്ഷേ അല്ല
മറ്റുള്ളവർ.

രണ്ടാമത്തെ ഘട്ടം പൊരുത്തപ്പെടുത്തലാണ്. പൊരുത്തം എന്നത് ഒരു ചോദ്യം പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ മുതൽ ഫിൽട്ടറിംഗ് സൂചിപ്പിക്കുന്നു
ചില മാനദണ്ഡങ്ങൾ, അത് അതിന്റെ ക്ലാസിൽ നിന്ന് നീക്കം ചെയ്തു. ഓരോ ക്ലാസിനും പൊരുത്തം സംഭവിക്കുന്നു. ആദ്യം,
പോലുള്ള വിവിധ "ക്വറി പൊരുത്തങ്ങൾ" ഓപ്‌ഷനുകൾ വഴി ചോദ്യങ്ങളെ അവരുടെ ക്ലാസിൽ നിന്ന് ഫിൽട്ടർ ചെയ്യുന്നു
"--മാച്ച്-ഉപയോക്താവ്". തുടർന്ന്, മുഴുവൻ ക്ലാസുകളും വിവിധ "ക്ലാസ് മാച്ചുകൾ" ഓപ്ഷനുകൾ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നു
"--query-count" പോലെ.

മൂന്നാമത്തെ ഘട്ടം ഇരയെ തിരഞ്ഞെടുക്കുന്നതാണ്, അതായത്, കൊല്ലാൻ ഓരോ ക്ലാസിലും പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ.
"--ഇരകൾ" എന്ന ഓപ്‌ഷനാണ് ഇത് നിയന്ത്രിക്കുന്നത്. ഒരു ക്ലാസിലെ പല ചോദ്യങ്ങളും പൊരുത്തപ്പെടുമെങ്കിലും,
നിങ്ങൾക്ക് ഏറ്റവും പഴയ ചോദ്യം അല്ലെങ്കിൽ എല്ലാ ചോദ്യങ്ങളും നശിപ്പിക്കാൻ മാത്രമേ താൽപ്പര്യമുണ്ടാകൂ.

എല്ലാ ക്ലാസുകളിൽ നിന്നും പൊരുത്തപ്പെടുന്ന എല്ലാ ചോദ്യങ്ങളിലും ചില നടപടികളെടുക്കുക എന്നതാണ് നാലാമത്തെയും അവസാനത്തെയും ഘട്ടം.
"പ്രവർത്തനങ്ങൾ" ഓപ്‌ഷനുകൾ ഏതൊക്കെ പ്രവർത്തനങ്ങളാണ് സ്വീകരിക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്നു. ഈ ഘട്ടത്തിൽ, ഇല്ല
കൂടുതൽ ക്ലാസുകൾ, കൊല്ലാനും പ്രിന്റ് ചെയ്യാനുമുള്ള ചോദ്യങ്ങളുടെ ഒരൊറ്റ ലിസ്റ്റ്.

ഔട്ട്പ്

"--കിൽ" മാത്രം കൊടുത്താൽ പിന്നെ ഔട്ട്പുട്ട് ഇല്ല. "--പ്രിന്റ്" മാത്രം നൽകിയാൽ, എ
കൊല്ലപ്പെടുമായിരുന്ന ഓരോ ചോദ്യത്തിനും ടൈംസ്റ്റാമ്പ് ചെയ്ത KILL സ്റ്റേറ്റ്മെന്റ് പ്രിന്റ് ചെയ്‌താൽ:

# 2009-07-15T15:04:01 കൊല്ലുക 8 (ചോദ്യം 42 സെക്കൻഡ്) * വലിയ_ടേബിളിൽ നിന്ന് തിരഞ്ഞെടുക്കുക

ലൈൻ ഒരു ടൈംസ്റ്റാമ്പ് കാണിക്കുന്നു, അന്വേഷണത്തിന്റെ ഐഡി (8), അതിന്റെ സമയം (42 സെക്കൻഡ്), അതിന്റെ വിവരങ്ങൾ (സാധാരണയായി
ചോദ്യം SQL).

"--കിൽ", "--പ്രിന്റ്" എന്നിവ രണ്ടും നൽകിയാൽ, പൊരുത്തപ്പെടുന്ന അന്വേഷണങ്ങൾ കൊല്ലപ്പെടുകയും അതിനുള്ള ഒരു ലൈൻ
മുകളിലുള്ളതുപോലെ ഓരോന്നും അച്ചടിച്ചിരിക്കുന്നു.

"--എക്‌സിക്യൂട്ട്-കമാൻഡ്" നടപ്പിലാക്കുന്ന ഏതൊരു കമാൻഡും അതിന്റേതായ ഔട്ട്‌പുട്ടിനും ലോഗിംഗിനും ഉത്തരവാദിയാണ്.
എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, pt-kill-ന് കമാൻഡുമായി യാതൊരു നിയന്ത്രണമോ ഇടപെടലോ ഇല്ല.

ഓപ്ഷനുകൾ

"--kill", "--kill-query", "--print", "--execute-command" എന്നിവയിലൊന്നെങ്കിലും വ്യക്തമാക്കുക
"--നിർത്തുക".

"--ഏത് തിരക്കുള്ള സമയവും", "--ഓരോ തിരക്കുള്ള സമയവും" എന്നിവ പരസ്പരവിരുദ്ധമാണ്.

"--കിൽ", "--കിൽ-ക്വറി" എന്നിവ പരസ്പരവിരുദ്ധമാണ്.

"--ഡെമോണൈസ്", "--ടെസ്റ്റ്-മാച്ചിംഗ്" എന്നിവ പരസ്പരവിരുദ്ധമാണ്.

ഈ ടൂൾ അധിക കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ സ്വീകരിക്കുന്നു. "സിനോപ്സിസും" ഉപയോഗവും കാണുക
വിശദാംശങ്ങൾക്ക് വിവരങ്ങൾ.

--ചോദിക്കുക-പാസ്
MySQL-ലേക്ക് കണക്‌റ്റ് ചെയ്യുമ്പോൾ ഒരു പാസ്‌വേഡ് ആവശ്യപ്പെടുക.

--അക്ഷരഗണം
ഹ്രസ്വ രൂപം: -എ; തരം: സ്ട്രിംഗ്

ഡിഫോൾട്ട് പ്രതീക സെറ്റ്. മൂല്യം utf8 ആണെങ്കിൽ, STDOUT-ൽ Perl ന്റെ ബിൻമോഡ് utf8 ആയി സജ്ജീകരിക്കുന്നു,
mysql_enable_utf8 ഓപ്‌ഷൻ DBD::mysql-ലേക്ക് കടത്തിവിടുകയും ശേഷം SET NAMES UTF8 പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു
MySQL-ലേക്ക് ബന്ധിപ്പിക്കുന്നു. മറ്റേതെങ്കിലും മൂല്യം UTF8 ലെയർ ഇല്ലാതെ STDOUT-ൽ ബിൻമോഡ് സജ്ജമാക്കുന്നു,
MySQL-ലേക്ക് കണക്റ്റുചെയ്‌തതിന് ശേഷം SET NAMES പ്രവർത്തിപ്പിക്കുന്നു.

--config
തരം: അറേ

കോൺഫിഗറേഷൻ ഫയലുകളുടെ കോമയാൽ വേർതിരിച്ച ഈ ലിസ്റ്റ് വായിക്കുക; വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഇത് ആദ്യത്തേതായിരിക്കണം
കമാൻഡ് ലൈനിലെ ഓപ്ഷൻ.

--ലോഗ്-ടേബിൾ സൃഷ്ടിക്കുക
അത് നിലവിലില്ലെങ്കിൽ "--log-dsn" പട്ടിക സൃഷ്ടിക്കുക.

ഈ ഐച്ഛികം "--log-dsn" വ്യക്തമാക്കിയ പട്ടിക സ്ഥിരസ്ഥിതിയായി സൃഷ്ടിക്കുന്നതിന് കാരണമാകുന്നു
ആ ഓപ്ഷന്റെ ഡോക്യുമെന്റേഷനിൽ കാണിച്ചിരിക്കുന്ന ഘടന.

--ഡെമോണൈസ്
പശ്ചാത്തലത്തിലേക്ക് ഫോർക്ക് ചെയ്ത് ഷെല്ലിൽ നിന്ന് വേർപെടുത്തുക. POSIX ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ മാത്രം.

--ഡാറ്റാബേസ്
ഹ്രസ്വ രൂപം: -D; തരം: സ്ട്രിംഗ്

കണക്ഷനായി ഉപയോഗിക്കേണ്ട ഡാറ്റാബേസ്.

--defaults-file
ഹ്രസ്വ രൂപം: -F; തരം: സ്ട്രിംഗ്

നൽകിയിരിക്കുന്ന ഫയലിൽ നിന്ന് mysql ഓപ്ഷനുകൾ മാത്രം വായിക്കുക. നിങ്ങൾ ഒരു സമ്പൂർണ്ണ പാതയുടെ പേര് നൽകണം.

--ഫിൽട്ടർ
തരം: സ്ട്രിംഗ്

ഈ Perl കോഡ് ശരിയാകാത്ത ഇവന്റുകൾ നിരസിക്കുക.

ഈ ഓപ്‌ഷൻ പേൾ കോഡിന്റെ ഒരു സ്‌ട്രിംഗ് അല്ലെങ്കിൽ കംപൈൽ ചെയ്‌ത പേൾ കോഡ് അടങ്ങിയ ഫയലാണ്
ഒരു ആർഗ്യുമെന്റുള്ള സബ്റൂട്ടീനിലേക്ക്: $event. ഇതൊരു ഹാഷ്രെഫാണ്. നൽകിയ മൂല്യമാണെങ്കിൽ
വായിക്കാൻ കഴിയുന്ന ഒരു ഫയലാണ്, തുടർന്ന് pt-kill മുഴുവൻ ഫയലും വായിക്കുകയും അതിലെ ഉള്ളടക്കങ്ങൾ ആയി ഉപയോഗിക്കുകയും ചെയ്യുന്നു
കോഡ്. ഫയലിൽ ഒരു ഷെബാംഗ് അടങ്ങിയിരിക്കരുത് (#!/usr/bin/perl) ലൈൻ.

കോഡ് ശരിയാണെങ്കിൽ, കോൾബാക്കുകളുടെ ശൃംഖല തുടരും; അല്ലെങ്കിൽ അത് അവസാനിക്കുന്നു. ദി
"$event" എന്നതിന് പുറമെ സബ്റൂട്ടീനിലെ അവസാന പ്രസ്താവനയാണ് കോഡ്. ദി
സബ്റൂട്ടീൻ ടെംപ്ലേറ്റ് ഇതാണ്:

ഉപ {$ഇവന്റ് = ഷിഫ്റ്റ്; ഫിൽട്ടർ && തിരികെ $event; }

കമാൻഡ് ലൈനിൽ നൽകിയിരിക്കുന്ന ഫിൽട്ടറുകൾ "( ഫിൽട്ടർ
)". സങ്കീർണ്ണമായ, മൾട്ടി-ലൈൻ ഫിൽട്ടറുകൾക്ക്, നിങ്ങൾ ഒരു ഫയലിനുള്ളിൽ കോഡ് ഇടണം, അങ്ങനെ അത് ചെയ്യും
പരാൻതീസിസിനുള്ളിൽ പൊതിയരുത്. ഏതുവിധേനയും, ഫിൽട്ടർ വാക്യഘടനാപരമായി നിർമ്മിക്കണം
ടെംപ്ലേറ്റ് നൽകിയിരിക്കുന്ന സാധുവായ കോഡ്. ഉദാഹരണത്തിന്, കമാൻഡിൽ നൽകിയിരിക്കുന്ന if-else ബ്രാഞ്ച്
വരി സാധുവായിരിക്കില്ല:

--ഫിൽട്ടർ 'എങ്കിൽ () { } വേറെ {}' # തെറ്റാണ്

ഇത് കമാൻഡ് ലൈനിൽ നൽകിയിരിക്കുന്നതിനാൽ, if-else ബ്രാഞ്ച് ഉള്ളിൽ പൊതിഞ്ഞിരിക്കും
വാക്യഘടനാപരമായി സാധുതയില്ലാത്ത പരാൻതീസിസുകൾ. അതിനാൽ കൂടുതൽ സങ്കീർണ്ണമായ എന്തെങ്കിലും ചെയ്യാൻ
ഇതുപോലെ ഒരു ഫയലിൽ കോഡ് ഇടേണ്ടതുണ്ട്, ഉദാഹരണത്തിന് filter.txt:

എന്റെ $event_ok; എങ്കിൽ (...) {$event_ok=1; } മറ്റ് {$event_ok=0; } $event_ok

അപ്പോൾ filter.txt-ൽ നിന്നുള്ള കോഡ് വായിക്കാൻ "--filter filter.txt" വ്യക്തമാക്കുക.

ഫിൽട്ടർ കോഡ് കംപൈൽ ചെയ്യുന്നില്ലെങ്കിൽ, pt-kill ഒരു പിശകോടെ മരിക്കും. ഫിൽട്ടർ കോഡ് ആണെങ്കിൽ
കംപൈൽ ചെയ്യുന്നു, കോഡ് എന്തെങ്കിലും ചെയ്യാൻ ശ്രമിച്ചാൽ റൺടൈമിൽ ഒരു പിശക് സംഭവിക്കാം
തെറ്റ് (നിർവചിക്കാത്ത മൂല്യവുമായി പൊരുത്തപ്പെടുന്ന പാറ്റേൺ പോലെ). pt-kill ഒന്നും നൽകുന്നില്ല
സുരക്ഷാ സംവിധാനങ്ങൾ അതിനാൽ ശ്രദ്ധാപൂർവ്വം കോഡ് ചെയ്യുക!

കോഡിന് പാർശ്വഫലങ്ങൾ ഉണ്ടാകുന്നത് അനുവദനീയമാണ് ($ഇവന്റ് മാറ്റുന്നതിന്).

--ഗ്രൂപ്പ്-ബൈ
തരം: സ്ട്രിംഗ്

ഈ ഷോ പ്രോസസ്‌ലിസ്റ്റ് കോളം അനുസരിച്ച് ഗ്രൂപ്പുചെയ്‌ത ഓരോ ക്ലാസിലെ ചോദ്യങ്ങളിലേക്കും പൊരുത്തങ്ങൾ പ്രയോഗിക്കുക. ഇൻ
SHOW PROCESSLIST (ഉപയോക്താവ്, ഹോസ്റ്റ്, കമാൻഡ്, സംസ്ഥാനം മുതലായവ) അടിസ്ഥാന നിരകൾക്ക് പുറമെ
"വിവരങ്ങൾ" എന്നതിലെ SQL ചോദ്യം സംഗ്രഹിക്കുന്ന "വിരലടയാളം" ഉപയോഗിച്ച് അന്വേഷണങ്ങൾ പൊരുത്തപ്പെടുത്താനാകും.
കോളം.

ഡിഫോൾട്ടായി, അന്വേഷണങ്ങൾ ഗ്രൂപ്പ് ചെയ്തിട്ടില്ല, അതിനാൽ പൊരുത്തങ്ങളും പ്രവർത്തനങ്ങളും എല്ലാ ചോദ്യങ്ങൾക്കും ബാധകമാണ്.
സമാന ചോദ്യങ്ങളുടെ ക്ലാസുകളുണ്ടെങ്കിൽ, പൊരുത്തങ്ങളും പ്രവർത്തനങ്ങളും പ്രയോഗിക്കാൻ ഗ്രൂപ്പിംഗ് അനുവദിക്കുന്നു
ക്ലാസ് മത്സരത്തിലെ ചോദ്യങ്ങൾ.

ഉദാഹരണത്തിന്, കാഷെ സ്റ്റാമ്പെഡുകൾ കണ്ടെത്തൽ ("--ഇരകൾ" എന്നതിന് താഴെയുള്ള "എല്ലാം എന്നാൽ പഴയത്" കാണുക
ആ പദത്തിന്റെ വിശദീകരണം) ചോദ്യങ്ങളെ "arg" ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് ഗ്രൂപ്പുചെയ്യേണ്ടതുണ്ട്.
ഇത് ഒരേ തരത്തിലുള്ള ചോദ്യങ്ങളുടെ ക്ലാസുകൾ സൃഷ്ടിക്കുന്നു (അഭിപ്രായങ്ങൾ ഒഴിവാക്കി). അതിനാൽ ചോദ്യങ്ങൾ "തിരഞ്ഞെടുക്കുക
c FROM t WHERE id=1", "SELECT c FROM t WHERE id=1" എന്നിവ ഒരേ ക്ലാസിലേക്ക് തരം തിരിച്ചിരിക്കുന്നു,
എന്നാൽ c<"SELECT c FROM t WHERE id=3"> എന്നത് ആദ്യത്തെ രണ്ട് ചോദ്യങ്ങളുമായി സാമ്യമുള്ളതല്ല.
അത് മറ്റൊരു ക്ലാസിലേക്ക് തരം തിരിച്ചിരിക്കുന്നു. തുടർന്ന് "--ഇരകൾ" "എല്ലാം എന്നാൽ ഏറ്റവും പഴയത്" എന്ന് വ്യക്തമാക്കുമ്പോൾ,
ഓരോ ക്ലാസിലെയും ഏറ്റവും പഴയ ചോദ്യം ഒഴികെയുള്ള എല്ലാ ചോദ്യങ്ങളും ഓരോ ക്ലാസിനും കൊല്ലപ്പെടുന്നു
മത്സര മാനദണ്ഡങ്ങളുമായി പൊരുത്തപ്പെടുന്നു.

--സഹായിക്കൂ
സഹായം കാണിച്ച് പുറത്തുകടക്കുക.

--ഹോസ്റ്റ്
ഹ്രസ്വ രൂപം: -h; തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: ലോക്കൽ ഹോസ്റ്റ്

ഹോസ്റ്റിലേക്ക് കണക്റ്റുചെയ്യുക.

--ഇടവേള
തരം: സമയം

കൊല്ലാനുള്ള ചോദ്യങ്ങൾ എത്ര തവണ പരിശോധിക്കണം. "--തിരക്കേറിയ സമയം" നൽകിയിട്ടില്ലെങ്കിൽ, പിന്നെ
ഡിഫോൾട്ട് ഇടവേള 30 സെക്കൻഡ് ആണ്. അല്ലെങ്കിൽ ഡിഫോൾട്ട് "--തിരക്കേറിയ സമയം" എന്നതിന്റെ പകുതിയാണ്.
"--ഇന്റർവെൽ", "--ബിസി-ടൈം" എന്നിവ നൽകിയിട്ടുണ്ടെങ്കിൽ, വ്യക്തമായ "--ഇന്റർവൽ" മൂല്യം
ഉപയോഗിക്കുന്നു.

"--റൺ-ടൈം" കൂടി കാണുക.

--ലോഗ്
തരം: സ്ട്രിംഗ്

ഡെമോണൈസ് ചെയ്യുമ്പോൾ ഈ ഫയലിലേക്കുള്ള എല്ലാ ഔട്ട്പുട്ടും പ്രിന്റ് ചെയ്യുക.

--ലോഗ്-ഡിഎസ്എൻ
തരം: DSN

ഈ DSN-ൽ കൊല്ലപ്പെട്ട ഓരോ ചോദ്യവും സംഭരിക്കുക.

കൊല്ലപ്പെട്ട എല്ലാ ചോദ്യങ്ങളും സംഭരിക്കുന്നതിനുള്ള ഒരു പട്ടിക ആർഗ്യുമെന്റ് വ്യക്തമാക്കുന്നു. DSN നിർബന്ധമായും പാസ്സായി
ഡാറ്റാബേസ് (ഡി), ടേബിൾ (ടി) ഓപ്ഷനുകൾ ഉണ്ട്. പട്ടികയിൽ കുറഞ്ഞത് ഇനിപ്പറയുന്നവ ഉണ്ടായിരിക്കണം
നിരകൾ. നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്കായി നിങ്ങൾക്ക് കൂടുതൽ കോളങ്ങൾ ചേർക്കാൻ കഴിയും, എന്നാൽ അവ ഉണ്ടാകില്ല
pt-kill ഉപയോഗിച്ചു. ഇനിപ്പറയുന്ന ക്രിയേറ്റ് ടേബിൾ നിർവചനവും ഉപയോഗിക്കുന്നു
"--ക്രിയേറ്റ്-ലോഗ്-ടേബിൾ". MAGIC_create_log_table:

ടേബിൾ കിൽ_ലോഗ് സൃഷ്‌ടിക്കുക (
കൊല്ലുക int(10) ഒപ്പിടാത്തത് ശൂന്യമല്ല AUTO_INCREMENT,
server_id ബിഗിന്റ്(4) NULL ഡിഫോൾട്ട് '0' അല്ല,
ടൈംസ്റ്റാമ്പ് DATETIME,
കാരണം TEXT,
kill_error TEXT,
Id ബിഗിന്റ്(4) NULL ഡിഫോൾട്ട് '0' അല്ല,
ഉപയോക്താവ് varchar(16) നൾ ഡിഫോൾട്ട് അല്ല '',
ഹോസ്റ്റ് varchar(64) നൾ ഡിഫോൾട്ട് അല്ല '',
db varchar(64) ഡിഫോൾട്ട് NULL,
കമാൻഡ് varchar(16) നൾ ഡിഫോൾട്ട് അല്ല '',
കാലം int(7) NULL ഡിഫോൾട്ട് '0' അല്ല,
അവസ്ഥ varchar(64) ഡിഫോൾട്ട് NULL,
വിവരങ്ങൾ ദീർഘവാചകം,
സമയം_മി ബിഗിന്റ്(21) ഡിഫോൾട്ട് '0', # കുറിപ്പ്, ചെയ്യേണ്ടത്: നിലവിൽ ഉപയോഗിക്കുന്നില്ല
പ്രാഥമിക കീ (kill_id)
) ഡിഫോൾട്ട് ചാർസെറ്റ്=utf8

--password
ഹ്രസ്വ രൂപം: -p; തരം: സ്ട്രിംഗ്

ബന്ധിപ്പിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട പാസ്‌വേഡ്. പാസ്‌വേഡിൽ കോമകളുണ്ടെങ്കിൽ അവ രക്ഷപ്പെടണം
ഒരു ബാക്ക്സ്ലാഷ് ഉപയോഗിച്ച്: "പരീക്ഷ\,ple"

--pid
തരം: സ്ട്രിംഗ്

നൽകിയിരിക്കുന്ന PID ഫയൽ സൃഷ്ടിക്കുക. PID ഫയൽ നിലവിലുണ്ടെങ്കിൽ ടൂൾ ആരംഭിക്കില്ല
അതിൽ അടങ്ങിയിരിക്കുന്ന PID നിലവിലെ PID-യിൽ നിന്ന് വ്യത്യസ്തമാണ്. എന്നിരുന്നാലും, PID ഫയൽ ആണെങ്കിൽ
നിലവിലുണ്ട്, അതിൽ അടങ്ങിയിരിക്കുന്ന PID ഇനി പ്രവർത്തിക്കില്ല, ഉപകരണം PID പുനരാലേഖനം ചെയ്യും
നിലവിലെ PID ഉള്ള ഫയൽ. ടൂൾ പുറത്തുകടക്കുമ്പോൾ PID ഫയൽ സ്വയമേവ നീക്കം ചെയ്യപ്പെടും.

--പോർട്ട്
ഹ്രസ്വ രൂപം: -പി; തരം: int

കണക്ഷനായി ഉപയോഗിക്കേണ്ട പോർട്ട് നമ്പർ.

--query-id
ഇപ്പോൾ കൊല്ലപ്പെട്ട അന്വേഷണത്തിന്റെ ഐഡി പ്രിന്റ് ചെയ്യുന്നു. ഇത് "ഐഡി" ഔട്ട്പുട്ടിന് തുല്യമാണ്
pt-query-digest എന്നതിന്റെ. രണ്ട് ടൂളുകളുടെയും ഔട്ട്പുട്ട് ക്രോസ്-റഫറൻസ് ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു.

ഉദാഹരണം:

അന്വേഷണ ഐഡി 0xE9800998ECF8427E

ഇത് അന്വേഷണത്തിന്റെ "വിരലടയാള" ത്തിന്റെ ഡൈജസ്റ്റ് (അല്ലെങ്കിൽ ഹാഷ്) ആണെന്ന് ശ്രദ്ധിക്കുക, അതിനാൽ അന്വേഷണങ്ങൾ
ഒരേ ഫോം എന്നാൽ വ്യത്യസ്ത മൂല്യങ്ങളുള്ള ഒരേ ഐഡി ഉണ്ടായിരിക്കും. ഇതിനായി pt-query-digest കാണുക
കൂടുതൽ വിവരങ്ങൾ.

--rds
ആമസോൺ RDS-ൽ ഉള്ളതാണ് ചോദ്യം. സ്ഥിരസ്ഥിതിയായി pt-kill MySQL പ്രവർത്തിപ്പിക്കുന്നു
"--kill", "kill query" "--kill-query" എന്നിവയ്ക്കായുള്ള "kill" കമാൻഡ്. RDS-ൽ ഇവ രണ്ടും
കമാൻഡുകൾ ലഭ്യമല്ല കൂടാതെ ഫംഗ്‌ഷൻ കോളുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഈ ഓപ്ഷൻ പരിഷ്കരിക്കുന്നു
"--kill" എന്നതിന് പകരം "CALL mysql.rds_kill(thread-id)" ഉപയോഗിക്കാനും "--kill-query" ഉപയോഗിക്കാനും
"കോൾ mysql.rds_kill_query(thread-id)"

--റൺ-ടൈം
തരം: സമയം

പുറത്തുകടക്കുന്നതിന് മുമ്പ് എത്ര സമയം ഓടണം. ഡിഫോൾട്ടായി pt-kill എന്നേക്കും പ്രവർത്തിക്കുന്നു, അല്ലെങ്കിൽ അതിന്റെ പ്രക്രിയ വരെ
ഒരു "--സെന്റിനൽ" ഫയൽ സൃഷ്ടിച്ച് കൊല്ലപ്പെടുകയോ നിർത്തുകയോ ചെയ്തു. ഈ ഓപ്ഷൻ ആണെങ്കിൽ
വ്യക്തമാക്കിയ, pt-kill നിർദ്ദിഷ്‌ട സമയത്തേക്ക് ഓടുകയും ഉറങ്ങുകയും ചെയ്യുന്നു "--ഇടവേള"
PROCESSLIST-ന്റെ ഓരോ ചെക്കിനുമിടയിൽ സെക്കൻഡുകൾ.

--സെന്റിനൽ
തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: /tmp/pt-kill-sentinel

ഈ ഫയൽ നിലവിലുണ്ടെങ്കിൽ പുറത്തുകടക്കുക.

"--സെന്റിനൽ" വ്യക്തമാക്കിയ ഫയലിന്റെ സാന്നിധ്യം പ്രവർത്തിക്കുന്ന എല്ലാ സംഭവങ്ങൾക്കും കാരണമാകും
പുറത്തുകടക്കാൻ pt-kill. ആവശ്യമെങ്കിൽ ക്രോൺ ജോലികൾ ഭംഗിയായി നിർത്താൻ ഇത് നിങ്ങൾക്ക് സഹായകമായേക്കാം.
"--നിർത്തുക" എന്നതും കാണുക.

--set-vars
തരം: അറേ

"വേരിയബിൾ=മൂല്യം" ജോഡികളുടെ കോമയാൽ വേർതിരിച്ച ഈ ലിസ്റ്റിൽ MySQL വേരിയബിളുകൾ സജ്ജമാക്കുക.

സ്ഥിരസ്ഥിതിയായി, ഉപകരണം സജ്ജമാക്കുന്നു:

wait_timeout=10000

കമാൻഡ് ലൈനിൽ വ്യക്തമാക്കിയിരിക്കുന്ന വേരിയബിളുകൾ ഈ ഡിഫോൾട്ടുകളെ അസാധുവാക്കുന്നു. ഉദാഹരണത്തിന്,
"--set-vars wait_timeout=500" വ്യക്തമാക്കുന്നത് 10000-ന്റെ സ്ഥിര മൂല്യത്തെ മറികടക്കുന്നു.

ഉപകരണം ഒരു മുന്നറിയിപ്പ് പ്രിന്റ് ചെയ്യുകയും ഒരു വേരിയബിൾ സജ്ജമാക്കാൻ കഴിയുന്നില്ലെങ്കിൽ തുടരുകയും ചെയ്യുന്നു.

--സോക്കറ്റ്
ചെറു വാക്കുകൾ; തരം: സ്ട്രിംഗ്

കണക്ഷനായി ഉപയോഗിക്കേണ്ട സോക്കറ്റ് ഫയൽ.

--നിർത്തുക
"--സെന്റിനൽ" ഫയൽ സൃഷ്‌ടിച്ച് ഇൻസ്‌റ്റൻസുകൾ പ്രവർത്തിപ്പിക്കുന്നത് നിർത്തുക.

"--sentinel" വ്യക്തമാക്കിയ സെന്റിനൽ ഫയൽ സൃഷ്ടിക്കുന്നതിനും പുറത്തുകടക്കുന്നതിനും pt-kill കാരണമാകുന്നു. ഈ
ഒരേ പോലെ കാണുന്ന എല്ലാ റണ്ണിംഗ് ഇൻസ്‌റ്റൻസുകളും നിർത്തുന്നതിന്റെ ഫലം ഉണ്ടായിരിക്കണം
സെന്റിനൽ ഫയൽ.

--[ഇല്ല]സ്ട്രിപ്പ്-അഭിപ്രായങ്ങൾ
സ്ഥിരസ്ഥിതി: അതെ

PROCESSLIST-ന്റെ വിവര കോളത്തിലെ ചോദ്യങ്ങളിൽ നിന്ന് SQL അഭിപ്രായങ്ങൾ നീക്കം ചെയ്യുക.

--ഉപയോക്താവ്
ഹ്രസ്വ രൂപം: -u; തരം: സ്ട്രിംഗ്

നിലവിലെ ഉപയോക്താവല്ലെങ്കിൽ ലോഗിൻ ചെയ്യാനുള്ള ഉപയോക്താവ്.

--പതിപ്പ്
പതിപ്പ് കാണിച്ച് പുറത്തുകടക്കുക.

--[ഇല്ല]പതിപ്പ്-പരിശോധന
സ്ഥിരസ്ഥിതി: അതെ

Percona Toolkit, MySQL, മറ്റ് പ്രോഗ്രാമുകൾ എന്നിവയുടെ ഏറ്റവും പുതിയ പതിപ്പിനായി പരിശോധിക്കുക.

ഇത് ഒരു സ്റ്റാൻഡേർഡ് "അപ്ഡേറ്റുകൾക്കായി യാന്ത്രികമായി പരിശോധിക്കുക" സവിശേഷതയാണ്, കൂടാതെ രണ്ട് അധികവും
ഫീച്ചറുകൾ. ആദ്യം, ടൂൾ ലോക്കൽ സിസ്റ്റത്തിലെ മറ്റ് പ്രോഗ്രാമുകളുടെ പതിപ്പ് പരിശോധിക്കുന്നു
സ്വന്തം പതിപ്പിന് പുറമേ. ഉദാഹരണത്തിന്, ഇത് എല്ലാ MySQL സെർവറിന്റെയും പതിപ്പ് പരിശോധിക്കുന്നു
ഇത് Perl, Perl മൊഡ്യൂൾ DBD::mysql എന്നിവയുമായി ബന്ധിപ്പിക്കുന്നു. രണ്ടാമതായി, അത് പരിശോധിക്കുകയും മുന്നറിയിപ്പ് നൽകുകയും ചെയ്യുന്നു
അറിയപ്പെടുന്ന പ്രശ്നങ്ങളുള്ള പതിപ്പുകളെക്കുറിച്ച്. ഉദാഹരണത്തിന്, MySQL 5.5.25-ന് ഒരു നിർണായക ബഗ് ഉണ്ടായിരുന്നു
5.5.25a ആയി വീണ്ടും റിലീസ് ചെയ്തു.

ഏതെങ്കിലും അപ്‌ഡേറ്റുകളോ അറിയപ്പെടുന്ന പ്രശ്‌നങ്ങളോ ടൂളിന്റെ സാധാരണ ഔട്ട്‌പുട്ടിന് മുമ്പ് STDOUT-ലേക്ക് പ്രിന്റ് ചെയ്യപ്പെടും.
ഈ സവിശേഷത ഒരിക്കലും ഉപകരണത്തിന്റെ സാധാരണ പ്രവർത്തനത്തെ തടസ്സപ്പെടുത്തരുത്.

കൂടുതൽ വിവരങ്ങൾക്ക്, സന്ദർശിക്കുക .

--ഇരകൾ
തരം: സ്ട്രിംഗ്; സ്ഥിരസ്ഥിതി: ഏറ്റവും പഴയത്

ഓരോ ക്ലാസിലെയും പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങളിൽ ഏതാണ് നശിപ്പിക്കപ്പെടുക. ക്ലാസ്സുകൾ കഴിഞ്ഞു
പൊരുത്തപ്പെട്ടു/ഫിൽട്ടർ ചെയ്‌തു, ഈ ഓപ്‌ഷൻ ഓരോ ക്ലാസിലെയും പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങളിൽ ഏതാണ് എന്ന് വ്യക്തമാക്കുന്നു
കൊല്ലപ്പെടും (അല്ലെങ്കിൽ അച്ചടിച്ചത് മുതലായവ). ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ സാധ്യമാണ്:

ഏറ്റവും പഴയത്
ഏറ്റവും പഴയ ചോദ്യം മാത്രം കൊല്ലുക. അല്ലാത്ത ചോദ്യങ്ങളെ കൊല്ലുന്നത് തടയാനാണിത്
ശരിക്കും ദീർഘകാലം പ്രവർത്തിക്കുന്നു, അവർ ദീർഘനേരം കാത്തിരിക്കുകയാണ്. ഇത് പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങളെ ക്രമപ്പെടുത്തുന്നു
സമയം, ഏറ്റവും ഉയർന്ന സമയ മൂല്യമുള്ളവനെ കൊല്ലുന്നു.

ക്ലാസിലെ എല്ലാ ചോദ്യങ്ങളും ഇല്ലാതാക്കുക.

ഏറ്റവും പഴയത്
ഏറ്റവും പഴയ ചോദ്യം ഒഴികെ മറ്റെല്ലാവരെയും കൊല്ലുക. ഇത് "ഏറ്റവും പഴയ" മൂല്യത്തിന്റെ വിപരീതമാണ്.

"കാഷെ സ്റ്റാമ്പെഡുകൾ" തടയാൻ ഈ മൂല്യം ഉപയോഗിക്കാം, ഇത് പലയിടത്തും
സമാനമായ ചോദ്യങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യുകയും ആദ്യ അന്വേഷണ ശ്രമങ്ങൾ നടത്തുമ്പോൾ ഒരു ബാക്ക്ലോഗ് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു
പൂർത്തിയാക്കാൻ. എല്ലാ ചോദ്യങ്ങളും ഒരുപോലെ ആയതിനാൽ, ആദ്യത്തെ ചോദ്യം ഒഴികെ എല്ലാം അങ്ങനെ നശിപ്പിക്കപ്പെടുന്നു
കാഷെ പൂർത്തിയാക്കാനും പോപ്പുലേറ്റ് ചെയ്യാനും ഇതിന് കഴിയും.

--കൊന്നു കഴിഞ്ഞ് കാത്തിരിക്കുക
തരം: സമയം

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

കൊല്ലുന്നതിന് മുമ്പ് കാത്തിരിക്കുക
തരം: സമയം

ഒരു ചോദ്യം ഇല്ലാതാക്കുന്നതിന് മുമ്പ് കാത്തിരിക്കുക. "--എക്‌സിക്യൂട്ട്-കമാൻഡ്" നൽകുക എന്നതാണ് ഇതിന്റെ ഉദ്ദേശം
പൊരുത്തപ്പെടുന്ന അന്വേഷണം കാണാനും മുമ്പ് മറ്റ് MySQL അല്ലെങ്കിൽ സിസ്റ്റം വിവരങ്ങൾ ശേഖരിക്കാനുമുള്ള അവസരം
അത് കൊല്ലപ്പെട്ടു.

ചോദ്യം മത്സരങ്ങൾ
ഈ ഓപ്ഷനുകൾ അവരുടെ ക്ലാസുകളിൽ നിന്നുള്ള ചോദ്യങ്ങൾ ഫിൽട്ടർ ചെയ്യുന്നു. ഒരു ചോദ്യം പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, അത് നീക്കം ചെയ്യപ്പെടും
അതിന്റെ ക്ലാസിൽ നിന്ന്. "--അവഗണിക്കുക" ഓപ്ഷനുകൾ മുൻഗണന നൽകുന്നു. കമാൻഡിനുള്ള പൊരുത്തങ്ങൾ, db,
ഹോസ്റ്റ് മുതലായവ ഷോ പ്രോസസ്സ്ലിസ്റ്റ് നൽകുന്ന കോളങ്ങളുമായി പൊരുത്തപ്പെടുന്നു: കമാൻഡ്, ഡിബി, ഹോസ്റ്റ് മുതലായവ.
എല്ലാ പാറ്റേൺ പൊരുത്തങ്ങളും ഡിഫോൾട്ടായി കേസ്-സെൻസിറ്റീവ് ആണ്, എന്നാൽ അവയെ കേസ്-ഇൻസെൻസിറ്റീവ് ആക്കാം
"(?i-xsm:select)" പോലെയുള്ള ഒരു regex പാറ്റേൺ വ്യക്തമാക്കുന്നതിലൂടെ.

"ഗ്രൂപ്പ്, മാച്ച്, കിൽ" എന്നിവയും കാണുക.

--തിരക്കേറിയ സമയം
തരം: സമയം; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ സമയത്തേക്കാൾ കൂടുതൽ നേരം പ്രവർത്തിക്കുന്ന ചോദ്യങ്ങൾ പൊരുത്തപ്പെടുത്തുക. ചോദ്യങ്ങൾ ആയിരിക്കണം
കമാൻഡ്=ക്വറി സ്റ്റാറ്റസിൽ. SHOW റിപ്പോർട്ട് ചെയ്‌തിരിക്കുന്ന ഒരു അന്വേഷണത്തിന്റെ സമയ മൂല്യവുമായി ഇത് പൊരുത്തപ്പെടുന്നു
പ്രോസസ്സ്ലിസ്റ്റ്.

--നിഷ്ക്രിയ സമയം
തരം: സമയം; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ സമയത്തേക്കാൾ കൂടുതൽ സമയം നിഷ്‌ക്രിയമായ/ഉറങ്ങിക്കിടക്കുന്ന ചോദ്യങ്ങൾ പൊരുത്തപ്പെടുത്തുക. ചോദ്യങ്ങൾ
കമാൻഡ്=സ്ലീപ്പ് സ്റ്റാറ്റസിൽ ആയിരിക്കണം. ഇത് റിപ്പോർട്ട് ചെയ്ത അന്വേഷണത്തിന്റെ സമയ മൂല്യവുമായി പൊരുത്തപ്പെടുന്നു
പ്രോസസ്സ്ലിസ്റ്റ് കാണിക്കുക.

--അവഗണിക്കുക-കമാൻഡ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

കമാൻഡ് ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ അവഗണിക്കുക.

"--മാച്ച്-കമാൻഡ്" കാണുക.

--അവഗണിക്കുക-db
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന db (ഡാറ്റാബേസ്) ചോദ്യങ്ങൾ അവഗണിക്കുക.

"--match-db" കാണുക.

--അവഗണിക്കുക-ഹോസ്റ്റ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന ഹോസ്റ്റ് ചോദ്യങ്ങൾ അവഗണിക്കുക.

"--മാച്ച്-ഹോസ്റ്റ്" കാണുക.

--വിവരങ്ങൾ അവഗണിക്കുക
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന വിവരങ്ങൾ (ചോദ്യം) ചോദ്യങ്ങൾ അവഗണിക്കുക.

"--മാച്ച്-ഇൻഫോ" കാണുക.

--[ഇല്ല] സ്വയം അവഗണിക്കുക
സ്ഥിരസ്ഥിതി: അതെ; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

pt-kill-ന്റെ സ്വന്തം ബന്ധം കൊല്ലരുത്.

--അവഗണിക്കുക-സംസ്ഥാനം
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ; സ്ഥിരസ്ഥിതി: ലോക്ക് ചെയ്തു

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന സംസ്ഥാനത്തിന്റെ ചോദ്യങ്ങൾ അവഗണിക്കുക. ത്രെഡുകൾ സൂക്ഷിക്കുക എന്നതാണ് സ്ഥിരസ്ഥിതി
മറ്റൊരു നൂലിനായി കാത്തിരിക്കുന്ന അവരെ പൂട്ടിയിട്ടാൽ കൊല്ലപ്പെടുന്നതിൽ നിന്ന്.

"--മാച്ച്-സ്റ്റേറ്റ്" കാണുക.

--ഉപയോക്താവിനെ അവഗണിക്കുക
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന ഉപയോക്താവിന്റെ ചോദ്യങ്ങൾ അവഗണിക്കുക.

"--മാച്ച്-ഉപയോക്താവ്" കാണുക.

--എല്ലാം പൊരുത്തപ്പെടുത്തുക
ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

അവഗണിക്കാത്ത എല്ലാ ചോദ്യങ്ങളും പൊരുത്തപ്പെടുത്തുക. അവഗണിക്കൽ ഓപ്‌ഷനുകളൊന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, പിന്നെ
എല്ലാ ചോദ്യങ്ങളും പൊരുത്തപ്പെടുന്നു (റെപ്ലിക്കേഷൻ ത്രെഡുകൾ ഒഴികെ, "--റെപ്ലിക്കേഷൻ-ത്രെഡുകൾ" ഒഴികെ
എന്നിവയും വ്യക്തമാക്കിയിട്ടുണ്ട്). നെഗറ്റീവ് പൊരുത്തങ്ങൾ വ്യക്തമാക്കാൻ ഈ ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു, അതായത് "പൊരുത്തം
ഓരോ ചോദ്യവും ഒഴികെ..."എവിടെ ഒഴിവാക്കലുകൾ വിവിധ വ്യക്തമാക്കിക്കൊണ്ട് നിർവചിക്കപ്പെടുന്നു
"--അവഗണിക്കുക" ഓപ്ഷനുകൾ.

ഈ ഓപ്ഷൻ ആണ് അല്ല "--ഇരകൾ" "എല്ലാം" പോലെ തന്നെ. ഈ ഓപ്ഷൻ എല്ലാ ചോദ്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നു
ഒരു ക്ലാസിനുള്ളിൽ, എന്നാൽ "--ഇരകൾ" "എല്ലാം" എന്നത് ഒരു പൊരുത്തമുള്ള എല്ലാ ചോദ്യങ്ങളും വ്യക്തമാക്കുന്നു
ക്ലാസ് (അവർ പൊരുത്തപ്പെടുന്നുണ്ടെങ്കിലും) കൊല്ലപ്പെടും. എന്നിരുന്നാലും, സാധാരണയായി, രണ്ടും ഉപയോഗിക്കുന്നു
ഒരുമിച്ച് കാരണം, ഉദാഹരണത്തിന്, നിങ്ങൾ "--ഇരകൾ" "ഏറ്റവും പഴയത്" എന്ന് വ്യക്തമാക്കിയാൽ, എല്ലാം ആണെങ്കിലും
ചോദ്യങ്ങൾ പൊരുത്തപ്പെടാം, ഏറ്റവും പഴയത് മാത്രമേ കൊല്ലപ്പെടൂ.

--മാച്ച്-കമാൻഡ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-ന്റെ കമാൻഡ് പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

പൊതുവായ കമാൻഡ് മൂല്യങ്ങൾ ഇവയാണ്:

ചോദ്യം
ഉറക്കം
ബിൻലോഗ് ഡംപ്
ബന്ധിപ്പിക്കുക
കാലതാമസം നേരിട്ട ഇൻസേർട്ട്
നിർവ്വഹിക്കുക
ലഭ്യമാക്കുക
Init DB
കിൽ
തയാറാക്കുക
പ്രോസസ്സ്ലിസ്റ്റ്
പുറത്തുകടക്കുക
stmt പുനഃസജ്ജമാക്കുക
ടേബിൾ ഡമ്പ്

കാണുകhttp://dev.mysql.com/doc/refman/5.1/en/thread-commands.html> ഒരു മുഴുവൻ ലിസ്റ്റിനും ഒപ്പം
കമാൻഡ് മൂല്യങ്ങളുടെ വിവരണം.

--പൊരുത്തം-db
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-മായി പൊരുത്തപ്പെടുന്ന db (ഡാറ്റാബേസ്) ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

--മാച്ച് ഹോസ്റ്റ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ പേൾ റീജക്‌സുമായി പൊരുത്തപ്പെടുന്ന ഹോസ്റ്റ് ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

ഹോസ്റ്റ് മൂല്യത്തിൽ പലപ്പോഴും "host:port" പോലുള്ള പോർട്ട് ഉൾപ്പെടുന്നു.

--പൊരുത്തം-വിവരങ്ങൾ
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ പേൾ റീജക്‌സുമായി പൊരുത്തപ്പെടുന്ന വിവരങ്ങൾ (ചോദ്യം) ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

പ്രോസസ്സ് ലിസ്റ്റിലെ വിവര കോളം എക്സിക്യൂട്ട് ചെയ്യുന്ന ചോദ്യം കാണിക്കുന്നു അല്ലെങ്കിൽ NULL if
ഒരു അന്വേഷണവും നടപ്പിലാക്കുന്നില്ല.

--മാച്ച്-സ്റ്റേറ്റ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-ന്റെ സംസ്ഥാനവുമായി പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

പൊതു സംസ്ഥാന മൂല്യങ്ങൾ ഇവയാണ്:

ലോക്കുചെയ്തു
ലോഗിൻ
tmp പട്ടികയിലേക്ക് പകർത്തുക
tmp പട്ടികയിലേക്ക് പകർത്തുന്നു
ഡിസ്കിലെ tmp പട്ടികയിലേക്ക് പകർത്തുന്നു
tmp പട്ടിക സൃഷ്ടിക്കുന്നു
നടപ്പിലാക്കുന്നു
നെറ്റിൽ നിന്ന് വായിക്കുന്നു
ഡാറ്റ അയയ്ക്കുന്നു
ഓർഡറിനായി അടുക്കുന്നു
സോർട്ടിംഗ് ഫലം
ടേബിൾ ലോക്ക്
അപ്ഡേറ്റുചെയ്യുന്നു

കാണുകhttp://dev.mysql.com/doc/refman/5.1/en/general-thread-states.html> ഒരു മുഴുവനായി
സംസ്ഥാന മൂല്യങ്ങളുടെ പട്ടികയും വിവരണവും.

--മാച്ച്-ഉപയോക്താവ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

ഈ Perl regex-ഉം ഉപയോക്താവുമായി പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ മാത്രം പൊരുത്തപ്പെടുത്തുക.

--റെപ്ലിക്കേഷൻ-ത്രെഡുകൾ
ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

റെപ്ലിക്കേഷൻ ത്രെഡുകൾ പൊരുത്തപ്പെടുത്താനും കൊല്ലാനും അനുവദിക്കുക.

സ്ഥിരസ്ഥിതിയായി, റെപ്ലിക്കേഷൻ ത്രെഡുകളിൽ പൊരുത്തങ്ങൾ ബാധകമല്ല; അതായത് റെപ്ലിക്കേഷൻ ത്രെഡുകൾ
പൂർണ്ണമായും അവഗണിച്ചു. ഈ ഓപ്‌ഷൻ വ്യക്തമാക്കുന്നത് പൊരുത്തങ്ങൾ പൊരുത്തപ്പെടുത്താൻ അനുവദിക്കുന്നു (കൂടാതെ സാധ്യതയുള്ളവയും
കൊല്ലുക) യജമാനന്മാരുടെയും അടിമകളുടെയും പകർപ്പ് ത്രെഡുകൾ.

--ടെസ്റ്റ്-മാച്ചിംഗ്
തരം: അറേ; ഗ്രൂപ്പ്: ചോദ്യ പൊരുത്തങ്ങൾ

പൊരുത്തപ്പെടുന്ന ഓപ്ഷനുകൾ പരീക്ഷിക്കുന്നതിന് പ്രോസസ്സ്ലിസ്റ്റ് സ്നാപ്പ്ഷോട്ടുകളുള്ള ഫയലുകൾ. പൊരുത്തം മുതൽ
ഓപ്ഷനുകൾ സങ്കീർണ്ണമായേക്കാം, നിങ്ങൾക്ക് ഫയലുകളിൽ പ്രോസസ്സ്ലിസ്റ്റിന്റെ സ്നാപ്പ്ഷോട്ടുകൾ സേവ് ചെയ്യാം, തുടർന്ന് ടെസ്റ്റ് ചെയ്യാം
ആ ഫയലുകളിലെ ചോദ്യങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ഓപ്ഷനുകൾ.

ഈ ഓപ്ഷൻ "--run-time", "--interval", "--[no]self-ignore-self" എന്നിവ പ്രവർത്തനരഹിതമാക്കുന്നു.

ക്ലാസ് മത്സരങ്ങൾ
ഈ പൊരുത്തങ്ങൾ മുഴുവൻ ചോദ്യ ക്ലാസുകൾക്കും ബാധകമാണ്. എന്ന് വ്യക്തമാക്കിയാണ് ക്ലാസുകൾ സൃഷ്ടിക്കുന്നത്
"--group-by" ഓപ്ഷൻ, അല്ലാത്തപക്ഷം എല്ലാ ചോദ്യങ്ങളും ഒരൊറ്റ, സ്ഥിരസ്ഥിതി ക്ലാസ്സിലെ അംഗങ്ങളാണ്.

"ഗ്രൂപ്പ്, മാച്ച്, കിൽ" എന്നിവയും കാണുക.

--ഏത് തിരക്കുള്ള സമയത്തും
തരം: സമയം; ഗ്രൂപ്പ്: ക്ലാസ് മത്സരങ്ങൾ

ഈ സമയത്തേക്കാൾ കൂടുതൽ സമയം ഏതെങ്കിലും ചോദ്യം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ ചോദ്യ ക്ലാസ് പൊരുത്തപ്പെടുത്തുക. "നീണ്ട
than" എന്നതിനർത്ഥം നിങ്ങൾ 10 വ്യക്തമാക്കുകയാണെങ്കിൽ, ഉദാഹരണത്തിന്, ക്ലാസ് ഉണ്ടെങ്കിൽ മാത്രമേ അത് പൊരുത്തപ്പെടൂ
10 സെക്കൻഡിൽ കൂടുതൽ പ്രവർത്തിക്കുന്ന ഒരു ചോദ്യമെങ്കിലും.

കൂടുതൽ വിവരങ്ങൾക്ക് "--ഓരോ തിരക്കുള്ള സമയത്തും" കാണുക.

--ഓരോ തിരക്കുള്ള സമയത്തും
തരം: സമയം; ഗ്രൂപ്പ്: ക്ലാസ് മത്സരങ്ങൾ

ഓരോ ചോദ്യവും ഈ സമയത്തേക്കാൾ കൂടുതൽ നേരം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ ചോദ്യ ക്ലാസ് പൊരുത്തപ്പെടുത്തുക. "നീണ്ട
than" എന്നതിനർത്ഥം, നിങ്ങൾ 10 വ്യക്തമാക്കുകയാണെങ്കിൽ, ഉദാഹരണത്തിന്, ഓരോന്നിനും ഒപ്പം എങ്കിൽ മാത്രമേ ക്ലാസ് പൊരുത്തപ്പെടൂ
ഓരോ ചോദ്യവും 10 സെക്കൻഡിൽ കൂടുതൽ പ്രവർത്തിക്കുന്നു.

"--any-busy-time" എന്നതും കാണുക (ഏതെങ്കിലും ചോദ്യം കൂടുതൽ സമയം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ ഒരു ക്ലാസുമായി പൊരുത്തപ്പെടുത്തുന്നതിന്
നിർദ്ദിഷ്ട സമയം) കൂടാതെ "--തിരക്കേറിയ സമയം".

--ചോദ്യങ്ങളുടെ എണ്ണം
തരം: int; ഗ്രൂപ്പ്: ക്ലാസ് മത്സരങ്ങൾ

ചോദ്യ ക്ലാസിന് ഇത്രയും ചോദ്യങ്ങളെങ്കിലും ഉണ്ടെങ്കിൽ അത് പൊരുത്തപ്പെടുത്തുക. ചോദ്യങ്ങൾ ഗ്രൂപ്പുചെയ്യുമ്പോൾ
"--group-by" വ്യക്തമാക്കുന്നതിലൂടെയുള്ള ക്ലാസുകൾ, ഈ ഐച്ഛികം മത്സരങ്ങൾ മാത്രം ബാധകമാക്കുന്നു
കുറഞ്ഞത് ഇത്രയധികം ചോദ്യങ്ങളുള്ള ക്ലാസുകൾ. "--group-by" വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ ഇത്
എന്നതിൽ ഇത്രയധികം ചോദ്യങ്ങളെങ്കിലും ഉണ്ടെങ്കിൽ മാത്രമേ പൊരുത്തങ്ങൾ പ്രയോഗിക്കാൻ ഓപ്ഷൻ കാരണമാകൂ
മുഴുവൻ ഷോ പ്രോസസ്സ്‌ലിസ്റ്റും.

--വാക്കുകൾ
ഹ്രസ്വ രൂപം: -വി

എന്താണ് ചെയ്യുന്നത് എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ STDOUT-ലേക്ക് പ്രിന്റ് ചെയ്യുക.

പ്രവർത്തനങ്ങൾ
എല്ലാ ക്ലാസുകളിൽ നിന്നും പൊരുത്തപ്പെടുന്ന ഓരോ ചോദ്യത്തിനും ഈ പ്രവർത്തനങ്ങൾ എടുക്കുന്നു. നടപടികൾ സ്വീകരിച്ചിട്ടുണ്ട്
ഈ ക്രമത്തിൽ: "--print", "--execute-command", "--kill"/"--kill-query". ഈ ഓർഡർ അനുവദിക്കുന്നു
"--പ്രിന്റ്" എന്നതിന്റെ ഔട്ട്‌പുട്ടും മുമ്പുള്ള അന്വേഷണവും കാണുന്നതിന് "--എക്‌സിക്യൂട്ട്-കമാൻഡ്"
"--കിൽ"/"--കിൽ-ക്വറി". pt-kill ഒന്നും കടന്നുപോകാത്തതിനാൽ ഇത് സഹായകമായേക്കാം
"--എക്‌സിക്യൂട്ട്-കമാൻഡ്" എന്നതിലേക്കുള്ള വിവരങ്ങൾ.

"ഗ്രൂപ്പ്, മാച്ച്, കിൽ" എന്നിവയും കാണുക.

--എക്സിക്യൂട്ട്-കമാൻഡ്
തരം: സ്ട്രിംഗ്; ഗ്രൂപ്പ്: പ്രവർത്തനങ്ങൾ

ഒരു ചോദ്യം പൊരുത്തപ്പെടുമ്പോൾ ഈ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുക.

കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, pt-kill ന് അതിൽ നിയന്ത്രണമില്ല, അതിനാൽ കമാൻഡ് ആണ്
സ്വന്തം വിവരശേഖരണം, ലോഗിംഗ്, ഇടവേള മുതലായവയുടെ ഉത്തരവാദിത്തം
ഓരോ തവണയും ഒരു ചോദ്യം പൊരുത്തപ്പെടുത്തുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്യുന്നു, അതിനാൽ കമാൻഡ് നന്നായി പ്രവർത്തിക്കുമ്പോൾ ശ്രദ്ധിക്കുക
ഒന്നിലധികം സന്ദർഭങ്ങൾ ഓടിച്ചു. pt-kill-ൽ നിന്നുള്ള വിവരങ്ങളൊന്നും കമാൻഡിലേക്ക് കൈമാറുന്നില്ല.

"--കൊല്ലുന്നതിന് മുമ്പ് കാത്തിരിക്കുക" എന്നതും കാണുക.

--കൊല്ലുക
ഗ്രൂപ്പ്: പ്രവർത്തനങ്ങൾ

പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾക്കായി കണക്ഷൻ ഇല്ലാതാക്കുക.

ഈ ഓപ്‌ഷൻ pt-kill-നെ ഉള്ള കണക്ഷനുകളെ (പ്രോസസ്സ്, ത്രെഡുകൾ) ഇല്ലാതാക്കുന്നു
പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ. നിങ്ങൾക്ക് വ്യക്തിഗത ചോദ്യങ്ങൾ മാത്രം ഇല്ലാതാക്കണമെങ്കിൽ "--kill-query" ഉപയോഗിക്കുക
അവരുടെ ബന്ധങ്ങളല്ല.

"--print" എന്നതും നൽകിയിട്ടില്ലെങ്കിൽ, pt- എന്ന് കാണിക്കുന്ന മറ്റ് വിവരങ്ങളൊന്നും അച്ചടിക്കില്ല.
കൊന്ന് പൊരുത്തപ്പെട്ടു ഒരു ചോദ്യം കൊന്നു.

"--കൊല്ലുന്നതിന് മുമ്പ്-കാത്ത്", "--കാത്തതിന് ശേഷം-കിൽ" എന്നിവയും കാണുക.

--കൊല്ലുക-ചോദ്യം
ഗ്രൂപ്പ്: പ്രവർത്തനങ്ങൾ

പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾ ഇല്ലാതാക്കുക.

ഈ ഓപ്‌ഷൻ pt-kill kill പൊരുത്തമുള്ള ചോദ്യങ്ങൾ ഉണ്ടാക്കുന്നു. ഇതിന് MySQL 5.0 അല്ലെങ്കിൽ പുതിയത് ആവശ്യമാണ്.
"--kill" എന്നതിൽ നിന്ന് വ്യത്യസ്തമായി, ചോദ്യങ്ങൾ പൊരുത്തപ്പെടുത്തുന്നതിനുള്ള കണക്ഷനെ ഇല്ലാതാക്കുന്നു, ഈ ഓപ്ഷൻ മാത്രം
ചോദ്യത്തെ കൊല്ലുന്നു, അതിന്റെ കണക്ഷനല്ല.

--അച്ചടി
ഗ്രൂപ്പ്: പ്രവർത്തനങ്ങൾ

പൊരുത്തപ്പെടുന്ന ചോദ്യങ്ങൾക്കായി ഒരു KILL പ്രസ്താവന അച്ചടിക്കുക; യഥാർത്ഥത്തിൽ ചോദ്യങ്ങളെ കൊല്ലുന്നില്ല.

ഏതൊക്കെ ചോദ്യങ്ങളാണ് പൊരുത്തപ്പെടുന്നതെന്നും യഥാർത്ഥത്തിൽ ഇല്ലാതെ കൊല്ലപ്പെടുമെന്നും കാണണമെങ്കിൽ
അവരെ കൊല്ലുന്നു, "--പ്രിന്റ്" വ്യക്തമാക്കുക. പൊരുത്തമുള്ള അന്വേഷണങ്ങൾ കൊല്ലുന്നതിനും പ്രിന്റ് ചെയ്യുന്നതിനും, വ്യക്തമാക്കുക
"--കിൽ", "--പ്രിന്റ്" എന്നിവ രണ്ടും.

ഡിഎസ്എൻ ഓപ്ഷനുകൾ

ഒരു DSN സൃഷ്ടിക്കാൻ ഈ DSN ഓപ്ഷനുകൾ ഉപയോഗിക്കുന്നു. ഓരോ ഓപ്ഷനും "option=value" പോലെ നൽകിയിരിക്കുന്നു.
ഓപ്‌ഷനുകൾ കേസ് സെൻസിറ്റീവ് ആയതിനാൽ പിയും പിയും ഒരേ ഓപ്ഷനല്ല. ഉണ്ടാകാൻ കഴിയില്ല
"=" എന്നതിന് മുമ്പോ ശേഷമോ വൈറ്റ്‌സ്‌പെയ്‌സ്, മൂല്യത്തിൽ വൈറ്റ്‌സ്‌പെയ്‌സ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ അത് ഉദ്ധരിക്കണം.
DSN ഓപ്ഷനുകൾ കോമയാൽ വേർതിരിച്ചിരിക്കുന്നു. പൂർണ്ണമായ വിശദാംശങ്ങൾക്ക് പെർകോണ-ടൂൾകിറ്റ് മാൻപേജ് കാണുക.

· എ

dsn: charset; പകർത്തുക: അതെ

ഡിഫോൾട്ട് പ്രതീക സെറ്റ്.

· ഡി

dsn: ഡാറ്റാബേസ്; പകർത്തുക: അതെ

സ്ഥിരസ്ഥിതി ഡാറ്റാബേസ്.

· എഫ്

dsn: mysql_read_default_file; പകർത്തുക: അതെ

നൽകിയിരിക്കുന്ന ഫയലിൽ നിന്നുള്ള ഡിഫോൾട്ട് ഓപ്ഷനുകൾ മാത്രം വായിക്കുക

. H.

dsn: ഹോസ്റ്റ്; പകർത്തുക: അതെ

ഹോസ്റ്റിലേക്ക് കണക്റ്റുചെയ്യുക.

· പി

dsn: രഹസ്യവാക്ക്; പകർത്തുക: അതെ

ബന്ധിപ്പിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട പാസ്‌വേഡ്. പാസ്‌വേഡിൽ കോമകളുണ്ടെങ്കിൽ അവ രക്ഷപ്പെടണം
ഒരു ബാക്ക്സ്ലാഷ് ഉപയോഗിച്ച്: "പരീക്ഷ\,ple"

· പി

dsn: പോർട്ട്; പകർത്തുക: അതെ

കണക്ഷനായി ഉപയോഗിക്കേണ്ട പോർട്ട് നമ്പർ.

. എസ്

dsn: mysql_socket; പകർത്തുക: അതെ

കണക്ഷനായി ഉപയോഗിക്കേണ്ട സോക്കറ്റ് ഫയൽ.

· യു

dsn: ഉപയോക്താവ്; പകർത്തുക: അതെ

നിലവിലെ ഉപയോക്താവല്ലെങ്കിൽ ലോഗിൻ ചെയ്യാനുള്ള ഉപയോക്താവ്.

· ടി

--log-dsn വഴി കടന്നുപോകുകയാണെങ്കിൽ, പ്രവർത്തനങ്ങൾ ലോഗിൻ ചെയ്യുന്നതിനുള്ള പട്ടിക.

ENVIRONMENT

പരിസ്ഥിതി വേരിയബിൾ "PTDEBUG" STDERR-ലേക്ക് വെർബോസ് ഡീബഗ്ഗിംഗ് ഔട്ട്പുട്ട് പ്രാപ്തമാക്കുന്നു. പ്രാപ്തമാക്കാൻ
ഡീബഗ്ഗ് ചെയ്ത് ഒരു ഫയലിലേക്ക് എല്ലാ ഔട്ട്‌പുട്ടും ക്യാപ്‌ചർ ചെയ്യുക, ടൂൾ പ്രവർത്തിപ്പിക്കുക:

PTDEBUG=1 pt-kill ... > FILE 2>&1

ശ്രദ്ധിക്കുക: ഡീബഗ്ഗിംഗ് ഔട്ട്‌പുട്ട് വളരെ വലുതാണ് കൂടാതെ നിരവധി മെഗാബൈറ്റ് ഔട്ട്‌പുട്ട് സൃഷ്ടിക്കാൻ കഴിയും.

സിസ്റം ആവശ്യകതകൾ

നിങ്ങൾക്ക് Perl, DBI, DBD::mysql, കൂടാതെ ഏതെങ്കിലും ഒന്നിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ട ചില കോർ പാക്കേജുകളും ആവശ്യമാണ്.
Perl-ന്റെ ന്യായമായ പുതിയ പതിപ്പ്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് pt-killp ഓൺലൈനായി ഉപയോഗിക്കുക