翼度科技»论坛 编程开发 mysql 查看内容

MySQL中sp运行check表版本更新流程解析

7

主题

7

帖子

21

积分

新手上路

Rank: 1

积分
21

  • GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源。
  • GreatSQL是MySQL的国产分支版本,使用上与MySQL一致。
  • 作者: wuyy
  • 文章来源:GreatSQL社区原创
目录

  • MySQL的sp运行SQL语句两个步骤介绍
  • 代码跟踪
  • 知识应用
  • 总结
一、MySQL的sp运行sql语句两个步骤介绍

MySQL的sp运行SQL语句需要执行2个步骤:prepare和execute。第一次执行的时候先执行prepare,进行相关语句parse、itemize、fix_fields等操作,然后才开始进行execute操作。等第二次再执行该sp的时候就直接运行execute而不需要再次进行重复的prepare操作,这样可以节省sp运行时候重复prepare的开销。但是,对于表操作就有一个问题产生,那就是如果执行第二遍的时候表的结构发生改变了,那么不进行reprepare而直接execute是会发生错误的。因此,本文章的目的在于寻找sp多次运行时候如何确认表版本更新并进行正确的操作。
  1. 先看下面的例子:
  2. CREATE TABLE t1 (a INT, b VARCHAR(10));
  3. INSERT INTO t1 VALUES (1,'11');
  4. INSERT INTO t1 VALUES (2,'21');
  5. MySQL> select * from t1;
  6. +------+------+
  7. | a    | b    |
  8. +------+------+
  9. |    1 | 11   |
  10. |    2 | 21   |
  11. +------+------+
  12. 2 rows in set (0.01 sec)
  13. DELIMITER $$
  14. CREATE PROCEDURE p1()
  15. BEGIN
  16. update t1 set b='aa' where a=1;
  17. END $$
  18. DELIMITER ;
  19. MySQL> call p1; #这里第一次操作,因此会先执行update这句SQL的prepare再进行execute。
  20. Query OK, 1 row affected (0.05 sec)
  21. MySQL> select * from t1;
  22. +------+------+
  23. | a    | b    |
  24. +------+------+
  25. |    1 | aa   |
  26. |    2 | 21   |
  27. +------+------+
  28. 2 rows in set (0.01 sec)
  29. MySQL> call p1; #这里第二次操作,直接执行update这句SQL的execute。
  30. Query OK, 0 rows affected (13.78 sec)
  31. #接着我们执行表结构的更新。
  32. MySQL> alter table t1 add i int;
  33. Query OK, 0 rows affected (0.41 sec)
  34. Records: 0  Duplicates: 0  Warnings: 0
  35. #然后再次执行sp,就会发现这次执行了这句SQL的prepare再进行execute。
  36. MySQL> call p1;
  37. Query OK, 0 rows affected (34.24 sec)
复制代码
二、代码跟踪

现在跟踪一下这个sp看看上面在哪里check表版本并且能正确执行reprepare的。
  1. #首先看一下这个sp涉及的instr。
  2. MySQL> show procedure code p1;
  3. +-----+---------------------------------------+
  4. | Pos | Instruction                           |
  5. +-----+---------------------------------------+
  6. |   0 | stmt "update t1 set b='aa' where a=1" |
  7. +-----+---------------------------------------+
  8. 1 row in set (0.01 sec)
  9. 可以看到这个sp只涉及了sp_instr_stmt::execute的运行,因此跟踪一下代码找到sp_lex_instr::validate_lex_and_execute_core,可以发现这个函数里面有一个无限while循环,如果发现is_invalid()的话就重新执行parse动作,如果!is_invalid()就直接执行exec_core,这个跟上面的运行步骤就对的上了。但是表结构变更后在哪里被判定为rc=true的呢,那就从reset_lex_and_exec_core这个函数继续跟踪下去。
  10. bool sp_lex_instr::validate_lex_and_execute_core(THD *thd, uint *nextp,
  11.                                                  bool open_tables) {
  12.   while (true) {
  13.     if (is_invalid() || (m_lex->has_udf() && !m_first_execution)) {
  14.       LEX *lex = parse_expr(thd, thd->sp_runtime_ctx->sp);
  15.     }
  16.     bool rc = reset_lex_and_exec_core(thd, nextp, open_tables);
  17.     if (!rc) return false;
  18.     thd->clear_error();
  19.     invalidate();
  20.   }
  21. }
  22. #跟踪代码发现有一个check_and_update_table_version函数是用来check表版本是否一致的
  23. #打印堆栈看一下代码调用过程:
  24. Thread 51 "mysqld" hit Breakpoint 6, check_and_update_table_version (thd=0x7fff70001060, tables=0x7fff702c4e20,
  25.     table_share=0x7fff70297640) at /mysql/sql/sql_base.cc:3722
  26. 3722   if (!tables->is_table_ref_id_equal(table_share)) {
  27. (gdb) bt
  28. #0  check_and_update_table_version (thd=0x7fff70001060, tables=0x7fff702c4e20, table_share=0x7fff70297640)
  29.     at /mysql/sql/sql_base.cc:3722
  30. #1  0x0000000003340f71 in open_and_process_table (thd=0x7fff70001060, lex=0x7fff702c2650, tables=0x7fff702c4e20,
  31.     counter=0x7fff702c26a8, prelocking_strategy=0x7fffec2e7478, has_prelocking_list=false, ot_ctx=0x7fffec2e7368)
  32.     at /MySQL/sql/sql_base.cc:5223
  33. #2  0x000000000333f788 in open_tables (thd=0x7fff70001060, start=0x7fffec2e7488, counter=0x7fff702c26a8, flags=0,
  34.     prelocking_strategy=0x7fffec2e7478) at /mysql/sql/sql_base.cc:5968
  35. #3  0x0000000003343c96 in open_tables_for_query (thd=0x7fff70001060, tables=0x7fff702c4e20, flags=0)
  36.     at /MySQL/sql/sql_base.cc:6958
  37. #4  0x0000000003514334 in Sql_cmd_dml::execute (this=0x7fff702c6138, thd=0x7fff70001060)
  38.     at /MySQL/sql/sql_select.cc:543
  39. #5  0x0000000003475097 in mysql_execute_command (thd=0x7fff70001060, first_level=false)
  40.     at /MySQL/sql/sql_parse.cc:3832
  41. #6  0x00000000033075c6 in sp_instr_stmt::exec_core (this=0x7fff70249a80, thd=0x7fff70001060, nextp=0x7fffec2eac38)
  42.     at /MySQL/sql/sp_instr.cc:1008
  43. #7  0x00000000033052ed in sp_lex_instr::reset_lex_and_exec_core (this=0x7fff70249a80, thd=0x7fff70001060,
  44.     nextp=0x7fffec2eac38, open_tables=false) at /mysql/sql/sp_instr.cc:457
  45. #8  0x00000000033060a4 in sp_lex_instr::validate_lex_and_execute_core (this=0x7fff70249a80, thd=0x7fff70001060,
  46.     nextp=0x7fffec2eac38, open_tables=false) at /mysql/sql/sp_instr.cc:741
  47. #9  0x0000000003306748 in sp_instr_stmt::execute (this=0x7fff70249a80, thd=0x7fff70001060, nextp=0x7fffec2eac38)
  48.     at /MySQL/sql/sp_instr.cc:925
  49. #10 0x00000000032f4d74 in sp_head::execute (this=0x7fff7018e7a0, thd=0x7fff70001060, merge_da_on_success=true)
  50.     at /MySQL/sql/sp_head.cc:2272
  51. #11 0x00000000032f80e1 in sp_head::execute_procedure (this=0x7fff7018e7a0, thd=0x7fff70001060, args=0x0)
  52.     at /MySQL/sql/sp_head.cc:2977
  53. #可以发现open_tables函数调用了这个函数,这个函数调用了ask_to_reprepare,
  54. #在sp运行中这个ask_to_reprepare返回的是true。因此这里就解开了之前的问题,
  55. #为何表版本更新了会return true然后重新进行parse操作。
  56. static bool check_and_update_table_version(THD *thd, TABLE_LIST *tables,
  57.                                            TABLE_SHARE *table_share) {
  58.   if (!tables->is_table_ref_id_equal(table_share)) {
  59.     /*
  60.       Version of the table share is different from the
  61.       previous execution of the prepared statement, and it is
  62.       unacceptable for this SQLCOM.
  63.     */
  64.     if (ask_to_reprepare(thd)) return true;
  65.     /* Always maintain the latest version and type */
  66.     tables->set_table_ref_id(table_share);
  67.   }
  68.   return false;
  69. }
复制代码
三、知识应用

如果想开发一种动态表类型,需要每次执行sp都重新parse这个表,那就可以借用这个ask_to_reprepare函数来保证多次执行sp的时候都会进行重新reprepare。
四、总结

在MySQL的sp操作中涉及表操作的sql语句一定会执行check_and_update_table_version这个函数,每次会根据这个函数的结果来确定要不要重新parse该sql语句,如果没有版本改变就直接进行execute操作,如果有改变就重新parse,先prepare再execute,这样可以保证每次执行sp的SQL语句的时候表结构一定是最新的。

Enjoy GreatSQL
来源:https://www.cnblogs.com/greatsql/p/17101938.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

举报 回复 使用道具