MySQL · 源码分析 · 临时表与TempTable存储引擎Allocator

本文基于MySQL Community 8.0.25 Version

临时表创建

显式创建临时表

临时表可使用 CREATE TEMPORARY TABLE 语句创建，它仅在当前session中可以使用，session断开时临时表会被自动drop掉。因此开启不同的session时可以使用相同的临时表名。


1. CREATE TEMPORARY TABLE temp_table (id int primary key auto_increment, payload int);
2. INSERT INTO temp_table (payload) VALUES (100), (200), (300);

8.0.13 版本后的MySQL的默认临时表存储引擎是 TempTable。 可以在创建临时表时指定存储引擎，如指定使用 Memory：


1. CREATE TEMPORARY TABLE temp_table_memory (x int) ENGINE=MEMORY;

隐式创建临时表

一些情况下，server在执行语句时会创建内部临时表，用户无法对此进行直接控制。如：

  • UNION 语句
  • 派生表（即在查询的FROM 子句中生成的表）
  • 通用表表达式（WITH 子句下的表达式）
  • DISTINCT 组合 ORDER BY
  • INSERT...SELECT 语句。MySQL会创建内部临时表保存SELECT 的结果，并将这些row INSERT 到目标表中
  • 窗口函数
  • GROUP_CONCAT()、COUNT(DISTINCT) 表达式

如何判断SQL语句是否隐式使用了临时表：使用EXPLAIN语句并检查EXTRA 列，若显示Using temporary，则说明使用了临时表。

临时表存储引擎

Memory

在MySQL 8.0.13版本引入TempTable 存储引擎前，使用Memory 存储引擎来创建内存中的临时表。

但是它有不足之处如下：

  • 不支持含有BLOB或TEXT类型的表，这种情况在8.0.13版本前只能将临时表建在disk上
  • 对于VARCHAR类型的字段，如VARCHAR(200)，映射到内存里处理的字段变为CHAR(200)，容易造成空间浪费

### InnoDB / MyISAM

MySQL 8.0.16及以后，server使用InnoDB 存储引擎在disk上创建临时表。internal_tmp_disk_storage_engine 变量已被删除，用户无法再自定义选择MyISAM 存储引擎。

### TempTable

MySQL 8.0.13版本引入 TempTable 存储引擎，此后TempTable 成为在内存中创建临时表的默认存储引擎。使用internal_tmp_mem_storage_engine可以指定内存中创建临时表的存储引擎（另一个是MEMORY）。 相较于MEMORY 存储引擎，TempTable 存储引擎可以支持变长数据类型的存储。

TempTable 内存分配策略及源码分析

MySQL 8.0.23版本之后引入temptable_max_mmap 变量，因此本次分析针对8.0.23版本后的策略及其源码。

内存分配策略

  • 若临时表分配空间未超过temptable_max_ram值，则使用TempTable存储引擎在RAM中为临时表分配空间
  • 若临时表大小超过了temptable_max_ram值
  • 若temptable_use_mmap=on且temptable_max_mmap > 0，则从memory-maped file中为临时表分配空间
    • 在此分配过程中，若临时表大小小于了temptable_max_ram值，则可以继续从RAM中分配空间
    • 若临时表大小超过了temptable_max_mmap值，则使用InnoDB 临时表从disk上分配空间，并将内存中的临时表迁移到disk上
  • 若temptable_use_mmap=off或temptable_max_mmap=0，则使用InnoDB 存储引擎从disk上分配空间，并将内存中的临时表迁移到disk上

源码分析

Allocator类及RAM、MMAP空间分配

TempTable 存储引擎分配空间由Allocator类完成，位于storage/temptable/include/temptable/allocator.h。


1. template <class T,
2. class AllocationScheme = Exponential_growth_preferring_RAM_over_MMAP>
3. class Allocator {
4. ...

首先可以看到Allocator类有一个模版参数类AllocationScheme


1. template <typename Block_size_policy, typename Block_source_policy>
2. struct Allocation_scheme {
3. static Source block_source(size_t block_size) {
4. return Block_source_policy::block_source(block_size);
5. }
6. static size_t block_size(size_t number_of_blocks, size_t n_bytes_requested) {
7. return Block_size_policy::block_size(number_of_blocks, n_bytes_requested);
8. }
9. };

它用来控制Allocator的分配机制。其中block_size()方法会指定每次分配的Block大小，block_source()方法会指定存储介质使用策略。

Allocator的默认模版参数为Exponential_growth_preferring_RAM_over_MMAP，其具体为：


1. using Exponential_growth_preferring_RAM_over_MMAP =
2. Allocation_scheme<Exponential_policy, Prefer_RAM_over_MMAP_policy>;

可以看到，默认的block_size的分配策略为Exponential_policy、block_source策略为Prefer_RAM_over_MMAP_policy。


1. struct Exponential_policy {
2. static size_t block_size(size_t number_of_blocks, size_t n_bytes_requested) {
3. size_t block_size_hint;
4. if (number_of_blocks < ALLOCATOR_MAX_BLOCK_MB_EXP) {
5. block_size_hint = (1ULL << number_of_blocks) * 1_MiB;
6. } else {
7. block_size_hint = ALLOCATOR_MAX_BLOCK_BYTES;
8. }
9. return std::max(block_size_hint, Block::size_hint(n_bytes_requested));
10. }
11. };

由上述代码可见，Exponential_policy的block_size()方法每次分配的block大小block_size_hint是指数级增加的，直到到了最大值ALLOCATOR_MAX_BLOCK_BYTES，此后每次分配的block的大小都是ALLOCATOR_MAX_BLOCK_BYTES。若函数调用者请求的block大小大于block_size_hint，则返回该请求大小，即使它可能大于ALLOCATOR_MAX_BLOCK_BYTES。


1. struct Prefer_RAM_over_MMAP_policy {
2. static Source block_source(uint32_t block_size) {
3. if (MemoryMonitor::RAM::consumption() < MemoryMonitor::RAM::threshold()) {
4. if (MemoryMonitor::RAM::increase(block_size) <=
5. MemoryMonitor::RAM::threshold()) {
6. return Source::RAM;
7. } else {
8. MemoryMonitor::RAM::decrease(block_size);
9. }
10. }
11. if (MemoryMonitor::MMAP::consumption() < MemoryMonitor::MMAP::threshold()) {
12. if (MemoryMonitor::MMAP::increase(block_size) <=
13. MemoryMonitor::MMAP::threshold()) {
14. return Source::MMAP_FILE;
15. } else {
16. MemoryMonitor::MMAP::decrease(block_size);
17. }
18. }
19. throw Result::RECORD_FILE_FULL;
20. }
21. };

由上述代码可见，Allocator会首先在RAM分配空间，若RAM消耗超过了RAM::threshold()，即temptable_max_ram，则会开始尝试在mmap files上分配空间。 MMAP::threshold()代码为：


1. static size_t threshold() {
2. if (temptable_use_mmap) {
3. return temptable_max_mmap;
4. } else {
5. return 0;
6. }
7. }

若temptable_use_mmap=false，threashold()函数返回0；当temptable_max_mmap=0时，threshold() 函数实际返回的也是0。这两种情况下不会在mmap file上分配空间，而是直接抛出Result::RECORD_FILE_FULL异常。所以可以看到temptable_max_mmap=0实际上是等价于temptable_use_mmap=false的。

当temptable_use_map=true、temptable_max_mmap>0且mmap file分配空间小于temptable_max_mmap时，Allocator会在mmap file上为临时表分配空间。

如果在此过程中，RAM分配使用空间小于了temptable_max_ram，则还会优先从RAM分配空间。

Allocator类的allocate(size_t)方法会调用以上方法为临时表进行空间的分配：


1. else if (m_state->current_block.is_empty() ||
2. !m_state->current_block.can_accommodate(n_bytes_requested)) {
3. const size_t block_size = AllocationScheme::block_size(
4. m_state->number_of_blocks, n_bytes_requested);
5. m_state->current_block =
6. Block(block_size, AllocationScheme::block_source(block_size));
7. block = &m_state->current_block;
8. ++m_state->number_of_blocks;
9. }

当当前block为空时，需要进行空间分配，会调用Block构造函数为current_block分配空间，Block构造函数中会掉用上述的Exponential_policy::block_size()方法进行空间分配大小计算以及调用Prefer_RAM_over_MMAP_policy::block_source()进行存储介质的选择以及空间分配。

disk空间分配

由上述代码可知，RAM空间不够且mmap file不允许使用或mmap file空间不够时，TempTable 存储引擎会抛出Result::RECORD_FILE_FULL异常，即HA_ERR_RECORD_FILE_FULL异常。

此时MySQL会将临时表迁移到disk上，由于使用的是InnoDB 存储引擎，所以在disk上建临时表的代码自然不会在storage/temptable路径下，而是在更上层的server层。

此功能的代码逻辑为：当server层调用ha_write_row向临时表中写入row时，同时会调用create_ondisk_from_heap()函数。

如sql/sql_union.cc的 Query_result_union::send_data()函数中：


1. const int error = table->file->ha_write_row(table->record[0]);
2. if (!error) {
3. m_rows_in_table++;
4. return false;
5. }
6. // create_ondisk_from_heap will generate error if needed
7. if (!table->file->is_ignorable_error(error)) {
8. bool is_duplicate;
9. if (create_ondisk_from_heap(thd, table, error, true, &is_duplicate))
10. return true; /* purecov: inspected */
11. // Table's engine changed, index is not initialized anymore
12. if (table->hash_field) table->file->ha_index_init(0, false);
13. if (!is_duplicate) m_rows_in_table++;
14. }

create_ondisk_from_heap()函数的作用是当接受到HA_ERR_RECORD_FILE_FULL异常时，即内存中的表已满时，会将该表迁移到disk上。

create_ondisk_from_heap()函数中，当接收到的error不是HA_ERR_RECORD_FILE_FULL时，会直接返回：


1. if (error != HA_ERR_RECORD_FILE_FULL) {
2. /*
3. We don't want this error to be converted to a warning, e.g. in case of
4. INSERT IGNORE ... SELECT.
5. */
6. wtable->file->print_error(error, MYF(ME_FATALERROR));
7. return true;
8. }

它会使用InnoDB 存储引擎创建新的表：


1. share.db_plugin = ha_lock_engine(thd, innodb_hton);
2. // ...
3. new_table.s = &share;  // New table points to new share

5. new_table.file =
6. get_new_handler(&share, false, old_share->alloc_for_tmp_file_handler,
7. new_table.s->db_type());

并将临时表迁移到该位于disk的表上：


1. /*
2. copy all old rows from heap table to on-disk table
3. This is the only code that uses record[1] to read/write but this
4. is safe as this is a temporary on-disk table without timestamp/
5. autoincrement or partitioning.
6. */
7. while (!table->file->ha_rnd_next(new_table.record[1])) {
8. write_err = new_table.file->ha_write_row(new_table.record[1]);
9. DBUG_EXECUTE_IF("raise_error", write_err = HA_ERR_FOUND_DUPP_KEY;);
10. if (write_err) goto err_after_open;
11. }
12. /* copy row that filled HEAP table */
13. if ((write_err = new_table.file->ha_write_row(table->record[0]))) {
14. if (!new_table.file->is_ignorable_error(write_err) ||
15. !ignore_last_dup)
16. goto err_after_open;
17. if (is_duplicate) *is_duplicate = true;
18. } else {
19. if (is_duplicate) *is_duplicate = false;
20. }

参考资料

Internal Temporary Table Use in MySQL MySQL · 引擎特性 · 临时表改进 MySQL 8.0: Support for BLOBs in TempTable engine Temporary Tables in MySQL mysql-server 8.0.25 Source Code/

原文：http://mysql.taobao.org/monthly/2021/07/07/