05_MySQL索引优化

news2024/11/28 21:43:32

四种：1.主键 2.单值 3.唯一 4.复合

1. 性能分析（explain）

mysql5.6以后优化器做了很多改进，执行时会自动进行大量的优化，很多现象需要在5.5才能演示成功。

1.1 explain是什么?

模拟优化器查看执行计划

使用EXPLAIN关键字可以模拟优化器执行SQL查询语句，从而知道MySQL是如何处理你的SQL语句的。分析你的查询语句或是表结构的性能瓶颈

1.2 explain能干什么？

  • 表的读取顺序

  • 那些索引可以使用

  • 数据读取操作的操作类型

  • 那些索引被实际使用

  • 表之间的引用

  • 每张表有多少行被物理查询

1.3 explain怎么玩？

explain + SQL语句

官方文档：MySQL :: MySQL 8.0 Reference Manual :: 8.8.2 EXPLAIN Output Format

数据准备：

CREATE TABLE t1(id INT(10) AUTO_INCREMENT, content VARCHAR(100) NULL, PRIMARY KEY (id));
CREATE TABLE t2(id INT(10) AUTO_INCREMENT, content VARCHAR(100) NULL, PRIMARY KEY (id));
CREATE TABLE t3(id INT(10) AUTO_INCREMENT, content VARCHAR(100) NULL, PRIMARY KEY (id));
CREATE TABLE t4(id INT(10) AUTO_INCREMENT, content VARCHAR(100) NULL, PRIMARY KEY (id));

# 以下新增sql多执行几次，以便演示
INSERT INTO t1(content) VALUES(CONCAT('t1_',FLOOR(1+RAND()*1000)));
INSERT INTO t2(content) VALUES(CONCAT('t2_',FLOOR(1+RAND()*1000)));
INSERT INTO t3(content) VALUES(CONCAT('t3_',FLOOR(1+RAND()*1000)));
INSERT INTO t4(content) VALUES(CONCAT('t4_',FLOOR(1+RAND()*1000)));

演示：explain select * from t1, t2, t3 where t1.id=t2.id and t2.id=t3.id;  

1.4 各字段解释

1.4.1 id(重要)

select查询的序列号，表示查询中执行select子句或操作表的顺序

三种情况：

① id相同，执行顺序由上至下。例如上图

② id不同，如果是子查询，id的序号会递增，id值越大优先级越高，越先被执行

EXPLAIN SELECT * 
FROM t1 WHERE t1.content =(
	SELECT t2.content
	FROM t2 WHERE t2.content=(
		SELECT t3.content
		FROM t3
		WHERE t3.content=""
	)
);

③  id既有相同又有不同

 id为NULL最后执行。

关注点：每个id号码，表示一趟独立的查询。一个sql 的查询趟数越少越好。

1.4.2 select_type(不会用于优化)

查询的类型，主要是用于区别普通查询、联合查询、子查询等的复杂查询

SIMPLE

简单的 SELECT(没有 使用UNION或者 子查询（PS：单表查询）)

PRIMARY

最外层的Select 作为primary 查询。(PS:含有子查询的情况,但是并不复杂)案例1

DERIVED

在from 查询语句中的（派生，嵌套很多）子查询.(PS:递归操作这些子查询)

SUBQUERY

在SELECT或WHERE列表中包含了子查询。案例2

DEPENDENT SUBQUERY

第一个查询是子查询，依赖于外部查询（相关查询）。案例3

MATERIALIZED

在非相关子查询中 并且需要进行物化时会出现MATERIALIZED关键词。案例4

UNCACHEABLE SUBQUERY

子查询结果(系统变量)不能被缓存， 而且必须重写（分析）外部查询的每一行。案例5

UNION

若第二个SELECT出现在UNION之后，则被标记为UNION。案例6

若UNION包含在FROM子句的子查询中,外层SELECT将被标记为：DERIVED

UNION RESULT

结果集是通过union 而来的。案例6

案例1：explain select * from (select t2.* from t2) s2

案例2：explain select * from t1 where t1.id=(select t2.id from t2 where t2.id=1)

案例3：explain select t1.*,(select t2.content from t2 where t2.id=t1.id) from t1 where t1.id=1;

案例4：explain select * from t1 where t1.content in (select t2.content from t2 where t2.content in (select t3.content from t3 where t3.content='')) #需要5.7以后版本演示

案例5：EXPLAIN SELECT * from t1 where t1.id=(select t2.id from t2 where t2.id=@@sort_buffer_size);

案例6：explain select * from t1 UNION select * from t2;

1.4.3 table

显示这一行的数据是关于哪张表的

1.4.3 partitions

代表分区表中的命中情况，非分区表，该项为null

1.4.5 type(重要)

type显示的是访问类型，是较为重要的一个指标，结果值从最好到最坏依次是：

null>system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL 

常见：system > const > eq_ref > ref > range > index > ALL

一般来说，得保证查询至少达到range级别，最好能达到ref。

null: MySQL不访问任何表或索引，直接返回结果

system：表只有一行记录（等于系统表），这是const类型的特列，平时不会出现，这个也可以忽略不计。

const：表示通过索引一次就找到了,const用于比较primary key或者unique索引。因为只匹配一行数据，所以很快。如将主键置于where列表中，MySQL就能将该查询转换为一个常量。（select * from t1 where t1.id=1）

eq_ref：唯一性索引扫描，对于每个索引键，表中只有一条记录与之匹配。常见于主键或唯一索引扫描。（select * from t1,t2 where t1.id=t2.id）

ref: 使用非唯一索引扫描或唯一索引前缀扫描，返回单条记录，常出现在关联查询中

range：只检索给定范围的行，使用一个索引来选择行。key 列显示使用了哪个索引，一般就是在你的where语句中出现了between、<、>、in等的查询。这种范围扫描索引扫描比全表扫描要好，因为它只需要开始于索引的某一点，而结束语另一点，不用扫描全部索引。（select * from t1 where t1.id<10）

index：出现index是sql使用了索引但是没用通过索引进行过滤，一般是使用了覆盖索引或者是利用索引进行了排序分组。（explain select id from t1）

all：Full Table Scan，将遍历全表以找到匹配的行。（explain select * from t1）

index_merge：在查询过程中需要多个索引组合使用，通常出现在有 or 的关键字的sql中。

ref_or_null：对于某个字段既需要关联条件，也需要null值得情况下。查询优化器会选择用ref_or_null连接查询。

index_subquery：利用索引来关联子查询，不再全表扫描。

unique_subquery：该联接类型类似于index_subquery。 子查询中的唯一索引。

① 创建索引

② index_merge

EXPLAIN SELECT * FROM t3 WHERE t3.content IS NULL OR t3.id=10;

③ ref_or_null

EXPLAIN SELECT * FROM t3 WHERE t3.content IS NULL OR t3.content='aaaa';

④ index_subquery

EXPLAIN SELECT * FROM t2 WHERE t2.content IN (SELECT t3.content FROM t3);

⑤ unique_subquery

EXPLAIN SELECT * FROM t2 WHERE t2.id IN (SELECT t3.id FROM t3);

1.4.6 possible_keys

显示可能应用在这张表中的索引，一个或多个。

查询涉及到的字段上若存在索引，则该索引将被列出，但不一定被查询实际使用。

1.4.7 key(优化重要指标)

实际使用的索引。如果为NULL，则没有使用索引。

查询中若使用了覆盖索引，则该索引和查询的select字段重叠。

1.4.8 key_len(重要)

表示索引中使用的字节数，可通过该列计算查询中使用的索引的长度。

key_len字段能够帮你检查是否充分的利用上了索引。

如何计算

① 先看索引上字段的类型+长度比如 int=4 ; varchar(20) =20 ; char(20) =20

② 如果是varchar或者char这种字符串字段，视字符集要乘不同的值，比如utf8mb3要乘 3(MySQL5.7)，如果是utf8mb4要乘4，,GBK要乘2

③ varchar这种动态字符串要加2个字节

④ 允许为空的字段要加1个字节

索引字段最好不要为NULL，因为NULL让统计更加复杂，并且需要额外一个字节的存储空间。

1.4.9 ref

显示索引的哪一列被使用了，如果可能的话，是一个常数。哪些列或常量被用于查找索引列上的值。

1.4.10 rows

rows列显示MySQL认为它执行查询时必须检查的行数。越少越好。

1.4.11 filtered

这个字段表示存储引擎返回的数据在server层过滤后，剩下多少满足查询的记录数量的比例，注意是百分比，不是具体记录数，值越大越好。

1.4.12 extra(重要)

包含不适合在其他列中显示但十分重要的额外信息，通过这些额外信息来理解MySQL到底将如何执行当前的查询语句。MySQL提供的额外信息有好几十个，这里只挑比较重要的介绍。

Using filesort：说明mysql会对数据使用一个外部的索引排序，而不是按照表内的索引顺序进行读取。

MySQL中无法利用索引完成的排序操作称为“文件排序”

这类SQL语句性能极差，需要进行优化。

在一个非索引列上进行了order by，就会触发filesort，常见的优化方案是，在order by的列上添加索引，避免每次查询都全量排序(只查询索引列的值)。

Using temporary：使了用临时表保存中间结果,MySQL在对查询结果排序时使用临时表。常见于排序 order by 和分组查询 group by。

group by和order by同时存在，且作用于不同的字段时，就会建立临时表，以便计算出最终的结果集。

USING index：利用索引进行了排序或分组。表示相应的select操作中使用了覆盖索引(Covering Index)，避免访问了表的数据行，效率不错！（EXPLAIN select * from t_emp where age=30 ORDER BY name）如果同时出现using where，表明索引被用来执行索引键值的查找;如果没有同时出现using where，表明索引只是用来读取数据而非利用索引执行查找。

Using where：表明使用了where过滤

using join buffer：使用了连接缓存，非主键关联(mysql8Using join buffer (hash join) 速度要好于 mysql5.7Using join buffer (Block Nested Loop) )

impossible where：where子句的值总是false，不能用来获取任何元组。（EXPLAIN select * from t_emp where false;）

select tables optimized away：在没有GROUPBY子句的情况下，基于索引优化MIN/MAX操作或者对于MyISAM存储引擎优化COUNT(*)操作，不必等到执行阶段再进行计算，查询执行计划生成的阶段即完成优化。

在innodb中：

在Myisam中：

1.5 小结

表的读取顺序：id

​ id趟数越少越好，id相同执行顺序由上至下，id不同 大的先执行

查询方式：select_type

那些索引可以使用：possible_keys

数据读取操作的操作类型：type

range index all

那些索引被实际使用：key

创建的索引是否能够被实际应用

使用索引的长度：key_len

命中的索引匹配的长度(用来判断索引是否被完全利用)

计算索引长度：

        utf-8

                varchar(len) =使用len*3+2 (如果字段可以为null，再+1)

                char(len) =使用len*3 (如果字段可以为null，再+1)

                int(len) = 4 (如果字段可以为null，再+1)

表之间的引用：table

每张表有多少行被物理查询：rows

行数越少越好(多表联查时 被驱动表的rows如果使用索引了一般非常小)

额外优化信息：extra

using join buffer(多表联查)、using filesort(排序)和 using temporary(分组) 需要考虑优化

其他情况性能都可以无需优化

1.6 Json格式的执行计划

EXPLAIN语句输出中缺少了一个衡量执行计划好坏的重要属性 —执行计划花费的成本，在EXPLAIN单词和真正的查询语句中间加上FORMAT=JSON。

EXPLAIN FORMAT=json SELECT * FROM t_emp;
{
  "query_block": {
    "select_id": 1,
    "cost_info": {
      "query_cost": "1.25" // 查询耗时：单位毫秒
    },
    "table": {
      "table_name": "t_emp",
      "access_type": "ALL",
      "rows_examined_per_scan": 10,
      "rows_produced_per_join": 10,
      "filtered": "100.00",
      "cost_info": {
        "read_cost": "0.25",//io耗时
        "eval_cost": "1.00",//获取处理返回结果耗时
        "prefix_cost": "1.25",
        "data_read_per_join": "800"//读取的数据量
      },
      "used_columns": [//投影列
        "id",
        "name",
        "age",
        "deptId",
        "empno"
      ]
    }
  }
}

2. 数据准备

在做优化之前，要准备大量数据。接下来创建两张表，并往员工表里插入50W数据，部门表中插入1W条数据。

建表sql：

CREATE TABLE `dept` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`deptName` VARCHAR(30) DEFAULT NULL,
	`address` VARCHAR(40) DEFAULT NULL,
	ceo INT NULL ,
	PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

CREATE TABLE `emp` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`empno` INT NOT NULL ,
	`name` VARCHAR(20) DEFAULT NULL,
	`age` INT(3) DEFAULT NULL,
	`deptId` INT(11) DEFAULT NULL,
	PRIMARY KEY (`id`)
	#CONSTRAINT `fk_dept_id` FOREIGN KEY (`deptId`) REFERENCES `t_dept` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

怎么快速插入50w条数据呢？ 存储过程

怎么保证插入的数据不重复？函数

以部门表分析：

​ id：自增长

​ deptName：随机字符串，允许重复

​ address：随机字符串，允许重复

​ CEO：1-50w之间的任意数字

以员工表分析：

​ id：自增长

​ empno：可以使用随机数字，或者从1开始的自增数字，不允许重复

​ name：随机生成，允许姓名重复

​ age：区间随机数

​ deptId：1-1w之间随机数

总结：需要产生随机字符串和区间随机数的函数。

2.1 创建函数

set global log_bin_trust_function_creators=1; 
# 随机产生字符串
DELIMITER $$
CREATE FUNCTION rand_string(n INT) RETURNS VARCHAR(255)
BEGIN    
	DECLARE chars_str VARCHAR(100) DEFAULT 'abcdefghijklmnopqrstuvwxyzABCDEFJHIJKLMNOPQRSTUVWXYZ';
	DECLARE return_str VARCHAR(255) DEFAULT '';
	DECLARE i INT DEFAULT 0;
	WHILE i < n DO  
		SET return_str =CONCAT(return_str,SUBSTRING(chars_str,FLOOR(1+RAND()*52),1));  
		SET i = i + 1;
	END WHILE;
	RETURN return_str;
END $$

#用于随机产生区间数字
DELIMITER $$
CREATE FUNCTION rand_num (from_num INT ,to_num INT) RETURNS INT(11)
BEGIN   
 DECLARE i INT DEFAULT 0;  
 SET i = FLOOR(from_num +RAND()*(to_num -from_num+1));
RETURN i;  
END$$

#假如要删除
#drop function rand_string;
#drop function rand_num;

2.2 存储过程

# 插入员工存储过程
DELIMITER $$
CREATE PROCEDURE  insert_emp(START INT, max_num INT)
BEGIN  
	DECLARE i INT DEFAULT 0;   
	#set autocommit =0 把autocommit设置成0  
	SET autocommit = 0;    
	REPEAT  
		SET i = i + 1;  
		INSERT INTO emp (empno, NAME, age, deptid ) VALUES ((START+i) ,rand_string(6), rand_num(30,50), rand_num(1,10000));  
		UNTIL i = max_num  
	END REPEAT;  
	COMMIT;  
END$$
 
#删除
# DELIMITER ;
# drop PROCEDURE insert_emp;

 
#往dept表添加随机数据
DELIMITER $$
CREATE PROCEDURE `insert_dept`(max_num INT)
BEGIN  
	DECLARE i INT DEFAULT 0;   
	SET autocommit = 0;    
	REPEAT  
		SET i = i + 1;  
		INSERT INTO dept ( deptname,address,ceo ) VALUES (rand_string(8),rand_string(10),rand_num(1,500000));  
		UNTIL i = max_num  
	END REPEAT;  
	COMMIT;  
END$$
 
#删除
# DELIMITER ;
# drop PROCEDURE insert_dept;

2.3 调用存储过程

#执行存储过程，往dept表添加1万条数据
DELIMITER ;
CALL insert_dept(10000); 

#执行存储过程，往emp表添加50万条数据
DELIMITER ;
CALL insert_emp(100000,500000);

2.4 批量删除表索引

批量删除某个表上的所有索引

DELIMITER $$
CREATE PROCEDURE `proc_drop_index`(dbname VARCHAR(200),tablename VARCHAR(200))
BEGIN
	DECLARE done INT DEFAULT 0;
	DECLARE ct INT DEFAULT 0;
	DECLARE _index VARCHAR(200) DEFAULT '';
	DECLARE _cur CURSOR FOR SELECT index_name FROM information_schema.STATISTICS WHERE table_schema=dbname AND table_name=tablename AND seq_in_index=1 AND index_name <>'PRIMARY'  ;
	DECLARE CONTINUE HANDLER FOR NOT FOUND set done=2 ;      
	OPEN _cur;
		FETCH _cur INTO _index;
		WHILE  _index<>'' DO 
			SET @str = CONCAT("drop index ",_index," on ",tablename ); 
			PREPARE sql_str FROM @str ;
			EXECUTE sql_str;
			DEALLOCATE PREPARE sql_str;
			SET _index=''; 
			FETCH _cur INTO _index; 
		END WHILE;
	CLOSE _cur;
END$$

执行批量删除：  

CALL proc_drop_index("dbname","tablename"); # 库名称和表名称

3. 单表优化

3.1 索引优化原则

  1. 不在索引列上做任何操作（计算、函数、(自动or手动)类型转换），会导致索引失效而转向全表扫描

  2. like以通配符开头('%abc...')mysql索引失效会变成全表扫描的操作

  3. mysql 在使用不等于(!=或者<>)的时候无法使用索引会导致全表扫描

  4. is not null 也无法使用索引，但是is null是可以使用索引的

  5. 字符串不加单引号索引失效

案例：

查找姓名以"abc"开头的员工信息

查找姓名含有"abc"的员工信息

查找年龄不等于25的员工

查找姓名不为空的员工信息

查找姓名等于"123"的员工信息

① 以下两个sql，那个写法更好？

# 创建索引
create index idx_emp_age on emp(age);
create index idx_emp_name on emp(name);

EXPLAIN SELECT SQL_NO_CACHE * FROM emp WHERE emp.name LIKE 'abc%';
EXPLAIN SELECT SQL_NO_CACHE * FROM emp WHERE LEFT(emp.name,3)='abc';

sql访问类型range > ALL；使用索引idx_emp_name > NULL； 使用索引长度63 > NULL; 扫描行数25 < 498951

第一个sql用时：0.00s

第二个sql用时：0.37s

由此可见第一个sql优于第二个sql：第一个走了索引，第二个走了全表扫描。

② 把第一个sql的like查询条件改成‘%abc%’，会怎样呢？  

可以发现改成'%abc%'之后，第一个sql失去了索引优势，走了全表扫描。

③ 再来看这两个sql：不等于(!=或者<>)

EXPLAIN SELECT SQL_NO_CACHE * FROM emp WHERE emp.age=30;
EXPLAIN SELECT SQL_NO_CACHE * FROM emp WHERE emp.age!=30;

④ is not null和is null

⑤ 字符串加引号

3.2 组合索引原则

  1. 全值匹配我最爱

  2. 符合最左原则：不跳过索引中的列。

  3. 如果where条件中是OR关系，加索引不起作用

  4. 存储引擎不能使用索引中范围条件右边的列

① 首先删除之前创建的索引

CALL proc_drop_index("mydb","emp");

② 全值匹配我最爱  

SELECT SQL_NO_CACHE * FROM emp WHERE age=30 and deptId=1 and name='abc';
create index idx_age_deptId_name on emp(age, deptId, name);
SELECT SQL_NO_CACHE * FROM emp WHERE age=30 and deptId=1 and name='abc';

③最左匹配原则

④ OR关联

⑤ 范围条件右边的列

3.3 小结

一般性建议：

  1. 对于单键索引，尽量选择针对当前query过滤性更好的索引

  2. 在选择组合索引的时候，当前Query中过滤性最好的字段在索引字段顺序中，位置越靠前越好。

  3. 在选择组合索引的时候，尽量选择可以能够包含当前query中的where字句中更多字段的索引

  4. 在选择组合索引的时候，如果某个字段可能出现范围查询时，尽量把这个字段放在索引次序的最后面

  5. 书写sql语句时，尽量避免造成索引失效的情况

假设index(a,b,c) 重要

Where语句索引是否被使用
where a = 3Y,使用到a
where a = 3 and b = 5Y,使用到a，b
where a = 3 and b = 5 and c = 4Y,使用到a,b,c
where b = 3 或者 where b = 3 and c = 4 或者 where c = 4N
where a = 3 and c = 5使用到a， 但是c不可以，b中间断了
where a = 3 and b > 4 and c = 5使用到a和b， c不能用在范围之后，b断了
where a is null and b is not nullis null 支持索引 is not null 类似范围查询，ab能使用，b右边的会失效
where a <> 3不能使用索引
where abs(a) =3不能使用 索引
where a = 3 and b like 'kk%' and c = 4Y,使用到a,b,c
where a = 3 and b like '%kk' and c = 4Y,只用到a
where a = 3 and b like '%kk%' and c = 4Y,只用到a
where a = 3 and b like 'k%kk%' and c = 4Y,使用到a,b,c

4. 关联查询优化

接下来再次创建两张表，并分别导入20条数据：

CREATE TABLE IF NOT EXISTS `class` (
	`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
	`card` INT(10) UNSIGNED NOT NULL,
	PRIMARY KEY (`id`)
);
CREATE TABLE IF NOT EXISTS `book` (
	`bookid` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
	`card` INT(10) UNSIGNED NOT NULL,
	PRIMARY KEY (`bookid`)
);
 
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO class(card) VALUES(FLOOR(1 + (RAND() * 20)));
 
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));
INSERT INTO book(card) VALUES(FLOOR(1 + (RAND() * 20)));

4.1 关联案例

explain分析一下两个sql：

EXPLAIN SELECT * FROM class LEFT JOIN book ON class.card = book.card;
EXPLAIN SELECT * FROM class RIGHT JOIN book ON class.card = book.card;
EXPLAIN SELECT * FROM class INNER JOIN book ON class.card = book.card;

给book.card创建索引：

ALTER TABLE `book` ADD INDEX idx_card ( `card`);

然后explain分析：  

删除旧索引，添加新索引：

# 删除旧索引 + 新建 + 第3次explain
drop index idx_card on book;
ALTER TABLE class ADD INDEX index_class_card (card);

再次explain分析：  

同时给两张表的card字段添加索引：（class(card)索引已有：index_class_card，只需给book（card）添加索引）

ALTER TABLE `book` ADD INDEX idx_card ( `card`);

最后explain分析：

4.2 优化建议

  1. 保证被驱动表的join字段已经创建了索引

  2. left/right join 时，选择小表作为驱动表，大表作为被驱动表。

  3. inner join 时，mysql会自己帮你把小结果集的表选为驱动表,对被驱动表连接字段创建索引。(5.6已经优化掉了，5.5需要手动编写)

  4. 子查询尽量不要放在被驱动表，有可能使用不到索引。

  5. 能够直接多表关联的尽量直接关联，不用子查询。(减少查询的趟数)

4.3 三种实现的比较

5. 子查询优化

尽量不要使用not in 或者 not exists

尽量不要使用子查询

6. 排序优化

以下三种情况不走索引：

  1. 无过滤，不索引

  2. 顺序错，不索引

  3. 方向反，不索引

create index idx_age_deptid_name on emp (age,deptid,name)

# 以下  是否能使用到索引，能否去掉using filesort

explain  select SQL_NO_CACHE * from emp order by age,deptid; 

explain  select SQL_NO_CACHE * from emp order by age,deptid limit 10; 
 
 # 无过滤 不索引  观察extra的值
 
explain  select * from emp where age=45 order by deptid;
 
 
explain  select * from emp where age=45 order by   deptid,name; 
 
explain  select * from emp where age=45 order by  deptid,empno;
 
explain  select * from emp where age=45 order by  name,deptid;
 
explain select * from emp where deptid=45 order by age;
 
# 顺序错，不索引
explain select * from emp where age=45 order by  deptid desc, name desc ;
# 方向反 不索引
explain select * from emp where age=45 order by  deptid asc, name desc ;

6.1 优化演示

ORDER BY子句，尽量使用Index方式排序,避免使用FileSort方式排序

执行案例前先清除emp上的索引，只留主键

# 查询 年龄为30岁的，且员工编号小于101000的用户，按用户名称排序
SELECT SQL_NO_CACHE * FROM emp WHERE age =30 AND empno <101000 ORDER BY NAME;

结论：很显然，执行时间为0.477s，type 是 ALL,即最坏的情况。Extra 里还出现了 Using filesort,也是最坏的情况。优化是必须的。

优化思路： 尽量让where的过滤条件和排序使用上索引。

现在过滤条件使用了两个字段（age，empno）排序使用了name。

我们建一个三个字段的组合索引可否？

CREATE INDEX idx_age_empno_name ON emp(age,empno,NAME);

再次explain测试：

我们发现using filesort 依然存在，所以name 并没有用到索引。

原因是因为empno是一个范围过滤，所以索引后面的字段不会再使用索引了。

所以我们建一个3值索引是没有意义的 那么我们先删掉这个索引：DROP INDEX idx_age_empno_name ON emp

为了去掉filesort我们可以把索引建成

CREATE INDEX idx_age_name ON emp(age,NAME);

也就是说empno 和name这个两个字段只能二选其一。 这样我们优化掉了 using filesort。

执行一下sql：

速度果然提高了4倍。

假如：选择创建age和empno会速度会怎样呢，自己试试有惊喜！

结果竟然有 filesort的 sql 运行速度，超过了已经优化掉 filesort的 sql ，而且快了好多倍。何故？

原因：是所有的排序都是在条件过滤之后才执行的，所以如果条件过滤了大部分数据的话，几百几千条数据进行排序其实并不是很消耗性能，即使索引优化了排序但实际提升性能很有限。 相对的 empno<101000 这个条件如果没有用到索引的话，要对几万条的数据进行扫描，这是非常消耗性能的，所以索引放在这个字段上性价比最高，是最优选择。

结论： 当范围条件和group by 或者 order by 的字段出现二选一时 ，优先观察条件字段的过滤数量，如果过滤的数据足够多，而需要排序的数据并不多时，优先把索引放在范围字段上。反之，亦然。

6.2 了解filesort算法

如果不在索引列上，filesort有两种算法：mysql就要启动双路排序和单路排序

6.2.1 双路排序

MySQL 4.1之前是使用双路排序,字面意思就是两次扫描磁盘，最终得到数据，读取行指针和orderby列，对他们进行排序，然后扫描已经排序好的列表，按照列表中的值重新从列表中读取对应的数据输出。

也就是：从磁盘取排序字段，再buffer进行排序，再从磁盘取其他字段。

取一批数据，要对磁盘进行了两次扫描，众所周知，I\O是很耗时的，所以在mysql4.1之后，出现了第二种改进的算法，就是单路排序。

6.2.2 单路排序

从磁盘读取查询需要的所有列，按照order by列在buffer对它们进行排序，然后扫描排序后的列表进行输出，它的效率更快一些，避免了第二次读取数据。并且把随机IO变成了顺序IO，但是它会使用更多的空间，因为它把每一行都保存在内存中了。

结论及引申出的问题：由于单路是后出的，总体而言好过双路。

但是用单路有问题：在sort_buffer中，比双路排序要多占用很多空间，因为单路排序是把所有字段都取出, 所以有可能取出的数据的总大小超出了sort_buffer的容量，导致每次只能取sort_buffer容量大小的数据，进行排序（创建tmp文件，多路合并），排完再取取sort_buffer容量大小，再排……从而多次I/O。

本来想省一次I/O操作，反而导致了大量的I/O操作，反而得不偿失。

6.2.3 优化策略

  1. Order by时select * 是一个大忌，只Query需要的字段， 这点非常重要。在这里的影响是

    • 当Query的字段大小总和小于max_length_for_sort_data 而且排序字段不是 TEXT|BLOB 类型时，会用改进后的算法——单路排序， 否则用老算法——多路排序。

    • 两种算法的数据都有可能超出sort_buffer的容量，超出之后，会创建tmp文件进行合并排序，导致多次I/O，但是用单路排序算法的风险会更大一些，所以要提高sort_buffer_size。

  2. 尝试提高 sort_buffer_size

    不管用哪种算法，提高这个参数都会提高效率，当然，要根据系统的能力去提高，因为这个参数是针对每个进程的 1M-8M之间调整

  3. 尝试提高 max_length_for_sort_data

    提高这个参数， 会增加用改进算法的概率。但是如果设的太高，数据总容量超出sort_buffer_size的概率就增大，明显症状是高的磁盘I/O活动和低的处理器使用率。1024-8192之间调整

7. 分组优化

group by 使用索引的原则几乎跟order by一致 ，唯一区别是groupby 即使没有过滤条件用到索引，也可以直接使用索引。

  • group by 先排序再分组，遵照索引建的最佳左前缀法则

  • 当无法使用索引列，增大max_length_for_sort_data和sort_buffer_size参数的设置

  • where高于having, 能写在where限定的条件就不要写在having中了

只要对分组列创建索引即可

8. 覆盖索引  

最后使用索引的手段：覆盖索引

什么是覆盖索引？简单说就是，select 到 from 之间查询的列 <=使用的索引列+主键

explain select * from emp where name like '%abc';

使用覆盖索引后  

理解方式一：索引是高效找到行的一个方法，但是一般数据库也能使用索引找到一个列的数据，因此它不必读取整个行。毕竟索引叶子节点存储了它们索引的数据；当能通过读取索引就可以得到想要的数据，那就不需要读取行了。==一个索引包含了满足查询结果的数据就叫做覆盖索引==

理解方式二：非聚集复合索引的一种形式，它包括在查询里的Select、Join和Where子句用到的所有列（即建索引的字段正好是覆盖查询条件中所涉及的字段，也即，索引包含了查询正在查找的数据）。

9. 索引无效说明

创建索引后，用不用索引，最终是优化器说了算。优化器会基于开销选择索引，怎么开销小就怎么来。不是基于规则，也不是基于语义。

另外SQL语句是否使用索引，和数据库的版本、数据量、数据选择度（查询中选择的列数）运行环境都有关系。

所有创建索引后需要结合explain进行分析索引是否有效

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/626556.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python基础----09-----类、对象、魔法方法、封装、继承、类型注解、多态

python基础----09-----类、对象、魔法方法、封装、继承、类型注解、多态

一 初识对象 说白了就是类的实例化&#xff0c;类是一个抽象层的定义。 例如下面class Student就是定义的一个类&#xff0c;它是抽象层&#xff0c;然后stu_1 Student()&#xff0c;我们根据类创建了一个对象&#xff0c;就是对类的实例化&#xff0c;这个实例化对象我们是可…
阅读更多...
FinalShell界面左侧为什么能够监测系统指标动态变化的原理

FinalShell界面左侧为什么能够监测系统指标动态变化的原理

前言&#xff1a; 我们可以看出FinalShell是用Java写的&#xff0c;具体怎么看出来的&#xff0c;不能光看界面logo是Java的logo&#xff0c;还要进它的安装目录下进行查看是否真是用Java编写的&#xff01;&#xff01;&#xff01; 具体查看如下&#xff1a; 查看finalshe…
阅读更多...
Qt+QtWebApp开发笔记（五）：http服务器html中使用json触发ajax与后台交互实现数据更新传递

Qt+QtWebApp开发笔记（五）：http服务器html中使用json触发ajax与后台交互实现数据更新传递

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/131122772 红胖子网络科技博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬…
阅读更多...
如何规划和执行安全测试

如何规划和执行安全测试

如何规划和执行安全测试 在现代软件开发中&#xff0c;安全测试已经成为一个必不可少的环节。在完成软件开发后&#xff0c;需要对应用程序进行安全测试&#xff0c;以确保其可以在生产环境中正常运行并能够抵御各种安全攻击和漏洞。 如何规划和执行安全测试是一个重要的问题&a…
阅读更多...
Microsoft Excel中HYPERLINK函数的6个用途

Microsoft Excel中HYPERLINK函数的6个用途

Excel 在工具栏中提供了自己的内置链接功能。但 HYPERLINK 功能可以让你做更多的事情，比如公司内部网上的工作簿链接、共享服务器、其他驱动器，甚至 Word 文档中的书签。让我们来看看使用这个多功能功能可以做的一切。 HYPERLINK函数的6个用途 链接到电子表格中的单元格链接到…
阅读更多...
概率论：方差、标准差、协方差、皮尔逊相关系数、线性相关

概率论：方差、标准差、协方差、皮尔逊相关系数、线性相关

方差和标准差&#xff1a; 一个随机变量&#xff0c;的值的变化程度可以用方差计算&#xff1a; &#xff1b;其中 是期望。 我们举个例子&#xff1a; 服从均一分布&#xff0c;取值为0.1&#xff0c;0.2&#xff0c;0.3&#xff0c;0.4&#xff0c;0.5 &#xff0c;每种值…
阅读更多...
springboot 精华

springboot 精华

一、基础 官方文档地址&#xff1a;Spring Boot 注&#xff1a;以下部分例子 有些用到 .properties 方式&#xff0c;有些用 .yml方式&#xff0c;两者可自行学习&#xff0c;这里部分是为了省空间而写 .properties 方式。 1、泛谈 &#xff08;1&#xff09;优势 快速构建…
阅读更多...
MyBatis Plus 拦截器实现数据权限控制(完整版)

MyBatis Plus 拦截器实现数据权限控制(完整版)

一、说明 变化&#xff1a;相比于之前写的数据权限拦截器&#xff0c;新增了白名单功能&#xff0c;通过注解的方式让哪些SQL不进行数据权限拦截&#xff0c;之前的文章地址 思路&#xff1a;通过MyBatisPlus的拦截器对每个要执行的SQL进行拦截&#xff0c;然后判断其是否为查询…
阅读更多...
勒索病毒远程桌面——防御方案

勒索病毒远程桌面——防御方案

一、适用目标&#xff08;校园网、企业网&#xff0c;windows系列的操作系统&#xff09;&#xff1a; 所有在局域网内运行windows系统的电脑&#xff0c;并非只感染服务器操作系统&#xff0c;单机照样感染。会将你电脑中的所有文件全部加密&#xff0c;部分已感染案例有2个共…
阅读更多...
常见的存储类型：DAS vs SAN vs NAS

常见的存储类型：DAS vs SAN vs NAS

什么是存储 你有想过你在朋友圈分享的照片都存在哪里&#xff1f;你在视频网站上浏览的视频都存放在哪里&#xff1f;甚至&#xff0c;你在银行卡里的存款、房贷是如何随时查询、随时存取的&#xff1f; 没错&#xff0c;这些照片、视频&#xff0c;甚至你的存款、房贷的数值…
阅读更多...
机器学习-6 支持向量机

机器学习-6 支持向量机

支持向量机 算法概述算法流程线性分类线性可分性向量内积硬间隔分类软间隔SVM模型非线性支持向量机非线性的情况非线性支持向量机核函数 SVM优点 算法步骤线性可支持向量机的程序流程图SVM算法步骤 算法实例有关数据集利用Sklearn的datasets模块生成数据集其他生成数据集的方法…
阅读更多...
BIM与点云：一种基于航空LiDAR点云的大规模建筑重建

BIM与点云：一种基于航空LiDAR点云的大规模建筑重建

文章&#xff1a;City3D: Large-Scale Building Reconstruction from Airborne LiDAR Point Clouds 作者&#xff1a;Jin Huang , Jantien Stoter , Ravi Peters and Liangliang Nan 编辑&#xff1a;点云PCL 来源&#xff1a;arXiv2023 欢迎各位加入知识星球&#xff0c;获取P…
阅读更多...
GeoServer SQL注入漏洞复现（CVE-2023-25157）

GeoServer SQL注入漏洞复现（CVE-2023-25157）

0x01 产品简介 GeoServer是一款开源的地理数据服务器软件&#xff0c;主要用于发布、共享和处理各种地理空间数据。它支持众多的地图和空间数据标准&#xff0c;能够使各种设备通过网络来浏览和使用这些地理信息数据。 0x02 漏洞概述 GeoServer在预览图层的时候&#xff0c;可…
阅读更多...
Ubuntu20.04平台下使用二进制包部署MongoDB-6.0.4单实例

Ubuntu20.04平台下使用二进制包部署MongoDB-6.0.4单实例

文章目录 1.1 准备服务器的基本信息1.2 操作系统上创建其用户1.3 部署MongoDB服务端1.4 部署MongoDB客户端1.5 部署MongoDB 27017实例1.5.1 创建相关目录1.5.2 准备配置文件1.5.3 准备启停脚本1.5.4 进行启停测试1.5.5 加入开机自启动 1.6 创建超级管理员用户1.6.1 创建本地的超…
阅读更多...
do..while、while、for循环反汇编剖析

do..while、while、for循环反汇编剖析

1、循环语句重要特征提取 循环语句最重要的特点就是执行的过程中会往上跳&#xff01;&#xff01;&#xff01; 箭头往上跳的一般都是循环语句&#xff0c;比如下面的for循环&#xff1a; 2、do..while语句反汇编 #include<iostream> using namespace std; #pragma …
阅读更多...
【SpinalHDL快速入门】2、新建SpinalHDL工程，通过计数器Demo快速上手

【SpinalHDL快速入门】2、新建SpinalHDL工程，通过计数器Demo快速上手

文章目录 新建工程各个工具版本build.sbt 示例build.properties 示例如何在IEDA中更新 SpinalVersion 并 Reload sbt Project SpinalHDL入门例子&#xff1a;计数器demo1demo2&#xff08;支持reset信号异步复位&#xff0c;低电平有效&#xff09;demo3&#xff08;一个文件&a…
阅读更多...
Flume学习--1、Flume概述、Flume入门、

Flume学习--1、Flume概述、Flume入门、

1、Flume概述 1.1 Flume定义 Flume是Cloudera提供的一个高可用&#xff0c;高可靠的&#xff0c;分布式的海量日志采集、聚合和传输的系统。Flume基于流式结构&#xff0c;灵活简单。 Flume最主要的作用就是实时读取服务器本地磁盘的数据&#xff0c;将数据写入到HDFS。 1.2…
阅读更多...
C#winform多国语言应用实例

C#winform多国语言应用实例

我们在开发项目中，一般需要软件支持多种语言，供不同客户使用。本文实例讲解实现办法。 1 窗体项目创建 添加控件MenuStrip、comboBox及Button，并修改对应显示文本，combobox编辑项输入英语 确定窗体的Localizable属性为true，自动创建Form1.resx，为False时，没有Form1.r…
阅读更多...
基站机房：保障通信网络稳定，如何解决安全隐患？

基站机房：保障通信网络稳定，如何解决安全隐患？

基站机房作为无线通信网络的关键组成部分&#xff0c;承载着大量的网络设备和通信设施&#xff0c;对于运营商和通信服务提供商来说具有重要意义。 无论是大型运营商还是通信服务提供商&#xff0c;动环监控系统都将成为他们成功运营和管理通信网络的关键工具。 客户案例 案例…
阅读更多...
vue使用高德地图--附带移动获取当前城市信息

vue使用高德地图--附带移动获取当前城市信息

高德地图 1.使用准备申请密钥vue使用 2.移动地图获取城市案例(注意事项)3.总结 1.使用准备 申请密钥 登录注册高德开放平台进入控制台 创建应用 申请key–生成key和安全密钥(2021之后key需要配合安全密钥使用) 注意&#xff1a;安全密钥需要在key之前 vue使用 首先在pubil…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023