《黑马程序员 MySQL数据库入门到精通,从MySQL安装到MySQL高级MySQL优化全囊括》——学习笔记进阶篇
Posted Maskfanatics
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了《黑马程序员 MySQL数据库入门到精通,从MySQL安装到MySQL高级MySQL优化全囊括》——学习笔记进阶篇相关的知识,希望对你有一定的参考价值。
进阶篇
前言
本文仅用作个人笔记使用,整理自《黑马程序员 mysql数据库入门到精通,从MySQL安装到MySQL高级、MySQL优化全囊括》(https://www.bilibili.com/video/BV1Kr4y1i7ru/)
存储引擎
MySQL体系结构
-
连接层
- 最上层是一些客户端和连接服务,主要完成一些类似于连接处理、授权认证、以及相关的安全方案。服务器也会为安全接入的每个客户端验证它所具有的操作权限。
-
服务层
- 第二层架构主要完成大多数的核心服务功能,如SQL接口,并完成缓存的查询,SQL的分析和优化,部分内置函数的执行。所有跨存储引擎的功能也在这一层实现,如存储过程、函数等。
-
引擎层
- 存储引擎真正的负责了MySQL中数据的存储和提起,服务器通过API和存储引擎进行通信。不同的存储引擎具有不同的功能,这样我们可以根据自己的需要,来选取合适的存储引擎。
-
存储层
-
主要是将数据(如: redolog、undolog、数据、索引、二进制日志、错误日志、查询
日志、慢查询日志等)存储在文件系统之上,并完成与存储引擎的交互。
-
和其他数据库相比,MySQL有点与众不同,它的架构可以在多种不同场景中应用并发挥良好作用。主要体现在存储引擎上,插件式的存储引擎架构,将查询处理和其他的系统任务以及数据的存储提取分离。这种架构可以根据业务的需求和实际需要选择合适的存储引擎。
存储引擎简介
存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式。存储引擎是基于表的,而不是基于库的,所以存储引擎也可被称为表类型。我们可以在创建表的时候,来指定选择的存储引擎,如果没有指定将自动选择默认的存储引擎。
#创建表时,指定存储引擎
CREATE TABLE 表名(
字段....
)ENGINE = 引擎;
#查看当前数据库支持的存储引擎
SHOW ENGINES;
实例:
#创建表my_myisam并指定MyISAM存储引擎
CREATE TABLE my_myisam(
id int,
name varchar(10)
)ENGINE = MYISAM;
#创建表my_memory并指定Memory存储引擎
CREATE TABLE my_memory(
id int,
name varchar(10)
)ENGINE = MEMORY;
存储引擎特点
InnoDB
介绍:
- InnoDB是一种兼顾高可靠性和高性能的通用存储引擎,在 MySQL 5.5 之后,InnoDB是默认的MySQL 存储引擎。
特点:
- DML操作遵循ACID模型,支持
事务
; - 支持
行级锁
,提高并发访问性能; - 支持
外键FOREIGN KEY约束
,保证数据的完整性和正确性;
文件:
- xxx.ibd:xxx代表的是表名,innoDB引擎的每张表都会对应这样一个表空间文件,存储该表的表结构(frm-早期的 、sdi-新版的)、数据和索引。
逻辑存储结构:
- 表空间 : InnoDB存储引擎逻辑结构的最高层,ibd文件其实就是表空间文件,在表空间中可以包含多个Segment段。
- 段 : 表空间是由各个段组成的, 常见的段有数据段、索引段、回滚段等。InnoDB中对于段的管理,都是引擎自身完成,不需要人为对其控制,一个段中包含多个区。
- 区 : 区是表空间的单元结构,每个区的大小为1M。 默认情况下, InnoDB存储引擎页大小为16K, 即一个区中一共有64个连续的页。
- 页 : 页是组成区的最小单元,页也是InnoDB存储引擎磁盘管理的最小单元,每个页的大小默认为 16KB。为了保证页的连续性,InnoDB 存储引擎每次从磁盘申请 4-5 个区。
- 行 : InnoDB 存储引擎是面向行的,也就是说数据是按行进行存放的,在每一行中除了定义表时所指定的字段以外,还包含两个隐藏字段(后面会详细介绍)。
MyISAM
介绍:
- MyISAM时MySQL早期的默认存储引擎。
特点:
- 不支持事务,不支持外键
- 支持表锁,不支持行锁
- 访问速度快
文件:
- xxx.sdi:存储表结构信息
- xxx.MYD:存储数据
- xxx.MYI:存储索引
Memory
介绍:
- Memory引擎的表数据是存放在内存中的,由于受到硬件问题或断电问题的影响,只能将这些表作为临时表或缓存使用。
特点:
- 内存存放
- hash索引(默认)
文件:
- xxx.sdi:存储表结构信息
特点 | InnoDB | MyISAM | Memory |
---|---|---|---|
存储限制 | 64TB | 有 | 有 |
事务安全 | 支持 | - | - |
锁 | 行级锁 | 表级锁 | 表级锁 |
B+Tree索引 | 支持 | 支持 | 支持 |
Hash索引 | - | - | 支持 |
全文索引 | 支持(5.6+) | 支持 | - |
空间使用 | 高 | 低 | N/A |
内存使用 | 高 | 低 | 中等 |
批量插入速度 | 低 | 高 | 高 |
外键 | 支持 | - | - |
存储引擎选择
在选择存储引擎时,应该根据应用系统的特点选择合适的存储引擎。对于复杂的应用系统,还可以根据实际情况选择多种存储引擎进行组合。
- InnoDB: 是Mysql的默认存储引擎,支持事务、外键、行级锁。如果应用对事务的完整性有比较高的要求,在并发条件下要求数据的一致性,数据操作除了插入和查询之外,还包含很多的更新、删除操作,那么InnoDB存储引擎是比较合适的选择。
- MyISAM : 如果应用是以读操作和插入操作为主,只有很少的更新和删除操作,并且对事务的完整性、并发性要求不是很高,那么选择这个存储引擎是非常合适的。
- MEMORY:将所有数据保存在内存中,访问速度快,通常用于临时表及缓存。MEMORY的缺陷就是对表的大小有限制,太大的表无法缓存在内存中,而且无法保障数据的安全性。
小结
-
体系结构
- 连接层
- 服务层
- 引擎层(索引在这)
- 存储层
-
存储引擎简介
-
SHOW ENGINES; CREATE TABLE XXXX(.....)ENGINE=INNODB;
-
-
存储引擎特点
- INNODB与MyISAM:事务、外键、行级锁
-
存储引擎应用
- INNODB:存储业务系统中对于事务、数据完整性要求较高的核心数据。
- MyISAM:存储业务系统的非核心事务。
索引
索引概述
介绍:索引(index)是帮助MySQL高效获取数据
的数据结构(有序)
。在数据之外,数据库系统还维护着满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据, 这样就可以在这些数据结构上实现高级查找算法,这种数据结构就是索引。
优缺点:
优点 | 缺点 |
---|---|
提高数据检索的效率,降低数据库的IO成本 | 索引列也是要占用空间的。 |
通过索引列对数据进行排序,降低数据排序的成本,降低CPU的消耗。 | 索引大大提高了查询效率,同时却也降低更新表的速度,如对表进行INSERT、UPDATE、DELETE时,效率降低。 |
索引结构
MySQL的索引是在存储引擎层实现的,不同的存储引擎有不同的索引结构,主要包含以下几种:
结构 | InnoDB | MyISAM | Memory | 说明 |
---|---|---|---|---|
B+Tree索引 | 支持 | 支持 | 支持 | 最常见的索引类型,大部分引擎都支持 B+ 树索引 |
Hash索引 | 不支持 | 不支持 | 支持 | 底层数据结构是用哈希表实现的, 只有精确匹配索引列的查询才有效, 不支持范围查询 |
R-tree(空间索引) | 不支持 | 支持 | 不支持 | 空间索引是MyISAM引擎的一个特殊索引类型,主要用于地理空间数据类型,通常使用较少 |
Full-text(全文索引) | 5.6+支持 | 支持 | 不支持 | 是一种通过建立倒排索引,快速匹配文档的方式。类似于Lucene,Solr,ES |
平常所说的索引,一般都是指B+树结构组织的索引。
二叉树
如果MySQL的索引使用二叉树结构,比较理想的结构为:
但如果主键是顺序插入,二叉树就会退化为一个单向链表:
缺点:顺序插入时,会退化成单向链表,性能大大降低。数据量较大的情况下,二叉树的层级较深,检索数据速度慢。
B-Tree(多路
平衡查找树)
以一颗最大度数(max-degree)为5(5阶)的B-Tree为例(每个节点最多存储4个key,5个指针):
树的度数指的是一个节点的子节点个数
特点:
- 5阶的B-Tree,每一个节点最多存储4个key,对应5个指针。
- 一旦节点存储的key数量到达5,就会裂变,中间元素向上分裂。
- 在B-Tree中,非叶子节点和叶子节点都会存放数据
B+Tree
B+Tree是B-Tree的变种,我们以一颗最大度数(max-degree)为4(4阶)的b+tree为例:
绿色框部分:索引部分,仅仅起到索引数据的作用,不存储数据
红色框部分:数据存储部分,在其叶子节点中要存储具体的数据
与B-Tree的区别:
- 所有数据都会出现在叶子节点
- 叶子节点形成一个单向链表
- 非叶子节点仅仅起到索引数据的作用,具体数据都存放在叶子节点
MySQL索引数据结构对经典的B+Tree进行了优化。在原B+Tree的基础上,增加一个指向相邻叶子节点的链表指针,就形成了带有顺序指针的B+Tree,提高区间访问的性能,利于排序。
Hash
哈希索引就是采用一定的Hash算法,将键值换算成新的Hash值,映射到对应的槽位上,然后存储在Hash表中。
如果两个(或多个)键值,映射到一个相同的槽位上,他们就产生了hash冲突(也称为hash碰撞),可以通过链表来解决。
特点:
- Hash索引只能用于对等比较(=,in),不支持范围查询(between,>,< ,…)
- 无法利用索引完成排序操作
- 查询效率高,通常(不存在hash冲突的情况)只需要一次检索就可以了,效率通常要高于B+Tree索引
在MySQL中,支持hash索引的是Memory存储引擎。 而InnoDB中具有自适应hash功能,hash索引是InnoDB存储引擎根据B+Tree索引在指定条件下自动构建的。
索引分类
分类 | 含义 | 特点 | 关键字 |
---|---|---|---|
主键索引 | 针对于表中主键创建的索引 | 默认自动创建,只能有一个 | PRIMARY |
唯一索引 | 避免同一个表中某数据列中的值重复 | 可以有多个 | UNIQUE |
常规索引 | 快速定位特定数据 | 可以有多个 | |
全文索引 | 全文索引查找的是文本中的关键词,而不是比较索引中的值 | 可以有多个 | FULLTEXT |
而在在InnoDB存储引擎中,根据索引的存储形式,又可以分为以下两种:
分类 | 含义 | 特点 |
---|---|---|
聚簇索引(Clustered Index) | 将数据存储与索引放到了一块,索引结构的叶子节点保存了行数据 | 必须有,而且只有一个 |
非聚簇索引(Secondary Index) | 将数据与索引分开存储,索引结构的叶子节点关联的是对应的主键值 | 可以有多个 |
聚簇索引选取规则:
- 如果存在主键,主键索引就是聚簇索引
- 如果不存在主键,将使用第一个唯一索引作为聚簇索引
- 如果表不存在主键或没有合适的唯一索引,则InnoDB会自动生成一个rowid作为隐藏的聚簇索引
聚簇索引和非聚簇索引的具体结构:
- 聚集索引的叶子节点下挂的是这一行的数据。
- 二级索引的叶子节点下挂的是该字段值对应的主键值。
当执行SELECT * FROM user WHERE name = 'arm'
时,查找过程如下:
- 由于是根据name字段进行查询,所以先根据name='Arm’到name字段的二级索引中进行匹配查找。但是在二级索引中只能查找到 Arm 对应的主键值 10。
- 由于查询返回的数据是*,所以此时,还需要根据主键值10,到聚集索引中查找10对应的记录,最 终找到10对应的行row。
- 最终拿到这一行的数据,直接返回即可。
回表查询:这种先到二级索引中查找数据,找到主键值,然后再到聚集索引中根据主键值,获取数据的方法,就称之为回表查询。
索引语法
创建索引
语法:
#创建索引
CREATE [UNIQUE|FULLTEXT] INDEX index_name ON table_name (index_column_name,...);
查看索引
语法:
#查看索引
SHOW INDEX FROM table_name;
删除索引
语法:
#删除索引
DROP INDEX index_name ON table_name;
实例:
#name字段为姓名字段,该字段的值可能会重复,为name字段创建索引
CREATE INDEX idx_user_name ON tb_user(name);
#phone手机号字段的值时非空且唯一的,为phone字段创建索引
CREATE UNIQUE INDEX idx_user_phone ON tb_user(phone);
#为profession、age、status创建联合索引
CREATE INDEX idx_user_pro_age_status ON tb_user(profession,age,status);
#为email创建合适的索引来提升查询效率
CREATE INDEX idx_user_email ON tb_user(email);
#删除idx_user_email索引
DROP INDEX idx_user_email ON tb_user;
SQL性能分析
SQL的执行频率
MySQL 客户端连接成功后,通过show [session|global] status
命令可以提供服务器状态信 息。通过如下指令,可以查看当前数据库的INSERT、UPDATE、DELETE、SELECT的访问频次:
#session 是查看当前会话 ;
#global 是查询全局数据 ;
SHOW GLOBAL STATUS LIKE 'Com_______';
通过上述指令,我们可以查看到当前数据库到底是以查询为主,还是以增删改为主,从而为数据 库优化提供参考依据。如果是以增删改为主,我们可以考虑不对其进行索引的优化。如果是以 查询为主,那么就要考虑对数据库的索引进行优化了。
慢查询日志
慢查询日志记录了所有执行时间超过指定参数(long_query_time
,单位:秒,默认10秒)的所有 SQL语句的日志。
MySQL的慢查询日志默认没有开启,我们可以查看一下系统变量slow_query_log
。
如果要开启慢查询日志,需要在MySQL的配置文件(/etc/my.cnf)
中进行配置。
#开启慢日志
slow_query_log=1
#设置阈值为1秒
long_query_time=1
配置完毕后,通过指令重新启动MySQL服务器进行测试,查看慢日志文件中记录的信息
#重启MySQL服务器
systemctl restart mysqld
#查看慢日志
cat /var/lib/mysql/localhost-slow.log
PROFILE详情
show profiles能够在做SQL优化时帮助我们了解时间都耗费到哪里去了。通过have_profiling 参数,能够看到当前MySQL是否支持profile操作:
SELECT @@have_profiling;
语法:
#查看每一条SQL的耗时基本情况
SHOW PROFILES;
#查看指定query_id的SQL语句各个阶段的耗时
SHOW PROFILE FOR QUERY query_id;
#查看指定query_id的SQL语句CPU的使用情况
SHOW PROFILE CPU FOR QUERY query_id;
EXPLAIN执行计划
EXPLAIN或者DESC命令获取MySQL如何执行SELECT语句的信息,包括在SELECT语句执行过程中表如何连接和连接的顺序。
语法:
#直接在select语句之前加上关键字 explain / desc
EXPLAIN SELECT 字段列表 FROM 表名 WHERE 条件 ;
说明:
字段 | 说明 |
---|---|
id | select查询的序列号,表示查询中执行select子句或者是操作表的顺序 (id相同,执行顺序从上到下;id不同,值越大,越先执行)。 |
select_type | 表示SELECT的类型,常见的取值有SIMPLE(简单表,即不使用表连接或者子查询)、PRIMARY(主查询,即外层的查询)、UNION(UNION中的第二个或者后面的查询语句)、SUBQUERY(SELECT/WHERE之后包含了子查询)等 |
type | 表示连接类型,性能由好到差的连接类型为NULL、system、const、eq_ref、ref、range、 index、all 。 |
possible_key | 显示可能应用在这张表上的索引,一个或多个。 |
key | 实际使用的索引,如果为NULL,则没有使用索引。 |
key_len | 表示索引中使用的字节数,该值为索引字段最大可能长度,并非实际使用长 度,在不损失精确性的前提下,长度越短越好。 |
rows | MySQL认为必须要执行查询的行数,在innodb引擎的表中,是一个估计值, 可能并不总是准确的。 |
filtered | 表示返回结果的行数占需读取行数的百分比, filtered的值越大越好。 |
索引使用
现在有一张表test_sku,其中有1000W条数据,有id以及name字段,id为自增主键。
先来测试:
mysql> SELECT * FROM test_squ WHERE id = 5473895;
+---------+-----------+
| id | name |
+---------+-----------+
| 5473895 | 韩晓明 |
+---------+-----------+
1 row in set (0.00 sec)
可以发现,即使数据量非常大,根据主键id来查询也还是非常快的。
接下来,来看看根据无索引的name字段:
mysql> SELECT * FROM test_squ WHERE name = '蒋某人';
+----------+-----------+
| id | name |
+----------+-----------+
| 10000000 | 蒋某人 |
+----------+-----------+
1 row in set (12.06 sec)
可以发现,查询只返回了一条数据,结果耗时12.06sec,就是因为name字段没有索引,而造成查询效率很低。故我们可以为name字段添加上一个索引
mysql> CREATE INDEX idx_squ_name ON test_squ(name);
Query OK, 0 rows affected (1 min 12.30 sec)
Records: 0 Duplicates: 0 Warnings: 0
再次执行相同的SQL命令
mysql> SELECT * FROM test_squ WHERE name = '蒋某人';
+----------+-----------+
| id | name |
+----------+-----------+
| 10000000 | 蒋某人 |
+----------+-----------+
1 row in set (0.00 sec)
可以发现,在给name字段建立了索引之后,查询性能大大提升。
最左前缀法则
如果索引了多列(联合索引),要遵守最左前缀法则。最左前缀法则指的是查询从索引的最左列开始, 并且不跳过索引中的列。如果跳跃某一列,索引将会部分失效(后面的字段索引失效)。
实例:
mysql> EXPLAIN SELECT * FROM tb_user WHERE profession = '软件工程' AND age = 31 and status = '0'\\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: ref
possible_keys: idx_user_pro_age_status
key: idx_user_pro_age_status
key_len: 54
ref: const,const,const
rows: 1
filtered: 100.00
Extra: Using index condition
1 row in set, 1 warning (0.00 sec)
mysql> explain select * from tb_user where profession = '软件工程' and age = 31 \\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: ref
possible_keys: idx_user_pro_age_status
key: idx_user_pro_age_status
key_len: 49
ref: const,const
rows: 1
filtered: 100.00
Extra: NULL
1 row in set, 1 warning (0.01 sec)
mysql> explain select * from tb_user where profession = '软件工程' \\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: ref
possible_keys: idx_user_pro_age_status
key: idx_user_pro_age_status
key_len: 47
ref: const
rows: 4
filtered: 100.00
Extra: NULL
1 row in set, 1 warning (0.00 sec)
上面三条都是以profession字段为首个WHERE条件的查询,下面看看其他的情况:
mysql> EXPLAIN SELECT * FROM tb_user WHERE age = 31 and status = '0'\\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 24
filtered: 4.17
Extra: Using where
1 row in set, 1 warning (0.00 sec)
mysql> EXPLAIN SELECT * FROM tb_user WHERE status = '0'\\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 24
filtered: 10.00
Extra: Using where
1 row in set, 1 warning (0.00 sec)
可以发现,这两条查询语句,他们的type都是ALL,表示走的是全表扫描。就是因为不满最左前缀法则。
范围查询
联合索引中,如果出现范围查询(>,<),范围查询右侧的索引会失效。
mysql> explain select * from tb_user where profession = '软件工程' and age > 30 and status
-> = '0'\\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: range
possible_keys: idx_user_pro_age_status
key: idx_user_pro_age_status
key_len: 49
ref: NULL
rows: 2
filtered: 10.00
Extra: Using index condition
1 row in set, 1 warning (0.01 sec)
mysql> explain select * from tb_user where profession = '软件工程' and age >= 30 and
-> status = '0'\\G;
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: tb_user
partitions: NULL
type: range
possible_keys: idx_user_pro_age_status
key: idx_user_pro_age_status
key_len: 54
ref: NULL
rows: 2
filtered: 10.00
Extra: Using index condition
1 row in set, 1 warning (0.00 sec)
所以,在业务允许的情况下,尽可能的使用类似于>=或<=这类的范围查询,而避免使用>或<。
索引失效情况
-
索引列运算
不要在索引列上进行运算操作,
索引将失效
。EXPLAIN SELECT * FROM tb_user WHERE SUBSTRING(phone,10,2) = '15'
-
字符串不加引号
字符串类型字段使用时,不加引号,
索引将失效
。explain select * from tb_user where profession = '软件工程' and age = 31 and status = '0'; explain select * from tb_user where profession = '软件工程' and age = 31 and status = 0; explain select * from tb_user where phone = '17799990015'; explain select * from tb_user where phone = 17799990015;
-
模糊查询
如果仅仅是尾部模糊匹配,索引不会失效。如果是头部模糊匹配,
索引将失效
。explain select * from tb_user where profession like '软件%';#生效 explain select * from tb_user where profession like '%工程';#失效 explain select * from tb_user where profession like '%工%';#失效
-
or连接的条件
用or分割开的条件,如果or前的条件中的列有索引,而后面的列中没有索引,那么涉及的索引都不会被用到。
explain select * from tb_user where id = 10 or age = 23; explain select * from tb_user where phone = '17799990017' or age = 23;
由于age没有索引,所以即使id、phone有索引,索引也会失效。所以需要针对于age也要建立索引。
-
数据分布影响
如果MySQL优化器评估使用索引比全表更慢,则不使用索引。
select * from tb_user where phone >= '17799990005'; select * from tb_user where phone >= '17799990015';
因为MySQL在查询时,会评估使用索引的效率与走全表扫描的效率,如果走全表扫描更快,则放弃 索引,走全表扫描。因为索引是用来索引少量数据的,如果通过索引查询返回大批量的数据,则还不如走全表扫描来的快,此时索引就会失效。
SQL提示
SQL提示,是优化数据库的一个重要手段,简单来说,就是在SQL语句中加入一些人为的提示来达到优 化操作的目的。
语法:
#use index : 建议MySQL使用哪一个索引完成此次查询(仅仅是建议,mysql内部还会再次进行评估)。
explain select * from tb_user use index(idx_user_pro) where profession = '软件工程';
#ignore index : 忽略指定的索引。
explain select * from tb_user ignore index(idx_user_pro) where profession = '软件工程';
#force index : 强制使用索引。
explain select * from tb_user force index(idx_user_pro) where profession = '软件工程';
先查看explain select * from tb_user where profession = '软件工程';
的结果:
mysql> explain select * from tb_user where profession = '软件工程';
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------+------+----------+-------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status | idx_user_pro_age_status | 47 | const | 4 | 100.00 | NULL |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.00 sec)
可以发现,因为WHERE条件的第一条符合最左前缀法则,MySQL走了联合索引
接下来创建一个profession的单列索引,再来查看这条SQL的执行计划
mysql> create index idx_user_pro on tb_user(profession);
Query OK, 0 rows affected (0.05 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> explain select * from tb_user where profession = '软件工程';
+----+-------------+---------+------------+------+--------------------------------------+-------------------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+--------------------------------------+-------------------------+---------+-------+------+----------+-------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status,idx_user_pro | idx_user_pro_age_status | 47 | const | 4 | 100.00 | NULL |
+----+-------------+---------+------------+------+--------------------------------------+-------------------------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.01 sec)
发现在possible_keys列中,MySQL确实给到两个可能的索引,但是最后选择了联合索引,这是MySQL自动选择的结果。
我们可以使用上面的语法,进行指定索引:
mysql> explain select * from tb_user force index(idx_user_pro) where profession = '软件工程';
+----+-------------+---------+------------+------+---------------+--------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+---------------+--------------+---------+-------+------+----------+-------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro | idx_user_pro | 47 | const | 4 | 100.00 | NULL |
+----+-------------+---------+------------+------+---------------+--------------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.00 sec)
覆盖索引
查询使用了索引,并且需要返回的列,在该索引中已经全部能够找到。
实例:
mysql> explain select id, profession from tb_user where profession = '软件工程' and age = 31 and status = '0' ;
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status | idx_user_pro_age_status | 54 | const,const,const | 1 | 100.00 | Using where; Using index |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
1 row in set, 1 warning (0.00 sec)
mysql> explain select id,profession,age, status from tb_user where profession = '软件工程' and age = 31 and status = '0' ;
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status | idx_user_pro_age_status | 54 | const,const,const | 1 | 100.00 | Using where; Using index |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+--------------------------+
1 row in set, 1 warning (0.00 sec)
mysql> explain select id,profession,age, status, name from tb_user where profession = '软件工程' and age = 31 and status = '0' ;
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status | idx_user_pro_age_status | 54 | const,const,const | 1 | 100.00 | Using index condition |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
1 row in set, 1 warning (0.01 sec)
mysql> explain select * from tb_user where profession = '软件工程' and age = 31 and status = '0';
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
| 1 | SIMPLE | tb_user | NULL | ref | idx_user_pro_age_status | idx_user_pro_age_status | 54 | const,const,const | 1 | 100.00 | Using index condition |
+----+-------------+---------+------------+------+-------------------------+-------------------------+---------+-------------------+------+----------+-----------------------+
1 row in set, 1 warning (0.00 sec)
解读:
Extra | 含义 |
---|---|
Using where;Using Index | 查找使用了索引,但是需要的数据都在索引列中能找到,所以不需要回表查询数据 |
Using Index Condition | 查找使用了索引,但是需要回表查询数据 |
思考:一张表有四个字段(id,username,password,status),由于数据量大,需要对一下SQL语句进行优化,该如何进行才是最优方案:
SELECT id,username,pasword FROM tb_user WHERE username = 'Mask';
解答:最优方案是为username和password字段建立一个联合索引
前缀索引
当字段类型为字符串(varchar,text,longtext等)时,有时候需要索引很长的字符串,这会让 索引变得很大,查询时,浪费大量的磁盘IO,影响查询效率。此时可以只将字符串的一部分前缀,建 立索引,这样可以大大节约索引空间,从而提高索引效率。
语法:
CREATE INDEX idx_xxxx on table_name(COLUMN(n));
前缀长度:
可以根据索引的选择性来决定,而选择性是指不重复的索引值(基数)和数据表的记录总数的比值, 索引选择性越高则查询效率越高,唯一索引的选择性是1,这是最好的索引选择性,性能也是最好的。
公式:
select count(distinct email) / count(*) from tb_user ;
select count(distinct substring(email,1,5)) / count(*) from tb_user ;
实例:
#为tb_user的email字段建立长度为5的前缀索引
mysql> CREATE INDEX idx_user_email ON tb_user(email(5));
Query OK, 0 rows affected (0.05 sec)
Records: 0 Duplicates: 0 Warnings: 0
设计原则
- 针对于数据量较大,且查询较为频繁的表建立索引。
- 针对于常作为查询条件(WHERE)、排序(ORDER BY)、分组(GROUP BY)操作的字段建立索引。
- 尽量选择区分度高的列作为索引,尽量建立唯一索引,区分度越高,使用索引的效率越高。
- 如果是字符串类型的字段,字段的长度较长,可以针对于字段的特点,建立前缀索引。
- 尽量使用联合索引,减少单列索引,查询时,联合索引很多时候可以覆盖索引,节省存储空间,避免回表,提高查询效率。
- 要控制索引的数量,索引并不是多多益善,索引越多,维护索引结构的代价也就越大,会影响增删改的效率。
- 如果索引列不能存储NULL值,请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时,它可以更好地确定哪个索引最有效地用于查询。
小结
-
索引概述
索引是高效获取数据的数据结构
-
索引结构
B+TREE、HASH
-
索引分类
主键索引、唯一索引、常规索引、全文索引
聚簇索引、非聚簇索引
-
索引语法
CREATE [UNIQUE] INDEX idx_xxx ON table_name(column,...); SHOW INDEX FROM table_name; DROP INDEX idx_xxx ON table_name;
-
SQL性能分析
执行频次、慢查询日志、PROFILE、EXPLAIN
-
索引使用
联合索引、索引失效、SQL提示、覆盖索引、前缀索引
-
索引设计原则
表、字段、索引
SQL优化
插入数据
INSERT优化
如果我们需要一次性往数据库中插入多条记录,可以从一下三个方面进行优化。
insert into tb_test values(1,'tom');
insert into tb_test values(2,'cat');
insert into tb_test values(3,'jerry');
.....
优化方案1:
#批量插入数据
Insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');
优化方案2:
#手动控制事务的提交
start transaction;
insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');
insert into tb_test values(4,'Tom'),(5,'Cat'),(6,'Jerry');
insert into tb_test values(7,'Tom'),(8,'Cat'),(9,'Jerry');
commit;
优化方案3:
#主键顺序插入,性能要高于乱序插入
主键乱序插入 : 8 1 9 21 88 2 4 15 89 5 7 3
主键顺序插入 : 1 2 3 4 5 7 8 9 15 21 88 89
大批量插入数据
如果一次性需要插入大批量数据(比如: 几百万的记录),使用insert语句插入性能较低,此时可以使用MySQL数据库提供的load指令进行插入。操作如下:
-- 客户端连接服务端时,加上参数 -–local-infile
mysql –-local-infile -u root -p
-- 设置全局参数local_infile为1,开启从本地加载文件导入数据的开关
set global local_infile = 1;
-- 执行load指令将准备好的数据,加载到表结构中
load data local infile '/root/sql1.log' into table tb_user fields
terminated by ',' lines terminated by '\\n' ;
顺序插入的性能高于乱序插入
主键优化
数据组织方式
在InnoDB存储引擎中,表数据都是根据主键顺序组织存放的,这种存储方式的表称为索引组织表(Index Organized Table IOT
)
在InnoDB引擎中,数据行是记录在逻辑结构 page 页中的,而每一个页的大小是固定的,默认16K。那也就意味着,一个页中所存储的行也是有限的,如果插入的数据行row在该页存储不小,将会存储到下一个页中,页与页之间会通过指针连接。
页分裂
页可以为空,也可以填充一半,也可以填充100%。每个页包含了2-N行数据(如果一行数据过大,会行溢出),根据主键排列。
页合并
当删除一行记录时,实际上记录并没有被物理删除,只是记录被标记(flaged)为删除并且它的空间变得允许被其他记录声明使用。当页中删除的记录到达MERGE_THRESHOLD(默认为页的50%),InnoDB会开始寻找最靠近的页(前或后)看看是否可以将两个页合并以优化空间使用。
主键设计原则
- 满足业务需求的情况下,尽量降低主键的长度
- 插入数据时,尽量选择顺序插入,选择使用AUTO_INCREMENT自增主键
- 尽量不要使用UUID做主键或者时是其他自然主键,如身份证号。
- 业务操作时,避免对主键的修改。
ORDER BY优化
MySQL的排序,有两种方式:
Using Filesort:通过表的索引或全表扫描,读取满足条件的数据行,然后在排序缓冲区sort buffer中完成排序操作,所有不是通过索引直接返回排序结果的排序都叫FileSort排序。
Using Index:通过有序索引顺序扫描直接返回有序数据,这种情况即为Using Index,不需要额外排序,操作效率高。对于以上的两种排序方式,Using Index的性能高,而Using Filesort的性能低,我们在优化排序操作时,尽量要优化为Using Index。
实例:
mysql> explain select id,age,phone from tb_user order by age ;
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
| 1 | SIMPLE | tb_user | NULL | ALL | NULL | NULL | NULL | NULL | 24 | 100.00 | Using filesort |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
1 row in set, 1 warning (0.00 sec)
mysql> explain select id,age,phone from tb_user order by age, phone ;
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
| 1 | SIMPLE | tb_user | NULL | ALL | NULL | NULL | NULL | NULL | 24 | 100.00 | Using filesort |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+----------------+
1 row in set, 1 warning (0.00 sec)
由于 age, phone 都没有索引,所以此时再排序时,出现Using filesort, 排序性能较低。
可以通过创建索引来解决:
#创建索引
mysql> create index idx_user_age_phone_aa on tb_user(age,phone);
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
#再次执行排序语句
mysql> explain select id,age,phone from tb_user order by age;
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+-------------+
| 1 | SIMPLE | tb_user | NULL | index | NULL | idx_user_age_phone_aa | 48 | NULL | 24 | 100.00 | Using index |
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)
建立索引之后,再次进行排序查询,就由原来的Using filesort, 变为了 Using index,性能 就是比较高的了。
如果我们根据age,phone进行降序排序:
mysql> explain select id,age,phone from tb_user order by age desc , phone desc ;
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+----------------------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+----------------------------------+
| 1 | SIMPLE | tb_user | NULL | index | NULL | idx_user_age_phone_aa | 48 | NULL | 24 | 100.00 | Backward index scan; Using index |
+----+-------------+---------+------------+-------+---------------+-----------------------+---------+------+------+----------+----------------------------------+
1 row in set, 1 warning (0.00 sec)
也出现 Using index, 但是此时Extra中出现了 Backward index scan,这个代表反向扫描索引,因为在MySQL中我们创建的索引,默认索引的叶子节点是从小到大排序的,而此时我们查询排序时,是从大到小,所以在扫描时就是反向扫描,就会出现Backward index scan。 在MySQL8版本中,支持降序索引,我们也可以创建降序索引。
排序时,也需要满足最左前缀法则,否则也会出现
小结:
- 根据排序字段建立合适的索引,多字段排序时,也遵循最左前缀法则。
- 尽量使用覆盖索引。
- 多字段排序, 一个升序一个降序,此时需要注意联合索引在创建时的规则(ASC/DESC)。
- 如果不可避免的出现filesort,大数据量排序时,可以适当增大排序缓冲区大小sort_buffer_size(默认256k)。
GROUP BY优化
首先,将表中的索引全部删除。
在没有索引的情况下执行如下SQL并查看执行计划:
mysql> explain select profession , count(*) from tb_user group by profession ;
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-----------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-----------------+
| 1 | SIMPLE | tb_user | NULL | ALL | NULL | NULL | NULL | NULL | 24 | 100.00 | Using temporary |
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-----------------+
1 row in set, 1 warning (0.00 sec)
然后我们再针对与profession,age,status字段创建一个联合索引,并执行上面相同的SQL。
mysql> create index idx_user_pro_age_sta on tb_user(profession , age , status);
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> explain select profession , count(*) from tb_user group by profession ;
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
| 1 | SIMPLE | tb_user | NULL | index | idx_user_pro_age_sta | idx_user_pro_age_sta | 54 | NULL | 24 | 100.00 | Using index |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)
再执行如下的分组查询SQL,查看执行计划:
mysql> explain select profession,count(*) from tb_user group by profession,age;
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
| 1 | SIMPLE | tb_user | NULL | index | idx_user_pro_age_sta | idx_user_pro_age_sta | 54 | NULL | 24 | 100.00 | Using index |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)
mysql> explain select age,count(*) from tb_user group by age;
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+------------------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+------------------------------+
| 1 | SIMPLE | tb_user | NULL | index | idx_user_pro_age_sta | idx_user_pro_age_sta | 54 | NULL | 24 | 100.00 | Using index; Using temporary |
+----+-------------+---------+------------+-------+----------------------+----------------------+---------+------+------+----------+------------------------------+
1 row in set, 1 warning (0.00 sec)
由上述执行计划可以发现,仅仅根据age进行分组,就会出现Using temporary;而如果是根据profession,age两个字段同时分组,则不会出现Using temporary。因为对于分组操作,在联合索引中也是符合索引的最左前缀法则的。
LIMIT优化
在数据量比较大时,如果进行LIMIT分页查询,在查询时,越往后分页查询性能越低。
先来看看不同分页位置查询耗时的对比:
#################################################
mysql> select * from test_squ limit 0,10;
...
10 rows in set (0.01 sec)
#################################################
mysql> select * from test_squ limit 1000000,10;
...
10 rows in set (0.27 sec)
#################################################
mysql> select * from test_squ limit 5000000,10;
...
10 rows in set (0.95 sec)
#################################################
mysql> select * from test_squ limit 9500000,10;
...
10 rows in set (2.58 sec)
通过上述测试可以看到,越往后,分页查询所需要的时间越长。
以最后一条SELECT * FROM test_squ LIMIT 9500000,10;
为例,当我们进行分页查询时,MySQL需要先扫描出前9500010条记录,并抛弃9499999条记录再返回第9500000开始到9500010的10条记录。
优化思路:一般分页查询时,通过创建覆盖索引
能够比较好地提高性能,可以通过覆盖索引加子查询形式进行优化。
COUNT优化
先来回顾以下两个存储引擎MyISAM和InnoDB。
- MyISAM:MyISAM存储引擎把一个表的总行数存放在了磁盘上,因此在指定了使用MyISAM引擎的表中执行
COUNT(*)
的时候效率非常高,但如果是带条件的COUNT,MyISAM也慢。 - InnoDB:InnoDB存储引擎在执行
COUNT(*)
时需要把数据一行行读出来再进行累加计数。
优化思路:主要可以通过Redis这样的非关系型数据库来辅助。
COUNT用法
COUNT()是一个聚合函数,对于返回的结果集,一行行地判断,如果COUNT函数的参数不是NULL,累计值就加 1,否则不加,最后返回累计值。