mysqlパフォーマンスパラメータの詳細

82722 ワード
mysql スクリプト パフォーマンスパラメータ
mysqlパフォーマンスパラメータ表示スクリプト

  
  
  
  
    
   
   
   
   
  1. #!/usr/bin/env python  
    2. 
   
   
   
   
  2. # -*- coding: utf-8 -*-  
    3. 
   
   
   
   
  3. # @Author:       wangwei  
    4. 
   
   
   
   
  4. # @E-mail:        [email protected]  
    5. 
   
   
   
   
  5. # @Create Date:  2012-06-19  
    6. 
   
   
   
   
  6. import MySQLdb  
    7. 
   
   
   
   
  7. import _mysql  
    8. 
   
   
   
   
  8. import re  
    9. 
   
   
   
   
  9. import time 
    10. 
   
   
   
   
  10. import sys  
    11. 
   
   
   
   
  11. import getpass  
    12. 
   
   
   
   
  12. from decimal import Decimal 
    13. 
   
   
   
   
  13.  
    14. 
   
   
   
   
  14. port=3306  
    15. 
   
   
   
   
  15. dbname="test" 
    16. 
   
   
   
   
  16. times=2  
    17. 
   
   
   
   
  17. slow=60  
    18. 
   
   
   
   
  18. version=Decimal("5.5")  
    19. 
   
   
   
   
  19.  
    20. 
   
   
   
   
  20. class tools(object):  
    21. 
   
   
   
   
  21.  @staticmethod  
    22. 
   
   
   
   
  22.  def println(header="",all="",current="",mark=""):  
    23. 
   
   
   
   
  23.   print header.ljust(42)+": "+all.ljust(30)+" "+current.ljust(30)+" "+mark  
    24. 
   
   
   
   
  24.  @staticmethod  
    25. 
   
   
   
   
  25.  def dRatio(param1,param2):  
    26. 
   
   
   
   
  26.   p1=param1  
    27. 
   
   
   
   
  27.   p2=param2  
    28. 
   
   
   
   
  28.   re="" 
    29. 
   
   
   
   
  29.   if(p1==0):  
    30. 
   
   
   
   
  30.    if(p2==0):  
    31. 
   
   
   
   
  31.     re="0:0" 
    32. 
   
   
   
   
  32.    else:  
    33. 
   
   
   
   
  33.     re="0:1" 
    34. 
   
   
   
   
  34.   else:  
    35. 
   
   
   
   
  35.    if(p2==0):  
    36. 
   
   
   
   
  36.     re="1:0" 
    37. 
   
   
   
   
  37.    else:  
    38. 
   
   
   
   
  38.     if(p1==p2):  
    39. 
   
   
   
   
  39.      re="1:1" 
    40. 
   
   
   
   
  40.     elif(p1>p2):  
    41. 
   
   
   
   
  41.      re= tools.dFormat(Decimal(p1)/Decimal(p2))+":1" 
    42. 
   
   
   
   
  42.     else:  
    43. 
   
   
   
   
  43.      re="1:"+tools.dFormat(Decimal(p2)/Decimal(p1))  
    44. 
   
   
   
   
  44.   return re+" "+tools.remarks([p1, p2])  
    45. 
   
   
   
   
  45.  @staticmethod  
    46. 
   
   
   
   
  46.  def remarks(params):  
    47. 
   
   
   
   
  47.   #print params  
    48. 
   
   
   
   
  48.   arr=[]  
    49. 
   
   
   
   
  49.   for param in params:  
    50. 
   
   
   
   
  50.    arr.append(tools.dFormat(param))  
    51. 
   
   
   
   
  51.   return "("+"/".join(arr)+")" 
    52. 
   
   
   
   
  52.  @staticmethod  
    53. 
   
   
   
   
  53.  def dFormat(val):  
    54. 
   
   
   
   
  54.   k=1024  
    55. 
   
   
   
   
  55.   m=k*k  
    56. 
   
   
   
   
  56.   g=k*m  
    57. 
   
   
   
   
  57.   t=k*g  
    58. 
   
   
   
   
  58.   p=k*t  
    59. 
   
   
   
   
  59.   dp=0  
    60. 
   
   
   
   
  60.   dm="" 
    61. 
   
   
   
   
  61.   if(val!=0):  
    62. 
   
   
   
   
  62.    if(val>p):  
    63. 
   
   
   
   
  63.     dp=p  
    64. 
   
   
   
   
  64.     dm="P" 
    65. 
   
   
   
   
  65.    elif(val>t):  
    66. 
   
   
   
   
  66.     dp=t  
    67. 
   
   
   
   
  67.     dm="T" 
    68. 
   
   
   
   
  68.    elif(val>g):  
    69. 
   
   
   
   
  69.     dp=g  
    70. 
   
   
   
   
  70.     dm="G" 
    71. 
   
   
   
   
  71.    elif(val>m):  
    72. 
   
   
   
   
  72.     dp=m  
    73. 
   
   
   
   
  73.     dm="M" 
    74. 
   
   
   
   
  74.    elif(val>k):  
    75. 
   
   
   
   
  75.     dp=k  
    76. 
   
   
   
   
  76.     dm="k" 
    77. 
   
   
   
   
  77.    else:  
    78. 
   
   
   
   
  78.     dp=1  
    79. 
   
   
   
   
  79.    return "%2.2f" % (Decimal(val)/Decimal(dp)) +dm  
    80. 
   
   
   
   
  80.   else:  
    81. 
   
   
   
   
  81.    return "%2.2f" % 0  
    82. 
   
   
   
   
  82.  
    83. 
   
   
   
   
  83. class mysqlvariables(object):  
    84. 
   
   
   
   
  84.  def __init__(self,variables):  
    85. 
   
   
   
   
  85.   self.variables=variables  
    86. 
   
   
   
   
  86.     
    87. 
   
   
   
   
  87.  def param(self,param1):  
    88. 
   
   
   
   
  88.   if(self.variables.has_key(param1)):  
    89. 
   
   
   
   
  89.    return long(self.variables[param1])  
    90. 
   
   
   
   
  90.   else:  
    91. 
   
   
   
   
  91.    if(param1=='table_open_cache'):  
    92. 
   
   
   
   
  92.     return long(self.variables['table_cache'])  
    93. 
   
   
   
   
  93.    else:  
    94. 
   
   
   
   
  94.     return 0L  
    95. 
   
   
   
   
  95.  def dFormat(self,param1):  
    96. 
   
   
   
   
  96.   return tools.dFormat(self.param(param1))  
    97. 
   
   
   
   
  97.  def strFormat(self,param1):  
    98. 
   
   
   
   
  98.   if(self.variables.has_key(param1)):  
    99. 
   
   
   
   
  99.    return self.variables[param1]  
    100. 
   
   
   
   
  100.   else:  
    101. 
   
   
   
   
  101.    if(param1=='character_set_server'):  
    102. 
   
   
   
   
  102.     return 'null' 
    103. 
   
   
   
   
  103.    elif(param1=='table_open_cache'):  
    104. 
   
   
   
   
  104.     return self.variables['table_cache']  
    105. 
   
   
   
   
  105.    else:  
    106. 
   
   
   
   
  106.     return 'null' 
    107. 
   
   
   
   
  107.  
    108. 
   
   
   
   
  108. class mysqlstatuscomputer(object):  
    109. 
   
   
   
   
  109.  def __init__(self,statuslist):  
    110. 
   
   
   
   
  110.   self.statuslist=statuslist  
    111. 
   
   
   
   
  111.   self.length=len(statuslist)  
    112. 
   
   
   
   
  112.   self.second=self.seconds()  
    113. 
   
   
   
   
  113.    
    114. 
   
   
   
   
  114.  def getval(self,param):  
    115. 
   
   
   
   
  115.   if(type(param)==type("")):  
    116. 
   
   
   
   
  116.    return self.param(param)  
    117. 
   
   
   
   
  117.   elif(type(param)==type([])):  
    118. 
   
   
   
   
  118.    return self.arange(param)  
    119. 
   
   
   
   
  119.   else:  
    120. 
   
   
   
   
  120.    return param  
    121. 
   
   
   
   
  121.    
    122. 
   
   
   
   
  122.  def param(self,param1):  
    123. 
   
   
   
   
  123.   if(self.length>1):  
    124. 
   
   
   
   
  124.    if(self.statuslist[0].has_key(param1)):  
    125. 
   
   
   
   
  125.     return long(self.statuslist[1][param1])-long(self.statuslist[0][param1])  
    126. 
   
   
   
   
  126.    else:  
    127. 
   
   
   
   
  127.     if(param1=='Innodb_buffer_pool_read_ahead' and version>5):  
    128. 
   
   
   
   
  128.      return (long(self.statuslist[1]['Innodb_buffer_pool_read_ahead_rnd'])+long(self.statuslist[1]['Innodb_buffer_pool_read_ahead_seq']))-(long(self.statuslist[0]['Innodb_buffer_pool_read_ahead_rnd'])+long(self.statuslist[0]['Innodb_buffer_pool_read_ahead_seq']))  
    129. 
   
   
   
   
  129.     elif(param1=='Uptime_since_flush_status'):  
    130. 
   
   
   
   
  130.      return long(self.statuslist[1]['Uptime'])-long(self.statuslist[0]['Uptime'])  
    131. 
   
   
   
   
  131.     else:  
    132. 
   
   
   
   
  132.      return 0L  
    133. 
   
   
   
   
  133.   else:  
    134. 
   
   
   
   
  134.    if(self.statuslist[0].has_key(param1)):  
    135. 
   
   
   
   
  135.     return long(self.statuslist[0][param1])  
    136. 
   
   
   
   
  136.    else:  
    137. 
   
   
   
   
  137.     if(param1=='Innodb_buffer_pool_read_ahead' and version>5):  
    138. 
   
   
   
   
  138.      return long(self.statuslist[0]['Innodb_buffer_pool_read_ahead_rnd'])+long(self.statuslist[0]['Innodb_buffer_pool_read_ahead_seq'])  
    139. 
   
   
   
   
  139.     elif(param1=='Uptime_since_flush_status'):  
    140. 
   
   
   
   
  140.      return long(self.statuslist[0]['Uptime'])  
    141. 
   
   
   
   
  141.     else:  
    142. 
   
   
   
   
  142.      return 0L    
    143. 
   
   
   
   
  143.  
    144. 
   
   
   
   
  144.  def seconds(self):  
    145. 
   
   
   
   
  145.   return self.param('Uptime_since_flush_status')  
    146. 
   
   
   
   
  146.  '''  
    147. 
   
   
   
   
  147.  param1+param2+....params  
    148. 
   
   
   
   
  148.  '''  
    149. 
   
   
   
   
  149.  def arange(self,params):  
    150. 
   
   
   
   
  150.   re=0  
    151. 
   
   
   
   
  151.   for param in params:  
    152. 
   
   
   
   
  152.    re+=self.getval(param)  
    153. 
   
   
   
   
  153.   return re  
    154. 
   
   
   
   
  154.  '''  
    155. 
   
   
   
   
  155.  param1+param2  
    156. 
   
   
   
   
  156.  '''  
    157. 
   
   
   
   
  157.  def add(self,param1,param2):  
    158. 
   
   
   
   
  158.   return self.getval(param1)+self.getval(param2)  
    159. 
   
   
   
   
  159.  '''  
    160. 
   
   
   
   
  160.  param1-param2  
    161. 
   
   
   
   
  161.  '''      
    162. 
   
   
   
   
  162.  def sub(self,param1,param2):  
    163. 
   
   
   
   
  163.   return self.getval(param1)-self.getval(param2)  
    164. 
   
   
   
   
  164.  '''  
    165. 
   
   
   
   
  165.  param1*param2  
    166. 
   
   
   
   
  166.  '''  
    167. 
   
   
   
   
  167.  def ext(self,param1,param2):  
    168. 
   
   
   
   
  168.   return self.getval(param1)*self.getval(param2)  
    169. 
   
   
   
   
  169.  '''  
    170. 
   
   
   
   
  170.  param1/param2  
    171. 
   
   
   
   
  171.  '''      
    172. 
   
   
   
   
  172.  def per(self,param1,param2):  
    173. 
   
   
   
   
  173.   a=self.getval(param1)  
    174. 
   
   
   
   
  174.   b=self.getval(param2)  
    175. 
   
   
   
   
  175.   if(b!=0):  
    176. 
   
   
   
   
  176.    return Decimal(a)/Decimal(b)  
    177. 
   
   
   
   
  177.   else:  
    178. 
   
   
   
   
  178.    return Decimal(0)  
    179. 
   
   
   
   
  179.    
    180. 
   
   
   
   
  180.  '''  
    181. 
   
   
   
   
  181.  param/seconds  
    182. 
   
   
   
   
  182.  '''  
    183. 
   
   
   
   
  183.  def ps(self,param):  
    184. 
   
   
   
   
  184.   val=self.getval(param)  
    185. 
   
   
   
   
  185.     
    186. 
   
   
   
   
  186.   if(self.second>0):  
    187. 
   
   
   
   
  187.    return Decimal(val)/Decimal(self.second)  
    188. 
   
   
   
   
  188.   else:  
    189. 
   
   
   
   
  189.    return Decimal(0)  
    190. 
   
   
   
   
  190.  '''  
    191. 
   
   
   
   
  191.  format param to P T G M K  
    192. 
   
   
   
   
  192.  '''  
    193. 
   
   
   
   
  193.  def format(self,param):  
    194. 
   
   
   
   
  194.   val=self.getval(param)  
    195. 
   
   
   
   
  195.   return tools.dFormat(val)  
    196. 
   
   
   
   
  196.    
    197. 
   
   
   
   
  197.  def strFormat(self,param):  
    198. 
   
   
   
   
  198.   return self.statuslist[0][param]  
    199. 
   
   
   
   
  199.    
    200. 
   
   
   
   
  200.  '''  
    201. 
   
   
   
   
  201.  param1:param2 (param1/param2)  
    202. 
   
   
   
   
  202.  '''  
    203. 
   
   
   
   
  203.  def ratioF(self,param1,param2):  
    204. 
   
   
   
   
  204.   p1=self.getval(param1)  
    205. 
   
   
   
   
  205.   p2=self.getval(param2)  
    206. 
   
   
   
   
  206.   return tools.dRatio(p1, p2)  
    207. 
   
   
   
   
  207.  '''  
    208. 
   
   
   
   
  208.  param1/param2 % (param1/param2)  
    209. 
   
   
   
   
  209.  '''  
    210. 
   
   
   
   
  210.  def perF(self,param1,param2):  
    211. 
   
   
   
   
  211.   return self.format(self.per(param1, param2)*100) + "% "+self.remark(param1, param2)  
    212. 
   
   
   
   
  212.  '''  
    213. 
   
   
   
   
  213.  1-(param1/param2) % (param1/param2)  
    214. 
   
   
   
   
  214.  '''  
    215. 
   
   
   
   
  215.  def dperF(self,param1,param2):  
    216. 
   
   
   
   
  216.   return self.format((Decimal(1)-self.per(param1, param2))*100) + "% "+self.remark(param1, param2)  
    217. 
   
   
   
   
  217.  '''  
    218. 
   
   
   
   
  218.  param1/(param1+param2) % (param1/param2)  
    219. 
   
   
   
   
  219.  '''  
    220. 
   
   
   
   
  220.  def aperF(self,param1,param2):  
    221. 
   
   
   
   
  221.   return self.format(self.per(param1,self.add(param1, param2))*100) + "% "+self.remark(param1, param2)  
    222. 
   
   
   
   
  222.  '''  
    223. 
   
   
   
   
  223.  param/seconds % (param/seconds)  
    224. 
   
   
   
   
  224.  '''  
    225. 
   
   
   
   
  225.  def psF(self,param):  
    226. 
   
   
   
   
  226.   return self.format(self.ps(param))+"/s "+self.remark(param, self.second)  
    227. 
   
   
   
   
  227.    
    228. 
   
   
   
   
  228.  '''  
    229. 
   
   
   
   
  229.  (param1/param2)  
    230. 
   
   
   
   
  230.  '''  
    231. 
   
   
   
   
  231.  def remark(self,param1,param2):  
    232. 
   
   
   
   
  232.   params=[]  
    233. 
   
   
   
   
  233.   params.append(param1)  
    234. 
   
   
   
   
  234.   params.append(param2)  
    235. 
   
   
   
   
  235.   return self.remarks(params)  
    236. 
   
   
   
   
  236.  '''  
    237. 
   
   
   
   
  237.  (param1/param2/.../params)  
    238. 
   
   
   
   
  238.  '''  
    239. 
   
   
   
   
  239.  def remarks(self,params):  
    240. 
   
   
   
   
  240.   #print params  
    241. 
   
   
   
   
  241.   arr=[]  
    242. 
   
   
   
   
  242.   for param in params:  
    243. 
   
   
   
   
  243.    arr.append(self.format(self.getval(param)))  
    244. 
   
   
   
   
  244.   return "("+"/".join(arr)+")" 
    245. 
   
   
   
   
  245.     
    246. 
   
   
   
   
  246. class mysqlstatusmonitor(object):  
    247. 
   
   
   
   
  247.  def __init__(self,conn):  
    248. 
   
   
   
   
  248.   self.inx=times  
    249. 
   
   
   
   
  249.   self.conn=conn  
    250. 
   
   
   
   
  250.   self.statusList=[]  
    251. 
   
   
   
   
  251.   self.statustmpList=[]  
    252. 
   
   
   
   
  252.   self.totalstatus={}  
    253. 
   
   
   
   
  253.   self.totaltmpstatus=()  
    254. 
   
   
   
   
  254.   self.getstatus()  
    255. 
   
   
   
   
  255.    
    256. 
   
   
   
   
  256.  def getstatus(self):  
    257. 
   
   
   
   
  257.   statustmp=()  
    258. 
   
   
   
   
  258.   mysqlstatus={}  
    259. 
   
   
   
   
  259.   sql="show /*!41000 GLOBAL */ status" 
    260. 
   
   
   
   
  260.   cursor=self.conn.cursor()  
    261. 
   
   
   
   
  261.   for i in range(self.inx):  
    262. 
   
   
   
   
  262.    cursor.execute(sql)  
    263. 
   
   
   
   
  263.    statustmp=cursor.fetchall()  
    264. 
   
   
   
   
  264.    mysqlstatus={}  
    265. 
   
   
   
   
  265.    for row in statustmp:  
    266. 
   
   
   
   
  266.     mysqlstatus.setdefault(row[0],row[1])  
    267. 
   
   
   
   
  267.    self.statustmpList.append(statustmp)  
    268. 
   
   
   
   
  268.    self.statusList.append(mysqlstatus)  
    269. 
   
   
   
   
  269.    if(i<(self.inx-1)):  
    270. 
   
   
   
   
  270.     time.sleep(slow)  
    271. 
   
   
   
   
  271.    else:  
    272. 
   
   
   
   
  272.     self.totalstatus=mysqlstatus  
    273. 
   
   
   
   
  273.     self.totaltmpstatus=statustmp  
    274. 
   
   
   
   
  274.       
    275. 
   
   
   
   
  275.  def getstatusList(self):  
    276. 
   
   
   
   
  276.   return self.statusList  
    277. 
   
   
   
   
  277.    
    278. 
   
   
   
   
  278.  def getstatustmpList(self):  
    279. 
   
   
   
   
  279.   return self.statustmpList  
    280. 
   
   
   
   
  280.    
    281. 
   
   
   
   
  281.  def gettotalstatus(self):  
    282. 
   
   
   
   
  282.   return self.totalstatus  
    283. 
   
   
   
   
  283.    
    284. 
   
   
   
   
  284.  def gettotaltmpstatus(self):  
    285. 
   
   
   
   
  285.   return self.totaltmpstatus  
    286. 
   
   
   
   
  286.    
    287. 
   
   
   
   
  287. class mysqlpulse(object):  
    288. 
   
   
   
   
  288.  def __init__(self,conn,monitor):  
    289. 
   
   
   
   
  289.   self.conn=conn  
    290. 
   
   
   
   
  290.   self.version=version  
    291. 
   
   
   
   
  291.   cursor=conn.cursor()  
    292. 
   
   
   
   
  292.   sql="select current_user();" 
    293. 
   
   
   
   
  293.   cursor.execute(sql)  
    294. 
   
   
   
   
  294.   self.currentuser=cursor.fetchall()  
    295. 
   
   
   
   
  295.   sql="show /*!41000 GLOBAL */ variables;" 
    296. 
   
   
   
   
  296.   cursor.execute(sql)  
    297. 
   
   
   
   
  297.   self.variablestmp=cursor.fetchall()  
    298. 
   
   
   
   
  298.   self.variables={}  
    299. 
   
   
   
   
  299.   for row in self.variablestmp:  
    300. 
   
   
   
   
  300.    self.variables.setdefault(row[0],row[1])  
    301. 
   
   
   
   
  301.   #  
    302. 
   
   
   
   
  302.   self.statusList=monitor.getstatusList()  
    303. 
   
   
   
   
  303.   self.statustmpList=monitor.getstatustmpList()  
    304. 
   
   
   
   
  304.   self.statustmp=monitor.gettotaltmpstatus()  
    305. 
   
   
   
   
  305.   self.mysqlstatus=monitor.gettotalstatus()  
    306. 
   
   
   
   
  306.     
    307. 
   
   
   
   
  307.   self.totalcomputer=mysqlstatuscomputer([self.mysqlstatus])  
    308. 
   
   
   
   
  308.   self.computer=mysqlstatuscomputer(self.statusList)  
    309. 
   
   
   
   
  309.   self.mysqlvariables=mysqlvariables(self.variables)  
    310. 
   
   
   
   
  310.   #   
    311. 
   
   
   
   
  311.   #sql="SHOW /*!41000 ENGINE */ INNODB STATUS;" 
    312. 
   
   
   
   
  312.   #cursor.execute(sql)  
    313. 
   
   
   
   
  313.   #self.innodbstatus=cursor.fetchall()  
    314. 
   
   
   
   
  314.     
    315. 
   
   
   
   
  315.   #ver="" 
    316. 
   
   
   
   
  316.   #match=re.compile(r'^([\d]+\.[\d]+)').match(set[0][0])  
    317. 
   
   
   
   
  317.   #if match:  
    318. 
   
   
   
   
  318.   #    ver=match.group(1)  
    319. 
   
   
   
   
  319.      
    320. 
   
   
   
   
  320.   #del set 
    321. 
   
   
   
   
  321.   sql="show databases" 
    322. 
   
   
   
   
  322.   cursor.execute(sql)  
    323. 
   
   
   
   
  323.   self.tables=[]  
    324. 
   
   
   
   
  324.   self.databases=cursor.fetchall()  
    325. 
   
   
   
   
  325.   for tmpdatabase in self.databases:  
    326. 
   
   
   
   
  326.    if(str(tmpdatabase[0])!="information_schema" and str(tmpdatabase[0])!="mysql" and str(tmpdatabase[0])!="performance_schema"):  
    327. 
   
   
   
   
  327.     sql="show table status from `"+str(tmpdatabase[0])+"`" 
    328. 
   
   
   
   
  328.     cursor.execute(sql)  
    329. 
   
   
   
   
  329.     tmptables=cursor.fetchall()  
    330. 
   
   
   
   
  330.     for tmptable in tmptables:  
    331. 
   
   
   
   
  331.      tableinfo=[]  
    332. 
   
   
   
   
  332.      tableinfo.append(tmpdatabase[0])  
    333. 
   
   
   
   
  333.      tableinfoindex=len(tmptable)  
    334. 
   
   
   
   
  334.      for idx in range(tableinfoindex):  
    335. 
   
   
   
   
  335.       tableinfo.append(tmptable[idx])  
    336. 
   
   
   
   
  336.      self.tables.append(tableinfo)  
    337. 
   
   
   
   
  337.        
    338. 
   
   
   
   
  338.     
    339. 
   
   
   
   
  339.   #  
    340. 
   
   
   
   
  340.   sql="SHOW PROCESSLIST;" 
    341. 
   
   
   
   
  341.   cursor.execute(sql)  
    342. 
   
   
   
   
  342.   self.processlist=cursor.fetchall()  
    343. 
   
   
   
   
  343.      
    344. 
   
   
   
   
  344.  def abs(self,left,right):  
    345. 
   
   
   
   
  345.   return cmp(left[8],right[8])  
    346. 
   
   
   
   
  346.    
    347. 
   
   
   
   
  347.    
    348. 
   
   
   
   
  348.  def desc(self,left,right):  
    349. 
   
   
   
   
  349.   return cmp(right[8],left[8])  
    350. 
   
   
   
   
  350.    
    351. 
   
   
   
   
  351.  def printstatus(self):  
    352. 
   
   
   
   
  352.   print "============MySQL status============" 
    353. 
   
   
   
   
  353.   print "get status times="+str(len(self.statustmpList))  
    354. 
   
   
   
   
  354.   for row in self.statustmp:  
    355. 
   
   
   
   
  355.    print row[0]+"\t:"+row[1]  
    356. 
   
   
   
   
  356.    
    357. 
   
   
   
   
  357.    
    358. 
   
   
   
   
  358.  def printinnodbstatus(self):  
    359. 
   
   
   
   
  359.   print self.innodbstatus[0][2]  
    360. 
   
   
   
   
  360.     
    361. 
   
   
   
   
  361.  def printtablestatus(self):  
    362. 
   
   
   
   
  362.   print "------------------------------------" 
    363. 
   
   
   
   
  363.   print "table status" 
    364. 
   
   
   
   
  364.   print "------------------------------------" 
    365. 
   
   
   
   
  365.   print "db\t\tName\t\tEngine\t\tVersion\t\tRow_format\t\tRows\t\tAvg_row_length\t\tData_length\t\tMax_data_length\t\tIndex_lengtht\t\tData_free\t\tAuto_increment\t\tCreate_time\t\tUpdate_time\t\tCheck_time\t\tCollation\t\tChecksum\t\tCreate_options\t\tComment" 
    366. 
   
   
   
   
  366.   self.tables.sort(cmp=self.desc)  
    367. 
   
   
   
   
  367.   for row in self.tables:  
    368. 
   
   
   
   
  368.    tableinfolen=len(row)  
    369. 
   
   
   
   
  369.    tableinfo="" 
    370. 
   
   
   
   
  370.    for idx in range(tableinfolen):  
    371. 
   
   
   
   
  371.     tableinfo+=str(row[idx])+"\t\t" 
    372. 
   
   
   
   
  372.    print tableinfo  
    373. 
   
   
   
   
  373.    
    374. 
   
   
   
   
  374.  def printprocesslist(self):  
    375. 
   
   
   
   
  375.   print "============processlist=============" 
    376. 
   
   
   
   
  376.   print "processlist rowcount ="+str(len(self.processlist))+"
    status time>0 threads list:"     
    377. 
   
   
   
   
  377.   print "Id\tUser\t\tHost\t\t\tdb\t\tCommand\t\tTime\t\tState\tInfo\t" 
    378. 
   
   
   
   
  378.   threadscount=0  
    379. 
   
   
   
   
  379.   for row in self.processlist:  
    380. 
   
   
   
   
  380.    if(str(row[4])!="Sleep" and long(row[5])>1):  
    381. 
   
   
   
   
  381.     print str(row[0])+"\t"+str(row[1])+"\t\t"+str(row[2])+"\t"+str(row[3])+"\t\t"+str(row[4])+"\t\t"+str(row[5])+"\t\t"+str(row[6])+"\t"+str(row[7])  
    382. 
   
   
   
   
  382.     threadscount+=1  
    383. 
   
   
   
   
  383.       
    384. 
   
   
   
   
  384.   print "status time>0 threads count="+str(threadscount)  
    385. 
   
   
   
   
  385.    
    386. 
   
   
   
   
  386.    
    387. 
   
   
   
   
  387.  def printmysqlinfo(self):  
    388. 
   
   
   
   
  388.   print "=============MySQL info=============" 
    389. 
   
   
   
   
  389.   print "Connection id        : "+str(self.conn.thread_id())  
    390. 
   
   
   
   
  390.   print "Current database     : "+dbname  
    391. 
   
   
   
   
  391.   print "Current user         : "+str(self.currentuser[0][0])  
    392. 
   
   
   
   
  392.   print "SSL                  : "+self.mysqlvariables.strFormat('have_openssl')  
    393. 
   
   
   
   
  393.   #print "Current pager        : " 
    394. 
   
   
   
   
  394.   #print "Using outfile        : " 
    395. 
   
   
   
   
  395.   #print "Using delimiter      : " 
    396. 
   
   
   
   
  396.   self.version=Decimal(self.mysqlvariables.strFormat('version')[0:3])  
    397. 
   
   
   
   
  397.   print "MySQL VERSION        : "+self.mysqlvariables.strFormat('version')+" "+self.mysqlvariables.strFormat('version_comment')  
    398. 
   
   
   
   
  398.   print "MySQL client info    : "+_mysql.get_client_info()  
    399. 
   
   
   
   
  399.   print "Protocol version     : "+str(self.conn.get_proto_info())  
    400. 
   
   
   
   
  400.   print "Connection           : "+self.conn.get_host_info()  
    401. 
   
   
   
   
  401.   print "Server characterset  : "+self.mysqlvariables.strFormat('character_set_server')  
    402. 
   
   
   
   
  402.   print "Db     characterset  : "+self.mysqlvariables.strFormat('character_set_database')  
    403. 
   
   
   
   
  403.   print "Client characterset  : "+self.mysqlvariables.strFormat('character_set_client')  
    404. 
   
   
   
   
  404.   print "Conn.  characterset  : "+self.mysqlvariables.strFormat('character_set_connection')  
    405. 
   
   
   
   
  405.   print "collation_connection : "+self.mysqlvariables.strFormat('collation_connection')  
    406. 
   
   
   
   
  406.   print "collation_database   : "+self.mysqlvariables.strFormat('collation_database')  
    407. 
   
   
   
   
  407.   print "collation_server     : "+self.mysqlvariables.strFormat('collation_server')  
    408. 
   
   
   
   
  408.   print "Uptime               : "+self.mysqlstatus['Uptime']+"s" 
    409. 
   
   
   
   
  409.     
    410. 
   
   
   
   
  410.  def printQcachestatus(self):  
    411. 
   
   
   
   
  411.   if(self.mysqlvariables.strFormat("have_query_cache")=="YES" and self.mysqlvariables.strFormat("query_cache_type")!="OFF" and self.mysqlvariables.param("query_cache_size")>0):  
    412. 
   
   
   
   
  412.    print "------------------------------------" 
    413. 
   
   
   
   
  413.    print "Qcache Status" 
    414. 
   
   
   
   
  414.    print "------------------------------------" 
    415. 
   
   
   
   
  415.    tools.println("Qcache queries hits ratio(hits/reads)",self.totalcomputer.perF("Qcache_hits", ["Com_select", "Qcache_hits"]),self.computer.perF("Qcache_hits", ["Com_select", "Qcache_hits"]),"Higher than 30.00")  
    416. 
   
   
   
   
  416.    tools.println("Qcache hits inserts ratio(hits/inserts)",self.totalcomputer.perF("Qcache_hits", "Qcache_inserts"),self.computer.perF("Qcache_hits", "Qcache_inserts"),"Higher than 300.00")  
    417. 
   
   
   
   
  417.    tools.println("Qcache memory used ratio(free/total)",self.totalcomputer.dperF("Qcache_free_memory",self.mysqlvariables.param("query_cache_size")))  
    418. 
   
   
   
   
  418.    tools.println("Qcache prune ratio(prunes/inserts)",self.totalcomputer.perF("Qcache_lowmem_prunes", "Qcache_inserts"),self.computer.perF("Qcache_lowmem_prunes", "Qcache_inserts"))  
    419. 
   
   
   
   
  419.    tools.println("Qcache block Fragmnt ratio(free/total)",self.totalcomputer.perF("Qcache_free_blocks", "Qcache_total_blocks"))  
    420. 
   
   
   
   
  420.    
    421. 
   
   
   
   
  421.  def printUptimesinceflushstatus(self):  
    422. 
   
   
   
   
  422.   print "-----------------------------------------------------------------------------------------------------------------------------" 
    423. 
   
   
   
   
  423.   print "Reads/Writes status                            total                        current                        proposal          " 
    424. 
   
   
   
   
  424.   print "-----------------------------------------------------------------------------------------------------------------------------" 
    425. 
   
   
   
   
  425.   tools.println("Reads:Writes ratio(Reads/Writes)",self.totalcomputer.ratioF(["Com_select", "Qcache_hits"], ["Com_insert","Com_insert_select","Com_update","Com_update_multi","Com_delete","Com_delete_multi","Com_replace","Com_replace_select"]),self.computer.ratioF(["Com_select", "Qcache_hits"], ["Com_insert","Com_insert_select","Com_update","Com_update_multi","Com_delete","Com_delete_multi","Com_replace","Com_replace_select"]))  
    426. 
   
   
   
   
  426.   tools.println("QPS(Questions/Uptime)",self.totalcomputer.psF("Questions"),self.computer.psF("Questions"))  
    427. 
   
   
   
   
  427.   tools.println("TPS(Questions/Uptime)",self.totalcomputer.psF(["Com_commit","Com_rollback"]),self.computer.psF(["Com_commit","Com_rollback"]))  
    428. 
   
   
   
   
  428.   tools.println("Table locks waited ratio(waited/immediate)",self.totalcomputer.ratioF("Table_locks_waited","Table_locks_immediate"),self.computer.ratioF("Table_locks_waited","Table_locks_immediate"),"0:1")  
    429. 
   
   
   
   
  429.   tools.println("select per second(select/Uptime)",self.totalcomputer.psF(["Com_select","Qcache_hits"]),self.computer.psF(["Com_select","Qcache_hits"]))  
    430. 
   
   
   
   
  430.   tools.println("insert per second(insert/Uptime)",self.totalcomputer.psF(["Com_insert","Com_insert_select"]),self.computer.psF(["Com_insert","Com_insert_select"]))  
    431. 
   
   
   
   
  431.   tools.println("update per second(update/Uptime)",self.totalcomputer.psF(["Com_update","Com_update_multi"]),self.computer.psF(["Com_update","Com_update_multi"]))  
    432. 
   
   
   
   
  432.   tools.println("delete per second(delete/Uptime)",self.totalcomputer.psF(["Com_delete","Com_delete_multi"]),self.computer.psF(["Com_delete","Com_delete_multi"]))  
    433. 
   
   
   
   
  433.   tools.println("replace per second(replace/Uptime)",self.totalcomputer.psF(["Com_replace","Com_replace_select"]),self.computer.psF(["Com_replace","Com_replace_select"]))   
    434. 
   
   
   
   
  434.   tools.println("Bytes sent per second(sent/Uptime)",self.totalcomputer.psF("Bytes_sent"),self.computer.psF("Bytes_sent"))  
    435. 
   
   
   
   
  435.   tools.println("Bytes received per second(re/Uptime)",self.totalcomputer.psF("Bytes_received"),self.computer.psF("Bytes_received"))  
    436. 
   
   
   
   
  436.   print "------------------------------------" 
    437. 
   
   
   
   
  437.   print "Slow and Sort queries status" 
    438. 
   
   
   
   
  438.   print "------------------------------------" 
    439. 
   
   
   
   
  439.   tools.println("Slow queries Ratio(Slow/Questions)",self.totalcomputer.perF("Slow_queries", "Questions"),self.computer.perF("Slow_queries", "Questions"),"Lower than 0")  
    440. 
   
   
   
   
  440.   tools.println("Slow queries PS(Slow/Uptime)",self.totalcomputer.psF("Slow_queries"),self.computer.psF("Slow_queries"),"Lower than 0")  
    441. 
   
   
   
   
  441.   tools.println("Full join PS(full/Uptime)",self.totalcomputer.psF("Select_full_join"),self.computer.psF("Select_full_join"),"Lower than 0")  
    442. 
   
   
   
   
  442.   tools.println("Sort merge passes PS(merge/Uptime)",self.totalcomputer.psF("Sort_merge_passes"),self.computer.psF("Sort_merge_passes"),"Lower than 0")  
    443. 
   
   
   
   
  443.   tools.println("Sort range PS(range/Uptime)",self.totalcomputer.psF("Sort_range"),self.computer.psF("Sort_range"),"Lower than 0")  
    444. 
   
   
   
   
  444.   tools.println("Sort rows PS(rows/Uptime)",self.totalcomputer.psF("Sort_rows"),self.computer.psF("Sort_rows"),"Lower than 0")  
    445. 
   
   
   
   
  445.   tools.println("Sort scan PS(scan/Uptime)",self.totalcomputer.psF("Sort_scan"),self.computer.psF("Sort_scan"),"Lower than 0")  
    446. 
   
   
   
   
  446.   print "------------------------------------" 
    447. 
   
   
   
   
  447.   print "connections status" 
    448. 
   
   
   
   
  448.   print "------------------------------------" 
    449. 
   
   
   
   
  449.   tools.println("Thread cache hits(created/Total)",self.totalcomputer.dperF("Threads_created", "Connections"),self.computer.dperF("Threads_created", "Connections"),"Higher than 0")  
    450. 
   
   
   
   
  450.   tools.println("Connections used ratio(Max used/Max)",self.totalcomputer.perF("Max_used_connections",self.mysqlvariables.param("max_connections")),self.computer.perF("Max_used_connections",self.mysqlvariables.param("max_connections")),"Lower than 90")  
    451. 
   
   
   
   
  451.   tools.println("Aborted connects ratio(Aborted/Max)",self.totalcomputer.perF(["Aborted_clients","Aborted_connects"],self.mysqlvariables.param("max_connections")),self.computer.perF(["Aborted_clients","Aborted_connects"],self.mysqlvariables.param("max_connections")),"Lower than 0")  
    452. 
   
   
   
   
  452.   tools.println("Threads running",self.totalcomputer.format("Threads_running"))  
    453. 
   
   
   
   
  453.   print "------------------------------------" 
    454. 
   
   
   
   
  454.   print "temp table and Open tables/files status" 
    455. 
   
   
   
   
  455.   print "------------------------------------" 
    456. 
   
   
   
   
  456.   tools.println("Temp tables to Disk ratio(disk/tmp)",self.totalcomputer.perF("Created_tmp_disk_tables", "Created_tmp_tables"),self.computer.perF("Created_tmp_disk_tables", "Created_tmp_tables"),"Lower than 0")  
    457. 
   
   
   
   
  457.   tools.println("Open tables/table open cache/Opened tables",self.totalcomputer.remarks(["Open_tables",self.mysqlvariables.param("table_open_cache"),"Opened_tables"]),self.computer.remarks(["Open_tables",self.mysqlvariables.param("table_open_cache"),"Opened_tables"]),"1:1:1")  
    458. 
   
   
   
   
  458.   tools.println("Opened files PS(Opened/Uptime)",self.totalcomputer.psF("Opened_files"),self.computer.psF("Opened_files"),"Lower than 0")  
    459. 
   
   
   
   
  459.    
    460. 
   
   
   
   
  460.  def printInnoDBStatus(self):  
    461. 
   
   
   
   
  461.   print "------------------------------------" 
    462. 
   
   
   
   
  462.   print "InnoDB Status" 
    463. 
   
   
   
   
  463.   print "------------------------------------" 
    464. 
   
   
   
   
  464.   tools.println( "Innodb buffer read hits(Disk/total)",self.totalcomputer.dperF(["Innodb_buffer_pool_reads","Innodb_buffer_pool_read_ahead"], "Innodb_buffer_pool_read_requests"),self.computer.dperF(["Innodb_buffer_pool_reads","Innodb_buffer_pool_read_ahead"], "Innodb_buffer_pool_read_requests"),"Higher than 99.99")  
    465. 
   
   
   
   
  465.   tools.println( "Innodb dblwr pages written:dblwr writes",self.totalcomputer.ratioF("Innodb_dblwr_pages_written", "Innodb_dblwr_writes"),"","Lower than 64:1")  
    466. 
   
   
   
   
  466.   tools.println( "Innodb buffer pages used ratio(free/total)",self.totalcomputer.dperF("Innodb_buffer_pool_pages_free", "Innodb_buffer_pool_pages_total"),"","Lower than 99.99")  
    467. 
   
   
   
   
  467.   tools.println( "Innodb buffer pages dirty ratio(dirty)",self.totalcomputer.perF("Innodb_buffer_pool_pages_dirty", "Innodb_buffer_pool_pages_total"))  
    468. 
   
   
   
   
  468.   tools.println( "Innodb buffer pages flushed PS(flushed)",self.totalcomputer.psF("Innodb_buffer_pool_pages_flushed"),self.computer.psF("Innodb_buffer_pool_pages_flushed"))  
    469. 
   
   
   
   
  469.   tools.println( "Innodb buffer pool pages misc",self.totalcomputer.format("Innodb_buffer_pool_pages_misc"))  
    470. 
   
   
   
   
  470.     
    471. 
   
   
   
   
  471.   tools.println( "Innodb row lock waits PS(waits/Uptime)",self.totalcomputer.psF("Innodb_row_lock_current_waits"),self.computer.psF("Innodb_row_lock_current_waits"))  
    472. 
   
   
   
   
  472.   tools.println( "Innodb row lock current waits",self.totalcomputer.format("Innodb_row_lock_current_waits"),self.computer.format("Innodb_row_lock_current_waits"))  
    473. 
   
   
   
   
  473.   tools.println( "Innodb row lock time avg",self.totalcomputer.format("Innodb_row_lock_time_avg"),self.computer.format("Innodb_row_lock_time_avg"))  
    474. 
   
   
   
   
  474.   tools.println( "Innodb row lock time max",self.totalcomputer.format("Innodb_row_lock_time_max"),self.computer.format("Innodb_row_lock_time_max"))  
    475. 
   
   
   
   
  475.   tools.println( "Innodb row lock time total",self.totalcomputer.format("Innodb_row_lock_time"),self.computer.format("Innodb_row_lock_time"))  
    476. 
   
   
   
   
  476.     
    477. 
   
   
   
   
  477.   tools.println( "Innodb rows read PS(read/Uptime)",self.totalcomputer.psF("Innodb_rows_read"),self.computer.psF("Innodb_rows_read"))  
    478. 
   
   
   
   
  478.   tools.println( "Innodb rows inserted PS(inserted/Uptime)",self.totalcomputer.psF("Innodb_rows_inserted"),self.computer.psF("Innodb_rows_inserted"))  
    479. 
   
   
   
   
  479.   tools.println( "Innodb rows updated PS(updated/Uptime)",self.totalcomputer.psF("Innodb_rows_updated"),self.computer.psF("Innodb_rows_updated"))  
    480. 
   
   
   
   
  480.     
    481. 
   
   
   
   
  481.   tools.println( "Innodb data reads PS(reads/Uptime)",self.totalcomputer.psF("Innodb_data_reads"),self.computer.psF("Innodb_data_reads"))  
    482. 
   
   
   
   
  482.   tools.println( "Innodb data writes PS(writes/Uptime)",self.totalcomputer.psF("Innodb_data_writes"),self.computer.psF("Innodb_data_writes"))  
    483. 
   
   
   
   
  483.   tools.println( "Innodb data fsyncs PS(fsyncs/Uptime)",self.totalcomputer.psF("Innodb_data_fsyncs"),self.computer.psF("Innodb_data_fsyncs"))  
    484. 
   
   
   
   
  484.     
    485. 
   
   
   
   
  485.   tools.println( "Innodb data pending reads PS(reads/Uptime)",self.totalcomputer.psF("Innodb_data_pending_reads"),self.computer.psF("Innodb_data_pending_reads"))  
    486. 
   
   
   
   
  486.   tools.println( "Innodb data pending writes PS(write/Uptime)",self.totalcomputer.psF("Innodb_data_pending_writes"),self.computer.psF("Innodb_data_pending_writes"))  
    487. 
   
   
   
   
  487.   tools.println( "Innodb data pending fsyncs PS(fsync/Uptime)",self.totalcomputer.psF("Innodb_data_pending_fsyncs"),self.computer.psF("Innodb_data_pending_fsyncs"))  
    488. 
   
   
   
   
  488.     
    489. 
   
   
   
   
  489.  def printkeystatus(self):  
    490. 
   
   
   
   
  490.   print "------------------------------------" 
    491. 
   
   
   
   
  491.   print "key buffer Status" 
    492. 
   
   
   
   
  492.   print "------------------------------------" 
    493. 
   
   
   
   
  493.   tools.println( "key buffer used ratio(used/size)",self.totalcomputer.perF(self.totalcomputer.ext("Key_blocks_used",self.mysqlvariables.param("key_cache_block_size")), self.mysqlvariables.param("key_buffer_size")),"","Lower than 99.99")  
    494. 
   
   
   
   
  494.   tools.println( "key buffer read hit ratio(reads/request)",self.totalcomputer.dperF("Key_reads", "Key_read_requests"),self.computer.dperF("Key_reads", "Key_read_requests"),"Higher than 99.99")  
    495. 
   
   
   
   
  495.   tools.println( "key buffer write hit ratio(writes/request)",self.totalcomputer.dperF("Key_writes", "Key_write_requests"),self.computer.dperF("Key_writes", "Key_write_requests"),"Higher than 99.99")  
    496. 
   
   
   
   
  496.    
    497. 
   
   
   
   
  497.  def printslavestatus(self):  
    498. 
   
   
   
   
  498.   print "------------------------------------" 
    499. 
   
   
   
   
  499.   print "Slave Status" 
    500. 
   
   
   
   
  500.   print "------------------------------------" 
    501. 
   
   
   
   
  501.   tools.println( "Slave running status",self.totalcomputer.strFormat("Slave_running"),self.computer.strFormat("Slave_running"))  
    502. 
   
   
   
   
  502.   tools.println( "Slave open temp tables",self.totalcomputer.format("Slave_open_temp_tables"),self.computer.format("Slave_open_temp_tables"))  
    503. 
   
   
   
   
  503.   tools.println( "Slave transactions PS(transactions/Uptime)",self.totalcomputer.psF("Slave_retried_transactions"),self.computer.psF("Slave_retried_transactions"))  
    504. 
   
   
   
   
  504.   tools.println( "Slave received PS(heartbeats/Uptime)",self.totalcomputer.psF("Slave_received_heartbeats"),self.computer.psF("Slave_received_heartbeats"))  
    505. 
   
   
   
   
  505.    
    506. 
   
   
   
   
  506.  def printflushstatus(self):  
    507. 
   
   
   
   
  507.   print "=========MySQL status pulse=========" 
    508. 
   
   
   
   
  508.   self.printUptimesinceflushstatus()  
    509. 
   
   
   
   
  509.   if(self.version> Decimal("5")):  
    510. 
   
   
   
   
  510.    self.printInnoDBStatus()  
    511. 
   
   
   
   
  511.   self.printkeystatus()  
    512. 
   
   
   
   
  512.   self.printQcachestatus()  
    513. 
   
   
   
   
  513.   self.printslavestatus()  
    514. 
   
   
   
   
  514.   #self.printtablestatus()  
    515. 
   
   
   
   
  515.  
    516. 
   
   
   
   
  516. class mysqlmonitor(object):  
    517. 
   
   
   
   
  517.  def __init__(self,dbs):  
    518. 
   
   
   
   
  518.   self.conn=MySQLdb.connect(host=dbs['host'],port=dbs['port'],user=dbs['user'],passwd=dbs['passwd'],db=dbs['db'])  
    519. 
   
   
   
   
  519.   self.monitor=mysqlstatusmonitor(self.conn)  
    520. 
   
   
   
   
  520.   self.pulse=mysqlpulse(self.conn,self.monitor)  
    521. 
   
   
   
   
  521.     
    522. 
   
   
   
   
  522.  def du(self):  
    523. 
   
   
   
   
  523.   self.pulse.printmysqlinfo()  
    524. 
   
   
   
   
  524.   self.pulse.printprocesslist()  
    525. 
   
   
   
   
  525.   self.pulse.printflushstatus()  
    526. 
   
   
   
   
  526.   #printstatus(statustmp, statustmpList)  
    527. 
   
   
   
   
  527.   #printinnodbstatus(innodbstatus)  
    528. 
   
   
   
   
  528.    
    529. 
   
   
   
   
  529.  def __del__( self ):  
    530. 
   
   
   
   
  530.   self.conn.close()  
    531. 
   
   
   
   
  531.  
    532. 
   
   
   
   
  532. if __name__ == '__main__':  
    533. 
   
   
   
   
  533.  host = raw_input("Host[localhost]:")  
    534. 
   
   
   
   
  534.  if not host.strip():host = "localhost" 
    535. 
   
   
   
   
  535.  user = raw_input("User[root]:")  
    536. 
   
   
   
   
  536.  if not user.strip():user = "root" 
    537. 
   
   
   
   
  537.  pwd = getpass.getpass("Password %s@%s:" % (user,host))  
    538. 
   
   
   
   
  538.  dbname = raw_input("database[mysql]:")  
    539. 
   
   
   
   
  539.  if not dbname.strip():dbname = "mysql"         
    540. 
   
   
   
   
  540.  dbs={'host':host,'port':port,'user':user,'passwd':pwd,'db':dbname}  
    541. 
   
   
   
   
  541.  monitor=mysqlmonitor(dbs)  
    542. 
   
   
   
   
  542.  monitor.du()  
    543. 
   
   
   
   
  543.  
    544.

転載先http://www.linuxidc.com/Linux/2012-08/67832.htmMySQLの最適化私は2つの部分に分けて、1つはサーバーの物理のハードウェアの最適化で、2つはMySQL自身(my.cnf)の最適化です.一、サーバーハードウェアがMySQL性能に与える影響①ディスクシーク能力(ディスクI/O)は、現在の高回転SCSIハードディスク(7200回転/秒)を例にとると、このハードディスクは理論的には毎秒7200回シークされ、これは物理特性によって決定され、変更できない.MySQLでは毎秒、大量で複雑なクエリー操作が行われており、ディスクの読み書き量が予想されます.そのため、ディスクI/OはMySQLの性能を制約する最大の要因の一つとされ、1日平均アクセス数が100万PV以上のDiscuzに対して!フォーラム、ディスクI/Oの制約のため、MySQLの性能はとても低いことができます!この制約要因を解決するには、RAID-0+1ディスクアレイを使用し、RAID-5を使用しないように注意してください.MySQLのRAID-5ディスクアレイでの効率は期待通りに速くありません.②CPUはMySQLアプリケーションに対して、S.M.P.アーキテクチャの多重対称CPUを推奨します.例えば、Intel Xeon 3.6 GHzのCPUを2つ使用することができます.今、mysqlだけでなく、4 Uのサーバでデータベースサーバを専門にすることをお勧めします.③物理メモリはMySQLを使用するDatabase Server 1台にとって、サーバーメモリは2 GB以下ではなく、4 GB以上の物理メモリを使用することをお勧めしますが、メモリは現在のサーバーにとって無視できる問題と言え、仕事中にハイエンドサーバーに遭遇した場合、基本的にメモリは16 Gを超えています.
二、MySQL自身の要因上記サーバーのハードウェア制約要因を解決した後、MySQL自身の最適化がどのように操作されているかを見てみましょう.MySQL自体の最適化は主にプロファイルmyです.cnfの各パラメータを最適化調整します.パフォーマンスに大きな影響を及ぼすパラメータについて説明します.なぜならcnfファイルの最適化設定はサーバハードウェア構成と密接に関係しているため、仮想的なサーバハードウェア環境を指定します.CPU:Intel Xeon 2.4 GHzメモリ2個:4 GB DDRハードディスク:SCSI 73 GB(一般的な2 Uサーバ).
次に、上記のハードウェア構成に基づいて、最適化されたmyを結合する.cnf説明:#vim/etc/my.cnf以下はmyのみをリストする.cnfファイルの[mysqld]段落の内容、その他の段落の内容はMySQLの実行性能にわずかな影響を及ぼすため、一応無視します.[mysqld] port = 3306 serverid = 1 socket =/tmp/mysql.sock skip-locking#MySQLの外部ロックを回避し、エラー確率を低減し安定性を向上させる.skip-name-resolve#は、MySQLが外部接続をDNS解析することを禁止します.このオプションを使用すると、MySQLがDNS解析を行う時間を排除できます.ただし、このオプションをオンにすると、すべてのリモートホスト接続許可はIPアドレス方式を使用しなければなりません.そうしないと、MySQLは接続要求を正常に処理できません.back_log = 384 #back_logパラメータの値は、MySQLが新しいリクエストへの応答を一時的に停止するまでの短時間でスタックに存在できるリクエストの数を示します.システムが短時間で多くの接続を持っている場合、そのパラメータの値を大きくする必要があります.このパラメータの値は、到来するTCP/IP接続のリスニングキューのサイズを指定します.異なるオペレーティングシステムは、このキューサイズに独自の制限があります.back_を設定しようとするlogがあなたのオペレーティングシステムより高い制限は無効です.既定値は50です.Linuxシステムでは512未満の整数を推奨します.key_buffer_size = 256M #key_buffer_sizeインデックスに使用するバッファサイズを指定し、インデックス処理のパフォーマンスを向上させます.このパラメータは、4 GB程度のサーバに対して256 Mまたは384 Mとすることができる.注意:このパラメータ値の設定が大きすぎると、サーバ全体の効率が低下します.max_allowed_packet = 4M thread_stack = 256K table_cache = 128K sort_buffer_size=6 M#クエリのソート時に使用できるバッファサイズ.注意:このパラメータに対応する割り当てメモリは、接続ごとに排他的であり、100個の接続がある場合、実際に割り当てられた合計ソートバッファサイズは100です.× 6 ＝ 600MB.したがって,4 GB程度のサーバについては6−8 Mを推奨する.read_buffer_size=4 M#リードクエリ操作で使用できるバッファサイズ.とsort_buffer_sizeと同様に、このパラメータに対応する割り当てメモリも接続ごとに使用されます.join_buffer_size=8 M#クエリー操作で使用できるバッファサイズとsort_buffer_sizeと同様に、このパラメータに対応する割り当てメモリも接続ごとに使用されます.myisam_sort_buffer_size = 64M table_cache = 512 thread_cache_size = 64 query_cache_size=64 M#MySQLクエリーバッファのサイズを指定します.Qcache_lowmem_prunesの値は非常に大きく、バッファが足りないことが多いことを示しています.Qcache_hitsの値が非常に大きい場合は、クエリー・バッファが頻繁に使用されていることを示します.この値が小さいと、逆に効率に影響を与える場合は、クエリー・バッファを使用しないことが考えられます.Qcache_free_blocksは、この値が非常に大きい場合、バッファに破片が多いことを示します.tmp_table_size = 256M max_Connections=768#MySQLが許可する最大接続プロセス数を指定します.フォーラムにアクセスするときにToo Many Connectionsのエラーメッセージが頻繁に表示される場合は、このパラメータ値を大きくする必要があります.max_connect_errors = 10000000 wait_timeout=10#1つのリクエストの最大接続時間を指定し、4 GB程度のメモリのサーバに対して5-10に設定できます.thread_concurrency=8#このパラメータの値はサーバロジックCPU数*2であり、この例ではサーバに物理CPUが2本あり、各物理CPUはH.Tハイパースレッドをサポートするので、実際の値は4*2=8 skip-networking#であり、このオプションをオンにするとMySQLのTCP/IP接続方式を完全にオフにすることができる.WEBサーバがリモート接続でMySQLデータベースサーバにアクセスしている場合は、このオプションをオンにしないでください.正常に接続できません.table_Cache=1024#物理メモリが大きいほど設定が大きくなる.デフォルトは2402で、512-1024に最適なinnodb_に変更されます.additional_mem_pool_size=4 M#デフォルトは2 M innodb_flush_log_at_trx_commit=1#を0に設定するとinnodb_まで待つlog_buffer_size列がいっぱいになったら統一的に保存し、デフォルトは1 innodb_log_buffer_size=2 M#デフォルトは1 M innodb_thread_concurrency=8#あなたのサーバーのCPUはいくつかあっていくつに設定して、デフォルトで普通は8 key_になることを提案しますbuffer_size=256 M#デフォルトは218で、128最適tmp_に調整されます.table_size=64 M#デフォルトは16 M、64-256最掛read_へbuffer_size=4 M#デフォルトは64 K read_rnd_buffer_size=16 M#デフォルトは256 K sort_buffer_size=32 M#デフォルトは256 K thread_cache_size=120#デフォルトは60 query_cache_size=32 M※注意すべきは、多くの場合、具体的な状況を具体的に分析する必要がある.readsが大きすぎるならmy.cnfでKey_buffer_sizeが大きくなり、Key_をキープreads/Key_read_requestsは少なくとも1/100以上で、小さいほどいいです.二、もしQcache_lowmem_prunesは大きくて、Queryを増やそうとしています.cache_sizeの転載先http://blog.csdn.net/xujinyang/article/details/7276945
 
 
 
 
カスタムViewで日付セレクタを実装
adbパフォーマンスデータ取得の一般的な方法