一文带你了解MySQL之undo日志

目录

一、事务回滚的需求

我们在前边学习事务的时候说过事务需要保证

原子性

，也就是

事务中的操作要么全做，要么全不做

。但是有的时候事务会出现一些情况，比如：

• 情况一：事务执行过程中可能遇到各种错误，比如服务器本身的错误，操作系统错误，甚至是突然断电导致的错误
• 情况二：程序员可以在事务执行过程中手动输入ROLLBACK语句结束当前的事务的执行

以上这两种情况都会导致事务执行到一半就结束，但是事务执行过程中可能已经修改了很多东西，为了保证事务的

原子性

，我们需要把东西改回原先的样子，这个过程就称之为

回滚

（英文名：

rollback

），这样就可以造成一个假象：这个事务看起来什么都没做，所以符合原子性要求。

好比小时候我们和小伙伴们完纸牌。悔牌就是一种非常典型的回滚操作，比如你出两张三纸牌，悔牌对应的操作就是把两张三纸牌在拿出去。数据库中的回滚跟悔牌差不多，你插入了一条记录，回滚操作对应的就是把这条记录删除掉；你更新了一条记录，回滚操作对应的就是把该记录更新为旧值；你删除了一条记录，回滚操作对应的自然就是把该记录再插进去。说的貌似很简单的样子

从上边的描述中我们已经能隐约感觉到，每当我们要对一条记录做改动时（这里的改动可以指

INSERT

、

DELETE

、

UPDATE

），都需要留一手 —— 把回滚时所需的东西都给记下来。比如说：

• 你插入一条记录时，至少要把这条记录的主键值记下来，之后回滚的时候只需要把这个主键值对应的记录删掉就好了
• 你删除了一条记录，至少要把这条记录中的内容都记下来，这样之后回滚时再把由这些内容组成的记录插入到表中就好了
• 你修改了一条记录，至少要把修改这条记录前的旧值都记录下来，这样之后回滚时再把这条记录更新为旧值就好了

数据库这些为了回滚⽽记录的这些东东称之为撤销日志，英文名为

undo log

，我们称之为

undo日志

。这里需要注意的一点是，由于查询操作（SELECT）并不会修改任何⽤户记录，所以在查询操作执行时，并不需要记录相应的

undo

日志。在真实的

InnoDB

中，

undo

日志其实并不像我们上边所说的那么简单，不同类型的操作产⽣的

undo

日志的格式也是不同的，不过先暂时把这些容易让人脑子糊的具体细节放一放，我们先回过头来看看事务id是什么东西

二、事务id

2.1 给事务分配id的时机

我们前边在学习事务简介时说过，一个事务可以是一个

只读事务

，或者是一个

读写事务

：

• 我们可以通过START TRANSACTION READ ONLY语句开启一个只读事务，在只读事务中不可以对普通的表（其他事务也能访问到的表）进行增、删、改操作，但可以对临时表做增、删、改操作
• 我们可以通过START TRANSACTION READ WRITE语句开启一个读写事务，或者使用BEGIN、START TRANSACTION语句开启的事务默认也算是读写事务，在读写事务中可以对表执行增删改查操作。

如果某个事务执行过程中对某个表执行了

增

、

删

、

改

操作，那么

InnoDB

存储引擎就会给它分配一个独一无二的

事务id

，分配如式如下：

• 对于只读事务来说，只有在它第一次对某个用户创建的临时表执行增、删、改操作时才会为这个事务分配一个事务id，否则的话是不分配事务id的> **> > 小提示：> > **> 我们前边说过对某个查询语句执行> > EXPLAIN> > 分析它的查询计划时，有时候在Extra列会看到Using temporary的提示，这个表明在执行该查询语句时会用到内部临时表。这个所谓的内部临时表和我们手动用> > CREATE TEMPORARY TABLE> > 创建的用户临时表并不一样，在事务回滚时并不需要把执行SELECT语句过程中用到的内部临时表也回滚，在执行SELECT语句用到内部临时表时并不会为它分配事务id。
• 对于读写事务来说，只有在它第一次对某个表（包括用户创建的临时表）执行增、删、改操作时才会为这个事务分配一个事务id，否则的话也是不分配事务id的

有的时候虽然我们开启了一个

读写事务

，但是在这个事务中全是查询语句，并没有执行增、删、改的语句，那也就意味着这个事务并不会被分配一个事务id

说了半天，事务id有啥子用？这个先保密哈，后边会一步步的详细唠叨。现在只要知道只有在事务对表中的记录做改动时才会为这个事务分配一个唯一的事务id。

2.2 事务id是怎么生成的

这个

事务id

本质上就是一个数字，它的分配策略和我们前边提到的对隐藏列

row_id

（当用户没有为表创建主键和UNIQUE键时InnoDB自动创建的列）的分配策略大抵相同，具体策略如下：

• 服务器会在内存中维护一个全局变量，每当需要为某个事务分配一个事务id时，就会把该变量的值当作事务id分配给该事务，并且把该变量自增1
• 每当这个变量的值为256的倍数时，就会将该变量的值刷新到系统表空间的⻚号为5的⻚⾯中一个称之为Max Trx ID的属性处，这个属性占用8个字节的存储空间
• 当系统下一次重新启动时，会将上边提到的Max Trx ID属性加载到内存中，将该值加上256之后赋值给我们前边提到的全局变量（因为在上次关机时该全局变 量的值可能大于Max Trx ID属性值）

这样就可以保证整个系统中分配的事务id值是一个递增的数字。先被分配id的事务得到的是较小的事务id，后被分配id的事务得到的是较大的事务id。

2.3 trx_id隐藏列

我们前边学习

InnoDB

记录行格式的时候重点强调过：聚簇索引的记录除了会保存完整的用户数据以外，而且还会自动添加名为

trx_id

、

roll_pointer

的隐藏列，如果用户

没有在表中定义主键以及UNIQUE键

，还会自动添加一个名为

row_id

的隐藏列。所以一条记录在页面中的真实结构看起来就是这样的：

其中的

trx_id

列其实还蛮好理解的，就是某个对这个聚簇索引记录做改动的语句所在的

事务对应的事务id

而已（此处的改动可以是

INSERT

、

DELETE

、

UPDATE

操作）。至于

roll_pointer

隐藏列我们后边分析～

三、undo日志的格式

为了实现事务的原子性，

InnoDB

存储引擎在实际进行

增

、

删

、

改

一条记录时，都需要先把对应的

undo

日志记下来。一般每对一条记录做一次改动，就对应着一条

undo

日志，但在某些更新记录的操作中，也可能会对应着2条

undo

日志，这个我们后边会仔细唠叨。一个事务在执行过程中可能

新增

、

删除

、

更新

若干条记录，也就是说需要记录很多条对应的

undo

日志，这些

undo

日志会被从

0

开始编号，也就是说根据生成的顺序分别被称为第0号undo日志、第1号undo日志、…、第n号undo日志等，这个编号也被称之为

undo no

。

这些undo日志是被记录到类型为

FIL_PAGE_UNDO_LOG

（对应的十六进制是

0x0002

，忘记了页面类型是个啥的同学需要回过头再看看前边的章节）的页面中。这些页面可以从系统表空间中分配，也可以从一种专门存放undo日志的表空间，也就是所谓的

undo tablespace

中分配。不过关于如何分配存储

undo

日志的页面这个事情我们稍后再说，现在先来看看不同操作都会产生什么样子的

undo

日志吧～ 为了故事的顺利发展，我们先来创建一个名为

demo18

的表：

mysql>CREATETABLE demo18 (
    id INTNOTNULL,
    key1 VARCHAR(100),
    col VARCHAR(100),PRIMARYKEY(id),KEY idx_key1 (key1))Engine=InnoDBCHARSET=utf8;
Query OK,0rows affected,1 warning (0.06 sec)

这个表中有3个列，其中

id

列是主键，我们为

key1

列建立了一个

二级索引

，col列是一个普通的列。我们前边介绍

InnoDB

的数据字典时说过，每个表都会被分配一个唯一的

table id

，我们可以通过系统数据库

information_schema

中的

innodb_tables

表来查看某个表对应的

table id

是什么，现在我们查看一下

demo18

对应的

table id

是多少：

mysql>SELECT*FROM information_schema.innodb_tables WHERE name ='testdb/demo18';+----------+---------------+------+--------+-------+------------+---------------+------------+--------------+--------------------+| TABLE_ID | NAME          | FLAG | N_COLS | SPACE | ROW_FORMAT | ZIP_PAGE_SIZE | SPACE_TYPE | INSTANT_COLS | TOTAL_ROW_VERSIONS |+----------+---------------+------+--------+-------+------------+---------------+------------+--------------+--------------------+|1128| testdb/demo18 |33|6|66| Dynamic    |0| Single     |0|0|+----------+---------------+------+--------+-------+------------+---------------+------------+--------------+--------------------+1rowinset(0.00 sec)

从查询结果可以看出，

demo18

表对应的

table id

为

1128

，先把这个值记住，我们后边有用

3.1 INSERT操作对应的undo日志

我们前边说过，当我们向表中插入一条记录时会有

乐观插入

和

悲观插入

的区分，但是不管怎么插入，最终导致的结果就是这条记录被放到了一个数据页中。如果希望回滚这个插入操作，那么把这条记录删除就好了，也就是说在写对应的

undo

日志时，主要是把这条记录的主键信息记上。所以

InnoDB

设计了一个类型为

TRX_UNDO_INSERT_REC

的

undo

日志，它的完整结构如下图所示：

根据示意图我们强调几点：

• undo no在一个事务中是从0开始递增的，也就是说只要事务没提交，每生成一条undo日志，那么该条日志的undo no就增1。
• 如果记录中的主键只包含一个列，那么在类型为TRX_UNDO_INSERT_REC的undo日志中只需要把该列占用的存储空间大小和真实值记录下来，如果记录中的主键包含多个列，那么每个列占用的存储空间大小和对应的真实值都需要记录下来（图中的len就代表列占用的存储空间大小，value就代表列的真实值）。> **> > 小提示：> > **> 当我们向某个表中插入一条记录时，实际上需要向聚簇索引和所有的二级索引都插入一条记录。不过记录undo日志时，我们只需要考虑向聚簇索引插入记录时的情况就好了，因为其实聚簇索引记录和二级索引记录是一一对应的，我们在回滚插入操作时，只需要知道这条记> 录的主键信息，然后根据主键信息做对应的删除操作，做删除操作时就会顺带着把所有二级索引中相应的记录也删除掉。后边说到的DELETE操作和UPDATE操作对应的undo日志也都是针对聚簇索引记录而⾔的，我们之后就不强调了。

现在我们向demo18中插入两条记录：

mysql>BEGIN;# 显式开启一个事务，假设该事务的id为100
Query OK,0rows affected (0.00 sec)

mysql># 插入两条记录
mysql>INSERTINTO demo18(id, key1, col)VALUES(1,'AWM','狙击枪'),(2,'M416','步枪');
Query OK,2rows affected (0.01 sec)
Records: 2  Duplicates: 0Warnings: 0

因为记录的主键只包含一个

id

列，所以我们在对应的

undo

日志中只需要将待插入记录的

id

列占用的存储空间长度（

id列的类型为INT，INT类型占用的存储空间长度为4个字节

）和

真实值

记录下来。本例中插入了两条记录，所以会产生两条类型为

TRX_UNDO_INSERT_REC

的

undo

日志:

• 第一条undo日志的undo no为0，记录主键占用的存储空间长度为4，真实值为1。画一个示意图就是这样：
• 第二条undo日志的undo no为1，记录主键占用的存储空间长度为4，真实值为2。画一个示意图就是这样：

与第一条

undo日志

对比，

undo no

和

主键各列信息

有不同。

roll_pointer隐藏列的含义

是时候揭开

roll_pointer

的真实面纱了，这个占用

7

个字节的字段其实一点都不神秘，本质上就是一个指向记录对应的

undo日志的一个指针

。比如说我们上边向

demo18

表里插入了

2

条记录，每条记录都有与其对应的一条

undo日志

。记录被存储到了类型为

FIL_PAGE_INDEX

的页面中（就是我们前边一直所说的数据页），

undo

日志被存放到了类型为

FIL_PAGE_UNDO_LOG

的页面中。效果如图所示：

从图中也可以更直观的看出来，

roll_pointer

本质就是一个指针，指向记录对应的

undo

日志。不过这7个字节的

roll_pointer

的每一个字节具体的含义我们后边唠叨完如何分配存储

undo

日志的页面之后再具体说哈～

3.2 DELETE操作对应的undo日志

我们知道插入到页面中的记录会根据记录头信息中的

next_record

属性组成一个单向链表，我们把这个链表称之为正常记录链表；我们在前边唠叨数据页结构的时候说过，被删除的记录其实也会根据记录头信息中的

next_record

属性组成一个链表，只不过这个链表中的

记录占用的存储空间可以被重新利用

，所以也称这个链表为

垃圾链表

。

PageHeader

部分有一个称之为

PAGE_FREE

的属性，它指向由被删除记录组成的垃圾链表中的头节点。为了故事的顺利发展，我们先画一个图，假设此刻某个页面中的记录分布情况是这样的（这个不是

demo18

表中的记录，只是我们随便举的一个例子）：

为了突出主题，在这个简化版的示意图中，我们只把记录的

delete_mask

标志位展示了出来。从图中可以看出，

正常记录链表中包含了3条正常记录

，垃圾链表里包含了

2条已删除记录

，在垃圾链表中的这些记录占用的存储空间可以被重新利用。页面的

Page Header

部分的

PAGE_FREE

属性的值代表指向垃圾链表头节点的指针。假设现在我们准备使用

DELETE

语句把

正常记录链表

中的最后一条记录给删除掉，其实这个删除的过程需要经历两个阶段：

• 阶段一：仅仅将记录的delete_mask标识位设置为1，其他的不做修改（其实会修改记录的trx_id、roll_pointer这些隐藏列的值）。InnoDB把这个阶段称之为delete mark。把这个过程画下来就是这样：可以看到，正常记录链表中的最后一条记录的delete_mask值被设置为1，但是并没有被加入到垃圾链表。也就是此时记录处于一个中间状态，在删除语句所在的事务提交之前，被删除的记录一直都处于这种所谓的中间状态。> **> > 小提示：> > **> 为啥会有这种奇怪的中间状态呢？其实主要是为了实现一个称之为MVCC的功能，哈哈，稍后再介绍。
• 阶段二：当该删除语句所在的事务提交之后，会有专门的线程后来真正的把记录删除掉。所谓真正的删除就是把该记录从正常记录链表中移除，并且加入到垃圾链表中，然后还要调整一些页面的其他信息，比如页面中的用户记录数量PAGE_N_RECS、上次插入记录的位置PAGE_LAST_INSERT、垃圾链表头节点的指针PAGE_FREE、页面中可重用的字节数量PAGE_GARBAGE、还有页⽬录的一些信息等等。InnoDB的把这个阶段称之为purge。把阶段二执行完了，这条记录就算是真正的被删除掉了。这条已删除记录占用的存储空间也可以被重新利用了。画下来就是这样： 对照着图我们还要注意一点，将被删除记录加入到垃圾链表时，实际上加入到链表的头节点处，会跟着修改PAGE_FREE属性的值。> **> > 小提示：> > **> 页面的Page Header部分有一个PAGE_GARBAGE属性，该属性记录着当前页面中可重用存储空间占用的总字节数。每当有已删除记录被加入到垃圾链表后，都会把这个PAGE_GARBAGE属性的值加上该已删除记录占用的存储空间大小。PAGE_FREE指向垃圾链表的头节点，之后每当新插入记录时，⾸先判断PAGE_FREE指向的头节点代表的已删除记录占用的存储空间是否足够容纳这条新插入的记录，如果不可以容纳，就直接向页面中申请新的空间来存储这条记录（是的，你没看错，并不会尝试遍历整个垃圾链表，找到一个可以容纳新记录的节点）。如果可以容纳，那么直接重用这条已删除记录的存储空间，并且把PAGE_FREE指向垃圾链表中的下一条已删除记录。但是这里有一个问题，如果新插入的那条记录占用的存储空间大小小于垃圾链表的头节点占用的存储空间大小，那就意味头节点对应的记录占用的存储空间里有一部分空间用不到，这部分空间就被称之为碎片空间。那这些碎片空间岂不是永远都用不到了么？其实也不是，这些碎片空间占用的存储空间大小会被统计到PAGE_GARBAGE属性中，这些碎片空间在整个页面快使用完前并不会被重新利用，不过当页面快满时，如果再插入一条记录，此时页面中并不能分配一条完整记录的空间，这时候会⾸先看一看PAGE_GARBAGE的空间和剩余可利用的空间加起来是不是可以容纳下这条记录，如果可以的话，InnoDB会尝试重新组织页内的记录，重新组织的过程就是先开辟一个临时页面，把页面内的记录依次插入一遍，因为依次插入时并不会产生碎片，之后再把临时页面的内容复制到本页面，这样就可以把那些碎片空间都解放出来（很显然重新组织页面内的记录比较耗费性能）。

从上边的描述中我们也可以看出来，在删除语句所在的事务提交之前，只会经历阶段一，也就是

delete mark

阶段（提交之后我们就不用回滚了，所以只需考虑对删除操作的阶段一做的影响进行回滚）。

InnoDB

为此设计了一种称之为

TRX_UNDO_DEL_MARK_REC

类型的

undo

日志，它的完整结构如下图所示：

额滴个神呐，这个里边的属性也太多了点儿吧～ （其实大部分属性的意思我们上边已经介绍过了） 是的，的确有点多，不过大家千万不要在意，如果记不住千万不要勉强自已，我这里把它们都列出来让大家混个脸熟而已。劳烦大家先克服一下密集恐急症，再抬头大致看一遍上边的这个类型为

TRX_UNDO_DEL_MARK_REC

的

undo

日志中的属性，特别注意一下这几点：

• 在对一条记录进行delete mark操作前，需要把该记录的旧的trx_id和roll_pointer隐藏列的值都给记到对应的undo日志中来，就是我们图中显示的oldtrx_id和old roll_pointer属性。这样有一个好处，那就是可以通过undo日志的old roll_pointer找到记录在修改之前对应的undo日志。比如说在一个事务中，我们先插入了一条记录，然后又执行对该记录的删除操作，这个过程的示意图就是这样：
• 从图中可以看出来，执行完delete mark操作后，它对应的undo日志和INSERT操作对应的undo日志就串成了一个链表。这个很有意思啊，这个链表就称之为版本链，现在貌似看不出这个版本链有啥用，等我们再往后看看，讲完UPDATE操作对应的undo日志后，这个所谓的版本链就慢慢的展现出它的⽜逼之处了。
• 与类型为TRX_UNDO_INSERT_REC的undo日志不同，类型为TRX_UNDO_DEL_MARK_REC的undo日志还多了一个索引列各列信息的内容，也就是说如果某个列被包含在某个索引中，那么它的相关信息就应该被记录到这个索引列各列信息部分，所谓的相关信息包括该列在记录中的位置（用pos表示），该列占用的存储空间大小（用len表示），该列实际值（用value表示）。所以索引列各列信息存储的内容实质上就是<pos, len, value>的一个列表。这部分信息主要是用在事务提交后，对该中间状态记录做真正删除的阶段二，也就是purge阶段中使用的，具体如何使用现在我们可以忽略～

该介绍的我们介绍完了，现在继续在上边那个事务

id

为

100

的事务中删除一条记录，比如我们把

id

为

1

的那条记录删除掉：

mysql>DELETEFROM demo18 WHERE id =1;
Query OK,1row affected (0.01 sec)

这个

delete mark

操作对应的

undo

日志的结构就是这样：
对照着这个图，我们得注意下边几点：

• 因为这条undo日志是id为100的事务中产生的第3条undo日志，所以它对应的undo no就是2。
• 在对记录做delete mark操作时，记录的trx_id隐藏列的值是100（也就是说对该记录最近的一次修改就发生在本事务中），所以把100填入old trx_id属性中。然后把记录的roll_pointer隐藏列的值取出来，填入old roll_pointer属性中，这样就可以通过old roll_pointer属性值找到最近一次对该记录做改动时产生的undo日志。
• 由于demo18表中有2个索引：一个是聚簇索引，一个是二级索引idx_key1。只要是包含在索引中的列，那么这个列在记录中的位置（pos），占用存储空间大小（len）和实际值（value）就需要存储到undo日志中。- 对于主键来说，只包含一个id列，存储到undo日志中的相关信息分别是：- pos：id列是主键，也就是在记录的第一个列，它对应的pos值为0。pos占用1个字节来存储。- len：id列的类型为INT，占用4个字节，所以len的值为4。len占用1个字节来存储。- value：在被删除的记录中id列的值为1，也就是value的值为1。value占用4个字节来存储。- 画一个图演示一下就是这样：- 所以对于id列来说，最终存储的结果就是<0, 4, 1>，存储这些信息占用的存储空间大小为1 + 1 + 4 = 6个字节。- 对于idx_key1来说，只包含一个key1列，存储到undo日志中的相关信息分别是：- pos：key1列是排在id列、trx_id列、roll_pointer列之后的，它对应的pos值为3。pos占用1个字节来存储。- len：key1列的类型为VARCHAR(100)，使用utf8字符集，被删除的记录实际存储的内容是AWM，所以一共占用3个字节，也就是所以len的值为3。len占用1个字节来存储。- value：在被删除的记录中key1列的值为AWM，也就是value的值为AWM。value占用3个字节来存储。- 画一个图演示一下就是这样： - 所以对于key1列来说，最终存储的结果就是<3, 3, 'AWM'>，存储这些信息占用的存储空间大小为1 + 1 + 3 = 5个字节。从上边的叙述中可以看到，<0, 4, 1>和<3, 3, 'AWM'>共占用11个字节。然后index_col_info len本身占用2个字节，所以加起来一共占用13个字节，把数字13就填到了index_col_info len的属性中。

3.3 UPDATE操作对应的undo日志

在执行

UPDATE

语句时，InnoDB对

更新主键

和

不更新主键

这两种情况有截然不同的处理如案。

3.3.1 不更新主键的情况

在不更新主键的情况下，又可以细分为被更新的列占用的存储空间不发生变化和发生变化的情况。

就地更新（in-place update）

更新记录时，对于被更新的每个列来说，如果更新后的列和更新前的列占用的存储空间都一样大，那么就可以进行就地更新，也就是直接在原记录的基础上修改对应列的值。再次强调一边，是每个列在更新前后占用的存储空间一样大，有任何一个被更新的列更新前比更新后占用的存储空间大，或者更新前比更新后占用的存储空间小都不能进行就地更新。比如说现在demo18表里还有一条id值为2的记录，它的各个列占用的大小如图所示（因为采用utf8字符集，所以’步枪’这两个字符占用6个字节）：

假如我们有这样的

UPDATE

语句：

UPDATE demo18 SET key1 ='P92', col ='手枪'WHERE id =2;

在这个UPDATE语句中，col列从步枪被更新为手枪，前后都占用6个字节，也就是占用的存储空间大小未改变；key1列从M416被更新为P92，也就是从4个字
节被更新为3个字节，这就不满足就地更新需要的条件了，所以不能进行就地更新。但是如果UPDATE语句长这样：

UPDATE demo18 SET key1 ='M249', col ='机枪'WHERE id =2;

由于各个被更新的列在更新前后占用的存储空间是一样大的，所以这样的语句可以执行就地更新。

先删除掉旧记录，再插入新记录

在不更新主键的情况下，如果有任何一个被更新的列更新前和更新后占用的存储空间大小不一致，那么就需要先把这条旧的记录从聚簇索引页面中删除掉，然后再根据更新后列的值创建一条新的记录插入到页面中。

请注意一下，我们这里所说的删除并不是

delete mark

操作，而是真正的删除掉，也就是把这条记录从正常记录链表中移除并加入到垃圾链表中，并且修改页面中相应的统计信息（比如

PAGE_FREE

、

PAGE_GARBAGE

等这些信息）。不过这里做真正删除操作的线程并不是在唠叨

DELETE

语句中做

purge

操作时使用的另外专门的线程，而是由用户线程同步执行真正的删除操作，真正删除之后紧接着就要根据各个列更新后的值创建的新记录插入。

这里如果新创建的记录占用的存储空间大小不超过旧记录占用的空间，那么可以直接重用被加入到垃圾链表中的旧记录所占用的存储空间，否则的话需要在页面中新申请一段空间以供新记录使用，如果本页面内已经没有可用的空间的话，那就需要进行页面分裂操作，然后再插入新记录。

针对UPDATE不更新主键的情况（包括上边所说的就地更新和先删除旧记录再插入新记录），InnoDB设计了一种类型为

TRX_UNDO_UPD_EXIST_REC

的undo日志，它的完整结构如下：

其实大部分属性和我们介绍过的

TRX_UNDO_DEL_MARK_REC

类型的undo日志是类似的，不过还是要注意这么几点：

• n_updated属性表示本条UPDATE语句执行后将有几个列被更新，后边跟着的<pos, old_len, old_value>分别表示被更新列在记录中的位置、更新前该列占用的存储空间大小、更新前该列的真实值。
• 如果在UPDATE语句中更新的列包含索引列，那么也会添加索引列各列信息这个部分，否则的话是不会添加这个部分的。

现在继续在上边那个事务

id

为

100

的事务中更新一条记录，比如我们把

id

为

2

的那条记录更新一下：

BEGIN;# 显式开启一个事务，假设该事务的id为100# 插入两条记录INSERTINTO demo18(id, key1, col)VALUES(1,'AWM','狙击枪'),(2,'M416','步枪');# 删除一条记录   DELETEFROM demo18 WHERE id =1;# 更新一条记录UPDATE demo18 SET key1 ='M249', col ='机枪'WHERE id =2;

这个

UPDATE

语句更新的列大小都没有改动，所以可以

采用就地更新

的如式来执行，在真正改动页面记录时，会先记录一条类型为

TRX_UNDO_UPD_EXIST_REC

的undo日志，长这样：

对照着这个图我们注意一下这几个地如：

• 因为这条undo日志是id为100的事务中产生的第4条undo日志，所以它对应的undo no就是3。
• 这条日志的roll_pointer指向undo no为1的那条日志，也就是插入主键值为2的记录时产生的那条undo日志，也就是最近一次对该记录做改动时产生的undo日志。
• 由于本条UPDATE语句中更新了索引列key1的值，所以需要记录一下索引列各列信息部分，也就是把主键和key1列更新前的信息填入。

3.3.2 更新主键的情况

在聚簇索引中，记录是按照主键值的大小连成了一个单向链表的，如果我们更新了某条记录的主键值，意味着这条记录在聚簇索引中的位置将会发生改变，比如你将记录的

主键值从1更新为10000

，如果还有非常多的记录的主键值分布在1 ~ 10000之间的话，那么这两条记录在聚簇索引中就有可能离得非常远，甚至中间隔了好多个页面。针对

UPDATE

语句中更新了记录主键值的这种情况，

InnoDB

在聚簇索引中分了两步处理：

• 将旧记录进行delete mark操作高能注意：这里是delete mark操作！也就是说在UPDATE语句所在的事务提交前，对旧记录只做一个delete mark操作，在事务提交后才由专门的线程做purge操作，把它加入到垃圾链表中。这里一定要和我们上边所说的在不更新记录主键值时，先真正删除旧记录，再插入新记录的如式区分开！> **> > 小提示：> > **> 之所以只对旧记录做delete mark操作，是因为别的事务同时也可能访问这条记录，如果把它真正的删除加入到垃圾链表后，别的事务就访问不到了。这个功能就是所谓的MVCC，我们后边的章节中会详细唠叨什么是个MVCC。
• 根据更新后各列的值创建一条新记录，并将其插入到聚簇索引中（需重新定位插入的位置）。由于更新后的记录主键值发生了改变，所以需要重新从聚簇索引中定位这条记录所在的位置，然后把它插进去。

针对

UPDATE

语句更新记录主键值的这种情况，在对该记录进行

delete mark

操作前，会记录一条类型为

TRX_UNDO_DEL_MARK_REC

的undo日志；之后插入新记录时，会记录一条类型为

TRX_UNDO_INSERT_REC

的

undo

日志，也就是说每对一条记录的主键值做改动时，会记录2条undo日志。这些日志的格式我们上边都唠叨过了，就不赘述了。

四、通用链表结构

在

写入undo日志

的过程中会使用到多个链表，很多链表都有同样的节点结构，如图所示：

在某个表空间内，我们可以通过一个页的页号和在页内的偏移量来唯一定位一个节点的位置，这两个信息也就相当于指向这个节点的一个指针。所以：

• Pre Node Page Number和Pre Node Offset的组合就是指向前一个节点的指针
• Next Node Page Number和Next Node Offset的组合就是指向后一个节点的指针。

整个

List Node

占用12个字节的存储空间。为了更好的管理链表，InnoDB的提出了一个

基节点的结构

，里边存储了这个

链表的头节点

、

尾节点

以及

链表长度信息

，基节点的结构示意图如下：

其中：

• List Length表明该链表一共有多少节点。
• First Node Page Number和First Node Offset的组合就是指向链表头节点的指针。
• Last Node Page Number和Last Node Offset的组合就是指向链表尾节点的指针。

整个

List Base Node

占用

16

个字节的存储空间。所以使用

List Base Node

和

List Node

这两个结构组成的链表的示意图就是这样：

五、 FIL_PAGE_UNDO_LOG页面

我们前边唠叨表空间的时候说过，表空间其实是由许许多多的

页面构成

的，页面

默认大小为16KB

。这些页面有不同的类型，比如类型为

FIL_PAGE_INDEX

的页面用于存储聚簇索引以及二级索引，类型为

FIL_PAGE_TYPE_FSP_HDR

的页面用于存储表空间头部信息的，还有其他各种类型的页面，其中有一种称之为

FIL_PAGE_UNDO_LOG

类型的页面是专门用来

存储undo日志

的，这种类型的页面的通用结构如下图所示（以默认的16KB大小为例）：

类型为

FIL_PAGE_UNDO_LOG

的页我们就简称为

Undo

页面。上图中的

File Header

和

File Trailer

是各种页面都有的通用结构，我们前边已经学习了很多遍了，这里就不赘述了。

Undo Page Header

是

Undo页面

所特有的，我们来看一下它的结构：

其中各个属性的意思如下：

• TRX_UNDO_PAGE_TYPE：本页面准备存储什么种类的undo日志。 我们前边介绍了好几种类型的undo日志，它们可以被分为两个大类：- TRX_UNDO_INSERT（使用十进制1表示）：类型为TRX_UNDO_INSERT_REC的undo日志属于此大类，一般由INSERT语句产生，或者在UPDATE语句中有更新主键的情况也会产生此类型的undo日志。- TRX_UNDO_UPDATE（使用十进制2表示），除了类型为TRX_UNDO_INSERT_REC的undo日志，其他类型的undo日志都属于这个大类，比如我们前边说的TRX_UNDO_DEL_MARK_REC、TRX_UNDO_UPD_EXIST_REC等，一般由DELETE、UPDATE语句产生的undo日志属于这个大类。这个TRX_UNDO_PAGE_TYPE属性可选的值就是上边的两个，用来标记本页面用于存储哪个大类的undo日志，不同大类的undo日志不能混着存储，比如一个Undo页面的TRX_UNDO_PAGE_TYPE属性值为TRX_UNDO_INSERT，那么这个页面就只能存储类型为TRX_UNDO_INSERT_REC的undo日志，其他类型的undo日志就不能放到这个页面中了。> **> > 小提示：> > **> 之所以把undo日志分成两个大类，是因为类型为TRX_UNDO_INSERT_REC的undo日志在事务提交后可以直接删除掉，而其他类型的undo日志还需要为所谓的MVCC服务，不能直接删除掉，对它们的处理需要区别对待。当然，如果你看这段话迷迷糊糊的话，那就不需要再看一遍了，现在只需要知道undo日志分为2个大类就好了，更详细的东西我们后边会有讲解。
• TRX_UNDO_PAGE_START：表示在当前页面中是从什么位置开始存储undo日志的，或者说表示第一条undo日志在本页面中的起始偏移量。
• TRX_UNDO_PAGE_FREE：与上边的TRX_UNDO_PAGE_START对应，表示当前页面中存储的最后一条undo日志结束时的偏移量，或者说从这个位置开始，可以继续写入新的undo日志。假设现在向页面中写入了3条undo日志，那么TRX_UNDO_PAGE_START和TRX_UNDO_PAGE_FREE的示意图就是这样： 当然，在最初一条undo日志也没写入的情况下，TRX_UNDO_PAGE_START和TRX_UNDO_PAGE_FREE的值是相同的。
• TRX_UNDO_PAGE_NODE：代表一个List Node结构（链表的普通节点，我们上边刚说的），下边马上用到这个属性，稍安勿躁。

六、Undo页面链表

6.1 单个事务中的Undo页面链表

因为一个事务可能包含多个语句，而且一个语句可能对若干条记录进行改动，而对每条记录进行改动前，都需要记录

1条或2条的undo日志

，所以在一个事务执行过程中可能

产生很多undo日志

，这些日志可能一个页面放不下，需要放到多个页面中，这些页面就通过我们上边介绍的

TRX_UNDO_PAGE_NODE

属性连成了链表：

大家可以看一看上边的图，一边情况下把链表中的第一个Undo页称它为

first undo page

，因为在

first undo page

中除了记录

Undo Page Header

之外，还会记录其他的一些管理信息。其余的Undo页面称之为

normal undo page

。

在一个事务执行过程中，可能混着执行INSERT、

DELETE

、

UPDATE

语句，也就意味着会产生不同类型的undo日志。但是我们前边又说过，同一个

Undo

页面要么只存储

TRX_UNDO_INSERT

大类的undo日志，要么只存储

TRX_UNDO_UPDATE

大类的undo日志，反正不能混着存，所以在一个事务执行过程中就可能需要2个Undo页面的链表，一个称之为

insert undo

链表，另一个称之为

update undo

链表，画个示意图就是这样：

另外，

InnoDB

对普通表和临时表的记录改动时产生的

undo

日志要分别记录（后边会有讲解），所以在一个事务中最多有4个以

Undo

页面为节点组成的链表：

当然，并不是在事务一开始就会为这个事务分配这4个链表，而是按需分配，具体分配策略如下：

• 刚刚开启事务时，一个Undo页面链表也不分配。
• 当事务执行过程中向普通表中插入记录或者执行更新记录主键- - 的操作之后，就会为其分配一个普通表的insert undo链表。
• 当事务执行过程中删除或者更新了普通表中的记录之后，就会为其分配一个普通表的update undo链表。
• 当事务执行过程中向临时表中插入记录或者执行更新记录主键的操作之后，就会为其分配一个临时表的insert undo链表。
• 当事务执行过程中删除或者更新了临时表中的记录之后，就会为其分配一个临时表的update undo链表。 总结一下就是：什么时候需要啥时候再分配，不需要就不分配。

6.2 多个事务中的Undo页面链表

为了尽可能提高undo日志的写入效率，

不同事务执行过程中产生的undo日志需要被写入到不同的Undo页面链表中

。比如说现在有事务id分别为1、2的两个事务，我们分别称之为

trx 1

和

trx 2

，假设在这两个事务执行过程中：

• trx 1对普通表做了DELETE操作，对临时表做了INSERT和UPDATE操作。InnoDB会为trx 1分配3个链表，分别是： - 针对普通表的update undo链表- 针对临时表的insert undo链表- 针对临时表的update undo链表。
• trx 2对普通表做了INSERT、UPDATE和DELETE操作，没有对临时表做改动。InnoDB会为trx 2分配2个链表，分别是： - 针对普通表的insert undo链表- 针对普通表的update undo链表。

综上所述，在

trx 1

和

trx 2

执行过程中，

InnoDB

共需为这两个事务分配5个

Undo

页面链表，画个图就是这样：

如果有更多的事务，那就意味着可能会产生更多的Undo页面链表。

七、undo日志具体写入过程

7.1 段（Segment）的概念

如果你有认真看过表空间那一章的话，对这个段的概念应该印象深刻，我们当时花了非常大的篇幅来唠叨这个概念。简单讲，这个段是一个逻辑上的概念，本质上是由若干个零散页面和若干个完整的区组成的。比如一个B+树索引被划分成两个段，一个叶子节点段，一个非叶子节点段，这样叶子节点就可以被尽可能的存到一起，非叶子节点被尽可能的存到一起。每一个段对应一个INODE Entry结构，这个INODE Entry结构描述了这个段的各种信息，比如段的ID，段内的各种链表基节点，零散页面的页号有哪些等信息（具体该结构中每个属性的意思大家可以到表空间那一章里再次重温一下）。我们前边也说过，为了定位一个INODE Entry，InnoDB的设计了一个

Segment Header

的结构：

整个

Segment Header

占用10个字节大小，各个属性的意思如下：

• Space ID of the INODE Entry：INODE Entry结构所在的表空间ID。
• Page Number of the INODE Entry：INODE Entry结构所在的页面页号。
• Byte Offset of the INODE Ent：INODE Entry结构在该页面中的偏移量

知道了表空间ID、页号、页内偏移量，不就可以唯一定位一个INODE Entry的地址了么～

**

小提士：

**
这部分关于段的各种概念我们在表空间那一章中都有详细解释，在这里重提一下只是为了唤醒大家沉睡的记忆，如果有任何不清楚的地方可以再次跳回表空间的那一章仔细读一下

7.2 Undo Log Segment Header

InnoDB

的规定，每一个Undo页面链表都对应着一个段，称之为

Undo Log Segment

。也就是说链表中的页面都是从这个段里边申请的，所以他们在Undo页面链表的第一个页面，也就是上边提到的

first undo page

中设计了一个称之为

Undo Log Segment Header

的部分，这个部分中包含了该链表对应的段的

segment header

信息以及其他的一些关于这个段的信息，所以

Undo页

面链表的第一个页面其实长这样：

可以看到这个

Undo链表

的第一个页面比普通页面多了个

Undo Log Segment Header

，我们来看一下它的结构：

其中各个属性的意思如下：

• TRX_UNDO_STATE：本Undo页面链表处在什么状态。一个Undo Log Segment可能处在的状态包括如下：- TRX_UNDO_ACTIVE：活跃状态，也就是一个活跃的事务正在往这个段里边写入undo日志。- TRX_UNDO_CACHED：被缓存的状态。处在该状态的Undo页面链表等待着之后被其他事务重用。- TRX_UNDO_TO_FREE：对于insert undo链表来说，如果在它对应的事务提交之后，该链表不能被重用，那么就会处于这种状态。- TRX_UNDO_TO_PURGE：对于update undo链表来说，如果在它对应的事务提交之后，该链表不能被重用，那么就会处于这种状态。- TRX_UNDO_PREPARED：包含处于PREPARE阶段的事务产生的undo日志> **> > 小提士：> > **> Undo页面链表什么时候会被重用，怎么重用我们之后会详细说的。事务的PREPARE阶段是在所谓的分布式事务中才出现的，本书中不会介绍更多关于分布式事务的事情，所以大家目前忽略这个状态就好了
• TRX_UNDO_LAST_LOG：本Undo页面链表中最后一个Undo Log Header的位置。
• TRX_UNDO_FSEG_HEADER：本Undo页面链表对应的段的Segment Header信息（就是我们上一节介绍的那个10字节结构，通过这个信息可以找到该段对应的INODE Entry）
• TRX_UNDO_PAGE_LIST：Undo页面链表的基节点。我们上边说Undo页面的Undo Page Header部分有一个12字节大小的TRX_UNDO_PAGE_NODE属性，这个属性代表一个List Node结构。每一个Undo页面都包含Undo Page Header结构，这些页面就可以通过这个属性连成一个链表。这个TRX_UNDO_PAGE_LIST属性代表着这个链表的基节点，当然这个基节点只存在于Undo页面链表的第一个页面，也就是first undo page中。

Undo Log Header

一个事务在向

Undo

页面中写入

undo

日志时的方式是十分简单暴力的，就是直接往里写，写完一条紧接着写另一条，各条

undo

日志之间是亲密无间的。写完一个Undo页面后，再从段里申请一个新页面，然后把这个页面插入到Undo页面链表中，继续往这个新申请的页面中写。InnoDB的认为同一个事务向一个Undo页面链表中写入的undo日志算是一个组，比方说我们上边介绍的trx 1由于会分配3个Undo页面链表，也就会写入3个组的undo日志；trx 2由于会分配2个Undo页面链表，也就会写入2个组的undo日志。在每写入一组undo日志时，都会在这组undo日志前先记录一下关于这个组的一些属性，InnoDB把存储这些属性的地方称之为

Undo Log Header

。所以Undo页面链表的第一个页面在真正写入undo日志前，其实都会被填充U

ndo Page Header

、

Undo Log Segment Header

、

Undo Log Header

这3个部分，如图所示：

这个

Undo Log Header

具体的结构如下：

又是一大堆属性，我们先大致看一下它们都是啥意思：

• TRX_UNDO_TRX_ID：生成本组undo日志的事务id
• TRX_UNDO_TRX_NO：事务提交后生成的一个需要序号，使用此序号来标记事务的提交顺序（先提交的此序号小，后提交的此序号大）。
• TRX_UNDO_DEL_MARKS：标记本组undo日志中是否包含由于Delete mark操作产生的undo日志。
• TRX_UNDO_LOG_START：表示本组undo日志中第一条undo日志的在页面中的偏移量。
• TRX_UNDO_XID_EXISTS：本组undo日志是否包含XID信息。
• TRX_UNDO_DICT_TRANS：标记本组undo日志是不是由DDL语句产生的。
• TRX_UNDO_TABLE_ID：如果TRX_UNDO_DICT_TRANS为真，那么本属性表示DDL语句操作的表的table id。
• TRX_UNDO_NEXT_LOG：下一组的undo日志在页面中开始的偏移量。
• TRX_UNDO_PREV_LOG：上一组的undo日志在页面中开始的偏移量。> **> > 小提士：> > **> 一般来说一个Undo页面链表只存储一个事务执行过程中产生的一组undo日志，但是在某些情况下，可能会在一个事务提交之后，之后开启的事务重复利用这个Undo页面链表，这样就会导致一个Undo页面中可能存放多组Undo日志，TRX_UNDO_NEXT_LOG和TRX_UNDO_PREV_LOG就是用来标记下一组和上一组undo日志在页面中的偏移量的。关于什么时候重用Undo页面链表，怎么重用这个链表我们稍后会详细说明的，现在先理解TRX_UNDO_NEXT_LOG和TRX_UNDO_PREV_LOG这两个属性的意思就好了。
• TRX_UNDO_HISTORY_NODE：一个12字节的List Node结构，代表一个称之为History链表的节点。

小结

对于没有被重用的

Undo

页面链表来说，链表的第一个页面，也就是

first undo page

在真正写入

undo

日志前，会填充

Undo Page Header、Undo Log Segment Header、Undo Log Header这3个部分

，之后才开始正式写入undo日志。对于其他的页面来说，也就是

normal undo page

在真正写入

undo

日志前，只会填充

Undo Page Header

。链表的

List Base Node

存放到

first undo page的Undo Log Segment Header部分

，

List Node

信息存放到每一个

Undo

页面的

undo Page Header

部分，所以画一个

Undo

页面链表的示意图就是这样：

八、重用Undo页面

我们前边说为了能提高并发执行的多个事务写入

undo

日志的性能，

InnoDB

决定为每个事务单独分配相应的

Undo

页面链表（最多可能单独分配4个链表）。但是这样也造成了一些问题，比如其实大部分事务执行过程中可能只修改了一条或几条记录，针对某个Undo页面链表只产生了非常少的undo日志，这些undo日志可能只占用一丢丢存储空间，每开启一个事务就新创建一个

Undo

页面链表（虽然这个链表中只有一个页面）来存储这么一丢丢undo日志岂不是太浪费了么？的确是挺浪费，于是InnoDB决定在事务提交后在某些情况下重用该事务的

Undo

页面链表。一个

Undo

页面链表是否可以被重用的条件很简单：

• 该链表中只包含一个Undo页面 如果一个事务执行过程中产生了非常多的undo日志，那么它可能申请非常多的页面加入到Undo页面链表中。在该事物提交后，如果将整个链表中的页面都重用，那就意味着即使新的事务并没有向该Undo页面链表中写入很多undo日志，那该链表中也得维护非常多的页面，那些用不到的页面也不能被别的事务所使用，这样就造成了另一种浪费。所以InnoDB的规定，只有在Undo页面链表中只包含一个Undo页面时，该链表才可以被下一个事务所重用
• 该Undo页面已经使用的空间小于整个页面空间的3/4 我们前边说过，Undo页面链表按照存储的undo日志所属的大类可以被分为insert undo链表和update undo链表两种，这两种链表在被重用时的策略也是不同的，我们分别看一下- insert undo链表insert undo链表中只存储类型为TRX_UNDO_INSERT_REC的undo日志，这种类型的undo日志在事务提交之后就没用了，就可以被清除掉。所以在某个事务提交后，重用这个事务的insert undo链表（这个链表中只有一个页面）时，可以直接把之前事务写入的一组undo日志覆盖掉，从头开始写入新事务的一组undo日志，如下图所示： 如图所示，假设有一个事务使用的insert undo链表，到事务提交时，只向insert undo链表中插入了3条undo日志，这个insert undo链表只申请了一个Undo页面。假设此刻该页面已使用的空间小于整个页面大小的3/4，那么下一个事务就可以重用这个insert undo链表（链表中只有一个页面）。假设此时有一个新事务重用了该insert undo链表，那么可以直接把旧的一组undo日志覆盖掉，写入一组新的undo日志。- update undo链表 在一个事务提交后，它的update undo链表中的undo日志也不能立即删除掉（这些日志用于MVCC，我们后边会说的）。所以如果之后的事务想重用update undo链表时，就不能覆盖之前事务写入的undo日志。这样就相当于在同一个Undo页面中写入了多组的undo日志，效果看起来就是这样

九、回滚段

9.1 回滚段的概念

我们现在知道一个事务在执行过程中最多可以分配4个

Undo

页面链表，在同一时刻不同事务拥有的

Undo

页面链表是不一样的，所以在同一时刻系统里其实可以有许许多多个Undo页面链表存在。为了更好的管理这些链表，

InnoDB

又设计了一个称之为

Rollback Segment Header

的页面，在这个页面中存放了各个

Undo

页面链表的

frist undo page

的页号，他们把这些页号称之为

undo slot

。我们可以这样理解，每个

Undo

页面链表都相当于是一个班，这个链表的

first undo page

就相当于这个班的班长，找到了这个班的班长，就可以找到班里的其他同学（其他同学相当于

normal undo page

）。有时候学校需要向这些班级传达一下精神，就需要把班长都召集在会议室，这个

Rollback Segment Header

就相当于是一个会议室。

我们看一下这个称之为

Rollback Segment Header

的页面长啥样（以默认的16KB为例）：

InnoDB

规定，每一个

Rollback Segment Header

页面都对应着一个段，这个段就称为

Rollback Segment

，也就是

回滚段

。与我们之前介绍的各种段不同的是，这个

Rollback Segment

里其实只有一个页面（这可能是

InnoDB

可能觉得为了某个目的去分配页面的话都得先申请一个段，或者他们觉得虽然目前版本的

MySQL

里

Rollback Segment

里其实只有一个页面，但可能之后的版本里会增加页面也说不定）。

了解了

Rollback Segment

的含义之后，我们再来看看这个称之为

Rollback Segment Header

的页面的各个部分的含义都是啥意思：

• TRX_RSEG_MAX_SIZE：本Rollback Segment中管理的所有Undo页面链表中的Undo页面数量之和的最大值。换句话说，本Rollback Segment中所有Undo页面链表中的Undo页面数量之和不能超过TRX_RSEG_MAX_SIZE代表的值。该属性的值默认为无限大，也就是我们想写多少Undo页面都可以。> **> > 小提士：> > **> 无限大其实也只是个夸张的说法，4个字节能表示最大的数也就是0xFFFFFFFF，但是我们之后会看到，0xFFFFFFFF这个数有特殊用途，所以实际上TRX_RSEG_MAX_SIZE的值为0xFFFFFFFE。
• TRX_RSEG_HISTORY_SIZE：History链表占用的页面数量。
• TRX_RSEG_HISTORY：History链表的基节点。
• TRX_RSEG_FSEG_HEADER：本Rollback Segment对应的10字节大小的Segment Header结构，通过它可以找到本段对应的INODE Entry。

TRX_RSEG_UNDO_SLOTS

：各个

Undo

页面链表的

first undo page

的页号集合，也就是

undo slot

集合。

一个页号占用

4

个字节，对于

16KB

大小的页面来说，这个

TRX_RSEG_UNDO_SLOTS

部分共存储了

1024

个

undo slot

，所以共需1

024 × 4 = 4096个字节

9.2 从回滚段中申请Undo页面链表

初始情况下，由于未向任何事务分配任何

Undo

页面链表，所以对于一个

Rollback Segment Header

页面来说，它的各个

undo slot

都被设置成了一个特殊的值：

FIL_NULL

（对应的十六进制就是0xFFFFFFFF），表示该

undo slot

不指向任何页面。

随着时间的流逝，开始有事务需要分配

Undo

页面链表了，就从回滚段的第一个

undo slot

开始，看看该

undo slot

的值是不是

FIL_NULL

：

• 如果是FIL_NULL，那么在表空间中新创建一个段（也就是Undo Log Segment），然后从段里申请一个页面作为Undo页面链表的first undo page，然后把该undo slot的值设置为刚刚申请的这个页面的页号，这样也就意味着这个undo slot被分配给了这个事务。
• 如果不是FIL_NULL，说明该undo slot已经指向了一个undo链表，也就是说这个undo slot已经被别的事务占用了，那就跳到下一个undo slot，判断该undo slot的值是不是FIL_NULL，重复上边的步骤。

一个

Rollback Segment Header

页面中包含

1024个undo slot

，如果这

1024

个

undo slot

的值都不为

FIL_NULL

，这就意味着这

1024

个

undo slot

都已经名花有主（被分配给了某个事务），此时由于新事务无法再获得新的

Undo

页面链表，就会回滚这个事务并且给用户报错：

Too many active concurrent transactions

用户看到这个错误，可以选择重新执行这个事务（可能重新执行时有别的事务提交了，该事务就可以被分配

Undo

页面链表了）。

当一个事务提交时，它所占用的

undo slot

有两种命运：

• 如果该undo slot指向的Undo页面链表符合被重用的条件（就是我们上边说的Undo页面链表只占用一个页面并且已使用空间小于整个页面的3/4）。该undo slot就处于被缓存的状态，InnoDB规定这时该Undo页面链表的TRX_UNDO_STATE属性（该属性在first undo page的Undo Log Segment Header部分）会被设置为TRX_UNDO_CACHED。被缓存的undo slot都会被加入到一个链表，根据对应的Undo页面链表的类型不同，也会被加入到不同的链表：- 如果对应的Undo页面链表是insert undo链表，则该undo slot会被加入insert undo cached链表。- 如果对应的Undo页面链表是update undo链表，则该undo slot会被加入update undo cached链表。一个回滚段就对应着上述两个cached链表，如果有新事务要分配undo slot时，先从对应的cached链表中找。如果没有被缓存的undo slot，才会到回滚段的Rollback Segment Header页面中再去找。
• 如果该undo slot指向的Undo页面链表不符合被重用的条件，那么针对该undo slot对应的Undo页面链表类型不同，也会有不同的处理：
• 如果对应的Undo页面链表是insert undo链表，则该Undo页面链表的TRX_UNDO_STATE属性会被设置为TRX_UNDO_TO_FREE，之后该Undo页面链表对应的段会被释放掉（也就意味着段中的页面可以被挪作他用），然后把该undo slot的值设置为FIL_NULL。
• 如果对应的Undo页面链表是update undo链表，则该Undo页面链表的TRX_UNDO_STATE属性会被设置为TRX_UNDO_TO_PRUGE，则会将该undo slot的值设置为FIL_NULL，然后将本次事务写入的一组undo日志放到所谓的History链表中（需要注意的是，这里并不会将Undo页面链表对应的段给释放掉，因为这些undo日志还有用呢～）

9.3 多个回滚段

我们说一个事务执行过程中最多分配

4个Undo页面链表

，而一个回滚段里只有

1024个undo slot

，很显然

undo slot

的数量有点少啊。我们即使假设一个读写事务执行过程中只分配

1

个

Undo

页面链表，那

1024

个

undo slot

也只能支持

1024

个读写事务同时执行，再多了就崩溃了。这就相当于会议室只能容下

1024

个班长同时开会，如果有几千人同时到会议室开会的话，那后来的那些班长就没地方坐了，只能等待前边的人开完会自己再进去开。

话说在

InnoDB

的早期发展阶段的确只有一个回滚段，但是

InnoDB

后来意识到了这个问题，咋解决这问题呢？会议室不够，多盖几个会议室不就得了。所以

InnoDB

一口气定义了

128

个回滚段，也就相当于有了

128 × 1024 = 131072个undo slot

。假设一个读写事务执行过程中只分配

1

个

Undo

页面链表，那么就可以同时支持

131072

个读写事务并发执行（这么多事务在一台机器上并发执行，还真没见过呢～）

每个回滚段都对应着一个

Rollback Segment Header

页面，有

128

个回滚段，自然就要有

128

个

Rollback Segment Header

页面，这些页面的地址总得找个地方存一下吧！于是

InnoDB

在系统表空间的第

5

号页面的某个区域包含了128个8字节大小的格子：

每个8字节的格子的构造就像这样：

如果所示，每个8字节的格子其实由两部分组成：

• 4字节大小的Space ID，代表一个表空间的ID。
• 4字节大小的Page number，代表一个页号。

也就是说每个8字节大小的

格子

相当于一个指针，指向某个表空间中的某个页面，这些页面就是

Rollback Segment Header

。这里需要注意的一点事，要定位一个Rollback Segment Header还需要知道对应的表空间ID，这也就意味着不同的回滚段可能分布在不同的表空间中。

所以通过上边的叙述我们可以大致清楚，在系统表空间的第

5

号页面中存储了

128

个

Rollback Segment Header

页面地址，每个

Rollback Segment Header

就相当于一个回滚段。在

Rollback Segment Header

页面中，又包含

1024个undo slot

，每个

undo slot

都对应一个

Undo

页面链表。我们画个示意图：

把图一画出来就清爽多了。

9.4 回滚段的分类

我们把这128个回滚段给编一下号，最开始的回滚段称之为第0号回滚段，之后依次递增，最后一个回滚段就称之为第127号回滚段。这128个回滚段可以被分成两大类：

• 第0号、第33～127号回滚段属于一类。其中第0号回滚段必须在系统表空间中（就是说第0号回滚段对应的Rollback Segment Header页面必须在系统表空间中），第33～127号回滚段既可以在系统表空间中，也可以在自己配置的undo表空间中，关于怎么配置我们稍后再说。如果一个事务在执行过程中由于对普通表的记录做了改动需要分配Undo页面链表时，必须从这一类的段中分配相应的undo slot。
• 第1～32号回滚段属于一类。这些回滚段必须在临时表空间（对应着数据目录中的ibtmp1文件）中。如果一个事务在执行过程中由于对临时表的记录做了改动需要分配Undo页面链表时，必须从这一类的段中分配相应的undo slot。

也就是说如果一个事务在执行过程中既对普通表的记录做了改动，又对临时表的记录做了改动，那么需要为这个记录分配2个回滚段，再分别到这两个回滚段中分配对应的

undo slot

。

不知道大家有没有疑惑，为啥要把针对普通表和临时表来划分不同种类的回滚段呢？这个还得从

Undo

页面本身说起，我们说

Undo

页面其实是类型为

FIL_PAGE_UNDO_LOG

的页面的简称，说到底它也是一个普通的页面。我们前边说过，在修改页面之前一定要先把对应的

redo

日志写上，这样在系统奔溃重启时才能恢复到奔溃前的状态。我们向

Undo

页面写入

undo

日志本身也是一个写页面的过程，

InnoDB

为此还设计了许多种

redo

日志的类型，比方说

MLOG_UNDO_HDR_CREATE

、

MLOG_UNDO_INSERT

、

MLOG_UNDO_INIT

等等，也就是说我们对

Undo

页面做的任何改动都会记录相应类型的

redo

日志。但是对于临时表来说，因为修改临时表而产生的

undo

日志只需要在系统运行过程中有效，如果系统奔溃了，那么在重启时也不需要恢复这些

undo

日志所在的页面，所以在写针对临时表的

Undo

页面时，并不需要记录相应的

redo

日志。总结一下针对普通表和临时表划分不同种类的回滚段的原因：在修改针对普通表的回滚段中的

Undo

页面时，需要记录对应的

redo

日志，而修改针对临时表的回滚段中的

Undo

页面时，不需要记录对应的

redo

日志。

**

小提士：

**
如果我们仅仅对普通表的记录做了改动，那么只会为该事务分配针对普通表的回滚段，不分配针对临时表的回滚段。但是如果我们仅仅对临时表的记录做了改动，那么既会为该事务分配针对普通表的回滚段，又会为其分配针对临时表的回滚段（不过分配了回滚段并不会立即分配undo slot，只有在真正需要Undo页面链表时才会去分配回滚段中的undo slot）。

9.5 为事务分配Undo页面链表详细过程

上边说了一大堆的概念，大家应该有一点点的小晕，接下来我们以事务对普通表的记录做改动为例，给大家梳理一下事务执行过程中分配

Undo页面

链表时的完整过程，

• 事务在执行过程中对普通表的记录首次做改动之前，首先会到系统表空间的第5号页面中分配一个回滚段（其实就是获取一个Rollback Segment Header页面的地址）。一旦某个回滚段被分配给了这个事务，那么之后该事务中再对普通表的记录做改动时，就不会重复分配了。使用传说中的round-robin（循环使用）方式来分配回滚段。比如当前事务分配了第0号回滚段，那么下一个事务就要分配第33号回滚段，下下个事务就要分配第34号回滚段，简单一点的说就是这些回滚段被轮着分配给不同的事务（就是这么简单粗暴，没啥好说的）。
• 在分配到回滚段后，首先看一下这个回滚段的两个cached链表有没有已经缓存了的undo slot，比如如果事务做的是INSERT操作，就去回滚段对应的insert undo cached链表中看看有没有缓存的undo slot；如果事务做的是DELETE操作，就去回滚段对应的update undo cached链表中看看有没有缓存的undo slot。如果有缓存的undo slot，那么就把这个缓存的undo slot分配给该事务。
• 如果没有缓存的undo slot可供分配，那么就要到Rollback Segment Header页面中找一个可用的undo slot分配给当前事务。从Rollback Segment Header页面中分配可用的undo slot的方式我们上边也说过了，就是从第0个undo slot开始，如果该undo slot的值为FIL_NULL，意味着这个undo slot是空闲的，就把这个undo slot分配给当前事务，否则查看第1个undo slot是否满足条件，依次类推，直到最后一个undo slot。如果这1024个undo slot都没有值为FIL_NULL的情况，就直接报错喽（一般不会出现这种情况）～
• 找到可用的undo slot后，如果该undo slot是从cached链表中获取的，那么它对应的Undo Log Segment已经分配了，否则的话需要重新分配一个Undo Log Segment，然后从该Undo Log Segment中申请一个页面作为Undo页面链表的first undo page。
• 然后事务就可以把undo日志写入到上边申请的Undo页面链表了！

对临时表的记录做改动的步骤和上述的一样，就不赘述了。不过需要再次强调一次，如果一个事务在执行过程中既对普通表的记录做了改动，又对临时表的记录做了改动，那么需要为这个记录分配2个回滚段。并发执行的不同事务其实也可以被分配相同的回滚段，只要分配不同的

undo slot

就可以了。

9.6 回滚段相关配置

9.6.1 配置回滚段数量

我们前边说系统中一共有

128

个回滚段，其实这只是默认值，我们可以通过启动参数

innodb_rollback_segments

来配置回滚段的数量，可配置的范围是

1~128

。但是这个参数并不会影响针对临时表的回滚段数量，针对临时表的回滚段数量一直是

32

，也就是说：

• 如果我们把innodb_rollback_segments的值设置为1，那么只会有1个针对普通表的可用回滚段，但是仍然有32个针对临时表的可用回滚段。
• 如果我们把innodb_rollback_segments的值设置为2～33之间的数，效果和将其设置为1是一样的。
• 如果我们把innodb_rollback_segments设置为大于33的数，那么针对普通表的可用回滚段数量就是该值减去32。

9.6.2 配置undo表空间

默认情况下，针对普通表设立的回滚段（第

0

号以及第

33~127

号回滚段）都是被分配到系统表空间的。其中的第

0

号回滚段是一直在系统表空间的，但是第

33~127

号回滚段可以通过配置放到自定义的

undo

表空间中。但是这种配置只能在系统初始化（创建数据目录时）的时候使用，一旦初始化完成，之后就不能再次更改了。我们看一下相关启动参数：

• 通过innodb_undo_directory指定undo表空间所在的目录，如果没有指定该参数，则默认undo表空间所在的目录就是数据目录。
• 通过innodb_undo_tablespaces定义undo表空间的数量。该参数的默认值为0，表明不创建任何undo表空间。第33~127号回滚段可以平均分布到不同的undo表空间中。

**

小提士：

**
如果我们在系统初始化的时候指定了创建了undo表空间，那么系统表空间中的第0号回滚段将处于不可用状态。

比如我们在系统初始化时指定的

innodb_rollback_segments

为

35

，

innodb_undo_tablespaces

为

2

，这样就会将第

33

、

34

号回滚段分别分布到一个

undo

表空间中。

设立

undo表空间

的一个好处就是在

undo

表空间中的文件大到一定程度时，可以自动的将该

undo表空间截断

（

truncate

）成一个小文件。而系统表空间的大小只能不断的增大，却不能截断。