mysql性能参数查看脚本
 

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

转载自http://www.linuxidc.com/Linux/2012-08/67832.htm
MySQL的优化我分为两个部分，一是服务器物理硬件的优化，二是MySQL自身(my.cnf)的优化。
一、服务器硬件对MySQL性能的影响
①磁盘寻道能力（磁盘I/O）,以目前高转速SCSI硬盘(7200转/秒)为例，这种硬盘理论上每秒寻道7200次，这是物理特性决定的，没有办法改变。MySQL每秒钟都在进行大量、复杂的查询操作，对磁盘的读写量可想而知。所以，通常认为磁盘I/O是制约MySQL性能的最大因素之一，对于日均访问量在100万PV以上的Discuz!论坛，由于磁盘I/O的制约，MySQL的性能会非常低下！解决这一制约因素可以考虑以下几种解决方案： 使用RAID-0+1磁盘阵列，注意不要尝试使用RAID-5，MySQL在RAID-5磁盘阵列上的效率不会像你期待的那样快。
②CPU 对于MySQL应用，推荐使用S.M.P.架构的多路对称CPU，例如：可以使用两颗Intel Xeon 3.6GHz的CPU，现在我较推荐用4U的服务器来专门做数据库服务器，不仅仅是针对于mysql。
③物理内存对于一台使用MySQL的Database Server来说，服务器内存建议不要小于2GB，推荐使用4GB以上的物理内存，不过内存对于现在的服务器而言可以说是一个可以忽略的问题，工作中遇到了高端服务器基本上内存都超过了16G。

二、MySQL自身因素当解决了上述服务器硬件制约因素后，让我们看看MySQL自身的优化是如何操作的。对MySQL自身的优化主要是对其配置文件my.cnf中的各项参数进行优化调整。下面我们介绍一些对性能影响较大的参数。 由于my.cnf文件的优化设置是与服务器硬件配置息息相关的，因而我们指定一个假想的服务器硬件环境：CPU: 2颗Intel Xeon 2.4GHz 内存: 4GB DDR 硬盘: SCSI 73GB(很常见的2U服务器)。

下面，我们根据以上硬件配置结合一份已经优化好的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指定用于索引的缓冲区大小，增加它可得到更好的索引处理性能。对于内存在4GB左右的服务器该参数可设置为256M或384M。注意：该参数值设置的过大反而会是服务器整体效率降低！
max_allowed_packet = 4M
thread_stack = 256K
table_cache = 128K
sort_buffer_size = 6M
#查询排序时所能使用的缓冲区大小。注意：该参数对应的分配内存是每连接独占，如果有100个连接，那么实际分配的总共排序缓冲区大小为100 × 6 ＝ 600MB。所以，对于内存在4GB左右的服务器推荐设置为6-8M。
read_buffer_size = 4M
#读查询操作所能使用的缓冲区大小。和sort_buffer_size一样，该参数对应的分配内存也是每连接独享。
join_buffer_size = 8M
#联合查询操作所能使用的缓冲区大小，和sort_buffer_size一样，该参数对应的分配内存也是每连接独享。
myisam_sort_buffer_size = 64M
table_cache = 512
thread_cache_size = 64
query_cache_size = 64M
#指定MySQL查询缓冲区的大小。可以通过在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
#指定一个请求的最大连接时间，对于4GB左右内存的服务器可以设置为5-10。
thread_concurrency = 8
#该参数取值为服务器逻辑CPU数量*2，在本例中，服务器有2颗物理CPU，而每颗物理CPU又支持H.T超线程，所以实际取值为4*2=8
skip-networking
#开启该选项可以彻底关闭MySQL的TCP/IP连接方式，如果WEB服务器是以远程连接的方式访问MySQL数据库服务器则不要开启该选项！否则将无法正常连接！
table_cache=1024   
#物理内存越大,设置就越大.默认为2402,调到512-1024最佳
innodb_additional_mem_pool_size=4M
#默认为2M
innodb_flush_log_at_trx_commit=1
#设置为0就是等到innodb_log_buffer_size列队满后再统一储存,默认为1
innodb_log_buffer_size=2M             
#默认为1M
innodb_thread_concurrency=8         
#你的服务器CPU有几个就设置为几,建议用默认一般为8
key_buffer_size=256M                      
#默认为218，调到128最佳
tmp_table_size=64M                        
#默认为16M，调到64-256最挂
read_buffer_size=4M                      
#默认为64K
read_rnd_buffer_size=16M             
#默认为256K
sort_buffer_size=32M                    
#默认为256K
thread_cache_size=120              
#默认为60
query_cache_size=32M 
※值得注意的是：
很多情况需要具体情况具体分析
一、如果Key_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