Mysql进阶--开发

存储引擎

MySQL体系结构

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

存储引擎介绍

• 介绍：

  存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式 。存储引擎是基于表的，而不是基于库的，所以存储引擎也可被称为表类型。我们可以在创建表的时候，来指定选择的存储引擎，如果没有指定将自动选择默认的存储引擎。

  • 建表时指定存储引擎：

  CREATE TABLE 表名(
  	字段1 字段1类型 [ COMMENT 字段1注释 ] ,
  	......
  	字段n 字段n类型 [COMMENT 字段n注释 ]
  ) ENGINE = INNODB [ COMMENT 表注释 ] ;
  
  #例：
  create table my_myisam(
  	id int,
  	name varchar(10)
  ) engine = MyISAM ;
  
  create table my_memory(
  	id int,
  	name varchar(10)
  ) engine = Memory ;
  

  • 查询当前数据库支持的存储引擎：

    show engines;
    

  创建表时，即使我们没有指定存储引擎，数据库也会自动选择默认的存储引擎。

存储引擎特点

InnoDB

• 介绍：

  InnoDB是一种兼顾高可靠性和高性能的通用存储引擎，在 MySQL 5.5 之后，InnoDB是默认的
  MySQL 存储引擎。

• 特点：

  1. DML操作遵循ACID模型，支持事务；
  2. 行级锁，提高并发访问性能；
  3. 支持外键FOREIGN KEY约束，保证数据的完整性和正确性；

• 文件：

  xxx.ibd：xxx代表的是表名，innoDB引擎的每张表都会对应这样一个表空间文件，存储该表的表结
  构（frm-早期的 、sdi-新版的）、数据和索引。

  参数：innodb_file_per_table

  show variables like 'innodb_1 file_per_table';
  

  如果该参数开启，代表对于InnoDB引擎的表，每一张表都对应一个ibd文件。

MyISAM

• 介绍：

  MyISAM是MySQL早期的默认存储引擎。

• 特点：

  1. 不支持事务，不支持外键
  2. 支持表锁，不支持行锁
  3. 访问速度快

• 文件：

  xxx.sdi：存储表结构信息
  xxx.MYD: 存储数据
  xxx.MYI: 存储索引

Memory

• 介绍：

  Memory引擎的表数据时存储在内存中的，由于受到硬件问题、或断电问题的影响，只能将这些表作为
  临时表或缓存使用。

• 特点：

  1. 内存存放
  2. hash索引（默认）

• 文件：

  xxx.sdi：存储表结构信息

• 面试题：

  InnoDB引擎与MyISAM引擎的区别 ?

  1. InnoDB引擎, 支持事务, 而MyISAM不支持。
  2. InnoDB引擎, 支持行锁和表锁, 而MyISAM仅支持表锁, 不支持行锁。
  3. InnoDB引擎, 支持外键, 而MyISAM是不支持的。

  主要是上述三点区别，当然也可以从索引结构、存储限制等方面，更加深入的回答，具体参
  考如下官方文档：
  https://dev.mysql.com/doc/refman/8.0/en/innodb-introduction.html
  https://dev.mysql.com/doc/refman/8.0/en/myisam-storage-engine.html

存储引擎选择

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

• InnoDB: 是Mysql的默认存储引擎，支持事务、外键。如果应用对事务的完整性有比较高的要
  求，在并发条件下要求数据的一致性，数据操作除了插入和查询之外，还包含很多的更新、删除操
  作，那么InnoDB存储引擎是比较合适的选择。
• MyISAM ： 如果应用是以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完
  整性、并发性要求不是很高，那么选择这个存储引擎是非常合适的。
• **MEMORY：**将所有数据保存在内存中，访问速度快，通常用于临时表及缓存。MEMORY的缺陷就是
  对表的大小有限制，太大的表无法缓存在内存中，而且无法保障数据的安全性。

索引

索引概述

• 介绍：

  索引（index）是帮助MySQL高效获取数据的数据结构(有序)。在数据之外，数据库系统还维护着满足
  特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据， 这样就可以在这些数据结构
  上实现高级查找算法，这种数据结构就是索引。

• 特点：

  

索引结构

概述

MySQL的索引是在存储引擎层实现的，不同的存储引擎有不同的索引结构，主要包含以下几种：

• 不同的存储引擎对于索引结构的支持

  • 注意： 我们平常所说的索引，如果没有特别指明，都是指B+树结构组织的索引。

  

B - Tree

• B-Tree：

  B树是一种多叉路衡查找树，相对于二叉树，B树每个节点可以有多个分支，即多叉。
  以一颗最大度数（max-degree）为5(5阶)的b-tree为例，那这个B树每个节点最多存储4个key，5
  个指针：(树的度数指的是一个节点的子节点个数。)

  

  B+Tree

  • B+Tree:

    是B-Tree的变种，我们以一颗最大度数（max-degree）为4（4阶）的b+tree为例，来看一
    下其结构示意图：

    

    • 我们可以看到，两部分：
      绿色框框起来的部分，是索引部分，仅仅起到索引数据的作用，不存储数据。
      红色框框起来的部分，是数据存储部分，在其叶子节点中要存储具体的数据。

  • 比较：

    B+Tree 与 B-Tree相比，主要有以下三点区别：

    1. 所有的数据都会出现在叶子节点。
    2. 叶子节点形成一个单向链表。
    3. 非叶子节点仅仅起到索引数据作用，具体的数据都是在叶子节点存放的。

  • MySQL优化B+Tree

    上述是标准的B+Tree的数据结构

    MySQL索引数据结构对经典的B+Tree进行了优化。在原B+Tree的基础上，增加一个指向相邻叶子节点
    的链表指针，就形成了带有顺序指针的B+Tree，提高区间访问的性能，利于排序。

    

    Hash

    • 结构：

      哈希索引就是采用一定的hash算法，将键值换算成新的hash值，映射到对应的槽位上，然后存储在
      hash表中。

      如果两个(或多个)键值，映射到一个相同的槽位上，他们就产生了hash冲突（也称为hash碰撞），可
      以通过链表来解决。

      

    • 特点：

      1. Hash索引只能用于对等比较(=，in)，不支持范围查询（between，>，< ，…）
      2. 无法利用索引完成排序操作
      3. 查询效率高，通常(不存在hash冲突的情况)只需要一次检索就可以了，效率通常要高于B+tree索引

    • 存储引擎支持：

      在MySQL中，支持hash索引的是Memory存储引擎。 而InnoDB中具有自适应hash功能，hash索引是
      InnoDB存储引擎根据B+Tree索引在指定条件下自动构建的。

    • 为什么InnoDB存储引擎选择使用B+tree索引结构?

      1. 相对于二叉树，层级更少，搜索效率高；
      2. 对于B-tree，无论是叶子节点还是非叶子节点，都会保存数据，这样导致一页中存储的键值减少，指针跟着减少，要同样保存大量数据，只能增加树的高度，导致性能降低；
      3. 相对Hash索引，B+tree支持范围匹配及排序操作；

索引分类

• 索引分类：

在MySQL数据库，将索引的具体类型主要分为以下几类：主键索引、唯一索引、常规索引、全文索引。

• 聚集索引&二级索引：

  而在在InnoDB存储引擎中，根据索引的存储形式，又可以分为以下两种：

  

  • 聚集索引选取规则:
    1. 如果存在主键，主键索引就是聚集索引。
    2. 如果不存在主键，将使用第一个唯一（UNIQUE）索引作为聚集索引。
    3. 如果表没有主键，或没有合适的唯一索引，则InnoDB会自动生成一个rowid作为隐藏的聚集索引。

• 聚集索引和二级索引的具体结构如下：

  1. 聚集索引的叶子节点下挂的是这一行的数据 。
  2. 二级索引的叶子节点下挂的是该字段值对应的主键值。

  

  如果执行这条SQL语句：

  select * from tb_user where name = 'Arm';
  

  具体过程如下：

  1. 由于是根据name字段进行查询，所以先根据name='Arm’到name字段的二级索引中进行匹配查找。但是在二级索引中只能查找到 Arm 对应的主键值 10。
  2. 由于查询返回的数据是*，所以此时，还需要根据主键值10，到聚集索引中查找10对应的记录，最终找到10对应的行row。
  3. 最终拿到这一行的数据，直接返回即可。

• **回表查询：**这种先到二级索引中查找数据，找到主键值，然后再到聚集索引中根据主键值，获取
  数据的方式，就称之为回表查询。

• InnoDB主键索引的B+Tree的高度：

  一行数据大小为1k，一页中可以存储16行这样的数据。InnoDB的指针占用6个字节的空
  间，主键即使为bigint，占用字节数为8。
  高度为2：
  n * 8 + (n + 1) * 6 = 161024 , 算出n约为 1170
  1171 16 = 18736
  也就是说，如果树的高度为2，则可以存储 18000 多条记录。
  高度为3：
  1171 * 1171 * 16 = 21939856
  也就是说，如果树的高度为3，则可以存储 2200w 左右的记录。

索引语法

• 创建索引：

  CREATE [ UNIQUE | FULLTEXT ] INDEX index_name ON table_name (index_col_name,... ) ;
  

• 查看索引：

  SHOW INDEX 1 FROM table_name ;
  

• 删除索引：

  DROP INDEX index_name ON table_name ;
  

SQL性能分析

SQL执行频率

MySQL 客户端连接成功后，通过 show [session|global] status 命令可以提供服务器状态信息。通过如下指令，可以查看当前数据库的INSERT、UPDATE、DELETE、SELECT的访问频次：

-- session 是查看当前会话 ;
-- global 是查询全局数据 ;
SHOW GLOBAL STATUS LIKE 'Com_______';

Com_delete: 删除次数
Com_insert: 插入次数
Com_select: 查询次数
Com_update: 更新次数

慢查询日志

慢查询日志记录了所有执行时间超过指定参数（long_query_time，单位：秒，默认10秒）的所有SQL语句的日志。

MySQL的慢查询日志默认没有开启，如果要开启慢查询日志，需要在MySQL的配置文件（/etc/my.cnf）中配置如下信息：

# 开启MySQL慢日志查询开关
slow_query_log=1
# 设置慢日志的时间为2秒，SQL语句执行时间超过2秒，就会视为慢查询，记录慢查询日志
long_query_time=2

profile详情

通过set语句在session/global级别开启profiling：

SET profiling = 1;

执行一系列的业务SQL的操作，然后通过如下指令查看指令的执行耗时：

-- 查看每一条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 条件 ;

Explain 执行计划中各个字段的含义:

索引使用

最左前缀法则

​ 如果索引了多列（联合索引），要遵守最左前缀法则。最左前缀法则指的是查询从索引的最左列开始，
并且不跳过索引中的列。如果跳跃某一列，索引将会部分失效(后面的字段索引失效)。

​ 对于最左前缀法则指的是，查询时，最左变的列，也就是profession必须存在，否则索引全部失效。
而且中间不能跳过某一列，否则该列后面的字段索引将失效。

索引最左前缀法则，联合索引的查询条件要按照顺序，第一个要是开头的那个索引，中间不能跳过，那样才能发挥出索引的功能
explain select * from tb_user where profession='软件工程' and age =31 and status='0';
explain select * from tb_user where age=31 and status='0';
explain select * from tb_user where profession='软件工程' and age=31;
explain select * from tb_user where profession='软件工程' and status='0';

当这三个是联合索引的时候，虽然没有按照顺序，但是优化器会帮助我们优化成联合索引的顺序，也就是会执行三条索引
explain select * from tb_user where age=31 and status='0' and profession='软件工程';

范围查询

联合索引中，出现范围查询(>,<)，范围查询右侧的列索引失效。

联合索引按照顺序来，如果使用 > 号的话，> 右边的索引会失效，使用 >= 则不会
explain select * from tb_user where profession='软件工程' and age>=30 and status='0';

所以，在业务允许的情况下，尽可能的使用类似于 >= 或 <= 这类的范围查询，而避免使用 > 或 < 。

索引失效情况

索引列运算

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

explain select * from tb_user where substring(phone,10,2) = '15';
#phone上的索引会失效

字符串不加引号

字符串类型字段使用时，不加引号，索引将失效。

模糊查询

如果仅仅是尾部模糊匹配，索引不会失效。如果是头部模糊匹配，索引失效。在like模糊查询中，在关键字后面加%，索引可以生效。而如果在关键字前面加了%，索引将会失效。、

or连接条件

用or分割开的条件， 如果or前的条件中的列有索引，而后面的列中没有索引，那么涉及的索引都不会
被用到。当or连接的条件，左右两侧字段都有索引时，索引才会生效。

数据分布影响

如果MySQL评估使用索引比全表更慢，则不使用索引。

MySQL在查询时，会评估使用索引的效率与走全表扫描的效率，如果走全表扫描更快，则放弃索引，走全表扫描。 因为索引是用来索引少量数据的，如果通过索引查询返回大批量的数据，则还不如走全表扫描来的快，此时索引就会失效。

SQL提示

• SQL提示：

  是优化数据库的一个重要手段，简单来说，就是在SQL语句中加入一些人为的提示来达到优
  化操作的目的。可以通过explain来查看这条语句使用的是哪个索引。

  • **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 = '软件工
    程';
    

覆盖索引

尽量使用覆盖索引，减少select *。覆盖索引是指 查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到 。

比如说 select id,age,name from tb_user where age=31; 假如说这条sql语句id是主键，则他是聚集索引，age创建了一个二级索引，叶子节点保存的是id，这时候查询就会走回表查询name，效率就会降低。解决办法是给age和name创建一个联合索引，这是age和name这个联合索引中叶子节点保存的是id，不会回表查询。

• extra含义：

  

前缀索引

当字段类型为字符串（varchar，text，longtext等）时，有时候需要索引很长的字符串，这会让索引变得很大，查询时，浪费大量的磁盘IO， 影响查询效率。此时可以只将字符串的一部分前缀，建立索引，这样可以大大节约索引空间，从而提高索引效率。

• 语法：

  create index idx_xxxx on table_1 name(column(n)) ;
  

• 前缀长度：

  可以根据索引的选择性来决定，而选择性是指不重复的索引值（基数）和数据表的记录总数的比值，索引选择性越高则查询效率越高， 唯一索引的选择性是1，这是最好的索引选择性，性能也是最好的。

  select count(distinct email) / count(*) from tb_user ;
  select count(distinct substring(email,1,5)) / count(*) from tb_user ;
  

• 前缀索引的查询流程：

  

  单列索引与联合索引

  • **单列索引：**即一个索引只包含单个列。

  • **联合索引：**即一个索引包含了多个列。

    在业务场景中，如果存在多个查询条件，考虑针对于查询字段建立索引时，建议建立联合索引，而非单列索引。

索引设计原则

1. 针对于数据量较大，且查询比较频繁的表建立索引。
2. 针对于常作为查询条件（where）、排序（order by）、分组（group by）操作的字段建立索引。
3. 尽量选择区分度高的列作为索引，尽量建立唯一索引，区分度越高，使用索引的效率越高。
4. 如果是字符串类型的字段，字段的长度较长，可以针对于字段的特点，建立前缀索引。
5. 尽量使用联合索引，减少单列索引，查询时，联合索引很多时候可以覆盖索引，节省存储空间，避免回表，提高查询效率。
6. 要控制索引的数量，索引并不是多多益善，索引越多，维护索引结构的代价也就越大，会影响增删改的效率。
7. 如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时，它可以更好地确定哪个索引最有效地用于查询。

SQL优化

插入数据

• insert优化：批量插入、手动提交事务（start transaction…commit）、主键顺序插入

• 大批量插入数据：如果一次性需要插入大量数据，使用insert语句插入性能较低，此时可以使用MySQL数据库提供的load指令进行插入。操作如下：

#客户端连接服务端时，加上参数 --local-infile
mysql --local-infile -uroot -p

#设置全局参数local_infile为1,开启从本地加载文件导入数据的开关
set global local_infile = 1;

#执行load指令将准备好的数据，加载到表结构中
load data local infile '/root/sql1.sql' into 'tb_user' fields terminated by ',' lines terminated by '\n';

主键优化

• 数据组织方式：在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，这种存储方式的表成为索引组织表

• 页分裂：页可以为空，也可以填充一半，也可以填充100%。每个页包含了2-N行数据（如果一行数据过大，会行溢出），根据主键排列。主键乱序插入会导致页分裂，导致性能降低

  

  

• 页合并：当删除一行记录时，实际上记录并没有被物理删除，只是记录被标记（flaged）为删除并且它的空间变得允许被其他记录声明使用。

  当页中删除的记录达到MERFE_THRESHOLD（默认为页的50%），InnoDB会开始寻找最靠近的页（前或后）看看是否可以将两个页合并以优化空间的使用

  

• 主键设计原则：

  1. 满足业务需求的情况下，尽量降低主键的长度。
  2. 插入数据时，尽量选择顺序插入，选择使用AUTO_INCREMENT自增主键。
  3. 尽量不要使用UUID做主键或者是其他自然主键，如身份证号。
  4. 业务操作时，避免对主键的修改。

order by 优化

1. Using filesort：通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区sort buffer中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫FileSort排序。

2. Using index：通过有序索引顺序扫描直接返回有序数据，这种情况即为using index ，不需要额外排序，操作效率高。

   #根据age，phone进行降序，一个升序，一个降序
   explain select id,age,phone from tb_user order by age asc,phone desc;
   
   #这时可以这样创建索引
   create index idx_user_age_phone_ad on tb_user(age asc,phone desc);
   #默认是asc，升序
   

order by总结：

1. 根据排序字段建立合适的索引，多字段排序时，页遵循最左前缀法则。

2. 尽量使用覆盖索引。

3. 多字段排序，一个升序一个降序，此时需要主要联合索引在创建时的规则（ASC/DESC）。

4. 如果不可避免的出现filesort，大数据量排序时，可以适当增大排序缓冲区大小sort_buffer_size（默认256k）。

group by 优化

#创建索引
create index idx_pro_age_sta on tb_user(profession,age,status);

1. 在分组操作时，可以通过索引来提高效率。
2. 分组操作时，索引的使用也是满足最左前缀法则的。

limit 优化

一个常见又非常头疼的问题就是 limit 2000000，10 ，此时需要MySQL排序前2000010记录，仅仅返回2000000-2000010的记录，其他记录丢弃，排序查询的代价非常大。

优化思路：一般分页查询时，通过创建覆盖索引能够比较好的提高性能，可以通过覆盖索引加子查询形式进行优化。

explain select t.* from tb_sku t, (select id from tb_sku order by id limit 2000000,10) a where t.id = a.id;

count 优化

explain select count(*) from table

• MyISAM 引擎把一个表的总行数存在了磁盘上，因此执行count(*)的时候会直接返回个数，效率很高；
• InnoDB殷勤就麻烦了，它执行count(*)的时候，需要把数据一行一行的从引擎里面读出来，然后累计计数。

**优化思路：**自己计数，使用其他key-value形式计数

• count的几种用法

  1. count(主键)：

     InnoDB引擎会遍历整张表，把每一行的主键id值都取出来，返回给服务层。服务层拿到主键后，直接按行进行累加（主键不可能为null）。

  2. count(字段)：

     没有not null 约束：InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，服务层判断是否为null，不为null，计数累加。

     有not null约束：取值，返回给服务层，直接累加

  3. count(1)：

     InnoDB会遍历整张表，但不取值。服务层对于返回的每一行，放一个数字“1”进去，直接按行进行累加。

  4. count(*):

     InnoDB引擎并不会把字段取出来，而是专门做了优化，不取值，服务层直接按行进行累加。

按照效率排序的话：count(字段) < count(主键id) < count(1) ≈ count(*)，所以尽量使用count(*)。

update 优化

​ 需要注意的是，InnoDB的行锁是针对索引加的锁，不是针对记录加的锁。所以在执行 update 语句时，要根据索引去进行更新，而且索引不能失效，这样才是行锁，否则就是表锁，会锁住整张表，从而降低并发性能。

视图/存储过程/触发器

视图

• 介绍：

  视图(View)是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且时在使用视图时动态生成的。

  通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以我们在创建视图的时候，主要的工作就落在创建这条SQL查询语句上。

• 创建：

  create [or replace] view 视图名称[(列名列表)] as select语句 [with[cascaed | local] check option]
  or replace可以省略，如果是替换一个视图的时候要加上
  
  #创建视图
  create or replace view stu_v_1 as select id, name from tb_stu where id <= 10;
  

• 查询：

  #查看创建视图语句
  show create view 视图名称;
  
  #查看视图数据
  select * from 视图名称......;
  

• 修改：

  #方式一 此处就是替换视图 必须加 or replace
  create [or replace] view 视图名称[(列名列表)] as select语句 [with[cascaed | local] check option]
  
  #方式二
  alter view 视图名称[(列名列表)] as select语句 [with[cascaed | local] check option]
  

• 删除：

  #if exists 可选项，如果存在则删除
  drop view [if exists] 视图名称[,视图名称] ...
  

• 视图的检查选项：

  当使用 with check option 子句创建视图时，MySQL会通过视图检查正在更改的每个行，例如 插入、更新、删除，以使其符合视图的定义。MySQL允许基于另一个视图创建视图，它还会检查依赖视图中的规则以保持一致性。为了确定检查的范围，MySQL提供了两个选项：

  CASCADED 和 LOCAL ，默认值是 CASCADED。

  • ​ CASCADED：

    #更改数据时，会检查更改的数据是否符合 where 后面的条件，符合则进行更改，否则报错
    create view v1 as select id, name from tb_stu where id <= 20 with cascaded check option;
    											|
                                                |
    create view v2 as select id, name from v1 where id >= 20 with cascaded check option;
    											|
                                                |
    create view v3 as select id, name from v2 where id <= 15;
    
    #CASCADED 翻译过来为级联，一旦我们在某一个视图创建的时候，加了 with cascaded option ,那么此时，我们在操作这个视图的时候，他会去检查当前视图，还会去检查当前视图所依赖的所有视图的条件是否满足，即使所依赖的视图没有检查选项，也依然会判断是否满足条件。
    

  • LOCAL：

    local 检查当前视图时，也会递归去检查当前视图所依赖的所有视图的条件是否满足，如果所依赖的视图有检查选项，则判断是否满足。若没有检查选项，则不检查。

• 视图的更新：

  要使视图可更新，视图中的行与基础表中的行之间必须存在一对一的关系。如果视图包含一下任何一项，则该视图不可更新：

  1. 聚合函数或窗口函数（sum( ), min( ), max( ), count( ) 等）
  2. distinct
  3. group by
  4. having
  5. union 或者 union all

• 视图的作用：

  • 简单：视图不仅可以简化用户对数据的理解，也可以简化他们的操作。那些被经常使用的查询可以被定义为视图，从而使得用户不必为以后的操作每次指定全部的条件。
  • **安全：**数据库可以授权，但是不能授权到数据库特定行和特定和列上。通过视图用户智能查询和修改他们所能见到的数据。
  • **数据独立：**视图可以帮助用户屏蔽真实表结构变化带来的影响。比如真实表中字段名发生了变化，我们只需要在视图中为该字段起别名，就可以避免因为表结构变化而带来的大量的业务代码的变化。

存储过程

存储过程

• 介绍：

  存储过程是实现经过编译并存储在数据库中的一段SQL语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是由好处的。

  存储过程思想上很简单，就是数据库SQL语言层面的代码封装与重用。

• 特点：

  1. 封装，复用
  2. 可以接收参数，也可以返回数据
  3. 减少网络交互，效率提升

• 存储过程的基本语法：

  1. 创建

     create procedure 存储过程名称([参数列表])
     begin
     	--SQL语句;
     end;
     
     #例：
     create procedure p1()
     begin
     	select count(*) from tb_user;
     end;
     
     call p1();
     
     #注意：在命令行中，执行创建存储过程的SQL时，需要通过关键字delimiter指定SQL语句的结束符
     

  2. 调用

     call 名称([参数]);
     

  3. 查看

     #查询指定数据库的存储过程及状态信息
     select * from information_schema.routines where routine_schema='数据库名称';
     
     #查询某个存储过程的定义
     show create procedure 存储过程名称;
     

  4. 删除

     drop procedure [if exists] 存储过程名称;
     

  变量

  • 变量

    系统变量是MySQL服务器提供，不是用户定义的，属于服务器层面。分为全局变量(global)、会话变量(session)

    1. 查看系统变量

       #可以指定session或者是global，如果不指定，默认是session
       #查看所有系统变量
       show [session | global] variables;
       #可以通过like模糊匹配方式查找变量
       show [session | global] variables like '...'
       #查看指定变量的值
       select @@[session | global].系统变量名;
       

    2. 设置系统变量

       #注意：如果没有指定session/global，默认是session，会话变量。
       #MySQL服务器重新启动之后，所设置的全局参数会失效，变成默认值，如果不想失效，需要在/etc/my.cnf中配置
       set [session | global] 系统变量名 = 值;
       set @@[session | global]系统变量名 = 值;
       

    用户自定义变量是用户根据需要自己定义的变量，用户变量不用提前声明，在用的时候直接用"@变量名使用就可以"。其作用域为当前连接。

    1. 赋值

       #用户自定义的变量是不需要声明的，只不过获取到的值为NULL
       set @var_name = expr [,@var_name = expr]...;
       set @var_name := expr [,@var_name := expr]...;
       
       select @var_name := expr [,@var_name := expr]...;
       select 字段名 into @var_name from 表名;
       

    2. 使用

       select @var_name;
       

  • 局部变量是根据需要定义的在局部生效的变量，访问之前，需要 declare 声明。可用作存储过程内的局部变量和输入参数，局部变量的范围是在其内声明的 begin…end 块。

    1. 声明

       declare 变量名 变量类型[default...];
       #变量类型就是数据库字段类型：int, bigint, char, varvhar, date, time 等。内容可以设置default
       

    2. 赋值

       set 变量名 = 值;
       set 变量名 := 值;
       select 字段名 into 变量名 from 表名...;
       

       #例：
       create procedure p2()
       begin
       	declare stu_count int default 0;
       	#或者直接赋值  set stu_count = 10;
       	select count(*) into stu_count from tb_user;
       	select stu_count;
       end;
       
       call p2();
       

if语句

if 条件1 then
	...               #可选
elseif 条件2 then
	...
else 
	...               #可选
end if;

#例：
create procedure p3()
begin
	declare score int default 0;
	declare result varchar(10);
	
	if score >= 85 then
		set result := '优秀';
	elseif score >= 60 then
		set result := '及格'
	else
		set result := '不及格'
	end if;
	select result;
end;
#调用
call p3();

参数

类型	含义	备注
in	该类参数作为输入，也就是需要调用时传入值	默认
out	该类参数作为输出，也就是该参数可以作为返回值
inout	既可以作为输入参数，也可以作为输出参数

• 用法

  create procedure 存储过程名称([in/out/inout 参数名 参数类型])
  begin
  	--SQL语句
  end;
  
  #例1，根据传入(in)参数score，判定当前分数对应的分数顶级，并返回(out)
  create procedure p4(in score int, out result varchar)
  begin
  	if score >= 85 then
  		set result := '优秀';
  	elseif score >= 60 then
  		set result := '及格'
  	else
  		set result := '不及格'
  	end if;
  end;
  call p4(85, @result);
  select @result;
  
  #例2，将传入的200分制的分数，进行换算，换算成百分制，然后返回
  create procedure p5(inout score double)
  begin
  	set score := score * 0.5;
  end;
  set @score = 78;
  call p5(@score);
  select @score;
  

case

#例：根据传入的月份，判定月份所属季节（case结构实现）
create procedure p6(in month int)
begin
	declare result varchar(10);
	case 
		when month >= 1 and month <= 3 then
			set result := "第一季度";
		when month >= 4 and month <= 6 then
			set result := "第二季度";
		when month >= 7 and month <= 9 then
			set result := "第三季度";
		when month >= 10 and month <= 12 then
			set result := "第四季度";
		else 
			set result := "非法参数"
	end case;
	select concat('您输入的月份为：',month,',所属的季度为：',result);
end;
call p6(4);

while循环

#满足则循环，不满足则退出
#例：计算从1累加到n的值，n为传入的参数值
create procedure p7(in n int)
begin
	declare total int default 0;
	while n>0 do
		set total := total + n;
		set n := n - 1;
	end while;
	select total;
end;
call p7(5);

repeat循环

#满足条件退出循环，不满足则循环
#例：计算从1累加到n的值，n为传入的参数值
create procedure p8(in n int)
begin
	declare total int default 0;
	repeat
		set total := total + n;
		set n := n - 1;
	until n<=0;
	end repeat;
	select total;
end;
call p8(5);

loop循环

#不加循环条件则是死循环，可以配合以下两个语句使用
#leave：配合循环使用，退出循环
#iterate：必须用在循环中，作用是跳过当前循环剩下的语句，直接进入下一次循环

#例1：计算从1累加到n的值，n为传入的参数值
create procedure p9(in n int)
begin
	declare total int default 0;
	sum:loop
		if n <= 0 then
			leave sum;
		end if;
		
		set total := total + n;
		set n := n - 1;
     end loop sum;
       
     select total; 
end;
call p9(8);

#例2：计算从1到n偶数累加的值，n为传入的参数值
create procedure p10(in n int)
begin
	declare total int default 0;
	sum:loop
		if n <= 0 then
			leave sum;
		end if;
		
		if n%2 == 1 then
			set n := n - 1;
			iterate sum;
		end if;
		
		set total := total + n;
		set n := n - 1;
     end loop sum;
       
     select total; 
end;
call p10(8);

游标

游标（cursor）是用来存储查询结果集的数据类型，在存储过程和函数中可以使用游标对结果集进行循环的处理。游标的使用包括游标的声明、open、fetch和close，其语法如下

#声明游标
declare 游标名称 cursor for 查询语句;

#打开游标
open 游标名称;

#获取游标记录
fetch 游标名称 into 变量[,变量];

#关闭游标
close 游标名称;

#例：根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名name和专业profession，并将用户的姓名和专业插入到所创建的一张新表（id,name,prodession）中。
#逻辑：
#A.声明游标，存储查询结果集
#B.准备，创建表结构
#C.开启游标
#D.获取游标中的记录
#E.插入数据到新表中
#F.关闭游标

create procedure p11(in uage int)
begin
	#需要先声明普通变量，再声明游标变量
	declare uname varchar(100);
	declare upro varchar(100);
	
	declare u_cursor cursor for select name, profsssion from tb_user where age <= uage;
	declare exit handler for SQLSTATE '02000' close u_cursor;
	
	drop table if exists tb_user_pro;
	create table if not exists tb_user_pro(
    	id int primary key auto_increment,
        name varchar(100),
        profession varchar(100)
    );
    
    open u_cursor;
    
    #条件处理程序（Handler）可以用来定义再流程控制结构执行过程中遇到问题时相应的处理步骤。
    while true do
    	fetch u_cursor into uname, upro;
    	insert into tb_user_pro values(null, uname, upro); 
    end while;
    close u_cursor;
    
end;

• 条件处理程序（Handler）

存储函数

• 存储函数是有返回值的存储过程，存储函数的参数只能是IN类型的。具体语法如下：

  

#例：计算累加和
create function fun1(n int)   #参数默认就是in
returns int deterministic
begin
	declare total int default 0;
	
	while n > 0 do
		set total := total + n;
		set n := n - 1;
	end while;
	
	return total;
end;
select fun1(100);

触发器

• 介绍：

  触发器是与表有关的数据库对象，指载insert/update/delete之前或之后，触发并执行触发器中定义的SQL语句集合。触发器的这种特性可以协助应用载数据库端确保数据的完整性，日志记录，数据校验等操作。

  使用别名OLD和NEW来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。现在触发器还只支持行级触发，不支持语句级触发。

• 语法：

  

#例：通过触发器记录tb_user表中的数据变更日志，将变更日志插入到日志表user_log中，包含增加，修改，删除；
#插入数据触发器
create trigger tb_user_insert_trigger
	after insert on tb_user for each row
begin
	insert into user_logs(id, operation, operate_time, operate_id, operate_params) values
	(null, 'insert', new.id, concat('id=',new.id ........))
end;

#查看
show triggers;

#删除
drop trigger tb_user_insert_trigger;

#更新数据触发器
create trigger tb_user_insert_trigger
	after update on tb_user for each row
begin
	insert into user_logs(id, operation, operate_time, operate_id, operate_params) values
	(null, 'update', old.id, concat('更新之前的数据，id=',old.id ........),
    (null, 'update', new.id, concat('更新之后的数据，id=',new.id ........));
end;
     
#删除数据触发器
create trigger tb_user_insert_trigger
	after delete on tb_user for each row
begin
	insert into user_logs(id, operation, operate_time, operate_id, operate_params) values
	(null, 'delete', old.id, concat('更新之前的数据，id=',old.id ........));
end;

锁

概述

• 介绍：

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

• 分类：

  MySQL中的锁，按照锁的粒度分，分为以下三类

  1. 全局锁:锁定数据库中的所有表。
  2. 表级锁:每次操作锁住整张表
  3. 行级锁:每次操作锁住对应的行数据。

全局锁

• 介绍：

  ​ 全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的RML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。
  ​ 其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性。

  • 不加全局锁，导致数据不一致

  

  • 加全局锁

• 操作：

  #加锁
  flush tables with read lock;  #此时更新，删除，插入操作都会被阻塞，只能执行查询语句
  
  #一致性数据备份
  mysqldump -hip地址 -u用户名 -p密码 数据库名 > D:/db.sql  #mysqldump是一个工具，不是sql语法，所以不能在mysql中执行，需要在命令行中执行。
  
  #解锁
  unlock tables;
  

• 特点：

  数据库中加全局锁，是一个比较重的操作，存在以下问题:

1. 如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆

2. 如果在从库上备份，那么在备份期间从库不能执行主库同步过来的二进制日志 (binlog)，会导致主从延迟

   在InnoDB引擎中，我们可以在备份时加上参数 --single-transaction 参数来完成不加锁的一致性数据备份

#使用 --single-transaction 完成一致性数据备份
mysqldump --single-transaction -hip地址 -u用户名 -p密码 数据库名 > D:/db.sql

表级锁

• 介绍：

  ​ 表级锁，每次操作锁住整张表。锁定粒度大，发生锁冲突的概率最高，并发度最低。应用在MyISAM、InnoDB、BDB等存储引擎中。

• 分类：

  1. 表锁
  2. 元数据锁(meta data lock，MDL)
  3. 意向锁

• 表锁：

  ​ 对于表锁，分为两类:

  1. 表共享读锁 (read lock) ，自己可以读不能写，别的客户端也一样

     

  2. 表独占写锁 (write lock)，自己可以读也可以写，别的客户端什么都不能干

     

     • 语法：

       #1.加锁：lock tables 表名... read/write
       #2.释放锁：unlock tables / 客户端断开连接
       

• 元数据锁(meta data lock，MDL)：

  ​ MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。为了避免DML与DDL冲突，保证读写的正确性.

  ​ 在MVSOL5.5中引入了MDL，当对一张表进行增删改查的时候，加MDL读锁(共享)，当对表结构进行变更操作的时候，加MDL写锁(排他)。

  

• 意向锁：

  1. 意向共享锁（IS）：由语句 select … lock in share mode 添加。与表锁共享锁（read）兼容，与表锁排他锁（write）互斥。
  2. 意向排他锁（IX）：由 insert，update，delete，select … for update 添加。与表锁共享锁（read）及排他锁（write）都互斥。意向锁之间不会互斥。

  ​ DML语句在执行的时候，会给该行的数据加上行锁，此时如果另外一个线程过来想给这个表加表锁的话，它就要去检查，看这个表中有没有加行锁，会一行一行的检查，会影响效率。

  ​ 所以、为了避免DML语句在执行时，加的行锁与表锁的冲突，在InnoDB中引入了意向锁，使得表锁不用检查每行的数据是否加锁，使用意向锁来减少表锁的检查。加表锁时会判断当前要加的表锁与行锁是否是兼容的，是就可以加表锁，不是兼容的就会处于阻塞状态。

行级锁

• 介绍：

  行级锁，每次操作锁住对应的行数据。锁定粒度最小，发生锁冲突的概率最低，并发度最高。应用在InnoDB存储引擎中。

  lnnoDB的数据是基于索引组织的，行锁是通过对索引上的索引项加锁来实现的，而不是对记录加的锁。对于行级锁，主要分为以下三类:

  1. 行锁(Record Lock): 锁定单个行记录的锁，防止其他事务对此行进行update和delete。在RC、RR隔离级别下都支持。
  2. 间隙锁(Gap Lock):锁定索引记录间隙(不含该记录)，确保索引记录间院不变，防止其他事务在这个间隙进行inse，产生幻读。在RR隔离级别下都支持。
  3. 临键锁(Next-Key Lock): 行锁和间隙锁组合，同时锁住数据，并锁住数据前面的间隙Gap。在RR隔离级别下支持。

• 行锁：

  InnoDB实现了以下两种类型的行锁：

  1. 共享锁(S):允许一个事务去读一行，阻止其他事务获得相同数据集的排它锁
  2. 排他锁(X):允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁

  共享锁与共享锁之间是兼容的，与排他锁之间互斥。排他锁与共享锁和排他锁都互斥。

  

  默认情况下，lnnoDB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读.

  1. 针对唯一索引进行检索时，对已存在的记录进行等值匹配时，将会自动优化为行锁。
  2. InnoDB的行锁是针对于索引加的锁，不通过索引条件检索数据，那么lnnDB将对表中的所有记录加锁，此时 就会升级为表锁。

• 间隙锁 / 临键锁：

  默认情况下，lnnoDB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读.

  1. 索引上的等值查询(唯一索引)，给不存在的记录加锁时,优化为间隙锁。
  2. 索引上的等值查询(普通索引)，向右遍历时最后一个值不满足查询需求时，next-keylock 退化为间隙锁。
  3. 索引上的范围查询(唯一索引)–会访问到不满足条件的第一个值为止。
     • **注意：**间隙锁唯一目的是防止其它事务插入间隙。间隙锁可以共存，一个事务采用的间隙锁不会阻止另一个事务在同一个间隙上采用间隙锁。

总结

1. 概述：
   • 在并发访问时，解决数据访问的一致性、有效性问题
   • 全局锁、表级锁、行级锁
2. 全局锁：
   • 对整个数据库实例加锁，加锁后整个实力就处于只读状态
   • 性能较差，数据逻辑备份时使用
3. 表级锁：
   • 操作锁住整张表，锁定粒度大，发生锁冲突的概率高
   • 表锁、元数据锁、意向锁
4. 行级锁：
   • 操作锁住对应的行数据，锁定粒度最小，发生锁冲突的概率最低
   • 行锁、间隙锁、临键锁

InnoDB引擎

逻辑存储结构

• 逻辑存储结构：

  

  • 表空间：（idb文件），一个MySQL实例可以对应多个表空间，用于存储记录、索引等数据。
  • 段：分为数据段（Leaf node segment）、索引段（None-leaf node segment）、回滚段（Rollback segment），InnoDB是索引组织表，数据段就是B+树的叶子节点，索引段即为B+树的非叶子节点。段用来管理多个Extent（区）。
  • **区：**表空间的单元结构，每个区的大小为1M。默认情况下，InnoDB存储引擎页大小为16K，即一个区中一共有64个连续的页。
  • **页：**是InnoDB存储引擎磁盘管理的最小单元，每个页的大小默认为16KB。为了保证页的连续性，InnoDB存储引擎每次从磁盘申请4-5个区。
  • **行：**InnoDB存储引擎是按行进行存放的
    • **Trx_id:**每次对某条数据记录进行改动时，都会把对应的事务id赋值给trx_id隐藏列。
    • **Roll_pointer:**每次对某条引记录进行改动时，都会把旧的版本写入到undo日志中，然后这个隐藏列就相当于一个指针，可以通过它来找到该记录修改前的信息。

架构

MySQL5.5 版本开始，默认使用InnoDB存储引擎，它擅长事务处理，具有崩溃恢复特性，在日常开发中使用非常广泛。下面是lnnoDB架构图，左侧为内存结构，右侧为磁盘结构

• 内存结构：

  • 缓冲池：

    Buffer Pool: 缓冲池是主内存中的一个区域，里面可以缓存磁盘经常操作的真实数据，在执行增删改查操作时，先操作缓冲池中的数据(若缓冲池没有数据，则从磁盘加载并缓存)，然后再以一定频率刷新到磁盘，从而减少磁盘IO，加快处理速度。

    缓冲池以Page页为单位，底层采用链表数据结构管理Page。根据状态，将Page分为三种类型

    1. free page:空闲page，未被使用。
    2. clean page:被使用page，数据没有被修改过。
    3. dirty page: 脏页，被使用page，数据被修改过，页中数据与磁盘的数据产生了不一致。

  • 更改缓冲区：

    Change Buffer: 更改缓冲区(针对于非唯一二级索引页)，在执行DML语句时，如果这些数据Page没有在Buffer Pool中，不会直接操作磁盘，而会将数据变更存在更改缓冲区 Change Buffer 中，在未来数据被读取时，再将数据合并恢复到Buffer Pool中，再将合并后的数据刷新到磁盘中。

    • **意义：**与聚集索引不同，二级索引通常是非唯一的，并且以相对随机的顺序插入二级索引。同样，删除和更新可能会影响索引树中不相邻的二级索引页，如果每一次都操作磁盘，会造成大量的磁盘IO。有了ChangeBuffer之后，我们可以在缓冲池中进行合并处理，减少磁盘IO。

  • 自适应hash：

    Adaptive Hashindex: 自适应hash索引，用于优化对Buffer Pool数据的查询。InnoDB存储引擎会监控对表上各索引页的查询，如果观察到hash索引可以提升速度，则建立hash索引，称之为自适应hash索引。

    自适应哈希索引，无需人工干预，是系统根据情况自动完成。参数:adaptive hash index。

  • 日志缓冲区：

    Log Buffer: 日志缓冲区，用来保存要写入到磁盘中的log日志数据 (redo log、undo log)，默认大小为

    16MB，日志缓冲区的日志会定期刷新到磁盘中。如果需要更新、插入或删除许多行的事务，增加日志

    缓冲区的大小可以节省磁盘IO。

    参数:
    innodb_log_buffer_size: 缓冲区大小

    innodb_flush_log_at_trx_commit: 日志刷新到磁盘时机

    ​ **1:**日志在每次事务提交时写入并刷新到磁盘

    ​ **0:**每秒将日志写入并刷新到磁盘一次。

    ​ **2:**日志在每次事务提交后写入，并每秒刷新到磁盘一次。

• 磁盘结构：

  

  • System Tablespace: 系统表空间是更改缓冲区的存储区域。如果表是在系统表空间而不是每个表文件或通用表空间中创建的，它也可能包含表和索引数据。(在MvSOL5x版本中还包含InnoDB数据字典、undolog等)
    参数:innodb_data_file_path
  • **File-Per-Table Tablespaces:**每个表的文件表空间包含单个InnoDB表的数据和索引，并存储在文件系统上的单个数据文件中
    参数:innodb_file_per_table
  • General Tablespaces: 通用表空间，需要通过CREATE TABLESPACE 语法创建通用表空间，在创建表时，可以指定该表空间。
  • Undo Tablespaces: 撤销表空间，MySQL实例在初始化时会自动创建两个默认的undo表空间(初始大小16M)，用于存储undo log日志。
  • Temporary Tablespaces: InnoDB 使用会话临时表空间和全局临时表空间。存储用户创建的临时表等数据。
  • Double write Buffer Files: 双写缓冲区，InnoDB引警将数据页从Buffer Pool刷新到磁盘前，先将数据页写入双写缓冲区文件中，便于系统异常时恢复数据。
  • Redo Log: 重做日志，是用来实现事务的持久性。该日志文件由两部分组成:重做日志缓冲(redo log buffer)以及重做日志文件(redo log)，前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都会存到该日志中，用于在刷新脏页到磁盘时，发生错误时,进行数据恢复使用。

• 后台线程：

  

  • **Master Thread：**核心后台线程，负责调度其他线程，还负责将缓冲池中的数据异步刷新到磁盘中,保持数据的一致性还包括脏页的刷新、合并插入缓存、undo页的回收。

  • **IO Thread：**在InnoDB存储引擎中大量使用了AIO来处理IO请求,这样可以极大地提高数据库的性能，而IOThread主要负责这些IO请求的回调。

    

  • **Purge Thread：**主要用于回收事务已经提交了的undo log，在事务提交之后，undo log可能不用了，就用它来回收。

  • **Page Cleaner Thread：**协助Master Thread 刷新脏页到磁盘的线程，它可以减轻Master Thread 的工作压力，减少阻塞。

事务原理

• 概述：

  事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

• 特性：

  原子性 (Atomicity): 事务是不可分割的最小操作单元，要么全部成功，要么全部失败。

  一致性(Consistency):事务完成时，必须使所有的数据都保持一致状态。

  隔离性(Isolation): 数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。

  持久性 (Durabilitv): 事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

• 原理：

  

  • redo log（保证持久性）：重做日志，记录的是事务提交时数据页的物理修改，是用来实现事务的持久性。该日志文件由两部分组成:重做日志缓冲(redo log bulfer)以及重做日志文件(redo log fle),前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都存到该日志文件中，用于在刷新脏页到磁盘，发生错误时，进行数据恢复使用。

    

• **undo log（保证原子性）：**回滚日志，用于记录数据被修改前的信息，作用包含两个:提供回滚和 MVCC(多版本并发控制)。

  undolog和redolog记录物理日志不一样，它是逻辑日志。可以认为当delete一条记录时，undo og中会记录一条对应的inset记录，反亦然，当update一条记录时，它记录一条对应相反的update记录。当执行rollback时，就可以从undo log中的逻辑记录读取到相应的内容并进行回滚。
  Undo log销毁: undo log在事务执行时产生，事务提交时，并不会立即删除undo og，因为这些日志可能

  还用于MVCC。

  Undo log存储: undo og采用段的方式进行管理和记录，存放在前面介绍的 rollback segment 回滚段中，内

  部包含1024个undo logsegment.

MVCC

• 基本概念：

  • 当前读：

    读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。对于我们日常的操作，如:
    select …lockin share mode(共享锁)，select … for update、update、insert、delete(排他锁)都是一种当前读。

  • 快照读：

    简单的select(不加锁)就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。
    Read Committed:每次select，都生成一个快照读
    Repeatable Read:开启事务后第一个select语句才是快照读的地方
    Serializable:快照读会退化为当前读。

  • MVCC：

    全称 Multi-Version Concurrency ontrol，多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突，快照读为MySQL实现MVCC提供了一个非阻塞读功能。MVCC的具体实现，还需要依赖于数据库记录中的三个隐式字段、undo log日志、readview。

• MVCC实现原理：

  • 记录中的隐藏字段：

    

  • undo log：

    回滚日志，在insert、update、delete的时候产生的便于数据回滚的日志

    当insert的时候，产生的undo log日志只在回滚时需要，在事务提交后，可被立即删除。

    而update、delete的时候，产生的undo log日志不仅在回滚时需要，在快照读时也需要，不会立即被删除。

  • undo log版本链：

    不同事务或相同事务对同一条记录进行修改，会导致该记录的undolog生成一条记录版本链表，链表的头部是最新的旧记录，链表尾部是最早的旧记录。

    

  • readview(读视图)：

    ReadView(读视图)是 快照读 SOL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务(未提交的)id。
    ReadView中包含了四个核心字段:

    

    • 版本链数据访问规则：

      

• 不同的隔离级别，生成ReadView的时机不同
  READ COMMITTED : 在事务中每一次执行快照读时生成ReadView。

• REPEATABLE READ: 仅在事务中第一次执行快照读时生成ReadView，后续复用该ReadView。

  

• 总结：

  

  1. 逻辑存储结构：
     • 表空间、段、区、页、行
  2. 架构：
     • 内存结构
     • 磁盘结构
  3. 事务原理：
     • 原子性 — undo log
     • 持久性 — redo log
     • 一致性 — undo log + redo log
     • 隔离性 — 锁 + MVCC
  4. MVCC：
     • 记录隐藏字段、undo log版本链、readView

MySQL管理

系统数据库

MySQL安装完成后，自带了以下四个数据库，具体作用如下：

常用工具

• **mysql：**该mysql不是指mysql服务，而是指mysql客户端工具

  

• mysqladmin：

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

  通过帮助文档查看选项：mysqladmin --help

  语法:
  	mysqladmin [options] command ...
  	
  选项:
  	-u, --user=name #指定用户名
  	-p, --password[=name] #指定密码
  	-h, --host=name #指定服务器IP或域名
  	-P, --port=port #指定连接端口
  	
  例：
  	mysqladmin -uroot –p1234 drop 'test01';
  	mysqladmin -uroot –p1234 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 指定位置间隔内的所有日志。
  

• mysqlshow：

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

  语法 ：
  	mysqlshow [options] [db_name [table_name [col_name]]]
  	
  选项 ：
  	--count 显示数据库及表的统计信息（数据库，表 均可以不指定）
  	-i 显示指定数据库或者指定表的状态信息
  	
  示例：
  #查询test库中每个表中的字段书，及行数
  mysqlshow -uroot -p2143 test --count
  #查询test库中book表的详细情况
  mysqlshow -uroot -p2143 test book --count
  

• mysqldump：

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

  语法 ：
  	mysqldump [options] db_name [tables]
  	mysqldump [options] --database/-B db1 [db2 db3...]
  	mysqldump [options] --all-databases/-A
  	
  连接选项 ：
  	-u, --user=name 指定用户名
  	-p, --password[=name] 指定密码
  	-h, --host=name 指定服务器ip或域名
  	-P, --port=# 指定连接端口
  	
  输出选项：
  	--add-drop-database 在每个数据库创建语句前加上 drop database 语句
  	--add-drop-table 在每个表创建语句前加上 drop table 语句 , 默认开启 ; 不开启 (--skip-add-drop-table)
  	-n, --no-create-db 不包含数据库的创建语句
  	-t, --no-create-info 不包含数据表的创建语句
  	-d --no-data 不包含数据
  	-T, --tab=name 自动生成两个文件：一个.sql文件，创建表结构的语句；一个.txt文件，数据文件
  

• mysqlimport/source：

  mysqlimport 是客户端数据导入工具，用来导入mysqldump 加 -T 参数后导出的文本文件。

  语法 ：
  	mysqlimport [options] db_name textfile1 [textfile2...]
  	
  示例 ：
  	mysqlimport -uroot -p2143 test /tmp/city.txt
  

  如果需要导入sql文件,可以使用mysql中的source 指令 :

  语法 ：
  	source /root/xxxxx.sql
  

  语法 ：
  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 指定位置间隔内的所有日志。

• mysqlshow：

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

  语法 ：
  	mysqlshow [options] [db_name [table_name [col_name]]]
  	
  选项 ：
  	--count 显示数据库及表的统计信息（数据库，表 均可以不指定）
  	-i 显示指定数据库或者指定表的状态信息
  	
  示例：
  #查询test库中每个表中的字段书，及行数
  mysqlshow -uroot -p2143 test --count
  #查询test库中book表的详细情况
  mysqlshow -uroot -p2143 test book --count
  

• mysqldump：

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

  语法 ：
  	mysqldump [options] db_name [tables]
  	mysqldump [options] --database/-B db1 [db2 db3...]
  	mysqldump [options] --all-databases/-A
  	
  连接选项 ：
  	-u, --user=name 指定用户名
  	-p, --password[=name] 指定密码
  	-h, --host=name 指定服务器ip或域名
  	-P, --port=# 指定连接端口
  	
  输出选项：
  	--add-drop-database 在每个数据库创建语句前加上 drop database 语句
  	--add-drop-table 在每个表创建语句前加上 drop table 语句 , 默认开启 ; 不开启 (--skip-add-drop-table)
  	-n, --no-create-db 不包含数据库的创建语句
  	-t, --no-create-info 不包含数据表的创建语句
  	-d --no-data 不包含数据
  	-T, --tab=name 自动生成两个文件：一个.sql文件，创建表结构的语句；一个.txt文件，数据文件
  

• mysqlimport/source：

  mysqlimport 是客户端数据导入工具，用来导入mysqldump 加 -T 参数后导出的文本文件。

  语法 ：
  	mysqlimport [options] db_name textfile1 [textfile2...]
  	
  示例 ：
  	mysqlimport -uroot -p2143 test /tmp/city.txt
  

  如果需要导入sql文件,可以使用mysql中的source 指令 :

  语法 ：
  	source /root/xxxxx.sql