一般进行性能分析,分如下三步:
让客户满意是我们工作的目标,不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户,将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴,公司提供的服务项目有:域名与空间、雅安服务器托管、营销软件、网站建设、纳溪网站维护、网站推广。
首先需要使用慢查询日志功能,去获取所有查询时间比较长的SQL语句
其次查看执行计划查看有问题的SQL的执行计划 explain
最后可以使用show profile查看有问题的SQL的性能使用情况
慢查询日志分析
首先我们要使用慢查询日志,因为它收集了查询时间比较长的SQL语句,但使用之前必须开启慢查询日志,在配置文件my.cnf(一般为/etc/my.cnf)中的[mysqld] 增加如下参数:
slow_query_log=ONlong_query_time=3slow_query_log_file=/var/lib/mysql/slow-log.log复制代码
增加这些参数之后,重启MySQL,可以进行查询慢查询日志是否开启。
1. 任何地方都不要使用 select * from t,用具体的字段列表代替“*“,不要返回用不到的任何字段。
2. 索引并不是越多越好,索引固然可以提高相应的 select 的效率,但同时也降低了 insert 及 update 的效率,因为 insert 或 update 时有可能会重建索引,所以怎样建索引需要慎重考虑,视具体情况而定。一个表的索引数最好不要超过6个,若太多则应考虑一些不常使用到的列上建的索引是否有必要。
3. 并不是所有索引对查询都有效,SQL是根据表中数据来进行查询优化的,当索引列有大量数据重复时,SQL查询可能不会去利用索引,如一表中有字段sex,male、female几乎各一半,那么即使在sex上建了索引也对查询效率起不了作用。
4. 尽量使用数字型字段,若只含数值信息的字段尽量不要设计为字符型,这会降低查询和连接的性能,并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符,而对于数字型而言只需要比较一次就够了。
5. 尽可能的使用 varchar 代替 char ,因为首先变长字段存储空间小,可以节省存储空间, 其次对于查询来说,在一个相对较小的字段内搜索效率显然要高些。
6. 如果使用到了临时表,在存储过程的最后务必将所有的临时表显式删除,先 truncate table ,然后 drop table ,这样可以避免系统表的较长时间锁定。
7. 对查询进行优化,应尽量避免全表扫描,首先应考虑在 where和order by相关的列上建立索引。
8. 应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描。
例如: select * from t where num is null
我们可以在num上设置默认值0,确保表中num列没有null值,然后这样查询:select * from t where num=0。
mysql优化是一个大方向,大的是要分布式、读写分离,小的是对sql语句进行优化。不过大多问的也是对sql语句优化,网上很多资料,我就大体说说。
1、explain+索引。
在你要查询的语句前加explain,看下有没有用到索引,如果出现type为all的,则说明有必要添加下索引。(附多表查询速度比较:表关联existsin)慢查询优化是一大块。
2、预统计。
很经常需要对历史的数据进行过滤统计。比如移动需要统计上个月电话小时数超过N小时的人,那么如果直接取原始数据,那将很慢,此时如果每天晚上凌晨都对数据进行预统计,统计每个人每天电话时数,那再来过滤就很快。
3、分表分区。
分表分区也是为了提高搜索速度。例如,公交车的gps行驶记录,gps每隔15s报一次,一辆车一天运行12小时,一天就要插入4*60*12条记录,N辆车就要再乘,其数量极大,所以经常按月分表,分表里再按上报时间做日分区,这样就达到很大的优化,想查询某段时间,mysql很快就可以定位到。
4、表结构。
表结构很重要,经常需要多表关联查询一些字段,有时可以冗余下放到同一张表。
mysql优化很有意思,多去查阅些资料,多去尝试,对你有好处的。
从句子中可以看到,选取的字段比较多,另外连接条件也比较多,另外还包括了子查询。
就此语句给出几个需要注意的问题:
1、请先使用explain,对这个语句进行分析,EXPLAIN解释SELECT命令如何被处理。这不仅对决定是否应该增加一个索引,而且对决定一个复杂的Join如何被MySQL处理都是有帮助的。
2、尽量在连接条件多的时候,把数据提取量少的条件放在前面,这样会减少后一个条件的查询时间。对了,这些经常用的连接条件最好建上索引。我不清楚
INNER JOIN table_user_profile AS up ON up.uid = u.uid
INNER JOIN table_user_count AS uc ON uc.uid = u.uid
INNER JOIN table_user_daren AS ud ON ud.uid = u.uid
这些那个先内连接数据比较少,自己排列一下试一试。
3、避免使用!=或<>、IS NULL或IS NOT NULL、IN ,NOT IN等这样的操作符,因为这会使系统无法使用索引,而只能直接搜索表中的数据。像in和not in这样的关键字用exists和not exists比较好。u.uid not in(SELECT uid FROM table_user_follow where f_uid=100)改成u.uid not exists(SELECT uid FROM table_user_follow where f_uid=100),效率会有提高。
4、mysql使用函数的时候会增加负担,完全可以交给脚本程序去解决。比如此子查询:
SELECT MAX(share_id) FROM table_share 完全可以不写在这个sql语句中,交给脚本程序可以了。
只有5种吗?我知道十种以上的说。
索引(没我得全表查询了)
改变数据储引擎(MyISAM没事务再也不用担心锁表了)
增加冗余数来减少连表查询数(消耗硬盘空间减少CPU使用)
调整查询顺序减少查询量优先(数量少了连表的笛卡儿积也少了)
全文索引(文字长度有限制,而且IO使用量会大增,但是妥妥的快)
查询尽量不要用函数(函数可是不走索引的哦亲)
查询变量类型要提前对好减少系统负担(我提前改变了系统你就不用检测了)
升级服务器硬件(没什么是氪金解决不了的)
配置好临时表空间,合理理由临时表减少主表查询抢资源(唯我独查)
合理理由函数减少系统的判断(明明都能确认内容不同你用UNION 系统还是傻傻的查一遍是否重复 UNION ALL则跳过这个步骤同理 inner join 和 left join 也一样 )
强制走索引(复合索引的情况有时候手动走比系统判断要好哦)
脏读、幻读等(你堵车我绕路)
数据归档,迁移(没用的数据要进仓哦,别占着主表的资源)
表的碎片整理(迁移后碎片整理更健康哦亲)
索引重构(数据都走了索引也应该重构一下才能保证速度哦)
善用存储过程(串N个表(N大于10)的查询千万别一个SQL到底,分布式查询在吧结果集合并吧骚年)
预处理数据(mysql也有job哦,对于经常要子查询的数据可以先弄个明细表根据主表在后台进行补完,查询的时候就更方便了)
懒得说了。。。。。。。。。。。。。。。。。。
在开始演示之前,我们先介绍下两个概念。
概念一,数据的可选择性基数,也就是常说的cardinality值。
查询优化器在生成各种执行计划之前,得先从统计信息中取得相关数据,这样才能估算每步操作所涉及到的记录数,而这个相关数据就是cardinality。简单来说,就是每个值在每个字段中的唯一值分布状态。
比如表t1有100行记录,其中一列为f1。f1中唯一值的个数可以是100个,也可以是1个,当然也可以是1到100之间的任何一个数字。这里唯一值越的多少,就是这个列的可选择基数。
那看到这里我们就明白了,为什么要在基数高的字段上建立索引,而基数低的的字段建立索引反而没有全表扫描来的快。当然这个只是一方面,至于更深入的探讨就不在我这篇探讨的范围了。
概念二,关于HINT的使用。
这里我来说下HINT是什么,在什么时候用。
HINT简单来说就是在某些特定的场景下人工协助MySQL优化器的工作,使她生成最优的执行计划。一般来说,优化器的执行计划都是最优化的,不过在某些特定场景下,执行计划可能不是最优化。
比如:表t1经过大量的频繁更新操作,(UPDATE,DELETE,INSERT),cardinality已经很不准确了,这时候刚好执行了一条SQL,那么有可能这条SQL的执行计划就不是最优的。为什么说有可能呢?
来看下具体演示
譬如,以下两条SQL,
A:
select * from t1 where f1 = 20;
B:
select * from t1 where f1 = 30;
如果f1的值刚好频繁更新的值为30,并且没有达到MySQL自动更新cardinality值的临界值或者说用户设置了手动更新又或者用户减少了sample page等等,那么对这两条语句来说,可能不准确的就是B了。
这里顺带说下,MySQL提供了自动更新和手动更新表cardinality值的方法,因篇幅有限,需要的可以查阅手册。
那回到正题上,MySQL 8.0 带来了几个HINT,我今天就举个index_merge的例子。
示例表结构:
mysql desc t1;+------------+--------------+------+-----+---------+----------------+| Field | Type | Null | Key | Default | Extra |+------------+--------------+------+-----+---------+----------------+| id | int(11) | NO | PRI | NULL | auto_increment || rank1 | int(11) | YES | MUL | NULL | || rank2 | int(11) | YES | MUL | NULL | || log_time | datetime | YES | MUL | NULL | || prefix_uid | varchar(100) | YES | | NULL | || desc1 | text | YES | | NULL | || rank3 | int(11) | YES | MUL | NULL | |+------------+--------------+------+-----+---------+----------------+7 rows in set (0.00 sec)
表记录数:
mysql select count(*) from t1;+----------+| count(*) |+----------+| 32768 |+----------+1 row in set (0.01 sec)
这里我们两条经典的SQL:
SQL C:
select * from t1 where rank1 = 1 or rank2 = 2 or rank3 = 2;
SQL D:
select * from t1 where rank1 =100 and rank2 =100 and rank3 =100;
表t1实际上在rank1,rank2,rank3三列上分别有一个二级索引。
那我们来看SQL C的查询计划。
显然,没有用到任何索引,扫描的行数为32034,cost为3243.65。
mysql explain format=json select * from t1 where rank1 =1 or rank2 = 2 or rank3 = 2\G*************************** 1. row ***************************EXPLAIN: { "query_block": { "select_id": 1, "cost_info": { "query_cost": "3243.65" }, "table": { "table_name": "t1", "access_type": "ALL", "possible_keys": [ "idx_rank1", "idx_rank2", "idx_rank3" ], "rows_examined_per_scan": 32034, "rows_produced_per_join": 115, "filtered": "0.36", "cost_info": { "read_cost": "3232.07", "eval_cost": "11.58", "prefix_cost": "3243.65", "data_read_per_join": "49K" }, "used_columns": [ "id", "rank1", "rank2", "log_time", "prefix_uid", "desc1", "rank3" ], "attached_condition": "((`ytt`.`t1`.`rank1` = 1) or (`ytt`.`t1`.`rank2` = 2) or (`ytt`.`t1`.`rank3` = 2))" } }}1 row in set, 1 warning (0.00 sec)
我们加上hint给相同的查询,再次看看查询计划。
这个时候用到了index_merge,union了三个列。扫描的行数为1103,cost为441.09,明显比之前的快了好几倍。
mysql explain format=json select /*+ index_merge(t1) */ * from t1 where rank1 =1 or rank2 = 2 or rank3 = 2\G*************************** 1. row ***************************EXPLAIN: { "query_block": { "select_id": 1, "cost_info": { "query_cost": "441.09" }, "table": { "table_name": "t1", "access_type": "index_merge", "possible_keys": [ "idx_rank1", "idx_rank2", "idx_rank3" ], "key": "union(idx_rank1,idx_rank2,idx_rank3)", "key_length": "5,5,5", "rows_examined_per_scan": 1103, "rows_produced_per_join": 1103, "filtered": "100.00", "cost_info": { "read_cost": "330.79", "eval_cost": "110.30", "prefix_cost": "441.09", "data_read_per_join": "473K" }, "used_columns": [ "id", "rank1", "rank2", "log_time", "prefix_uid", "desc1", "rank3" ], "attached_condition": "((`ytt`.`t1`.`rank1` = 1) or (`ytt`.`t1`.`rank2` = 2) or (`ytt`.`t1`.`rank3` = 2))" } }}1 row in set, 1 warning (0.00 sec)
我们再看下SQL D的计划:
不加HINT,
mysql explain format=json select * from t1 where rank1 =100 and rank2 =100 and rank3 =100\G*************************** 1. row ***************************EXPLAIN: { "query_block": { "select_id": 1, "cost_info": { "query_cost": "534.34" }, "table": { "table_name": "t1", "access_type": "ref", "possible_keys": [ "idx_rank1", "idx_rank2", "idx_rank3" ], "key": "idx_rank1", "used_key_parts": [ "rank1" ], "key_length": "5", "ref": [ "const" ], "rows_examined_per_scan": 555, "rows_produced_per_join": 0, "filtered": "0.07", "cost_info": { "read_cost": "478.84", "eval_cost": "0.04", "prefix_cost": "534.34", "data_read_per_join": "176" }, "used_columns": [ "id", "rank1", "rank2", "log_time", "prefix_uid", "desc1", "rank3" ], "attached_condition": "((`ytt`.`t1`.`rank3` = 100) and (`ytt`.`t1`.`rank2` = 100))" } }}1 row in set, 1 warning (0.00 sec)
加了HINT,
mysql explain format=json select /*+ index_merge(t1)*/ * from t1 where rank1 =100 and rank2 =100 and rank3 =100\G*************************** 1. row ***************************EXPLAIN: { "query_block": { "select_id": 1, "cost_info": { "query_cost": "5.23" }, "table": { "table_name": "t1", "access_type": "index_merge", "possible_keys": [ "idx_rank1", "idx_rank2", "idx_rank3" ], "key": "intersect(idx_rank1,idx_rank2,idx_rank3)", "key_length": "5,5,5", "rows_examined_per_scan": 1, "rows_produced_per_join": 1, "filtered": "100.00", "cost_info": { "read_cost": "5.13", "eval_cost": "0.10", "prefix_cost": "5.23", "data_read_per_join": "440" }, "used_columns": [ "id", "rank1", "rank2", "log_time", "prefix_uid", "desc1", "rank3" ], "attached_condition": "((`ytt`.`t1`.`rank3` = 100) and (`ytt`.`t1`.`rank2` = 100) and (`ytt`.`t1`.`rank1` = 100))" } }}1 row in set, 1 warning (0.00 sec)
对比下以上两个,加了HINT的比不加HINT的cost小了100倍。
总结下,就是说表的cardinality值影响这张的查询计划,如果这个值没有正常更新的话,就需要手工加HINT了。相信MySQL未来的版本会带来更多的HINT。