深入解析InnoDB索引结构，向MySQL调优持续进军
0、导读
InnoDB表的索引有哪些特性，以及索引组织结构是怎样的
1、InnoDB聚集索引特点
我们知道，InnoDB引擎的聚集索引组织表，必然会有一个聚集索引。
行数据（row data）存储在聚集索引的叶子节点（除了发生overflow的列，参见 ，后面简称 “前置文”），并且其存储的相对顺序取决于聚集索引的顺序。这里说相对顺序而不是物理顺序，是因为叶子节点数据页中，行数据的物理顺序和相对顺序可能并不是一致的，放在后面会讲。
InnoDB聚集索引的选择先后顺序是这样的：
-
如果有显式定义的主键（PRIMARY KEY），则会选择该主键作为聚集索引
-
否则，选择第一个所有列都不允许为NULL的唯一索引
-
若前两者都没有，则InnoDB会选择内置的DB_ROW_ID作为聚集索引，命名为GEN_CLUST_INDEX
特别提醒： DB_ROW_ID占用6个字节，每次自增，且是整个实例内全局分配。也就是说，当前实例如果有多个表都采用了内置的DB_ROW_ID作为聚集索引，则在这些表插入新数据时，他们的内置DB_ROW_ID值并不是连续的，而是跳跃的。像下面这样：
2、InnoDB索引结构
InnoDB默认的索引数据结构采用B+树（空间索引采用R树），索引数据存储在叶子节点。
InnoDB的基本I/O存储单位是数据页(page)，一个page默认是16KB。我们在 前置文 说过，每个page默认会预留1/16空闲空间用于后续数据“变长”更新所需，因此在最理想的顺序插入状态下，其产生的碎片也最少，这时候差不多能填满15/16的page空间。如果是随机写入的话，则page空间利用率大概是1/2 ~ 15/16。
当 row_format = DYNAMIC|COMPRESSED 时，索引最多长度为 3072字节，当 row_format = REDUNDANT|COMPACT 时，索引最大长度为 767字节。当page size不是默认的16KB时，最大索引长度限制也会跟着发生变化。
我们接下来分别验证关于InnoDB索引的基本结构特点。
首先创建如下测试表：
1 [root@yejr.me] [innodb]> CREATE TABLE `t1` ( 2 `id` int(10) unsigned NOT NULL AUTO_INCREMENT, 3 `c1` int(10) unsigned NOT NULL DEFAULT '0', 4 `c2` varchar(100) NOT NULL, 5 `c3` varchar(100) NOT NULL, 6 PRIMARY KEY (`id`), 7 KEY `c1` (`c1`) 8 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
用下面的方法写入10条测试数据：
1 set @uuid1=uuid(); set @uuid2=uuid(); 2 insert into t1 select 0, round(rand()*1024), 3 @uuid1, concat(@uuid1, @uuid2);
看下 t1 表的整体结构：
1 # 用innodb_ruby工具查看 2 [root@yejr.me]# innodb_space -s ibdata1 -T innodb/t1 space-indexes 3 id name root fseg fseg_id used allocated fill_factor 4 238 PRIMARY 3 internal 1 1 1 100.00% 5 238 PRIMARY 3 leaf 2 0 0 0.00% 6 239 c1 4 internal 3 1 1 100.00% 7 239 c1 4 leaf 4 0 0 0.0 8 9 # 用innblock工具查看 10 [root@yejr.me]# innblock innodb/t1.ibd scan 16 11 ... 12 ===INDEX_ID:238 13 level0 total block is (1) 14 block_no: 3,level: 0|*| 15 ===INDEX_ID:239 16 level0 total block is (1) 17 block_no: 4,level: 0|*|
可以看到
| 索引ID | 索引类型 | 根节点page no | 索引层高 |
|---|---|---|---|
| 238 | 主键索引(聚集索引) | 3 | 1 |
| 239 | 辅助索引 | 4 | 1 |
3、InnoDB索引特点验证
3.1 特点1：聚集索引叶子节点存储整行数据
先扫描第3个page，截取其中第一条物理记录的内容：
1 [root@yejr.me]# innodb_space -s ibdata1 -T innodb/t1 -p 3 page-dump 2 ... 3 records: 4 {:format=>:compact, 5 :offset=>127, 6 :header=> 7 {:next=>263, 8 :type=>:conventional, 9 :heap_number=>2, 10 :n_owned=>0, 11 :min_rec=>false, 12 :deleted=>false, 13 :nulls=>[], 14 :lengths=>{"c2"=>36, "c3"=>72}, 15 :externs=>[], 16 :length=>7}, 17 :next=>263, 18 :type=>:clustered, 19 #第一条物理记录，id=1 20 :key=>[{:name=>"id", :type=>"INT UNSIGNED", :value=>1}], 21 :row=> 22 [{:name=>"c1", :type=>"INT UNSIGNED", :value=>777}, 23 {:name=>"c2", 24 :type=>"VARCHAR(400)", 25 :value=>"a1c1a7c7-bda5-11e9-8476-0050568bba82"}, 26 {:name=>"c3", 27 :type=>"VARCHAR(400)", 28 :value=> 29 "a1c1a7c7-bda5-11e9-8476-0050568bba82a1c1aec5-bda5-11e9-8476-0050568bba82"}], 30 :sys=> 31 [{:name=>"DB_TRX_ID", :type=>"TRX_ID", :value=>10950}, 32 {:name=>"DB_ROLL_PTR", 33 :type=>"ROLL_PTR", 34 :value=> 35 {:is_insert=>true, 36 :rseg_id=>119, 37 :undo_log=>{:page=>469, :offset=>272}}}], 38 :length=>129, 39 :transaction_id=>10950, 40 :roll_pointer=> 41 {:is_insert=>true, :rseg_id=>119, :undo_log=>{:page=>469, :offset=>272}}}
很明显，的确是存储了整条数据的内容。
聚集索引树的键值(key)是主键索引值(i=10)，聚集索引节点值(value)是其他非聚集索引列(c1,c2,c3)以及隐含列(DB_TRX_ID、DB_ROLL_PTR)。
优化建议1：尽量不要存储大对象数据，使得每个叶子节点都能存储更多数据，降低碎片率，提高buffer pool利用率。此外也能尽量避免发生overflow。
3.2 特点2：聚集索引非叶子节点存储指向子节点的指针
对上面的测试表继续写入新数据，直到聚集索引树从一层分裂成两层。
我们根据旧文 InnoDB表聚集索引层高什么时候发生变化 里的计算方式，推算出来预计一个叶子节点最多可存储111条记录，因此在插入第112条记录时，就会从一层高度分裂成两层高度。经过实测，也的确是如此。
1 [root@yejr.me] [innodb]>select count(*) from t1; 2 +----------+ 3 | count(*) | 4 +----------+ 5 | 112 | 6 +----------+ 7 8 [root@yejr.me]# innblock innodb/t1.ibd scan 16 9 ... 10 ===INDEX_ID:238 11 level1 total block is (1) 12 block_no: 3,level: 1|*| 13 level0 total block is (2) 14 block_no: 5,level: 0|*|block_no: 6,level: 0|*| 15 ...
此时可以看到根节点依旧是pageno=3，而叶子节点变成了[5, 6]两个page。由此可知，根节点上应该只有两条物理记录，存储着分别指向pageno=[5, 6]这两个page的指针。
我们解析下3号page，看看它的具体结构：
1 [root@yejr.me]# innodb_space -s ibdata1 -T innodb/t1 -p 3 page-dump 2 ... 3 records: 4 {:format=>:compact, 5 :offset=>125, 6 :header=> 7 {:next=>138, 8 :type=>:node_pointer, 9 :heap_number=>2, 10 :n_owned=>0, 11 :min_rec=>true, #第一条记录是min_key 12 :deleted=>false, 13 :nulls=>[], 14 :lengths=>{}, 15 :externs=>[], 16 :length=>5}, 17 :next=>138, 18 :type=>:clustered, 19 #第一条记录，只存储key值 20 :key=>[{:name=>"id", :type=>"INT UNSIGNED", :value=>1}], 21 :row=>[], 22 :sys=>[], 23 :child_page_number=>5, #value值是指向的叶子节点pageno=5 24 :length=>8} #整条记录消耗8字节，除去key值4字节外，指针也需要4字节 25 26 {:format=>:compact, 27 :offset=>138, 28 :header=> 29 {:next=>112, 30 :type=>:node_pointer, 31 :heap_number=>3, 32 :n_owned=>0, 33 :min_rec=>false, 34 :deleted=>false, 35 :nulls=>[], 36 :lengths=>{}, 37 :externs=>[], 38 :length=>5}, 39 :next=>112, 40 :type=>:clustered, 41 #第二条记录，只存储key值 42 :key=>[{:name=>"id", :type=>"INT UNSIGNED", :value=>56}], 43 :row=>[], 44 :sys=>[], 45 :child_page_number=>6, #value值是指向的叶子节点pageno=6 46 :length=>8}
优化建议2: 索引列数据长度越小越好，这样索引树存储效率越高，在非叶子节点能存储越多数据，延缓索引树层高分裂的速度，平均搜索效率更高。
3.3 特点3：辅助索引同时会存储主键索引列值
在辅助索引中，总是同时会存储主键索引（或者说聚集索引）的列值，其作用就是在对辅助索引扫描时，可以从叶子节点直接得到对应的聚集索引值，并可根据该值回表查询获取行数据（如果需要回表查询的话）。这个特性也被称为Index Extensions（5.6版本之后的优化器新特性，详见 Use of Index Extensions）。
此外，在辅助索引的非叶子节点中，索引记录的key值是索引定义的列值，而对应的value值则是聚集索引列值（简称PKV）。如果辅助索引定义时已经包含了部分聚集索引列，则索引记录的value值是未被包含的余下的聚集索引列值。
创建如下测试表：
1 CREATE TABLE `t3` ( 2 `a` int(10) unsigned NOT NULL AUTO_INCREMENT, 3 `b` int(10) unsigned NOT NULL DEFAULT '0', 4 `c` varchar(20) NOT NULL DEFAULT '', 5 `d` varchar(20) NOT NULL DEFAULT '', 6 `e` varchar(20) NOT NULL DEFAULT '', 7 PRIMARY KEY (`a`,`b`), 8 KEY `k1` (`c`,`b`) 9 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
随机插入一些测试数据：
1 # 调用shell脚本写入500条数据 2 [root@yejr.me]# cat insert.sh 3 #!/bin/bash 4 . ~/.bash_profile 5 cd /data/perconad 6 i=1 7 max=500 8 while [ $i -le $max ] 9 do 10 mysql -Smysql.sock -e "insert ignore into t3 select 11 rand()*1024, rand()*1024, left(md5(uuid()),20) , 12 left(uuid(),20), left(uuid(),20);" innodb 13 i=`expr $i + 1` 14 done 15 16 # 实际写入498条数据（其中有2条主键冲突失败） 17 [root@yejr.me] [innodb]>select count(*) from t3; 18 +----------+ 19 | count(*) | 20 +----------+ 21 | 498 | 22 +----------+
解析数据结构：
1 # 主键 2 [root@test1 perconad]# innodb_space -s ibdata1 -T innodb/t2 space-indexes 3 id name root fseg fseg_id used allocated fill_factor 4 245 PRIMARY 3 internal 1 1 1 100.00% 5 245 PRIMARY 3 leaf 2 5 5 100.00% 6 246 k1 4 internal 3 1 1 100.00% 7 246 k1 4 leaf 4 2 2 1 8 9 [root@yejr.me]# innodb_space -s ibdata1 -T innodb/t2 -p 4 page-dump 10 ... 11 records: 12 {:format=>:compact, 13 :offset=>126, 14 :header=> 15 {:next=>164, 16 :type=>:node_pointer, 17 :heap_number=>2, 18 :n_owned=>0, 19 :min_rec=>true, 20 :deleted=>false, 21 :nulls=>[], 22 :lengths=>{"c"=>20}, 23 :externs=>[], 24 :length=>6}, 25 :next=>164, 26 :type=>:secondary, 27 :key=> 28 [{:name=>"c", :type=>"VARCHAR(80)", :value=>"00a5d42dd56632893b5f"}, 29 {:name=>"b", :type=>"INT UNSIGNED", :value=>323}], 30 :row=> 31 [{:name=>"a", :type=>"INT UNSIGNED", :value=>310}, 32 {:name=>"b", :type=>"INT UNSIGNED", :value=>9}], 33 # 此处给解析成b列的值了，实际上是指向叶子节点的指针，即child_page_number=9 34 # b列真实值是323 35 :sys=>[], 36 :child_page_number=>335544345, 37 # 此处解析不准确，实际上是下一条记录的record header，共6个字节 38 :length=>36} 39 40 {:format=>:compact, 41 :offset=>164, 42 :header=> 43 {:next=>112, 44 :type=>:node_pointer, 45 :heap_number=>3, 46 :n_owned=>0, 47 :min_rec=>false, 48 :deleted=>false, 49 :nulls=>[], 50 :lengths=>{"c"=>20}, 51 :externs=>[], 52 :length=>6}, 53 :next=>112, 54 :type=>:secondary, 55 :key=> 56 [{:name=>"c", :type=>"VARCHAR(80)", :value=>"7458824a39892aa77e1a"}, 57 {:name=>"b", :type=>"INT UNSIGNED", :value=>887}], 58 :row=> 59 [{:name=>"a", :type=>"INT UNSIGNED", :value=>623}, 60 {:name=>"b", :type=>"INT UNSIGNED", :value=>10}], 61 # 同上，其实是child_page_number=10，而非b列的值 62 :sys=>[], 63 :child_page_number=>0, 64 :length=>36} #数据长度16字节
顺便说下，辅助索引上没存储TRX_ID, ROLL_PTR这些（他们只存储在聚集索引上）。
上面用innodb_ruby工具解析的非叶子节点部分内容不够准确，所以我们用二进制方式打开数据文件二次求证确认：
1 # 此处也可以用 hexdump 工具 2 [root@yejr.me]# vim -b path/t3.ibd 3 ... 4 :%!xxd 5 6 # 找到辅助索引所在的那部分数据 7 0010050: 0002 0272 0000 00e1 0000 0002 01b2 0100 ...r............ 8 0010060: 0200 1b69 6e66 696d 756d 0003 000b 0000 ...infimum...... 9 0010070: 7375 7072 656d 756d 1410 0011 0026 3030 supremum.....&00 10 0010080: 6135 6434 3264 6435 3636 3332 3839 3362 a5d42dd56632893b 11 0010090: 3566 0000 0143 0000 0136 0000 0009 1400 5f...C...6...... 12 00100a0: 0019 ffcc 3734 3538 3832 3461 3339 3839 ....7458824a3989 13 00100b0: 3261 6137 3765 3161 0000 0377 0000 026f 2aa77e1a...w...o 14 00100c0: 0000 000a 0000 0000 0000 0000 0000 0000 ................ 15 16 # 参考page物理结构方式进行解析，得到下面的结果 17 /* 第一条记录 */ 18 1410 0011 0026, record header, 5字节 19 3030 6135 6434 3264 6435 3636 3332 3839 3362 3566,c='00a5d42dd56632893b5f',20B 20 0000 0143, b=323, 4B 21 0000 0136, a=310, 4B 22 0000 0009, child_pageno=9, 4B 23 24 /* 2 */ 25 1400 0019 ffcc, record header 26 3734 3538 3832 3461 3339 3839 3261 6137 3765 3161, c='7458824a39892aa77e1a' 27 0000 0377, b=887 28 0000 026f, a=623 29 0000 000a, child_pageno=10
现在反过来看，上面用innodb_ruby工具解析出来的page-dump结果应该是这样的才对（我只选取一条记录，请自行对比和之前的不同之处）：
1 {:format=>:compact, 2 :offset=>164, 3 :header=> 4 {:next=>112, 5 :type=>:node_pointer, 6 :heap_number=>3, 7 :n_owned=>0, 8 :min_rec=>false, 9 :deleted=>false, 10 :nulls=>[], 11 :lengths=>{"c"=>20}, 12 :externs=>[], 13 :length=>6}, 14 :next=>112, 15 :type=>:secondary, 16 :key=> 17 [{:name=>"c", :type=>"VARCHAR(80)", :value=>"7458824a39892aa77e1a"}, 18 {:name=>"b", :type=>"INT UNSIGNED", :value=>887}], 19 :row=> [{:name=>"a", :type=>"INT UNSIGNED", :value=>623}], 20 :sys=>[], 21 :child_page_number=>10, 22 :length=>36}
可以看到，的确如前面所说，辅助索引的非叶子节点的value值存储的是聚集索引列值。
优化建议3：辅助索引列定义的长度越小越好，定义辅助索引时，没必要显式的加上聚集索引列（5.6版本之后）。
3.4 特点4：没有可用的聚集索引列时，会使用内置的ROW_ID作为聚集索引
创建几个像下面这样的表，使其选择内置的ROW_ID作为聚集索引：
1 [root@yejr.me] [innodb]> CREATE TABLE `tn1` ( 2 `c1` int(10) unsigned NOT NULL DEFAULT 0, 3 `c2` int(10) unsigned NOT NULL DEFAULT 0 4 ) ENGINE=InnoDB;
循环对几个表写数据：
1 insert into tt1 select 1,1; 2 insert into tt2 select 1,1; 3 insert into tt3 select 1,1; 4 insert into tt1 select 2,2; 5 insert into tt2 select 2,2; 6 insert into tt3 select 2,2;
查看 tn1 - tn3 表里的数据（这里由于innodb_ruby工具解析的结果不准确，所以我改用hexdump来分析）：
1 tn1 2 000c060: 0200 1a69 6e66 696d 756d 0003 000b 0000 ...infimum...... 3 000c070: 7375 7072 656d 756d 0000 1000 2000 0000 supremum.... ... 4 000c080: 0003 1200 0000 003d f6aa 0000 01d9 0110 .......=........ 5 000c090: 0000 0001 0000 0001 0000 18ff d300 0000 ................ 6 000c0a0: 0003 1500 0000 003d f9ad 0000 01da 0110 .......=........ 7 000c0b0: 0000 0002 0000 0002 0000 0000 0000 0000 ................ 8 9 tn2 10 000c060: 0200 1a69 6e66 696d 756d 0003 000b 0000 ...infimum...... 11 000c070: 7375 7072 656d 756d 0000 1000 2000 0000 supremum.... ... 12 000c080: 0003 1300 0000 003d f7ab 0000 0122 0110 .......=.....".. 13 000c090: 0000 0001 0000 0001 0000 18ff d300 0000 ................ 14 000c0a0: 0003 1600 0000 003d feb0 0000 01db 0110 .......=........ 15 000c0b0: 0000 0002 0000 0002 0000 0000 0000 0000 ................ 16 tn3 17 000c060: 0200 1a69 6e66 696d 756d 0003 000b 0000 ...infimum...... 18 000c070: 7375 7072 656d 756d 0000 1000 2000 0000 supremum.... ... 19 000c080: 0003 1400 0000 003d f8ac 0000 0123 0110 .......=.....#.. 20 000c090: 0000 0001 0000 0001 0000 18ff d300 0000 ................ 21 000c0a0: 0003 1700 0000 003e 03b3 0000 012a 0110 .......>.....*.. 22 000c0b0: 0000 0002 0000 0002 0000 0000 0000 0000 ................
其中表示DB_ROW_ID的值分别是：
1 tn1 2 0003 12 => (1,1) 3 0003 15 => (2,2) 4 5 tn2 6 0003 13 => (1,1) 7 0003 16 => (2,2) 8 9 tn3 10 0003 14 => (1,1) 11 0003 17 => (2,2)
很明显，内置的DB_ROW_ID的确是在整个实例级别共享自增分配的，而不是每个表独享一个DB_ROW_ID序列。
我们可以想象下，如果一个实例中有多个表都用到这个DB_ROW_ID的话，势必会造成并发请求的竞争/等待。此外也可能会造成主从复制环境下，从库上relay log回放时可能会因为数据扫描机制的问题造成严重的复制延迟问题。详情参考 从库数据的查找和参数slave_rows_search_algorithms。
优化建议4：自行显示定义可用的聚集索引/主键索引，不要让InnoDB选择内置的DB_ROW_ID作为聚集索引，避免潜在的性能损失。
篇幅已经有点大了，本次的浅析工作就先到这里吧，以后再继续。
4、几点总结
最后针对InnoDB引擎表，总结几条建议吧。
-
每个表都要有显式主键，最好是自增整型，且没有业务用途
-
无论是主键索引，还是辅助索引，都尽可能选择数据类型较小的列
-
定义辅助索引时，没必要显式加上主键索引列（针对MySQL 5.6之后）
-
行数据越短越好，如果每个列都是固定长的则更好（不是像VARCHAR这样的可变长度类型）
喜欢请多多点赞评论，关注小编，你们的支持就是小编最大的动力！！！
