索引

索引可以高效获取数据，避免对数据进行全盘扫描（查询速度很慢），索引就是一种数据结构（树）
MySQL官方对索引的定义为：索引（index）是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护者满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据， 这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。如下面的示意图所示 :

此时的索引树是一个平衡二叉树，上图的索引树的建立就是平衡二叉树的建立。 此时 查找数据就像二分查找一样了

索引建设规则

优势

1） 类似于书籍的目录索引，提高数据检索的效率，降低数据库的IO成本。（时间）
2） 通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗。（资源消耗）

劣势

1） 实际上索引也是一张表，该表中保存了主键与索引字段，并指向实体类的记录，所以索引列也是要占用空间的。
2） 虽然索引大大提高了查询效率，同时却也降低更新表的速度（需要维护索引），如对表进行INSERT、UPDATE、DELETE。因为更新表时，MySQL 不仅要保存数据，还要保存一下索引文件每次更新添加了索引列的字段，都会调整因为更新所带来的键值变化后的索引信息。

索引 InnoDB引擎 MyISAM引擎 Memory引擎
BTREE索引 支持 支持 支持
HASH 索引 不支持 不支持 支持
R-tree 索引 不支持 支持 不支持
Full-text 5.6版本之后支持 支持 不支持

索引分类

1） 单值索引 ：即一个索引只包含单个列，一个表可以有多个单列索引

2） 唯一索引 ：索引列的值必须唯一，但允许有空值

3） 复合索引 ：即一个索引包含多个列

mysql8.0

1.降序索引：升序索引不适合 反向扫描



2.隐藏索引（类似逻辑删除，主键不能设置为隐藏索引）

索引的语法

建表

create database demo_01 default charset=utf8mb4;use demo_01;CREATE TABLE `city` (`city_id` int(11) NOT NULL AUTO_INCREMENT,`city_name` varchar(50) NOT NULL,`country_id` int(11) NOT NULL,PRIMARY KEY (`city_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;CREATE TABLE `country` (`country_id` int(11) NOT NULL AUTO_INCREMENT,`country_name` varchar(100) NOT NULL,PRIMARY KEY (`country_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;insert into `city` (`city_id`, `city_name`, `country_id`) values(1,'西安',1);
insert into `city` (`city_id`, `city_name`, `country_id`) values(2,'NewYork',2);
insert into `city` (`city_id`, `city_name`, `country_id`) values(3,'北京',1);
insert into `city` (`city_id`, `city_name`, `country_id`) values(4,'上海',1);insert into `country` (`country_id`, `country_name`) values(1,'China');
insert into `country` (`country_id`, `country_name`) values(2,'America');
insert into `country` (`country_id`, `country_name`) values(3,'Japan');
insert into `country` (`country_id`, `country_name`) values(4,'UK');

创建索引

主键默认有索引

CREATE   [UNIQUE|FULLTEXT|SPATIAL]  INDEX index_name
[USING  index_type]
ON tbl_name(index_col_name,...)index_col_name : column_name[(length)][ASC | DESC]1). alter  table  tb_name  add  primary  key(column_list); 该语句添加一个主键，这意味着索引值必须是唯一的，且不能为NULL2). alter  table  tb_name  add  unique index_name(column_list);这条语句创建索引的值必须是唯一的（除了NULL外，NULL可能会出现多次）3). alter  table  tb_name  add  index index_name(column_list);添加普通索引， 索引值可以出现多次。4). alter  table  tb_name  add  fulltext  index_name(column_list);该语句指定了索引为FULLTEXT， 用于全文索引5）. 创建组合索引创建复合索引:CREATE INDEX idx_name_email_status ON tb_seller(NAME,email,STATUS);就相当于对name 创建索引 ;对name , email 创建了索引 ;对name , email, status 创建了索引  --------------------------------------------------------------------#创建索引 city_name
create index idx_city_name on city(city_name) ;#查看索引
show index from city#删除索引
drop index idx_city_name on city ;

索引设计原则

​ 索引的设计可以遵循一些已有的原则，创建索引的时候请尽量考虑符合这些原则，便于提升索引的使用效率，更高效的使用索引。

  • 对查询频次较高，且数据量比较大的表建立索引。

  • 索引字段的选择，最佳候选列应当从where子句的条件中提取，如果where子句中的组合比较多，那么应当挑选最常用、过滤效果最好的列的组合。

  • 使用唯一索引，区分度越高，使用索引的效率越高。

  • 索引可以有效的提升查询数据的效率，但索引数量不是多多益善，索引越多，维护索引的代价自然也就水涨船高。对于插入、更新、删除等DML操作比较频繁的表来说，索引过多，会引入相当高的维护代价，降低DML操作的效率，增加相应操作的时间消耗。另外索引过多的话，MySQL也会犯选择困难病，虽然最终仍然会找到一个可用的索引，但无疑提高了选择的代价。

  • 使用短索引，索引创建之后也是使用硬盘来存储的，因此提升索引访问的I/O效率，也可以提升总体的访问效率。假如构成索引的字段总长度比较短，那么在给定大小的存储块内可以存储更多的索引值，相应的可以有效的提升MySQL访问索引的I/O效率。

  • 利用最左前缀，N个列组合而成的组合索引，那么相当于是创建了N个索引，如果查询时where子句中使用了组成该索引的前几个字段，那么这条查询SQL可以利用组合索引来提升查询效率。

视图

创建视图的语法为：

CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]VIEW view_name [(column_list)]AS select_statement[WITH [CASCADED | LOCAL] CHECK OPTION]

修改视图的语法为：

ALTER [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]VIEW view_name [(column_list)]AS select_statement[WITH [CASCADED | LOCAL] CHECK OPTION]

选项 : WITH [CASCADED | LOCAL] CHECK OPTION 决定了是否允许更新数据使记录不再满足视图的条件。LOCAL ： 只要满足本视图的条件就可以更新。CASCADED ： 必须满足所有针对该视图的所有视图的条件才可以更新。 默认值.

示例 , 创建city_country_view视图 , 执行如下SQL :

create or replace view city_country_view
as
select t.*,c.country_name from country c , city t where c.country_id = t.country_id;
#创建视图 （视图字段不能重复 ！！！）  正常的sql 语句-》 select c.* from city c ,country t where c.country_id = t.country_id
create view vi_city_country as  select c.* from city c ,country t where c.country_id = t.country_id;#操作视图
#视图查询
select * from vi_city_country;#更新 （更新的是基础表的数据 ！！跟新视图也更新了 原表， 不建议更新视图 ）
update vi_city_country set city_name =  '西安市' where city_id = 1 ;

3.3 查看视图

​ 从 MySQL 5.1 版本开始，使用 SHOW TABLES 命令的时候不仅显示表的名字，同时也会显示视图的名字，而不存在单独显示视图的 SHOW VIEWS 命令。

同样，在使用 SHOW TABLE STATUS 命令的时候，不但可以显示表的信息，同时也可以显示视图的信息。

如果需要查询某个视图的定义，可以使用 SHOW CREATE VIEW 命令进行查看 ：

3.4 删除视图

语法 :

DROP VIEW [IF EXISTS] view_name [, view_name] ...[RESTRICT | CASCADE]

示例 , 删除视图city_country_view :

DROP VIEW city_country_view ;

存储过程和函数

函数 ： 是一个有返回值的过程 ；
过程 ： 是一个没有返回值的函数 ；

存储过程

CREATE PROCEDURE procedure_name ([proc_parameter[,...]])
begin-- SQL语句
end ;# 实例#创建
create procedure pro_test2()
beginselect 'Hello yyyy' ;
end;#调用
call pro_test2();#删除
drop procedure pro_test1

语法

变量

create procedure prp_t1()
begin#声明变量declare num int default 10 ;#查找变量select concat('num 是：',num) ;
end;create procedure prp_t2()
begin#声明变量declare num int default 10 ;#修改变量set num = num + 10 ;#查找变量select concat('num 是：',num) ;
end;create procedure prp_t3()
begin#声明变量declare num int  ;#给变量赋值select count(*) into num from city ;select concat('num 是：',num) ;
end;call prp_t3()

if条件判断

# 语法结构
if search_condition then statement_list[elseif search_condition then statement_list] ...[else statement_list]end if;

案例

根据定义的身高变量，判定当前身高的所属的身材类型 180 及以上 ----------> 身材高挑170 - 180  ---------> 标准身材170 以下  ----------> 一般身材create procedure p_t4()begindeclare h int default 175 ;declare des varchar(50) default '';if h >=180 thenset des= '美女';elseif h>=170 and h<= 180 thenset des= '还行吧' ;elseset des = '一般身材';end if ;select concat('身高:',h,' 对应描述是:',des) ;end;

传递参数

create procedure procedure_name([in/out/inout] 参数名   参数类型)
...IN :   该参数可以作为输入，也就是需要调用方传入值 , 默认
OUT:   该参数作为输出，也就是该参数可以作为返回值
INOUT: 既可以作为输入参数，也可以作为输出参数## in
create procedure p_t4()begindeclare h int default 175 ;declare des varchar(50) default '';if h >=180 thenset des= '美女';elseif h>=170 and h<= 180 thenset des= '还行吧' ;elseset des = '一般身材';end if ;select concat('身高:',h,' 对应描述是:',des) ;end;## outcreate procedure p_t6(in h int,out des varchar(50))beginif h >=180 thenset des= '美女';elseif h>=170 and h<= 180 thenset des= '还行吧' ;elseset des = '一般身材';end if ;end;## 获取返回值并且输出
call p_t6(180,@descri);select @descri

case --when --then – end

 create procedure pro_t7(mon int)begindeclare res varchar(50);casewhen  mon >=1 and mon <=2 thenset res = '第一季度';when mon>=2 and mon<=3 thenset res = '第二季度';when mon>=3 and mon<=4 thenset res = '第三季度';end case ;select concat('传递的月份为:',mon,' 计算出的结果:',res);end;call pro_t7(3)

while --do --end while（循环）

create procedure p_t8(n int)begindeclare total int default 0 ;declare num int default 1 ;while num <= n doset total = total+num ;set num = num+1 ;end while;select total ;end;drop procedure p_t8 ;

repeat结构


create procedure pro_test10(n int)
begindeclare total int default 0;repeat set total = total + n;set n = n - 1;until n=0  end repeat;select total ;end;

loop语句

[begin_label:] LOOPstatement_listEND LOOP [end_label]

leave语句

用来从标注的流程构造中退出，通常和 BEGIN … END 或者循环一起使用。下面是一个使用 LOOP 和 LEAVE 的简单例子 , 退出循环：

delimiter $CREATE PROCEDURE pro_test11(n int)
BEGINdeclare total int default 0;ins: LOOPIF n <= 0 thenleave ins;END IF;set total = total + n;set n = n - 1;END LOOP ins;select total;
END$delimiter ;

游标/光标

一个容器装数据 ，然后用光标和游标对结果集进行遍历操作

  • 声明光标：
DECLARE cursor_name CURSOR FOR select_statement ;
  • OPEN 光标：
OPEN cursor_name ;
  • FETCH 光标：
FETCH cursor_name INTO var_name [, var_name] ...
  • CLOSE 光标：
CLOSE cursor_name ;

案例：

create procedure pro_test14()
beginDECLARE id int(11);DECLARE name varchar(50);DECLARE age int(11);DECLARE salary int(11);DECLARE has_data int default 1;DECLARE emp_result CURSOR FOR select * from emp;# 获得循环指针，  当循环中的数据为0 ，has_data变成 0 DECLARE EXIT HANDLER FOR NOT FOUND set has_data = 0;open emp_result;repeatfetch emp_result into id , name , age , salary;select concat('id为',id, ', name 为' ,name , ', age为 ' ,age , ', 薪水为: ', salary);until has_data = 0end repeat;close emp_result;end;
call pro_test14()

存储函数

CREATE FUNCTION function_name([param type ... ])
RETURNS type
BEGIN...
END;

案例

#防止 ERROR 1418 (HY000): This function has none of DETERMINISTIC, NO SQL, or READS SQL DATA in its declaration and binary logging is enabled (you might want to use the less safe log_bin_trust_function_creators variable)
set global log_bin_trust_function_creators=TRUE;
create function count_city1(countryId int)returns int
begindeclare cnum1 int ;select count(*) into cnum1 from city where country_id = countryId;return cnum1;end;select count_city1(1) ;

触发器

触发器是与表有关的数据库对象，指在 insert/update/delete 之前或之后，触发并执行触发器中定义的SQL语句集合。触发器的这种特性可以协助应用在数据库端确保数据的完整性 , 日志记录 , 数据校验等操作 。
使用别名 OLD 和 NEW 来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。现在触发器还只支持行级触发，不支持语句级触发。

触发器类型 NEW 和 OLD的使用
INSERT 型触发器 NEW 表示将要或者已经新增的数据
UPDATE 型触发器 OLD 表示修改之前的数据 , NEW 表示将要或已经修改后的数据
DELETE 型触发器 OLD 表示将要或者已经删除的数据

创建触发器

create trigger trigger_name before/after insert/update/deleteon tbl_name [ for each row ]  -- 行级触发器begintrigger_stmt ;end;

create table emp_logs(id int(11) not null auto_increment,operation varchar(20) not null comment '操作类型, insert/update/delete',operate_time datetime not null comment '操作时间',operate_id int(11) not null comment '操作表的ID',operate_params varchar(500) comment '操作参数',primary key(`id`)
)engine=innodb default charset=utf8;#创建 insert 型触发器，完成插入数据后的日志记录 :
create trigger emp_in_tr
after insert
on emp
for each row
begininsert into emp_logs (id,operation,operate_time,operate_id,operate_params)# new.id ： 引用的 新插入数据的 id  ， new : 引用 插入数据的数据~~values(null,'insert',now(),new.id,concat('插入后(id:',new.id,', name:',new.name,', age:',new.age,', salary:',new.salary,')'));
end;# 当插入一条新的数据之后  ， emp_logs会新增一条数据
insert into emp(id,name,age,salary) values(null, '光明左使',30,3500);
修改触发器
create trigger emp_logs_update_trigger
after update
# on -> 监听
on emp
for each row
begininsert into emp_logs (id,operation,operate_time,operate_id,operate_params) values(null,'update',now(),new.id,concat('修改前(id:',old.id,', name:',old.name,', age:',old.age,', salary:',old.salary,') , 修改后(id',new.id, 'name:',new.name,', age:',new.age,', salary:',new.salary,')'));
end $新增触发器
create trigger emp_logs_delete_trigger
after delete
on emp
for each row
begininsert into emp_logs (id,operation,operate_time,operate_id,operate_params) values(null,'delete',now(),old.id,concat('删除前(id:',old.id,', name:',old.name,', age:',old.age,', salary:',old.salary,')'));
end $

mysql体系

1） 连接层最上层是一些客户端和链接服务，包含本地sock 通信和大多数基于客户端/服务端工具实现的类似于 TCP/IP的通信。主要完成一些类似于连接处理、授权认证、及相关的安全方案。在该层上引入了线程池的概念，为通过认证安全接入的客户端提供线程。同样在该层上可以实现基于SSL的安全链接。服务器也会为安全接入的每个客户端验证它所具有的操作权限。2） 服务层第二层架构主要完成大多数的核心服务功能，如SQL接口，并完成缓存的查询，SQL的分析和优化，部分内置函数的执行。所有跨存储引擎的功能也在这一层实现，如 过程、函数等。在该层，服务器会解析查询并创建相应的内部解析树，并对其完成相应的优化如确定表的查询的顺序，是否利用索引等， 最后生成相应的执行操作。如果是select语句，服务器还会查询内部的缓存，如果缓存空间足够大，这样在解决大量读操作的环境中能够很好的提升系统的性能。3） 引擎层存储引擎层， 存储引擎真正的负责了MySQL中数据的存储和提取，服务器通过API和存储引擎进行通信。不同的存储引擎具有不同的功能，这样我们可以根据自己的需要，来选取合适的存储引擎。4）存储层数据存储层， 主要是将数据存储在文件系统之上，并完成与存储引擎的交互。和其他数据库相比，MySQL有点与众不同，它的架构可以在多种不同场景中应用并发挥良好作用。主要体现在存储引擎上，插件式的存储引擎架构，将查询处理和其他的系统任务以及数据的存储提取分离。这种架构可以根据业务的需求和实际需要选择合适的存储引擎。

存储引擎

和大多数的数据库不同, MySQL中有一个存储引擎的概念, 针对不同的存储需求可以选择最优的存储引擎。
​ 存储引擎就是存储数据，建立索引，更新查询数据等等技术的实现方式 。存储引擎是基于表的，而不是基于库的。所以存储引擎也可被称为表类型。
​ Oracle，SqlServer等数据库只有一种存储引擎。MySQL提供了插件式的存储引擎架构。所以MySQL存在多种存储引擎，可以根据需要使用相应引擎，或者编写存储引擎。
​ MySQL5.0支持的存储引擎包含 ： InnoDB 、MyISAM 、BDB、MEMORY、MERGE、EXAMPLE、NDB Cluster、ARCHIVE、CSV、BLACKHOLE、FEDERATED等，其中InnoDB和BDB提供事务安全表，其他存储引擎是非事务安全表。
可以通过指定 show engines ， 来查询当前数据库支持的存储引擎 ：

# 查看存储引擎
show engines ;#查看mysql环境变量
show variables like '%storage_engine%' ;


各种存储引擎特性

下面重点介绍几种常用的存储引擎， 并对比各个存储引擎之间的区别， 如下表所示 ：

特点 InnoDB MyISAM MEMORY MERGE NDB
存储限制 64TB 有 有 没有 有
事务安全 支持
锁机制 行锁(适合高并发) 表锁 表锁 表锁 行锁
B树索引 支持 支持 支持 支持 支持
哈希索引 支持
全文索引 支持(5.6版本之后) 支持
集群索引 支持
数据索引 支持 支持 支持
索引缓存 支持 支持 支持 支持 支持
数据可压缩 支持
空间使用 高 低 N/A 低 低
内存使用 高 低 中等 低 高
批量插入速度 低 高 高 高 高
支持外键 支持

下面我们将重点介绍最长使用的两种存储引擎： InnoDB、MyISAM ， 另外两种 MEMORY、MERGE ， 了解即可。

InnoDB

创表

create table goods_innodb(id int NOT NULL AUTO_INCREMENT,name varchar(20) NOT NULL,primary key(id)
)ENGINE=innodb DEFAULT CHARSET=utf8;

事务

start transaction;insert into goods_innodb(id,name)values(null,'Meta30');
#事务提交 会查询不到数据！
commit ;

外键

create table country_innodb(country_id int NOT NULL AUTO_INCREMENT,country_name varchar(100) NOT NULL,primary key(country_id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;create table city_innodb(city_id int NOT NULL AUTO_INCREMENT,city_name varchar(50) NOT NULL,country_id int NOT NULL,primary key(city_id),key idx_fk_country_id(country_id),## 关联 country_innodb 中的 country_id ## ON DELETE RESTRICT   ## ON UPDATE CASCADECONSTRAINT `fk_city_country` FOREIGN KEY(country_id) REFERENCES country_innodb(country_id) ON DELETE RESTRICT ON UPDATE CASCADE)ENGINE=InnoDB DEFAULT CHARSET=utf8;insert into country_innodb values(null,'China'),(null,'America'),(null,'Japan');
insert into city_innodb values(null,'Xian',1),(null,'NewYork',2),(null,'BeiJing',1);#删除主表中的数据 ，报错
DELETE from country_innodb where country_id = 2 ;# 子表id也更新~~
update country_innodb set country_id = 100 where country_id = 1;

MyISAM

不支持事务 ，也不支持外键！！但是速度很快 （前提是你允许少量数据丢失）

在这里插入代码片

InnoDB vs MyISAM 谁的速度快？

InnoDB ：


MyISAM ：


测试数据 ：相同的表 ， 相同的数据
InnoDB ：138 ms 145 ms
MyISAM ：109 ms 113ms
可以看出来 InnoDB 的查询速度快 20%左右
这是我的数据 当然你也可以看看别人的数据
InnoDB vs MyISAM

对引擎的选择

​ 在选择存储引擎时，应该根据应用系统的特点选择合适的存储引擎。对于复杂的应用系统，还可以根据实际情况选择多种存储引擎进行组合。以下是几种常用的存储引擎的使用环境。

  • InnoDB : 是Mysql的默认存储引擎，用于事务处理应用程序，支持外键。如果应用对事务的完整性有比较高的要求，在并发条件下要求数据的一致性，数据操作除了插入和查询意外，还包含很多的更新、删除操作，那么InnoDB存储引擎是比较合适的选择。InnoDB存储引擎除了有效的降低由于删除和更新导致的锁定， 还可以确保事务的完整提交和回滚，对于类似于计费系统或者财务系统等对数据准确性要求比较高的系统，InnoDB是最合适的选择。
  • MyISAM ： 如果应用是以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完整性、并发性要求不是很高，那么选择这个存储引擎是非常合适的。
  • MEMORY：将所有数据保存在RAM中，在需要快速定位记录和其他类似数据环境下，可以提供几块的访问。MEMORY的缺陷就是对表的大小有限制，太大的表无法缓存在内存中，其次是要确保表的数据可以恢复，数据库异常终止后表中的数据是可以恢复的。MEMORY表通常用于更新不太频繁的小表，用以快速得到访问结果。
  • MERGE：用于将一系列等同的MyISAM表以逻辑方式组合在一起，并作为一个对象引用他们。MERGE表的优点在于可以突破对单个MyISAM表的大小限制，并且通过将不同的表分布在多个磁盘上，可以有效的改善MERGE表的访问效率。这对于存储诸如数据仓储等VLDB环境十分合适。、

mysql优化

查看 crud 执行频率

Com_xxx 表示每个 xxx 语句执行的次数，我们通常比较关心的是以下几个统计参数。

参数 含义
Com_select 执行 select 操作的次数，一次查询只累加 1。
Com_insert 执行 INSERT 操作的次数，对于批量插入的 INSERT 操作，只累加一次。
Com_update 执行 UPDATE 操作的次数。
Com_delete 执行 DELETE 操作的次数。
Innodb_rows_read select 查询返回的行数。
Innodb_rows_inserted 执行 INSERT 操作插入的行数。
Innodb_rows_updated 执行 UPDATE 操作更新的行数。
Innodb_rows_deleted 执行 DELETE 操作删除的行数。
Connections 试图连接 MySQL 服务器的次数。
Uptime 服务器工作时间。
Slow_queries 慢查询的次数。

Com_*** : 这些参数对于所有存储引擎的表操作都会进行累计。

Innodb_*** : 这几个参数只是针对InnoDB 存储引擎的，累加的算法也略有不同。

# 查看对数据库的操作（ c r u d ）次数 global:全局信息
# 可以看见 这个数据库 到底已查询为主还是以更新为主
show status like 'Com_______';# 产看 Innodb 的crud 数据
show status like 'Innodb_rows_%';


定位低效率执行SQL

#查看 每一个连接数据库的客户端的操作
show processlist;

  • 慢查询日志 : 通过慢查询日志定位那些执行效率较低的 SQL 语句，用–log-slow-queries[=file_name]选项启动时，mysqld 写一个包含所有执行时间超过 long_query_time 秒的 SQL 语句的日志文件。具体可以查看本书第 26 章中日志管理的相关部分。
  • show processlist : 慢查询日志在查询结束以后才纪录，所以在应用反映执行效率出现问题的时候查询慢查询日志并不能定位问题，可以使用show processlist命令查看当前MySQL在进行的线程，包括线程的状态、是否锁表等，可以实时地查看 SQL 的执行情况，同时对一些锁表操作进行优化。

explain分析执行计划

explain  select * from tb_item where id = 1;
字段 含义
id select查询的序列号，是一组数字，表示的是查询中执行select子句或者是操作表的顺序。
select_type 表示 SELECT 的类型，常见的取值有 SIMPLE（简单表，即不使用表连接或者子查询）、PRIMARY（主查询，即外层的查询）、UNION（UNION 中的第二个或者后面的查询语句）、SUBQUERY（子查询中的第一个 SELECT）等
table 输出结果集的表
type 表示表的连接类型，性能由好到差的连接类型为( system —> const -----> eq_ref ------> ref -------> ref_or_null----> index_merge —> index_subquery -----> range -----> index ------> all )
possible_keys 表示查询时，可能使用的索引
key 表示实际使用的索引
key_len 索引字段的长度
rows 扫描行的数量
extra 执行情况的说明和描述

插入测试数据

用户表 角色表 关系表
CREATE TABLE `t_role` (`id` varchar(32) NOT NULL,`role_name` varchar(255) DEFAULT NULL,`role_code` varchar(255) DEFAULT NULL,`description` varchar(255) DEFAULT NULL,PRIMARY KEY (`id`),UNIQUE KEY `unique_role_name` (`role_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;CREATE TABLE `t_user` (`id` varchar(32) NOT NULL,`username` varchar(45) NOT NULL,`password` varchar(96) NOT NULL,`name` varchar(45) NOT NULL,PRIMARY KEY (`id`),UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;CREATE TABLE `user_role` (`id` int(11) NOT NULL auto_increment ,`user_id` varchar(32) DEFAULT NULL,`role_id` varchar(32) DEFAULT NULL,PRIMARY KEY (`id`),KEY `fk_ur_user_id` (`user_id`),KEY `fk_ur_role_id` (`role_id`),CONSTRAINT `fk_ur_role_id` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,CONSTRAINT `fk_ur_user_id` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;insert into `t_user` (`id`, `username`, `password`, `name`) values('1','super','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe','超级管理员');
insert into `t_user` (`id`, `username`, `password`, `name`) values('2','admin','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe','系统管理员');
insert into `t_user` (`id`, `username`, `password`, `name`) values('3','itcast','$2a$10$8qmaHgUFUAmPR5pOuWhYWOr291WJYjHelUlYn07k5ELF8ZCrW0Cui','test02');
insert into `t_user` (`id`, `username`, `password`, `name`) values('4','stu1','$2a$10$pLtt2KDAFpwTWLjNsmTEi.oU1yOZyIn9XkziK/y/spH5rftCpUMZa','学生1');
insert into `t_user` (`id`, `username`, `password`, `name`) values('5','stu2','$2a$10$nxPKkYSez7uz2YQYUnwhR.z57km3yqKn3Hr/p1FR6ZKgc18u.Tvqm','学生2');
insert into `t_user` (`id`, `username`, `password`, `name`) values('6','t1','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe','老师1');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('5','学生','student','学生');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('7','老师','teacher','老师');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('8','教学管理员','teachmanager','教学管理员');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('9','管理员','admin','管理员');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('10','超级管理员','super','超级管理员');
INSERT INTO user_role(id,user_id,role_id) VALUES(NULL, '1', '5'),(NULL, '1', '7'),(NULL, '2', '8'),(NULL, '3', '9'),(NULL, '4', '8'),(NULL, '5', '10') ;

id ：标记执行顺序

1.执行一条sql ，如果id相同 表示从上到下依次执行

explain select * from t_role r, t_user u, user_role ur where r.id = ur.role_id and u.id = ur.user_id ;


2. id值越大 优先级越高 ， 越先执行！

嵌套查询
EXPLAIN SELECT * FROM t_role WHERE id =(SELECT role_id FROM user_role WHERE user_id =(SELECT id FROM t_user WHERE username = 'stu1'))


3.

子查询和连接查询EXPLAIN SELECT * FROM t_role r ,(SELECT * FROM user_role ur WHERE ur.`user_id` = '2') a
WHERE r.id = a.role_id ;

select_Type

从 子查询 连接查询进行 union 进行考虑
表示 SELECT 的类型，常见的取值，如下表所示：
从上到下 效率越来越低

select_type 含义
SIMPLE 简单的select查询，查询中不包含子查询或者UNION
PRIMARY 查询中若包含任何复杂的子查询，最外层查询标记为该标识
SUBQUERY 在SELECT 或 WHERE 列表中包含了子查询
DERIVED 在FROM 列表中包含的子查询，被标记为 DERIVED（衍生） MYSQL会递归执行这些子查询，把结果放在临时表中
UNION 若第二个SELECT出现在UNION之后，则标记为UNION ； 若UNION包含在FROM子句的子查询中，外层SELECT将被标记为 ： DERIVED
UNION RESULT 从UNION表获取结果的SELECT

PRIMARY 和 SUBQUERY

DERIVED ： 在msql 8.0 被废弃 …

union ：

1,PRIMARY,t_user,,index,,unique_user_username,137,,6,100,Using index
2,UNION,t_user,,ALL,,,,,6,100,
,UNION RESULT,"<union1,2>",,ALL,,,,,,,Using temporary

explain -type

type 显示的是访问类型，是较为重要的一个指标，可取值为：

type 含义
NULL MySQL不访问任何表，索引，直接返回结果
system 表只有一行记录(等于系统表)，这是const类型的特例，一般不会出现
const 表示通过索引一次就找到了，const 用于比较primary key 或者 unique 索引。因为只匹配一行数据，所以很快。如将主键置于where列表中，MySQL 就能将该查询转换为一个常亮。const于将 “主键” 或 “唯一” 索引的所有部分与常量值进行比较
eq_ref 类似ref，区别在于使用的是唯一索引，使用主键的关联查询，关联查询出的记录只有一条。常见于主键或唯一索引扫描
ref 非唯一性索引扫描，返回匹配某个单独值的所有行。本质上也是一种索引访问，返回所有匹配某个单独值的所有行（多个）
range 只检索给定返回的行，使用一个索引来选择行。 where 之后出现 between ， < , > , in 等操作。
index index 与 ALL的区别为 index 类型只是遍历了索引树， 通常比ALL 快， ALL 是遍历数据文件。
all 将遍历全表以找到匹配的行

结果值从最好到最坏以此是：

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

一般来说， 我们需要保证查询至少达到 range 级别， 最好达到ref 。

  • const ： 查询结果只有一条，但是注意 ，， 如果查的是 索引 会走索引

  • eq_ref

    ref：非唯一性索引进行查询

explain 之 key

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

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

key_len : 表示索引中使用的字节数， 该值为索引字段最大可能长度，并非实际使用长度，在不损失精确性的前提下， 长度越短越好 。

explain 之 rows

扫描行的数量，建立了索引就不会整表扫描

explain 之 extra

其他的额外的执行计划信息，在该列展示 。

extra 含义
using filesort 说明mysql会对数据使用一个外部的索引排序，而不是按照表内的索引顺序进行读取， 称为 “文件排序”, 效率低。
using temporary 使用了临时表保存中间结果，MySQL在对查询结果排序时使用临时表。常见于 order by 和 group by； 效率低
using index 表示相应的select操作使用了覆盖索引， 避免访问表的数据行， 效率不错。


根据文件内容进行排序，效率非常低

CREATE UNIQUE INDEX IX_City_CountryId   ON city(city_name);#Extra : Using index （走索引） ，想让排序走索引。只能包含索引这一个字段
explain select  city_name from city order by city_name;#Extra : Using filesort (慢)
explain select  city_name, country_id from city order by city_name;

show profile分析SQL

#通过 have_profiling 参数，能够看到当前MySQL是否支持profile：
show profilesset profiling=1; //开启profiling 开关；select count(*) from country ;select * from city where city_name = '西安市';#查看日志
show profiles;


#查看单条sql 详细记录
show PROFILE for QUERY 9;

TIP ：
executing 状态表示MySQL线程开始访问数据行并把结果返回给客户端，而不仅仅是返回个客户端。由于在Sending data状态下，MySQL线程往往需要做大量的磁盘读取操作，所以经常是整各查询中耗时最长的状态。

索引的使用

环境准备

create table `tb_seller` (    `sellerid` varchar (100),    `name` varchar (100),    `nickname` varchar (50),    `password` varchar (60),    `status` varchar (1),    `address` varchar (100),    `createtime` datetime,    primary key(`sellerid`))engine=innodb default charset=utf8mb4; ​insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('alibaba','阿里巴巴','阿里小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('baidu','百度科技有限公司','百度小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('huawei','华为科技有限公司','华为小店','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('itcast','传智播客教育科技有限公司','传智播客','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('itheima','黑马程序员','黑马程序员','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('luoji','罗技科技有限公司','罗技小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('oppo','OPPO科技有限公司','OPPO官方旗舰店','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('ourpalm','掌趣科技股份有限公司','掌趣小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('qiandu','千度科技','千度小店','e10adc3949ba59abbe56e057f20f883e','2','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('sina','新浪科技有限公司','新浪官方旗舰店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('xiaomi','小米科技','小米官方旗舰店','e10adc3949ba59abbe56e057f20f883e','1','西安市','2088-01-01 12:00:00');insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('yijia','宜家家居','宜家家居旗舰店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');​​
#创建索引
create index idx_seller_name_sta_addr on tb_seller(name,status,address);

1）全职匹配 直接走索引(跟where组装顺序无关，跟查询条件有关 ，是否包含最左列 ，并且不跳列)
就像爬楼梯一样

explain select * from tb_seller where name = '阿里巴巴' and status = 1 and  address = '北京市';

2）最左匹配法则（针对组合索引，某个索引左边的索引一定要在）
创建复合索引

create index idx_name_sta_address on tb_seller(name, status, address);就相当于创建了三个索引 ： namename + statusname + status + address
# 如果表有多列索引，则优化器可以使用索引的任何最左侧前缀来查找行。
# 例如，如果在（col1，col2，col3）上有一个三列索引，则在（col1）、（col1，col2）和（col1，col2，col3）上有索引搜索功能。
explain select password, name, status, address from tb_seller where  address = '西安市';

但是 如果你 查询的字段里面全是索引还是会走索引查询 (sellerid主键索引)


//自定义异常处理
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GgktException extends RuntimeException{private Integer code ;private String msg ;// 执行的方法@ExceptionHandler(GgktException.class)@ResponseBodypublic Result error(ArithmeticException e){e.printStackTrace();return Result.fail(null).message("执行了自定义异常处理");}}

3). 范围查询右边的列，不能使用索引 。

4). 不要在索引列上进行运算操作， 索引将失效。

6). 尽量使用覆盖索引，避免select *
尽量使用覆盖索引（只访问索引的查询（索引列完全包含查询列））

TIP : using index ：使用覆盖索引的时候就会出现using where：在查找使用索引的情况下，需要回表去查询所需的数据using index condition：查找使用了索引，但是需要回表查询数据using index ; using where：查找使用了索引，但是需要的数据都在索引列中能找到，所以不需要回表查询数据

7). 用or分割开的条件， 如果or前的条件中的列有索引，而后面的列中没有索引，那么涉及的索引都不会被用到。

示例，name字段是索引列 ， 而createtime不是索引列，中间是or进行连接是不走索引的 ：

7). 用or分割开的条件， 如果or前的条件中的列有索引，而后面的列中没有索引，那么涉及的索引都不会被用到。

示例，name字段是索引列 ， 而createtime不是索引列，中间是or进行连接是不走索引的 ：

但是不用select * ， 使用 索引列 也可以走索引

9). 如果MySQL评估使用索引比全表更慢，则不使用索引。
10). is NULL ， is NOT NULL 有时走索引，索引失效。
11）in 走索引， not in 索引失效。

12). 单列索引和复合索引。

尽量使用复合索引，而少使用单列索引 。

创建复合索引

create index idx_name_sta_address on tb_seller(name, status, address);就相当于创建了三个索引 ： namename + statusname + status + address

创建单列索引

create index idx_seller_name on tb_seller(name);
create index idx_seller_status on tb_seller(status);
create index idx_seller_address on tb_seller(address);

数据库会选择一个最优的索引（辨识度最高索引）来使用，并不会使用全部索引 。

查看索引使用情况

show status like ‘Handler_read%’;
show global status like ‘Handler_read%’; （全局）

Handler_read_first：索引中第一条被读的次数。如果较高，表示服务器正执行大量全索引扫描（这个值越低越好）。Handler_read_key：如果索引正在工作，这个值代表一个行被索引值读的次数，如果值越低，表示索引得到的性能改善不高，因为索引不经常使用（这个值越高越好）。Handler_read_next ：按照键顺序读下一行的请求数。如果你用范围约束或如果执行索引扫描来查询索引列，该值增加。Handler_read_prev：按照键顺序读前一行的请求数。该读方法主要用于优化ORDER BY ... DESC。Handler_read_rnd ：根据固定位置读一行的请求数。如果你正执行大量查询并需要对结果进行排序该值较高。你可能使用了大量需要MySQL扫描整个表的查询或你的连接没有正确使用键。这个值较高，意味着运行效率低，应该建立索引来补救。Handler_read_rnd_next：在数据文件中读下一行的请求数。如果你正进行大量的表扫描，该值较高。通常说明你的表索引不正确或写入的查询没有利用索引。

sql优化

数据插入

CREATE TABLE `tb_user_1` (`id` int(11) NOT NULL AUTO_INCREMENT,`username` varchar(45) NOT NULL,`password` varchar(96) NOT NULL,`name` varchar(45) NOT NULL,`birthday` datetime DEFAULT NULL,`sex` char(1) DEFAULT NULL,`email` varchar(45) DEFAULT NULL,`phone` varchar(45) DEFAULT NULL,`qq` varchar(32) DEFAULT NULL,`status` varchar(32) NOT NULL COMMENT '用户状态',`create_time` datetime NOT NULL,`update_time` datetime DEFAULT NULL,PRIMARY KEY (`id`),UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;CREATE TABLE `tb_user_2` (`id` int(11) NOT NULL AUTO_INCREMENT,`username` varchar(45) NOT NULL,`password` varchar(96) NOT NULL,`name` varchar(45) NOT NULL,`birthday` datetime DEFAULT NULL,`sex` char(1) DEFAULT NULL,`email` varchar(45) DEFAULT NULL,`phone` varchar(45) DEFAULT NULL,`qq` varchar(32) DEFAULT NULL,`status` varchar(32) NOT NULL COMMENT '用户状态',`create_time` datetime NOT NULL,`update_time` datetime DEFAULT NULL,PRIMARY KEY (`id`),UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;

关闭唯一性校验

再插入数据的时候使用

在导入数据前执行 SET UNIQUE_CHECKS=0，关闭唯一性校验，在导入结束后执行SET UNIQUE_CHECKS=1，恢复唯一性校验，可以提高导入的效率。

手动提交事务

如果应用使用自动提交的方式，建议在导入前执行 SET AUTOCOMMIT=0，关闭自动提交，导入结束后再执行 SET AUTOCOMMIT=1，打开自动提交，也可以提高导入的效率。

优化insert语句

当进行数据的insert操作的时候，可以考虑采用以下几种优化方案。

  • 如果需要同时对一张表插入很多行数据时，应该尽量使用多个值表的insert语句，这种方式将大大的缩减客户端与数据库之间的连接、关闭等消耗。使得效率比分开执行的单个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');
  1. 手动提交事务
start transaction;
insert into tb_test values(1,'Tom');
insert into tb_test values(2,'Cat');
insert into tb_test values(3,'Jerry');
commit;
  1. 有序插入（b+树也是搜索树）
insert into tb_test values(1,'Tom');
insert into tb_test values(2,'Cat');
insert into tb_test values(3,'Jerry');
insert into tb_test values(4,'Tim');
insert into tb_test values(5,'Rose');

优化order by语句

环境

CREATE TABLE `emp` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(100) NOT NULL,`age` int(3) NOT NULL,`salary` int(11) DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4;insert into `emp` (`id`, `name`, `age`, `salary`) values('1','Tom','25','2300');
insert into `emp` (`id`, `name`, `age`, `salary`) values('2','Jerry','30','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('3','Luci','25','2800');
insert into `emp` (`id`, `name`, `age`, `salary`) values('4','Jay','36','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('5','Tom2','21','2200');
insert into `emp` (`id`, `name`, `age`, `salary`) values('6','Jerry2','31','3300');
insert into `emp` (`id`, `name`, `age`, `salary`) values('7','Luci2','26','2700');
insert into `emp` (`id`, `name`, `age`, `salary`) values('8','Jay2','33','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('9','Tom3','23','2400');
insert into `emp` (`id`, `name`, `age`, `salary`) values('10','Jerry3','32','3100');
insert into `emp` (`id`, `name`, `age`, `salary`) values('11','Luci3','26','2900');
insert into `emp` (`id`, `name`, `age`, `salary`) values('12','Jay3','37','4500');create index idx_emp_age_salary on emp(age,salary);

两种排序方式

1). 第一种是通过对返回数据进行排序，也就是通常说的 filesort 排序，所有不是通过索引直接返回排序结果的排序都叫 FileSort 排序。


2).第二种通过有序索引顺序扫描直接返回有序数据，这种情况即为 using index，不需要额外排序，操作效率高
查询字段包是索引


多字段排序



通过创建合适的索引，能够减少 Filesort 的出现，但是在某些情况下，条件限制不能让Filesort消失，那就需要加快 Filesort的排序操作。对于Filesort ， MySQL 有两种排序算法：

1） 两次扫描算法 ：MySQL4.1 之前，使用该方式排序。首先根据条件取出排序字段和行指针信息，然后在排序区 sort buffer 中排序，如果sort buffer不够，则在临时表 temporary table 中存储排序结果。完成排序之后，再根据行指针回表读取记录，该操作可能会导致大量随机I/O操作。
2）一次扫描算法：一次性取出满足条件的所有字段，然后在排序区 sort buffer 中排序后直接输出结果集。排序时内存开销较大，但是排序效率比两次扫描算法要高。

MySQL 通过比较系统变量 max_length_for_sort_data 的大小和Query语句取出的字段总大小， 来判定是否那种排序算法，如果max_length_for_sort_data 更大，那么使用第二种优化之后的算法；否则使用第一种。

可以适当提高 ==sort_buffer_size ==和 ==max_length_for_sort_data ==系统变量，来增大排序区的大小，提高排序的效率。

group by

利用 索引进行分组

嵌套查询优化

子查询可以利用 链表查询优化 ，但在8.0 ，即使优化了 执行效率也是一样的…
例如：


OR 优化

 ## 下面都不会走索引
explain select * from emp where id= 1 or name='Tom';explain select * from emp where id= 1 or salary=2300;explain select * from emp where id= 1 or id=2;

unin 进行优化 走了索引 （相当于拆成了两句）

explain  select * from emp where id= 1 union  select * from emp where id= 2 ;


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

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

UNION 语句的 type 值为 ref，OR 语句的 type 值为 range，可以看到这是一个很明显的差距
UNION 语句的 ref 值为 const，OR 语句的 type 值为 null，const 表示是常量值引用，非常快
这两项的差距就说明了 UNION 要优于 OR 。

优化分页查询

一般分页查询时，通过创建覆盖索引能够比较好地提高性能。一个常见又非常头疼的问题就是 limit 2000000,10 ，此时需要MySQL排序前2000010 记录，仅仅返回2000000 - 2000010 的记录，其他记录丢弃，查询排序的代价非常大 。

优化思路一

在索引上完成排序分页操作，最后根据主键关联回原表查询所需要的其他列内容。就是分两步

优化思路二

该方案适用于主键自增的表，可以把Limit 查询转换成某个位置的查询 。

使用SQL提示

USE INDEX

IGNORE INDEX

explain select * from tb_seller ignore index(idx_seller_name) where name = '小米科技';

FORCE INDEX

为强制MySQL使用一个特定的索引，可在查询中使用 force index 作为hint 。

create index idx_seller_address on tb_seller(address);

应用优化

连接池

1.对于访问数据库来说，建立连接的代价是比较昂贵的，因为我们频繁的创建关闭连接，是比较耗费资源的，我们有必要建立 数据库连接池，以提高访问的性能。

减少对mysql的访问‘

比如 ，需要获取书籍的id 和name字段 ， 则查询如下：

 select id , name from tb_book;

之后，在业务逻辑中有需要获取到书籍状态信息， 则查询如下：

select id , status from tb_book;

这样，就需要向数据库提交两次请求，数据库就要做两次查询操作。其实完全可以用一条SQL语句得到想要的结果。

select id, name , status from tb_book;

增加cache

一些数据存Nosql

负载均衡

使用mysql 复制来读写分离 ，增删改在主节点上，读的压力 在子节点上，一般是 读的操作更多
负载均衡是应用中使用非常普遍的一种优化方法，它的机制就是利用某种均衡算法，将固定的负载量分布到不同的服务器上， 以此来降低单台服务器的负载，达到优化的效果。

采用分布式数据库架构

-分布式数据库架构适合大数据量、负载高的情况，它有良好的拓展性和高可用性。通过在多台服务器之间分布数据，可以实现在多台服务器之间的负载均衡，提高访问效率。

查询缓存

MySQL 8.0将不支持查询缓存，并且鼓励用户升级以使用服务器端查询重写或ProxySQL作为中间人缓存。

  1. 查看当前的MySQL数据库是否支持查询缓存：
SHOW VARIABLES LIKE 'have_query_cache';

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XTZNe7m1-1662167296673)(assets/1555249929012.png)]

  1. 查看当前MySQL是否开启了查询缓存 ：

    SHOW VARIABLES LIKE 'query_cache_type';

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AflNeNTG-1662167296674)(assets/1555250015377.png)]

  2. 查看查询缓存的占用大小 ：

    SHOW VARIABLES LIKE 'query_cache_size';

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bPrafMg6-1662167296675)(assets/1555250142451.png)]

  3. 查看查询缓存的状态变量：

    SHOW STATUS LIKE 'Qcache%';

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xo2OvwlM-1662167296675)(assets/1555250443958.png)]

    各个变量的含义如下：

    参数 含义
    Qcache_free_blocks 查询缓存中的可用内存块数
    Qcache_free_memory 查询缓存的可用内存量
    Qcache_hits 查询缓存命中数
    Qcache_inserts 添加到查询缓存的查询数
    Qcache_lowmen_prunes 由于内存不足而从查询缓存中删除的查询数
    Qcache_not_cached 非缓存查询的数量（由于 query_cache_type 设置而无法缓存或未缓存）
    Qcache_queries_in_cache 查询缓存中注册的查询数
    Qcache_total_blocks 查询缓存中的块总数

查询缓存失效的情况

1） SQL 语句不一致的情况， 要想命中查询缓存，查询的SQL语句必须一致。

SQL1 : select count(*) from tb_item;
SQL2 : Select count(*) from tb_item;

2） 当查询语句中有一些不确定的时，则不会缓存。如 ： now() , current_date() , curdate() , curtime() , rand() , uuid() , user() , database() 。

SQL1 : select * from tb_item where updatetime < now() limit 1;
SQL2 : select user();
SQL3 : select database();

3） 不使用任何表查询语句。

select 'A';

4） 查询 mysql， information_schema或 performance_schema 数据库中的表时，不会走查询缓存。

select * from information_schema.engines;

5） 在存储的函数，触发器或事件的主体内执行的查询。

6） 如果表更改，则使用该表的所有高速缓存查询都将变为无效并从高速缓存中删除。这包括使用MERGE映射到已更改表的表的查询。一个表可以被许多类型的语句，如被改变 INSERT， UPDATE， DELETE， TRUNCATE TABLE， ALTER TABLE， DROP TABLE，或 DROP DATABASE 。

Mysql内存管理及优化

3.1 内存优化原则

1） 将尽量多的内存分配给MySQL做缓存，但要给操作系统和其他程序预留足够内存。

2） MyISAM 存储引擎的数据文件读取依赖于操作系统自身的IO缓存，因此，如果有MyISAM表，就要预留更多的内存给操作系统做IO缓存。

3） 排序区、连接区等缓存是分配给每个数据库会话（session）专用的，其默认值的设置要根据最大连接数合理分配，如果设置太大，不但浪费资源，而且在并发连接较高时会导致物理内存耗尽。

缓存索引

InnoDB 内存优化

innodb用一块内存区做IO缓存池，该缓存池不仅用来缓存innodb的索引块，而且也用来缓存innodb的数据块。

innodb_buffer_pool_size

该变量决定了 innodb 存储引擎表数据和索引数据的最大缓存区大小。在保证操作系统及其他程序有足够内存可用的情况下，innodb_buffer_pool_size 的值越大，缓存命中率越高，访问InnoDB表需要的磁盘I/O 就越少，性能也就越高。

innodb_buffer_pool_size=512M

innodb_log_buffer_size（越大 ，就不需要将日志写入磁盘空间）

决定了innodb重做日志缓存的大小，对于可能产生大量更新记录的大事务，增加innodb_log_buffer_size的大小，可以避免innodb在事务提交前就执行不必要的日志写入磁盘操作。

innodb_log_buffer_size=10M

Mysql并发参数调整

从实现上来说，MySQL Server 是多线程结构，包括后台线程和客户服务线程。多线程可以有效利用服务器资源，提高数据库的并发性能。在Mysql中，控制并发连接和线程的主要参数包括 max_connections、back_log、thread_cache_size、table_open_cahce。

max_connections

采用max_connections 控制允许连接到MySQL数据库的最大数量，默认值是 151。如果状态变量 connection_errors_max_connections 不为零，并且一直增长，则说明不断有连接请求因数据库连接数已达到允许最大值而失败，这是可以考虑增大max_connections 的值。

Mysql 最大可支持的连接数，取决于很多因素，包括给定操作系统平台的线程库的质量、内存大小、每个连接的负荷、CPU的处理速度，期望的响应时间等。在Linux 平台下，性能好的服务器，支持 500-1000 个连接不是难事，需要根据服务器性能进行评估设定。

back_log

back_log 参数控制MySQL监听TCP端口时设置的积压请求栈大小。如果MySql的连接数达到max_connections时，新来的请求将会被存在堆栈中，以等待某一连接释放资源，该堆栈的数量即back_log，如果等待连接的数量超过back_log，将不被授予连接资源，将会报错。5.6.6 版本之前默认值为 50 ， 之后的版本默认为 50 + （max_connections / 5）， 但最大不超过900。
如果需要数据库在较短的时间内处理大量连接请求， 可以考虑适当增大back_log 的值。

table_open_cache

该参数用来控制所有SQL语句执行线程可打开表缓存的数量， 而在执行SQL语句时，每一个SQL执行线程至少要打开 1 个表缓存。该参数的值应该根据设置的最大连接数 max_connections 以及每个连接执行关联查询中涉及的表的最大数量来设定 ：

​ max_connections x N ；

thread_cache_size

相当于mysql的线程池
为了加快连接数据库的速度，MySQL 会缓存一定数量的客户服务线程以备重用，通过参数 thread_cache_size 可控制 MySQL 缓存客户服务线程的数量。

innodb_lock_wait_timeout

行锁等待时间，适合快速反应
该参数是用来设置InnoDB 事务等待行锁的时间，默认值是50ms ， 可以根据需要进行动态设置。对于需要快速反馈的业务系统来说，可以将行锁的等待时间调小，以避免事务长时间挂起； 对于后台运行的批量处理程序来说， 可以将行锁的等待时间调大， 以避免发生大的回滚操作。

mysql锁

锁是计算机协调多个进程或线程并发访问某一资源的机制**（避免争抢）**。
在数据库中，除传统的计算资源（如 CPU、RAM、I/O 等）的争用以外，数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性、有效性是所有数据库必须解决的一个问题，锁冲突也是影响数据库并发访问性能的一个重要因素。从这个角度来说，锁对数据库而言显得尤其重要，也更加复杂。

分类

两个维度来分
从对数据操作的粒度分 ：

1） 表锁：操作时，会锁定整个表。

2） 行锁：操作时，会锁定当前操作行。

从对数据操作的类型分（java redis 都是这分样的 ）：

1） 读锁（共享锁）：针对同一份数据，多个读操作可以同时进行而不会互相影响。

2） 写锁（排它锁）：当前操作没有完成之前，它会阻断其他写锁和读锁。

Mysql 锁

相对其他数据库而言，MySQL的锁机制比较简单，其最显著的特点是不同的存储引擎支持不同的锁机制。下表中罗列出了各存储引擎对锁的支持情况：

存储引擎 表级锁 行级锁 页面锁
MyISAM 支持 不支持 不支持
InnoDB 支持 支持 不支持
MEMORY 支持 不支持 不支持
BDB 支持 不支持 支持
锁类型 特点
表级锁 偏向MyISAM 存储引擎，开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高,并发度最低。
行级锁 偏向InnoDB 存储引擎，开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。
如何加表锁

select 默认 读锁，增删改默认写锁
MyISAM 在执行查询语句（SELECT）前，会自动给涉及的所有表加读锁，在执行更新操作（UPDATE、DELETE、INSERT 等）前，会自动给涉及的表加写锁，这个过程并不需要用户干预，因此，用户一般不需要直接用 LOCK TABLE 命令给 MyISAM 表显式加锁。

显示加表锁语法：

加读锁 ： lock table table_name read;加写锁 ： lock table table_name write；

myisam（表锁） 读写锁演示案例

# 加读锁（相当于无锁）
lock tables tb_book read ;# 读锁其他的线程也可以读表
select * from tb_book ;# 报错Unsafe query: 'Update' statement without 'where' updates all table rows at once
# 读的时候不能写（增删改默认写锁）
update tb_book set name = 'cunk' ;#释放读锁
unlock tables;# 写锁（读写互斥）
lock tables tb_book write ;# （clint1 ，client2）没写的时候不可读
select * from tb_book;# 写操作
insert into tb_book (id ,name) value (70,'aEas');# （客户端2）写完再读，可以读不到数据，被阻塞
# (加锁客户端执行 unlock tables ，客户端2瞬间读到数据)
select * from tb_book;unlock tables ;

查看锁的争用情况
show open tables；

show status like ‘Table_locks%’;

Table_locks_immediate ： 指的是能够立即获得表级锁的次数，每立即获取锁，值加1。Table_locks_waited ： 指的是不能立即获取表级锁而需要等待的次数，每等待一次，该值加1，此值高说明存在着较为严重的表级锁争用情况。

innoDB 行锁

行锁特点 ：偏向InnoDB 存储引擎，开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。

InnoDB 与 MyISAM 的最大不同有两点：一是支持事务；二是 采用了行级锁。

事务及其ACID属性

事务是由一组SQL语句组成的逻辑处理单元。

事务具有以下4个特性，简称为事务ACID属性。

ACID属性 含义
原子性（Atomicity） 事务是一个原子操作单元，其对数据的修改，要么全部成功，要么全部失败。
一致性（Consistent） 在事务开始和完成时，数据都必须保持一致状态。
隔离性（Isolation） 数据库系统提供一定的隔离机制，保证事务在不受外部并发操作影响的 “独立” 环境下运行。
持久性（Durable） 事务完成之后，对于数据的修改是永久的。

为了解决上述提到的事务并发问题，数据库提供一定的事务隔离机制来解决这个问题。数据库的事务隔离越严格，并发副作用越小，但付出的代价也就越大，因为事务隔离实质上就是使用事务在一定程度上“串行化” 进行，这显然与“并发” 是矛盾的。

数据库的隔离级别有4个，由低到高依次为Read uncommitted、Read committed、Repeatable read、Serializable，这四个级别可以逐个解决脏写、脏读、不可重复读、幻读这几类问题。

隔离级别 丢失更新 脏读 不可重复读 幻读
Read uncommitted × √ √ √
Read committed × × √ √
Repeatable read（默认） × × × √
Serializable × × × ×

Mysql 的数据库的默认隔离级别为 Repeatable read ， 查看方式：

show variables like 'tx_isolation';

InnoDB 的行锁模式

  • 共享锁（S）：又称为读锁，简称S锁，共享锁就是多个事务对于同一数据可以共享一把锁，都能访问到数据，但是只能读不能修改。
  • 排他锁（X）：又称为写锁，简称X锁，排他锁就是不能与其他锁并存，如一个事务获取了一个数据行的排他锁，其他事务就不能再获取该行的其他锁，包括共享锁和排他锁，但是获取排他锁的事务是可以对数据就行读取和修改。

对于UPDATE、DELETE和INSERT语句，InnoDB会自动给涉及数据集加排他锁（X)；

对于普通SELECT语句，InnoDB不会加任何锁；

跟…表锁的加锁规则一样…

准备工作

create table test_innodb_lock(id int(11),name varchar(16),sex varchar(1)
)engine = innodb default charset=utf8;insert into test_innodb_lock values(1,'100','1');
insert into test_innodb_lock values(3,'3','1');
insert into test_innodb_lock values(4,'400','0');
insert into test_innodb_lock values(5,'500','1');
insert into test_innodb_lock values(6,'600','0');
insert into test_innodb_lock values(7,'700','0');
insert into test_innodb_lock values(8,'800','1');
insert into test_innodb_lock values(9,'900','1');
insert into test_innodb_lock values(1,'200','0');create index idx_test_innodb_lock_id on test_innodb_lock(id);
create index idx_test_innodb_lock_name on test_innodb_lock(name);

测试

# 关闭自动提交
set autocommit =0 ;#select 不会加锁
select * from tb_book where id = 1;# updatetest_innodb_lock ,会加上排他锁
update test_innodb_lock set name = 'updateName' where id = 3 ;# client2 执行  未提交事务 对数据库进行查询
# res：3,3,1  name字段是 3
select * from test_innodb_lock where id = 3;#提交事务
commit ;# client2 执行  提交事务 对数据库进行查询
#res：3,updateName,1 ，正常数据
select * from test_innodb_lock where id = 3;#可重复读： c1 c2 同时开一个事务，c1提交，但是c2 读取的还只能是c1提交前的数据、

完成后记得打开自动提交
set autocommit =1 ;

无索引行锁升级为表锁

如果不通过索引条件检索数据(索引失效，索引不存在 )，那么InnoDB将对表中的所有记录加锁，实际效果跟表锁一样。

间隙锁的危害

# 间隙锁危害
set autocommit  = 0 ;# id < 4 ： 会对 ’2‘ 进行加锁 即使这条数据不存在
update test_innodb_lock set sex = '0' where id < 4 ;# 查询
select *
from test_innodb_lock ;#此时客户端1 未提交

客户端2试图插入数据，但是由于间隙锁 ，插入失败

set autocommit  = 0 ;insert into test_innodb_lock value(2,'222','1');


优化建议：

  • 尽可能让所有数据检索都能通过索引来完成，避免无索引行锁升级为表锁。
  • 合理设计索引，尽量缩小锁的范围
  • 尽可能减少索引条件，及索引范围，避免间隙锁
  • 尽量控制事务大小，减少锁定资源量和时间长度
  • 尽可使用低级别事务隔离（但是需要业务层面满足需求）

常用SQL技巧

SQL执行顺序

编写顺序

SELECT DISTINCT<select list>
FROM<left_table> <join_type>
JOIN<right_table> ON <join_condition>
WHERE<where_condition>
GROUP BY<group_by_list>
HAVING<having_condition>
ORDER BY<order_by_condition>
LIMIT<limit_params>

执行顺序

FROM <left_table>ON        <join_condition><join_type>     JOIN    <right_table>WHERE        <where_condition>GROUP BY     <group_by_list>HAVING     <having_condition>SELECT DISTINCT     <select list>ORDER BY <order_by_condition>LIMIT     <limit_params>

正则表达式使用

正则表达式（Regular Expression）是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。

符号 含义
^ 在字符串开始处进行匹配
$ 在字符串末尾处进行匹配
. 匹配任意单个字符, 包括换行符
[…] 匹配出括号内的任意字符
[^…] 匹配不出括号内的任意字符
a* 匹配零个或者多个a(包括空串)
a+ 匹配一个或者多个a(不包括空串)
a? 匹配零个或者一个a
a1|a2 匹配a1或a2
a(m) 匹配m个a
a(m,) 至少匹配m个a
a(m,n) 匹配m个a 到 n个a
a(,n) 匹配0到n个a
(…) 将模式元素组成单一元素 
select * from emp where name regexp '^T';select * from emp where name regexp '2$';select * from emp where name regexp '[uvw]';

数字函数

函数名称 作 用
ABS 求绝对值
SQRT 求二次方根
MOD 求余数
CEIL 和 CEILING 两个函数功能相同，都是返回不小于参数的最小整数，即向上取整
FLOOR 向下取整，返回值转化为一个BIGINT
RAND 生成一个0~1之间的随机数，传入整数参数是，用来产生重复序列
ROUND 对所传参数进行四舍五入
SIGN 返回参数的符号
POW 和 POWER 两个函数的功能相同，都是所传参数的次方的结果值
SIN 求正弦值
ASIN 求反正弦值，与函数 SIN 互为反函数
COS 求余弦值
ACOS 求反余弦值，与函数 COS 互为反函数
TAN 求正切值
ATAN 求反正切值，与函数 TAN 互为反函数
COT 求余切值
函数名称 作 用
CURDATE 和 CURRENT_DATE 两个函数作用相同，返回当前系统的日期值
CURTIME 和 CURRENT_TIME 两个函数作用相同，返回当前系统的时间值
NOW 和 SYSDATE 两个函数作用相同，返回当前系统的日期和时间值
MONTH 获取指定日期中的月份
MONTHNAME 获取指定日期中的月份英文名称
DAYNAME 获取指定曰期对应的星期几的英文名称
DAYOFWEEK 获取指定日期对应的一周的索引位置值
WEEK 获取指定日期是一年中的第几周，返回值的范围是否为 0〜52 或 1〜53
DAYOFYEAR 获取指定曰期是一年中的第几天，返回值范围是1~366
DAYOFMONTH 获取指定日期是一个月中是第几天，返回值范围是1~31
YEAR 获取年份，返回值范围是 1970〜2069
TIME_TO_SEC 将时间参数转换为秒数
SEC_TO_TIME 将秒数转换为时间，与TIME_TO_SEC 互为反函数
DATE_ADD 和 ADDDATE 两个函数功能相同，都是向日期添加指定的时间间隔
DATE_SUB 和 SUBDATE 两个函数功能相同，都是向日期减去指定的时间间隔
ADDTIME 时间加法运算，在原始时间上添加指定的时间
SUBTIME 时间减法运算，在原始时间上减去指定的时间
DATEDIFF 获取两个日期之间间隔，返回参数 1 减去参数 2 的值
DATE_FORMAT 格式化指定的日期，根据参数返回指定格式的值
WEEKDAY 获取指定日期在一周内的对应的工作日索引

聚合函数

函数名称 作用
MAX 查询指定列的最大值
MIN 查询指定列的最小值
COUNT 统计查询结果的行数
SUM 求和，返回指定列的总和
AVG 求平均值，返回指定列数据的平均值

还有分区函数…

Mysql高级

1. MySql中常用工具

1.1 mysql

该mysql不是指mysql服务，而是指mysql的客户端工具。

语法 ：

mysql [options] [database]
1.1.1 连接选项
参数 ： -u, --user=name         指定用户名-p, --password[=name] 指定密码-h, --host=name            指定服务器IP或域名-P, --port=#         指定连接端口示例 ：mysql -h 127.0.0.1 -P 3306 -u root -pmysql -h127.0.0.1 -P3306 -uroot -p2143
1.1.2 执行选项
-e, --execute=name      执行SQL语句并退出

此选项可以在Mysql客户端执行SQL语句，而不用连接到MySQL数据库再执行，对于一些批处理脚本，这种方式尤其方便。

示例：mysql -uroot -p2143 db01 -e "select * from tb_book";

mysqladmin

附赠：mysql8安全控制
mysqladmin 是一个执行管理操作的客户端程序。可以用它来检查服务器的配置和当前状态、创建并删除数据库等。

mysqladmin --help  指令查看帮助文档

mysqladmin -uroot -p2143 create 'test01';  mysqladmin -uroot -p2143 drop 'test01';mysqladmin -uroot -p2143 version;

mysqlbinlog

由于服务器生成的二进制日志文件以二进制格式保存，所以如果想要检查这些文本的文本格式，就会使用到mysqlbinlog 日志管理工具。

语法 ：

mysqlbinlog [options]  log-files1 log-files2 ...选项：-d, --database=name : 指定数据库名称，只列出指定的数据库相关操作。-o, --offset=# : 忽略掉日志中的前n行命令。-r,--result-file=name : 将输出的文本格式日志输出到指定文件。-s, --short-form : 显示简单格式， 省略掉一些信息。--start-datatime=date1  --stop-datetime=date2 : 指定日期间隔内的所有日志。--start-position=pos1 --stop-position=pos2 : 指定位置间隔内的所有日志。

mysqldump

mysqldump 客户端工具用来备份数据库或在不同数据库之间进行数据迁移。备份内容包含创建表，及插入表的SQL语句。

语法 ：

mysqldump [options] db_name [tables]mysqldump [options] --database/-B db1 [db2 db3...]mysqldump [options] --all-databases/-A
1.4.1 连接选项
参数 ： -u, --user=name         指定用户名-p, --password[=name] 指定密码-h, --host=name            指定服务器IP或域名-P, --port=#         指定连接端口

mysqlshow

mysqlshow 客户端对象查找工具，用来很快地查找存在哪些数据库、数据库中的表、表中的列或者索引。

语法：

mysqlshow [options] [db_name [table_name [col_name]]]

参数：

--count      显示数据库及表的统计信息（数据库，表 均可以不指定）-i           显示指定数据库或者指定表的状态信息

示例：

#查询每个数据库的表的数量及表中记录的数量
mysqlshow -uroot -p2143 --count#查询test库中每个表中的字段书，及行数
mysqlshow -uroot -p2143 test --count#查询test库中book表的详细情况
mysqlshow -uroot -p2143 test book --count

集成spring优化综合案例

析性能问题

系统中用户访问日志的数据量，随着时间的推移，这张表的数据量会越来越大，因此我们需要根据业务需求，来对日志查询模块的性能进行优化。

1） 分页查询优化

由于在进行日志查询时，是进行分页查询，那也就意味着，在查看时，至少需要查询两次：

A. 查询符合条件的总记录数。–> count 操作

B. 查询符合条件的列表数据。–> 分页查询 limit 操作

通常来说，count() 都需要扫描大量的行（意味着需要访问大量的数据）才能获得精确的结果，因此是很难对该SQL进行优化操作的。如果需要对count进行优化，可以采用另外一种思路，可以增加汇总表，或者redis缓存来专门记录该表对应的记录数，这样的话，就可以很轻松的实现汇总数据的查询，而且效率很高，但是这种统计并不能保证百分之百的准确 。对于数据库的操作，“快速、精确、实现简单”，三者永远只能满足其二，必须舍掉其中一个。

2） 条件查询优化

针对于条件查询,需要对查询条件,及排序字段建立索引。

3） 读写分离

通过主从复制集群，来完成读写分离，使写操作走主节点， 而读操作，走从节点。

4） MySQL服务器优化

5） 应用优化

性能优化 - 分页

4.8.1 优化count

在InnoDB存储引擎中，count(*)函数是先从内存中读取表中的数据到内存缓冲区，然后扫描全表获得行记录数的。

创建一张表用来记录日志表的总数据量：

create table log_counter(logcount bigint not null
)engine = innodb default CHARSET = utf8;

在每次插入数据之后，更新该表 ：

<update id="updateLogCounter" >update log_counter set logcount = logcount + 1
</update>

在进行分页查询时, 获取总记录数，从该表中查询既可。

<select id="countLogFromCounter" resultType="long">select logcount from log_counter limit 1
</select>
优化 limit

例如： limit10000,20的意思扫描满足条件的10020行，扔掉前面的10000行，返回最后的20行，问题就在这里。 ​ LIMIT 2000000, 30 扫描了200万+ 30行，怪不得慢的都堵死了，甚至会导致磁盘io 100%消耗。 ​ 但是: limit 30 这样的语句仅仅扫描30行。

优化手段
干掉或者利用 limit offset,size 中的offset

不是直接使用limit，而是首先获取到offset的id然后直接使用limit size来获取数据
覆盖索引:

就是select 的数据列只用从索引中就能获得，不必读取数据行。mysql 可以利用索引返回select列表中的字段，而不必根据索引再次读取数据文件，换句话说：查询列要被所创建的索引覆盖

因为利用索引查找有优化算法，且数据就在查询索引上面，不用再去找相关的数据地址了，这样节省了很多时间。另外Mysql中也有相关的索引缓存，在并发高的时候利用缓存就效果更好了。在我们的例子中，我们知道id字段是主键，自然就包含了默认的主键索引。

这次我们之间查询最后一页的数据（利用覆盖索引，只包含id列），如下：

#覆盖索引只包含id列 的时间显著优于 select * 不言而喻
select * from order_table where company_id = 1 and mark =0 order by id desc limit 200000 ,20;
select id from order_table where company_id = 1 and mark =0 order by id desc limit 200000 ,20;
那么如果我们也要查询所有列，有两种方法，一种是id>=的形式，另一种就是利用join，看下实际情况：

#两者用的都是一个原理嘛，所以效果也差不多
SELECT * FROM xxx WHERE ID > =(select id from xxx limit 1000000, 1) limit 20;
SELECT * FROM xxx a JOIN (select id from xxx limit 1000000, 20) b ON a.ID = b.id;

在进行分页时，一般通过创建覆盖索引，能够比较好的提高性能。一个非常常见，而又非常头疼的分页场景就是 “limit 1000000,10” ，此时MySQL需要搜索出前1000010 条记录后，仅仅需要返回第 1000001 到 1000010 条记录，前1000000 记录会被抛弃，查询代价非常大。

当点击比较靠后的页码时，就会出现这个问题，查询效率非常慢。

优化SQL：

select * from operation_log limit 3000000 , 10; （这里会默认排序）

将上述SQL优化为 :

select * from operation_log t , (select id from operation_log order by id limit 3000000,10) b where t.id = b.id ;

<select id="selectListByCondition" parameterType="map" resultType="operationLog">selectid ,operate_class as operateClass ,operate_method as operateMethod,return_class as returnClass,operate_user as operateUser,operate_time as operateTime,param_and_value as paramAndValue,cost_time as costTime,return_value as returnValuefrom operation_log t,(select id from operation_log <where><include refid="oplog_where"/></where>order by id limit #{start},#{rows}) b  where t.id = b.id
</select>

性能优化 - 索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y6BKon3O-1662344741475)(assets/1555152703824.png)]

当根据操作人进行查询时， 查询的效率很低，耗时比较长。原因就是因为在创建数据库表结构时，并没有针对于 操作人 字段建立索引。

CREATE INDEX idx_user_method_return_cost ON operation_log(operate_user,operate_method,return_class,cost_time);

同上 ， 为了查询效率高，我们也需要对 操作方法、返回值类型、操作耗时 等字段进行创建索引，以提高查询效率。

CREATE INDEX idx_optlog_method_return_cost ON operation_log(operate_method,return_class,cost_time);CREATE INDEX idx_optlog_return_cost ON operation_log(return_class,cost_time);CREATE INDEX idx_optlog_cost ON operation_log(cost_time);

性能优化 - 排序

在查询数据时，如果业务需求中需要我们对结果内容进行了排序处理 , 这个时候,我们还需要对排序的字段建立适当的索引, 来提高排序的效率 。

读写分离

mysql8 主从集群和读写分离

mysql8 其他更新

1.窗口函数 （具体使用看我 mysql大厂面试题解析）mysql大厂面试题解析

MySQL8高级优化，持续更新......相关推荐

  1. Database之SQLSever：SQLSever数据库管理学习并深入理解SQL命令语句进阶综合篇《初级→中级→高级》(持续更新，建议收藏)

    Database之SQLSever:SQLSever数据库管理学习并深入理解SQL命令语句进阶综合篇<初级→中级→高级>(持续更新,建议收藏) 目录 SQLSever数据库管理学习并深入理 ...

  2. 前端知识点总结——JS高级（持续更新中）

    前端知识点总结--JS高级(持续更新中) 1.字符串 什么是: 连续存储多个字符的字符数组 相同: 1. 下标 2. .length 3. 遍历 4. 选取: slice(starti[, endi] ...

  3. 非线性优化汇总——Matlab优化工具箱（持续更新中）

    非线性优化汇总--Matlab优化工具箱(持续更新中) 室内定位/导航/优化技术探讨:WX: ZB823618313 原创不易,路过的各位大佬请点个赞 目录 非线性优化汇总--Matlab优化工具箱( ...

  4. 「高级java工程师」常见面试题及其答案(持续更新)

    「java工程师」常见面试题及其答案请见: 「java工程师」常见面试题及其答案(持续更新)_好人老李的博客-CSDN博客 目录 java基础 常用的 jvm 调优方法? OOM的常见场景及其原因.解 ...

  5. mysql查询更新优化_mysql查询优化(持续更新中)

    1.索引不会包含有NULL值的列 (1)   应尽量避免在where子句中对字段进行null值判断,否则将导致引擎放弃使用索引而进行全表扫描 (2)   数据库设计时不要让字段的默认值为null,可以 ...

  6. Hexo 博客优化之博客美化系列（持续更新）

    2022-01-25 更新:博客新地址:https://www.itbob.cn/,文章距上次编辑时间较远,部分内容可能已经过时! 本文将讲述一些 Hexo 博客的美化,本文以作者 luuman 的 ...

  7. Hexo 博客优化之实用功能添加系列（持续更新）

    2022-01-25 更新:博客新地址:https://www.itbob.cn/,文章距上次编辑时间较远,部分内容可能已经过时! 本文将讲述一些 Hexo 博客实用功能的添加,本文以作者 luuma ...

  8. Unity优化总结（持续更新）

    工欲善其事,必先利其器.优先利用性能分析工具快速找出性能瓶颈,从瓶颈入手分析性能问题产生原因,可以事半功倍. 尽量减少占用的内存(资源体积)和CPU(计算量),首先着重减少总量才能更好的进行后续细节的 ...

  9. 爱下载分享seo必经之路之搜索引擎优化算法持续更新

    你务必掌握一些比较敏感行业! 搜索引擎优化算法持续更新,考核评价系统软件逐步完善.很多优化方式都会持续降低他们的占比,并且已经开发的评定系统软件.比如,在extrampking时期,评分也在降低,但这 ...

最新文章

  1. 才一年，智能车就不再是新势力专利！
  2. oracle安装过程掉电,oracle数据库掉电恢复
  3. [leetcode]1007. 行相等的最少多米诺旋转
  4. 高德地图怎么搜索marker_2018-07-06 高德地图搜索定位，滑动地图显示周边信息，根据地址搜经...
  5. ImportError: cannot import name '_ellipsoid'
  6. （笔试题）和一半的组合数
  7. git无法上传大文件
  8. delphi开发回忆录——面向对象的基础，继承
  9. JAVA中方法和变量在继承中的覆盖和隐藏
  10. Java 加密、解密PDF文档
  11. Revit二次开发 —— 点到面的投影
  12. matlab线性规划的最优化,【OR】Matlab求解最优化问题(1) 线性规划
  13. 透明网桥的自学习算法
  14. Android 标题下划线 选中效果
  15. 彻底关闭windows defender，Antimalware Service Executable
  16. 为什么要高内聚低耦合？
  17. Linux粘滞位简析
  18. 2.15 双创园区：武汉东湖高新区
  19. Android开机阶段log分析
  20. 用jquery制作凡客诚品帮助中心页面

热门文章

  1. 基于javaweb的宠物商城系统(java+jsp+javascript+servlet+mysql)
  2. Java mail使用QQ邮箱发送邮件配置方案
  3. 关于图文识别功能相关技术的大致实现
  4. python解除windows锁屏_用python获取win10锁屏图片
  5. 谷歌“隐私沙盒”引争议，广告业务与用户隐私难平衡？
  6. 深切悼念JAVA培训界第一人张孝祥老师意外辞世
  7. OpenSIPS实战（八）：修改sip消息-使用lumps system
  8. 邮件发送失败服务器繁忙,★邮件发送失败的原因和解决方法
  9. 二级建造师继续教育留念
  10. 【Blender小技巧】点对齐