登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›CTE查询数据量过大导致MySQL 8.0发生CORE问题解析 ...

CTE查询数据量过大导致MySQL 8.0发生CORE问题解析

敖雨燕 2025-9-26 11:30:32
CTE查询数据量过大导致MySQL 8.0发生CORE问题解析

一、问题发现

在客户现场的一次问题报告中发现某个带有CTE语句进行查询的时候，数据量少的时候没问题，但是数据量大的时候会导致core。注意：这个问题只在 MySQL 8.0.32 版本才会复现，最新的8.4.4版本没有问题。
看下面例子：
1、准备表
  1. CREATE TABLE t1 (
  2.   ORG_ID decimal(12,0) NOT NULL,
  3.   ORG_NAME varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL,
  4.   ORG_CODE varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL,
  5.   ORG_TYPE varchar(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT (_utf8mb4'01'),
  6.   ORG_LEVEL varchar(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  7.   PORG_ID decimal(12,0) DEFAULT NULL,
  8.   ORG_STATE varchar(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL,
  9.   COMMENTS varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  10.   MANAGER_FLAG varchar(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  11.   SOET_WEEKLY varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  12.   CONTACT_NAME varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  13.   CONTACT_TELEPHONE decimal(32,0) DEFAULT NULL,
  14.   OTHER_TELEPHONE decimal(32,0) DEFAULT NULL,
  15.   OFFICE_ADDR varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  16.   PROVINCE varchar(3) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  17.   CITY varchar(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  18.   COUNTRY varchar(6) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  19.   ORG_CLASS varchar(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  20.   UPDATE_TIME datetime DEFAULT NULL,
  21.   OPERATE_TYPE varchar(3) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  22.   CREATE_TIME datetime DEFAULT NULL,
  23.   KEY IDX_t1 (ORG_ID,PORG_ID),
  24.   KEY INX_ESOP_ORG_OID (ORG_ID),
  25.   KEY IDX_PROVINCE_CITY (PROVINCE,CITY)
  26. );
  27. INSERT INTO t1 VALUES(29100709,'数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识',29100709,01,5,291007,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,290,9150,915009,02,'2018-02-09 04:19:00',1,'2017-11-15 00:00:00');
  28. INSERT INTO t1 VALUES(29100708,'数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识',29100709,01,5,291007,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,290,9150,915009,02,'2018-02-09 04:19:00',1,'2017-11-15 00:00:00');
  29. INSERT INTO t1 VALUES(29100707,'数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识数据库数据知识',29100709,01,5,291007,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,290,9150,915009,02,'2018-02-09 04:19:00',1,'2017-11-15 00:00:00');
  30. INSERT INTO t1 SELECT * FROM t1;
  31. INSERT INTO t1 SELECT * FROM t1;
  33. CREATE TABLE t2 (
  34.   USER_ID decimal(14,0) NOT NULL,
  35.   USER_NAME varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL,
  36.   NICK_NAME varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  37.   USER_CODE varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL,
  38.   PASS_WORD varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  39.   ORG_ID decimal(12,0) DEFAULT NULL,
  40.   POSITION varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  41.   FUNCTIONS varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  42.   MOBILE_NO varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  43.   EXTENSION_NO varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  44.   EMAIL varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  45.   STATE varchar(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  46.   COMMENTS varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  47.   SCORE decimal(10,0) DEFAULT NULL,
  48.   IDCARD varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  49.   AUDIT_STATE decimal(1,0) DEFAULT NULL,
  50.   UPDATE_TIME datetime DEFAULT NULL,
  51.   OPERATE_TYPE varchar(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  52.   MAPPINGCODE varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin DEFAULT NULL,
  53.   CREATE_TIME datetime DEFAULT NULL,
  54.   KEY IDX_t2_ID (USER_ID,USER_CODE),
  55.   KEY INX_EUS_MCOD (MAPPINGCODE),
  56.   KEY INX_EUERS_UNM (USER_NAME),
  57.   KEY IDX_t2_MOBILE_NO (MOBILE_NO),
  58.   KEY INX_ESOP_USR_ID (USER_ID),
  59.   KEY IDX_t2_USER_CODE (USER_CODE),
  60.   KEY IDX_ORG_ID (ORG_ID)
  61. );
  62. INSERT INTO t2(USER_ID, user_name, user_code, org_id) VALUES(1001, 'daizhong', 'daizhong', 1);
  63. INSERT INTO t2(USER_ID, user_name, user_code, org_id) VALUES(1002, 'daizhong1', 'daizhong1', 29100709);
  64. INSERT INTO t2(USER_ID, user_name, user_code, org_id) VALUES(1003, 'daizhong1', 'daizhong1', 29100708);
  65. INSERT INTO t2(USER_ID, user_name, user_code, org_id) VALUES(1003, 'daizhong1', 'daizhong1', 29100707);
  66. INSERT INTO t2 SELECT * FROM t2;
  67. INSERT INTO t2 SELECT * FROM t2;
复制代码
2、tmp_table_size为默认值场合
如下所示用默认tmp_table_size并且进行CTE派生表查询，可以发现结果正常显示一条数据，符合预期。
  1. -- tmp_table_size参数为默认值的情况
  2. greatsql> SHOW variables LIKE '%tmp_table_size%';
  3. +----------------+----------+
  4. | Variable_name  | Value    |
  5. +----------------+----------+
  6. | tmp_table_size | 16777216 |
  7. +----------------+----------+
  9. greatsql> WITH RECURSIVE cte_tree AS ( SELECT 1 AS LEVEL, t.org_id,t.org_id as porg_id,user_name, nick_name, user_code FROM t2 t UNION ALL SELECT LEVEL + 1 AS LEVEL, pt.org_id,pt.porg_id,pt.ORG_NAME,pt.CONTACT_NAME,pt.ORG_CODE FROM t1 pt JOIN cte_tree ct ON pt.org_id = ct.porg_id )  SELECT a.* FROM cte_tree a limit 1;
  10. +-------+--------+---------+-----------+-----------+-----------+
  11. | LEVEL | org_id | porg_id | user_name | nick_name | user_code |
  12. +-------+--------+---------+-----------+-----------+-----------+
  13. |     1 |      1 |       1 | daizhong  | NULL      | daizhong  |
  14. +-------+--------+---------+-----------+-----------+-----------+
复制代码
3、tmp_table_size修改小的场合
为了不让之前的临时表影响RAM内存的阈值，重新启动数据库。然后执行以下命令。
  1. -- 设置tmp_table_size参数值比临时表数据大的情况
  2. greatsql> SET tmp_table_size=1342;
  4. -- 以下同样的命令导致core
  5. greatsql> WITH RECURSIVE cte_tree AS ( SELECT 1 AS LEVEL, t.org_id,t.org_id as porg_id,user_name, nick_name, user_code FROM t2 t UNION ALL SELECT LEVEL + 1 AS LEVEL, pt.org_id,pt.porg_id,pt.ORG_NAME,pt.CONTACT_NAME,pt.ORG_CODE FROM t1 pt JOIN cte_tree ct ON pt.org_id = ct.porg_id )  SELECT a.* FROM cte_tree a limit 1;
  7. core堆栈如下：
  8. Thread 56 "mysqld" received signal SIGABRT, Aborted.
  9. __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
  10. 50        ../sysdeps/unix/sysv/linux/raise.c: No such file or directory.
  11. (gdb) bt
  12. #0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
  13. #1  0x00007ffff7508859 in __GI_abort () at abort.c:79
  14. #2  0x00007ffff7508729 in __assert_fail_base (
  15.     fmt=0x7ffff769e588 "%s%s%s:%u: %s%sAssertion `%s' failed.\n%n",
  16.     assertion=0x55555dd91569 "m_opened_table != nullptr",
  17.     file=0x55555dd91510 "storage/temptable/include/temptable/handler.h", line=563, function=<optimized out>) at assert.c:94
  18. #3  0x00007ffff7519fd6 in __GI___assert_fail (
  19.     assertion=0x55555dd91569 "m_opened_table != nullptr",
  20.     file=0x55555dd91510 "storage/temptable/include/temptable/handler.h", line=563,
  21.     function=0x55555dd914d8 "void temptable::Handler::opened_table_validate()")
  22.     at assert.c:103
  23. #4  0x000055555bb98e96 in temptable::Handler::opened_table_validate (this=0x7fff2020f7e8)
  24.     at storage/temptable/include/temptable/handler.h:563
  25. #5  0x000055555bb95354 in temptable::Handler::info (this=0x7fff2020f7e8)
  26.     at storage/temptable/src/handler.cc:751
  27. #6  0x000055555bb93482 in temptable::Handler::open (this=0x7fff2020f7e8,
  28.     table_name=0x7fff2020b170 "greatdb/confper/tmp/#sqlf1fea_8_2")
  29.     at storage/temptable/src/handler.cc:218
  30. #7  0x0000555558fd1804 in handler::ha_open (this=0x7fff2020f7e8, table_arg=0x7fff2020edf0,
  31.     name=0x7fff2020b170 "greatdb/confper/tmp/#sqlf1fea_8_2", mode=2,
  32.     test_if_locked=516, table_def=0x0)
  33.     at sql/handler.cc:2927
  34. #8  0x00005555597c223e in open_tmp_table (table=0x7fff2020edf0)
  35.     at sql/sql_tmp_table.cc:2422
  36. #9  0x000055555923a798 in FollowTailIterator::Init (this=0x7fff2021e9c0)
  37.     at sql/iterators/basic_row_iterators.cc:345
  38. #10 0x0000555559255c13 in FilterIterator::Init (this=0x7fff2021ea20)
  39.     at sql/iterators/composite_iterators.h:85
  40. #11 0x0000555559b8fb69 in NestedLoopIterator::Init (this=0x7fff2021ea90)
  41.     at sql/iterators/composite_iterators.cc:523
  42. #12 0x0000555559b9805b in MaterializeIterator<DummyIteratorProfiler>::MaterializeQueryBlock (
  43.     this=0x7fff2021ec08, query_block=..., stored_rows=0x7fffc83eedd8)
  44.     at sql/iterators/composite_iterators.cc:1221
  45. #13 0x0000555559b979f1 in MaterializeIterator<DummyIteratorProfiler>::MaterializeRecursive (
  46.     this=0x7fff2021ec08)
  47.     at sql/iterators/composite_iterators.cc:1129
  48. #14 0x0000555559b960b9 in MaterializeIterator<DummyIteratorProfiler>::Init (
  49.     this=0x7fff2021ec08)
  50.     at sql/iterators/composite_iterators.cc:971
  51. #15 0x0000555559b8e859 in LimitOffsetIterator::Init (this=0x7fff2021eca8)
  52.     at sql/iterators/composite_iterators.cc:100
  53. #16 0x00005555597dacd5 in Query_expression::ExecuteIteratorQuery (this=0x7fff201c20d0,
  54.     thd=0x7fff20001050) at sql/sql_union.cc:1814
  55. #17 0x00005555597db113 in Query_expression::execute (this=0x7fff201c20d0, thd=0x7fff20001050)
  56.     at sql/sql_union.cc:1877
  57. #18 0x00005555597001c0 in Sql_cmd_dml::execute_inner (this=0x7fff20200a80,
  58.     thd=0x7fff20001050) at sql/sql_select.cc:872
  59. #19 0x00005555596ff38e in Sql_cmd_dml::execute (this=0x7fff20200a80, thd=0x7fff20001050)
  60.     at sql/sql_select.cc:612
  61. #20 0x000055555966207c in mysql_execute_command (thd=0x7fff20001050, first_level=true)
  62.     at sql/sql_parse.cc:5227
  65. 打印m_opened_table变量，发现结果为空，所以导致core
  66. #4  0x000055555bb98e96 in temptable::Handler::opened_table_validate (this=0x7fff2c20ed88)
  67.     at storage/temptable/include/temptable/handler.h:563
  68. 563          assert(m_opened_table != nullptr);
  69. (gdb) p m_opened_table
  70. $21 = (temptable::Table *) 0x0
复制代码
二、问题调查过程

查询带有CTE派生表的时候内部会创建临时表用于保存临时数据，因此先看一下上面2个场合的临时表情况：
tmp_table_size值查询开始时候临时表情况查询过程中临时表情况说明16777216内存表内存表没问题1342内存表转为落盘表CORE1、正常执行的代码流程调查
先看一下tmp_table_size=16777216时候没问题的代码流程，以下代码通过Handler::create()函数向kv_store这个map插入了一条新的table信息。
  1. 首先创建内部物化表，代码调用流程如下：
  2. Table_ref::create_materialized_table -> instantiate_tmp_table -> create_tmp_table_with_fallback
  3. -> temptable::Handler::create -> temptable::Allocator
  4. -> temptable::Prefer_RAM_over_MMAP_policy_obeying_per_table_limit::block_source
  6. bool instantiate_tmp_table(THD *thd, TABLE *table) {
  7.   // 这里创建临时表，包括引擎，调用Handler::create，注意这里handler=temptable::Handler
  8.   if (create_tmp_table_with_fallback(thd, table)) return true;
  9.   // 这里打开表，调用Handler::open打开临时表引擎
  10.   open_tmp_table(table);
  11. }
  13. int Handler::create(const char *table_name, TABLE *mysql_table,
  14.                     HA_CREATE_INFO *, dd::Table *) {
  15.   try {
  16.     size_t per_table_limit = thd_get_tmp_table_size(ha_thd());
  17.     auto &kv_store = kv_store_shard[thd_thread_id(ha_thd())];
  18.     // 这里创建表引擎的时候申请新的内存用于保存table信息，kv_store.emplace调用下面的block_source()函数申请新的内存。
  19.     const auto insert_result = kv_store.emplace(
  20.         std::piecewise_construct, std::forward_as_tuple(table_name),
  21.         std::forward_as_tuple(mysql_table, m_shared_block,
  22.                               all_columns_are_fixed_size, per_table_limit));
  24.     ret = insert_result.second ? Result::OK : Result::TABLE_EXIST;
  26.   } catch (Result ex) {
  27.     ret = ex;
  28.   } catch (...) {
  29.     ret = Result::OUT_OF_MEM;
  30.   }
  31. }
  32. // 申请新的内存
  33. struct Prefer_RAM_over_MMAP_policy_obeying_per_table_limit {
  34.   static Source block_source(uint32_t block_size,
  35.                              TableResourceMonitor *table_resource_monitor) {
  36.     assert(table_resource_monitor);
  37.     assert(table_resource_monitor->consumption() <=
  38.            table_resource_monitor->threshold());
  39.     /* 以下各参数值：
  40.        table_resource_monitor->consumption() = 0  这个值为已经申请到的内存值
  41.        block_size = 1048576 这个值为当前新申请的内存值为1MB内存，为新申请的块大小
  42.        table_resource_monitor->threshold() = 16777216 这个值为当前tmp_table_size值
  43.        这个比较结果可以看出没有超出tmp_table_size值，因此正常新增1048576内存。
  44.     */
  45.     if (table_resource_monitor->consumption() + block_size >
  46.         table_resource_monitor->threshold())
  47.       throw Result::RECORD_FILE_FULL;
  49.     return Prefer_RAM_over_MMAP_policy::block_source(block_size);
  50.   }
  51. };
复制代码
接着FollowTailIterator迭代器通过open_tmp_table函数用temptable::Handler:pen函数在kv_store这个map寻找刚才插入的那条记录成功。
  1. int Handler::open(const char *table_name, int, uint, const dd::Table *) {
  2.   try {
  3.     auto &kv_store = kv_store_shard[thd_thread_id(ha_thd())];
  4.     m_opened_table = kv_store.find(table_name);
  5.     if (m_opened_table) {
  6.       ret = Result::OK;
  7.       opened_table_validate();
  8.     } else {
  9.       ret = Result::NO_SUCH_TABLE;
  10.     }
  11.   } catch (std::bad_alloc &) {
  12.     ret = Result::OUT_OF_MEM;
  13.   }
  15.   info(HA_STATUS_VARIABLE);
  16.   DBUG_RET(ret);
  17. }
复制代码
2、导致core的代码流程调查
设置完tmp_table_size=1342，这里代码流程跟上面是一样的，但是有一些参数值有变化。
  1. bool instantiate_tmp_table(THD *thd, TABLE *table) {
  2.   // 这里创建临时表，包括引擎，调用Handler::create，因为创建临时表内存超过阈值，因此这里引擎改为落盘表，hangler=ha_innobase
  3.   if (create_tmp_table_with_fallback(thd, table)) return true;
  4.   // 这里打开落盘表，调用Handler::open
  5.   open_tmp_table(table);
  6. }
  8. static bool create_tmp_table_with_fallback(THD *thd, TABLE *table) {
  9.   // 一开始临时表handler=temptable::Handler，但是申请内存超过阈值
  10.   int error =
  11.       table->file->create(share->table_name.str, table, &create_info, nullptr);
  12.   if (error == HA_ERR_RECORD_FILE_FULL &&
  13.       table->s->db_type() == temptable_hton) {
  14.     // 这里修改临时表handler=ha_innobase
  15.     table->file = get_new_handler(
  16.         table->s, false, share->alloc_for_tmp_file_handler, innodb_hton);
  17.     error = table->file->create(share->table_name.str, table, &create_info,
  18.                                 nullptr);
  19.   }
  20. }
  22. int Handler::create(const char *table_name, TABLE *mysql_table,
  23.                     HA_CREATE_INFO *, dd::Table *) {
  24.   try {
  25.     size_t per_table_limit = thd_get_tmp_table_size(ha_thd());
  26.     auto &kv_store = kv_store_shard[thd_thread_id(ha_thd())];
  27.     // 这里创建表引擎的时候申请新的内存用于保存table信息，kv_store.emplace调用下面的block_source()函数申请新的内存。
  28.     // 这里因为新申请的内存大于tmp_table_size=1342这个阈值，因此报错RECORD_FILE_FULL，这回kv_store这个map因为报错因此没有插入table信息。
  29.     const auto insert_result = kv_store.emplace(
  30.         std::piecewise_construct, std::forward_as_tuple(table_name),
  31.         std::forward_as_tuple(mysql_table, m_shared_block,
  32.                               all_columns_are_fixed_size, per_table_limit));
  34.     ret = insert_result.second ? Result::OK : Result::TABLE_EXIST;
  36.   } catch (Result ex) {
  37.     ret = ex;
  38.   } catch (...) {
  39.     ret = Result::OUT_OF_MEM;
  40.   }
  41. }
  42. // 申请新的内存
  43. struct Prefer_RAM_over_MMAP_policy_obeying_per_table_limit {
  44.   static Source block_source(uint32_t block_size,
  45.                              TableResourceMonitor *table_resource_monitor) {
  46.     assert(table_resource_monitor);
  47.     assert(table_resource_monitor->consumption() <=
  48.            table_resource_monitor->threshold());
  49.     /* 以下各参数值：
  50.        table_resource_monitor->consumption() = 0  这个值为已经申请到的内存值
  51.        block_size = 1048576 这个值为当前新申请的内存值
  52.        table_resource_monitor->threshold() = 1342 这个值为当前tmp_table_size值
  53.        这个比较结果可以看出这次新申请的内存超出tmp_table_size值，因此这次返回Result::RECORD_FILE_FULL的错误。
  54.     */
  55.     if (table_resource_monitor->consumption() + block_size >
  56.         table_resource_monitor->threshold())
  57.       throw Result::RECORD_FILE_FULL;
  59.     return Prefer_RAM_over_MMAP_policy::block_source(block_size);
  60.   }
  61. };
复制代码
接着继续执行sql，这次在FollowTailIterator迭代器打开临时表，注意，这里临时表引擎还是temptable::Handler而不是ha_innobase，那是因为FollowTailIterator迭代器用到的临时表跟上面MaterializeIterator迭代器用到的临时表是在prepare阶段，通过Common_table_expr::clone_tmp_table函数拷贝出来的，所以他们的handler虽然类型相同但是地址不同，只有table->share相同。
打开这张临时表，在kv_store寻找临时表信息的时候找不到对应临时表信息，导致m_opened_table为空，接着调用info()函数的时候core了。
实际上这时候FollowTailIterator迭代器用到的临时表的引擎应该跟上面的临时表一样改为innodb引擎，因为这里引擎没有跟着改动，加上kv_store没有存放相关临时表信息，因此导致这里core了。
  1. 打开临时表代码流程：
  2. MaterializeIterator<DummyIteratorProfiler>::Init -> aterializeIterator<DummyIteratorProfiler>::MaterializeRecursive
  3. -> MaterializeIterator<DummyIteratorProfiler>::MaterializeQueryBlock
  4. -> NestedLoopIterator::Init
  5. -> FilterIterator::Init
  6. -> FollowTailIterator::Init
  7. -> open_tmp_table
  8. -> handler::ha_open -> temptable::Handler::open
  10. int Handler::open(const char *table_name, int, uint, const dd::Table *) {
  11.   try {
  12.     auto &kv_store = kv_store_shard[thd_thread_id(ha_thd())];
  13.     // 因为上面Handler::create创建的时候，kv_store没有插入临时表信息，因此这里找不到这张临时表的信息，导致这里m_opened_table为空。
  14.     m_opened_table = kv_store.find(table_name);
  15.     if (m_opened_table) {
  16.       ret = Result::OK;
  17.       opened_table_validate();
  18.     } else {
  19.       ret = Result::NO_SUCH_TABLE;
  20.     }
  21.   } catch (std::bad_alloc &) {
  22.     ret = Result::OUT_OF_MEM;
  23.   }
  25.   info(HA_STATUS_VARIABLE);
  26.   DBUG_RET(ret);
  27. }
复制代码
3、总结问题
根据上面分析可以知道，第二次修改tmp_table_size值为较小数值之后core，原因在于申请内存的时候tmp_table_size值超过阈值，因此在kv_store插入表信息失败，后面open临时表的时候，通过kv_store寻找这张表信息没有找到，因此最后m_opened_table为空指针。
从上面判断阈值公式其实可以看出这里判断方法有问题，因为实际申请的是96大小，但是这里却用块大小1MB来进行阈值比较。
  1.     if (table_resource_monitor->consumption() + block_size >
  2.         table_resource_monitor->threshold())
  3.       throw Result::RECORD_FILE_FULL;
复制代码
三、问题解决

结合上面分析，我们发现问题原因在于内存申请额时候用的判断阈值的公式有问题，导致提前报错使kv_store没有插入相关临时表信息，同时CTE的其中一个相关临时表引擎改变了，但是其它层的临时表引擎没改，这两个原因导致最后的core。
我们用较新的8.4.4版本代码尝试运行该sql发现没有问题，因此可见最新代码已经修复该bug。查看代码，可以发现有一个如下修复patch：
Change-Id: I90d7374971bdfc1fc178801d0c793382c6ab8a49
Bug #33814188 - Assertion consumption > threshold
MySQL 8.4.4版本代码作如下修复，就可以解决这个问题了。
  1. 修复storage/temptable/include/temptable/allocator.h文件的如下代码：
  3. 删除Prefer_RAM_over_MMAP_policy_obeying_per_table_limit::block_source函数，
  4. 申请内存的时候判断阈值从判断新增块大小改为判断实际新增内存大小，
  5. 这样第一次申请内存的时候就不会超过tmp_table_size,
  6. 在temptable::Handler::create可以正常向kv_store插入临时表信息。
  8. 同时在allocate()函数申请完内存之后增加如下阈值判断的操作。这样第二次申请内存的时候就会正常报错。
  9. template <class T, class AllocationScheme>
  10. inline T *Allocator<T, AllocationScheme>::allocate(size_t n_elements) {
  11.   // 增加申请内存之后执行判断阈值操作的代码。这里从原来的block_size改为n_bytes_requested来判断，
  12.   // 也就是从原来判断新增块大小改为判断实际新增内存大小，这样用实际新增大小来判断阈值。
  13.   if (m_table_resource_monitor.consumption() + n_bytes_requested(※注意这个改动) >
  14.       m_table_resource_monitor.threshold()) {
  15.     throw Result::RECORD_FILE_FULL;
  16.   }
  17. }
复制代码
修改之后的代码调用流程如下：
  1. 1、一开始创建正常handler=temptable::Handler临时表，并且向kv_store插入表信息成功。
  2. 2、通过handler::ha_write_row在向临时表写数据的时候，因为新申请的内存64kBytes超过了阈值
  3. 因此修改handler=ha_innobase，接着通过create_ondisk_from_heap函数创建落盘表。
  4. 3、create_ondisk_from_heap函数创建落盘表的时候会把之前CTE拷贝出来的相关表的引擎都一起改为
  5. innodb表，因此接着FollowTailIterator迭代器的表执行open_tmp_table的时候打开的就跟
  6. MaterializeIterator迭代器一样都是innodb表了，就不会有查找临时表handler的kv_store为空的情况了。
复制代码
接着执行上面的查询，发现可以查出结果了。
  1. greatsql> SET tmp_table_size=1342;
  2. Query OK, 0 rows affected (0.00 sec)
  4. greatsql> WITH RECURSIVE cte_tree AS ( SELECT 1 AS LEVEL, t.org_id,t.org_id as porg_id,user_name, nick_name, user_code FROM t2 t UNION ALL SELECT LEVEL + 1 AS LEVEL, pt.org_id,pt.porg_id,pt.ORG_NAME,pt.CONTACT_NAME,pt.ORG_CODE FROM t1 pt JOIN cte_tree ct ON pt.org_id = ct.porg_id )  SELECT a.* FROM cte_tree a limit 1;
  5. +-------+--------+---------+-----------+-----------+-----------+
  6. | LEVEL | org_id | porg_id | user_name | nick_name | user_code |
  7. +-------+--------+---------+-----------+-----------+-----------+
  8. |     1 |      1 |       1 | daizhong  | NULL      | daizhong  |
  9. +-------+--------+---------+-----------+-----------+-----------+
  10. 1 row in set (1 min 1.63 sec)
复制代码
四、问题总结

通过以上分析我们可以发现，带有CTE派生表的查询会在内部创建临时表用于储存中间数据，根据tmp_table_size值设置会影响临时表存放地方，如果tmp_table_size设置小了那么一开始就会从内存表改为创建落盘表，但是CTE内部涉及好几层迭代器，这时候每一层临时表的引擎都需要改，而导致core的代码只改了其中一层的临时表，没有把别的引擎一起改了，最后导致core。
通过分析可以发现，问题代码判断阈值的公式也有问题，因此才导致一开始其中一层临时表申请内存超过阈值判断错误，修改了引擎类型。
这个问题涉及了2个原因，一环套一环，分析类似问题的时候，需要持续深挖本质原因，同时结合查询计划的执行和临时表创建情况分析，还需要对内存申请过程熟悉才能更好解决问题。

Enjoy GreatSQL
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
CTE查询数据过大导致

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
敖雨燕
2025-9-26 11:30:32

0

粉丝关注

20

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫