BEGIN-END-ABORT

最新推荐文章于 2025-03-23 15:37:05 发布
最新推荐文章于 2025-03-23 15:37:05 发布
阅读量795 收藏 23
点赞数 29
文章标签： 数据库 java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42744640/article/details/144136862
版权

海山数据库(He3DB)源码详解：事务块执行过程及内核函数

本文介绍了事务执行过程中，从BEGIN事务开始到事务结束END/ABORT的内核函数执行过程。

前言：

事务SQL语句的执行过程，会先通过事务块函数修改事务块状态，然后根据事务块状态执行不同的事务行为。因此，本章会讲解事务块的开始和结束过程的事务块函数。

事务块控制事务执行的过程：

在讲具体函数之前，有必要在此讲解一下，事务块是如何控制事务行为的。事务管理器中，事务块会根据当前事务状态，来控制具体的事务操作行为，具体流程如下：
在这里插入图片描述

  • 开始事务块：表示一个新的事务块的开始。
  • 检查事务状态：检查当前事务的状态，是否活跃、空闲或处于错误状态。
    • 活跃：如果事务处于活跃状态，执行事务操作。
      • 执行事务操作：执行具体的事务操作，如插入、更新或删除数据。
    • 空闲：如果事务处于空闲状态，等待操作命令。
      • 等待操作命令：在事务空闲时等待接收到新的操作命令。
      • 接收到操作命令：一旦接收到操作命令，开始执行事务操作。
    • 执行事务操作：执行具体的事务操作，如插入、更新或删除数据。
      • 操作成功?：检查事务操作是否成功。
      • 提交事务：如果操作成功，提交事务。
      • 回滚事务：如果操作失败或事务处于错误状态，回滚事务。
    • 错误：如果事务处于错误状态，进行回滚操作。
      • 回滚事务：如果操作失败或事务处于错误状态，回滚事务。
  • 结束事务块：表示事务块的结束，此时事务已经提交或回滚。

如何进行事务块操作：

使用 BEGIN 命令可以手动控制启动事务的边界，开始一个新的事务块；
使用 END \COMMIT 命令可以手动控制结束事务，结束一个执行中的事务块；
使用 ABORT \ ROLLBACK 命令可以手动控制放弃回滚事务，结束一个出错的事务块；
当执行这些SQL语句时，系统底层会调用相对应的事务块函数，来修改当前事务块的状态，从而控制具体的事务操作行为。其中，事务块操作的开始和结束分别对应的函数为：

  1. BEGIN 对应的事务块函数为 BeginTransactionBlock() 函数；
  2. END \ COMMIT 对应的事务块函数为 EndTransactionBlock() 函数；
  3. ABORT \ ROLLBACK 对应的事务块函数为 UserAbortTransactionBlock() 函数。
    那么，这些函数的执行流程是什么样的？

BeginTransactionBlock()函数的执行过程：

当终端输入BEGIN或者START TRANSACTION命令时，会开始一个事务块。处理过程首先会调用BeginTransactionBlock()函数。该函数内部主体为一个switch结构，会对枚举类型TBlockState中的所有状态都进行一个判断，并作一个对应的处理。执行过程示意图如下：

在这里插入图片描述

  1. 首先通过全局变量CurrentTransactionState获得当前事务块状态的变量；

     TransactionState s = CurrentTransactionState;

  2. 然后通过switch-case结构，根据当前事务块状态做对应的操作，其中有包括：

  • 如果当前事务块状态为TBLOCK_STARTED，则修改为TBLOCK_BEGIN；
        case TBLOCK_STARTED:
		s->blockState = TBLOCK_BEGIN;
		break;
  • 如果当前事务块状态为TBLOCK_IMPLICIT_INPROGRESS，则修改为TBLOCK_BEGIN；
        case TBLOCK_IMPLICIT_INPROGRESS:
		s->blockState = TBLOCK_BEGIN;
		break;
  • 如果当前事务块状态为TBLOCK_INPROGRESS、TBLOCK_PARALLEL_INPROGRESS、TBLOCK_SUBINPROGRESS、TBLOCK_ABORT和TBLOCK_SUBABORT，会进行WARNING报警，但是不会影响执行过程，可以继续执行；
        case TBLOCK_INPROGRESS:
	case TBLOCK_PARALLEL_INPROGRESS:
	case TBLOCK_SUBINPROGRESS:
	case TBLOCK_ABORT:
	case TBLOCK_SUBABORT:
		ereport(WARNING,
				(errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
				 errmsg("there is already a transaction in progress")));
		break;
  • 如果当前事务块状态为上述提到的其他状态，则直接报FATAL错误，直接退出事务块过程；
        case TBLOCK_DEFAULT:
	case TBLOCK_BEGIN:
	case TBLOCK_SUBBEGIN:
	case TBLOCK_END:
	case TBLOCK_SUBRELEASE:
	case TBLOCK_SUBCOMMIT:
	case TBLOCK_ABORT_END:
	case TBLOCK_SUBABORT_END:
	case TBLOCK_ABORT_PENDING:
	case TBLOCK_SUBABORT_PENDING:
	case TBLOCK_SUBRESTART:
	case TBLOCK_SUBABORT_RESTART:
	case TBLOCK_PREPARE:
		elog(FATAL, "BeginTransactionBlock: unexpected state %s",
			 BlockStateAsString(s->blockState));
		break;

以上，就是BeginTransactionBlock()函数的全部执行过程。

EndTransactionBlock()函数的执行过程：

当终端输入COMMIT或者EDN语句时，这时一个事务块会发起提交或者结束，如果输入END，正确结束为提交，错误结束为回滚。处理过程首先会调用EndTransactionBlock()函数，并根据返回值判断是否时错误结束发生回滚。EndTransactionBlock()函数和BeginTransactionBlock()十分相似，内部主要是一个swith结构，这里直接说执行流程：
在这里插入图片描述

  1. 首先通过全局变量CurrentTransactionState获得当前事务块状态的变量，并定义返回值bool变量result；

     TransactionState s = CurrentTransactionState;
 bool		result = false;

  2. 然后通过switch-case结构，根据当前事务块状态做对应的操作，其中有包括：

  • 如果当前事务块状态为TBLOCK_INPROGRESS，则修改为TBLOCK_END，并将变量result赋值为true；
     case TBLOCK_INPROGRESS:
     s->blockState = TBLOCK_END;
     result = true;
     break;
  • 如果当前事务块状态为TBLOCK_IMPLICIT_INPROGRESS，表示当前处在一个隐式的事务进程模式。判断入参chain的值，如果为true，表示该状态下存在子事务，报Error错误，退出事务执行过程；否则报Warning，修改事务块状态为TBLOCK_END，并将变量result赋值为true；
     case TBLOCK_IMPLICIT_INPROGRESS:
     if (chain)
         ereport(ERROR,
                 (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
         /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                         "COMMIT AND CHAIN")));
     else
         ereport(WARNING,
                 (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                     errmsg("there is no transaction in progress")));
     s->blockState = TBLOCK_END;
     result = true;
     break;
  • 如果当前事务块状态为TBLOCK_ABORT，只修改事务块状态为TBLOCK_ABORT_END；
     case TBLOCK_ABORT:
     s->blockState = TBLOCK_ABORT_END;
     break;
  • 如果当前事务块状态为TBLOCK_SUBINPROGRESS，表示当前事务属于正常状态可以提交，需要从当前节点逐级回溯到父节点，并修改过程中每个节点的状态；
     case TBLOCK_SUBINPROGRESS:
     while (s->parent != NULL)
     {
         if (s->blockState == TBLOCK_SUBINPROGRESS)
             s->blockState = TBLOCK_SUBCOMMIT;
         else
             elog(FATAL, "EndTransactionBlock: unexpected state %s",
                     BlockStateAsString(s->blockState));
         s = s->parent;
     }
     if (s->blockState == TBLOCK_INPROGRESS)
         s->blockState = TBLOCK_END;
     else
         elog(FATAL, "EndTransactionBlock: unexpected state %s",
                 BlockStateAsString(s->blockState));
     result = true;
     break;
    • 首先，通过while循环，回溯每个节点，并对每个节点的事务块状态进行判断。如果是TBLOCK_SUBINPROGRESS，则修改为TBLOCK_SUBCOMMIT，由后续的CommitSubTransaction()函数中进行提交，如果是其他，则直接报FATAL错误，退出事务操作过程；
    • 退出while后，判断父节点事务块状态，如果是TBLOCK_INPROGRESS，则修改为TBLOCK_END，表示事务完成，后续由CommitTransaction()函数完成具体的事务提交，如果是其他，报FATAL错误；
    • 最后修改返回值result为true。
  • 如果当前事务块状态为TBLOCK_SUBABORT，表示当前事务整体处于放弃状态，需要从当前节点逐级回溯到父节点，并修改过程中每个节点的状态以实现整体事务的放弃；
     case TBLOCK_SUBABORT:
     while (s->parent != NULL)
     {
         if (s->blockState == TBLOCK_SUBINPROGRESS)
             s->blockState = TBLOCK_SUBABORT_PENDING;
         else if (s->blockState == TBLOCK_SUBABORT)
             s->blockState = TBLOCK_SUBABORT_END;
         else
             elog(FATAL, "EndTransactionBlock: unexpected state %s",
                     BlockStateAsString(s->blockState));
         s = s->parent;
     }
     if (s->blockState == TBLOCK_INPROGRESS)
         s->blockState = TBLOCK_ABORT_PENDING;
     else if (s->blockState == TBLOCK_ABORT)
         s->blockState = TBLOCK_ABORT_END;
     else
         elog(FATAL, "EndTransactionBlock: unexpected state %s",
                 BlockStateAsString(s->blockState));
     break;
    • 首先，通过while循环，回溯每个节点，并对每个节点的事务块状态进行判断。如果是TBLOCK_SUBINPROGRESS，则修改为TBLOCK_SUBABORT_PENDING，表示处于准备放弃的状态，后续会通过AbortSubTransaction()和CleanupSubTransaction()函数处理；如果是TBLOCK_SUBABORT，则修改为TBLOCK_SUBABORT_END，表示处于结束放弃的状态，已经由AbortSubTransaction()函数处理过，后续只需要通过CleanupSubTransaction()清理相关资源即可；如果是其他，则直接报FATAL错误，退出事务操作过程；
    • 退出while后，判断父节点事务块状态，如果是TBLOCK_INPROGRESS，则修改为TBLOCK_ABORT_PENDING，表示事务准备放弃，后续由AbortTransaction()和CleanupTransaction()函数处理；如果是TBLOCK_ABORT，则修改为TBLOCK_ABORT_END，表示处于结束放弃的状态，已经由AbortTransaction()函数处理过，后续只需要通过CleanupTransaction()清理相关资源即可；如果是其他，报FATAL错误。
  • 如果当前事务块状态为TBLOCK_STARTED，表示当前事务执行出错，需要通过chain判断错误的严重性。判断入参chain的值，如果为true，表示当前状态下存在子事务，报Error错误，退出事务执行过程；否则报Warning，并将变量result赋值为true；
     if (chain)
     ereport(ERROR,
             (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
     /* translator: %s represents an SQL statement name */
                 errmsg("%s can only be used in transaction blocks",
                     "COMMIT AND CHAIN")));
 else
     ereport(WARNING,
             (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                 errmsg("there is no transaction in progress")));
 result = true;
 break;
  • 如果当前事务块状态为TBLOCK_PARALLEL_INPROGRESS，表示当前事务处于并行操作的状态，不能有parallel worker进行提交，报FATAL错误，直接退出事务操作过程；
     case TBLOCK_PARALLEL_INPROGRESS:
     ereport(FATAL,
             (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot commit during a parallel operation")));
     break;
  • 如果处于其他状态，则表示当前事务状态出现预料之外的情况，报FATAL错误，直接退出事务操作过程。
         /* These cases are invalid. */
 case TBLOCK_DEFAULT:
 case TBLOCK_BEGIN:
 case TBLOCK_SUBBEGIN:
 case TBLOCK_END:
 case TBLOCK_SUBRELEASE:
 case TBLOCK_SUBCOMMIT:
 case TBLOCK_ABORT_END:
 case TBLOCK_SUBABORT_END:
 case TBLOCK_ABORT_PENDING:
 case TBLOCK_SUBABORT_PENDING:
 case TBLOCK_SUBRESTART:
 case TBLOCK_SUBABORT_RESTART:
 case TBLOCK_PREPARE:
     elog(FATAL, "EndTransactionBlock: unexpected state %s",
             BlockStateAsString(s->blockState));
     break;

UserAbortTransactionBlock()函数执行过程：

当终端输入ROLLBACK语句时，这时会发起一个事务的回滚操作，放弃之前的所有操作，数据库回滚到事务开始之前的样子。通过调用UserAbortTransactionBlock()函数执行该过程。该函数和其他事务块操作函数十分相似，内部主要是一个swith结构，这里直接说执行流程：

在这里插入图片描述

  1. 首先通过全局变量CurrentTransactionState获得当前事务块状态的变量；
    TransactionState s = CurrentTransactionState;
  1. 然后通过switch-case结构，根据当前事务块状态做对应的操作，其中有包括：
  • 如果事务块处在TBLOCK_INPROGRESS状态下，将状态修改为TBLOCK_ABORT_PENDING；
	case TBLOCK_INPROGRESS:
        s->blockState = TBLOCK_ABORT_PENDING;
        break;
  • 如果事务块处在TBLOCK_ABORT状态下，将状态修改为TBLOCK_ABORT_END；
	case TBLOCK_ABORT:
        s->blockState = TBLOCK_ABORT_END;
        break;
  • 如果事务块处在TBLOCK_SUBINPROGRESS或TBLOCK_SUBABORT，标记每个子事务状态为放弃状态，直到top事务位置；
    case TBLOCK_SUBINPROGRESS:
    case TBLOCK_SUBABORT:
        while (s->parent != NULL)
        {
            if (s->blockState == TBLOCK_SUBINPROGRESS)
                s->blockState = TBLOCK_SUBABORT_PENDING;
            else if (s->blockState == TBLOCK_SUBABORT)
                s->blockState = TBLOCK_SUBABORT_END;
            else
                elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                        BlockStateAsString(s->blockState));
            s = s->parent;
        }
        if (s->blockState == TBLOCK_INPROGRESS)
            s->blockState = TBLOCK_ABORT_PENDING;
        else if (s->blockState == TBLOCK_ABORT)
            s->blockState = TBLOCK_ABORT_END;
        else
            elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                    BlockStateAsString(s->blockState));
        break;

  • 循环检查当前节点的父节点状态，如果不为空，则根据blockState值对应修改当前事务的事务块状态，并将事务指针指向父节点；

  • 当循环到top节点时，退出循环，并根据top节点的blockState值对应修改当前top事务的事务块状态。

  • 如果事务块处在TBLOCK_STARTED或TBLOCK_IMPLICIT_INPROGRESS，根据chain的值报ERROR或者WARING错误，并将事务块状态修改为TBLOCK_ABORT_PENDING；

    case TBLOCK_STARTED:
    case TBLOCK_IMPLICIT_INPROGRESS:
        if (chain)
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                        errmsg("%s can only be used in transaction blocks",
                            "ROLLBACK AND CHAIN")));
        else
            ereport(WARNING,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                        errmsg("there is no transaction in progress")));
        s->blockState = TBLOCK_ABORT_PENDING;
        break;

  • 如果chain为true，表示事务的链式执行，事务在结束后会开启一个新事务，如果开启则汇报ERROR错误；

  • 如果chain为false，报WARIING错误，修改事务块状态。

  • 如果务块处在TBLOCK_PARALLEL_INPROGRESS，则直接报FATAL错误。

    case TBLOCK_PARALLEL_INPROGRESS:
        ereport(FATAL,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                    errmsg("cannot abort during a parallel operation")));
        break;

原因：事务管理系统设计上避免在并行执行的事务中执行 ABORT，以维护系统的稳定性和数据的一致性。这种设计确保了并行查询的性能和可靠性。

  • 如果事务块处于其他状态，直接FATAL。
    case other_TBLOCK:
        elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                BlockStateAsString(s->blockState));
        break;
  • 对当前事务块状态做判断，并保存chain的值到
	Assert(s->blockState == TBLOCK_ABORT_END ||
		   s->blockState == TBLOCK_ABORT_PENDING);

	s->chain = chain;
统设计上避免在并行执行的事务中执行 ABORT，以维护系统的稳定性和数据的一致性。这种设计确保了并行查询的性能和可靠性。

- 如果事务块处于其他状态，直接FATAL。
```C 
    case other_TBLOCK:
        elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                BlockStateAsString(s->blockState));
        break;
  • 对当前事务块状态做判断，并保存chain的值到
	Assert(s->blockState == TBLOCK_ABORT_END ||
		   s->blockState == TBLOCK_ABORT_PENDING);

	s->chain = chain;
牛燕飞
关注
海山数据库(He3DB)源码解读：BEGIN-END-ABORT
weixin_51457815的博客
11-15 843
事务SQL语句的执行过程，会先通过事务块函数修改事务块状态，然后根据事务块状态执行不同的事务行为。因此，本章会讲解事务块的开始和结束过程的事务块函数。
verilog语法学习_3.语句块 & 常用语句（If, case, while,for, repeat, forver）
weixin_47139649的博客
03-29 3630
文章目录语句块顺序语句块 begin end并行语句块 fork join嵌套使用命名块If 语句If语句语法用法说明Case语句Case语句语法用法说明循环语句while语句语法for语句语法repeat 语句语法forever 语句语法 语句块 顺序语句块 begin end 顺序块用关键字 begin 和 end 来表示。 顺序块中的语句是一条条执行的。当然，非阻塞赋值除外。 顺序块中每条语句的时延总是与其前面语句执行的时间相关。 在本节之前的仿真中，initial 块中的阻塞赋值，
如何开启一个事务
青箫的博客
03-11 3490
MYSQL的事务处理主要有两种方法。 1、用begin,rollback,commit来实现 begin 开始一个事务 rollback 事务回滚 commit 事务确认 2、直接用set来改变mysql的自动提交模式 MYSQL默认是自动提交的，也就是你提交一个QUERY，它就直接执行！我们可以通过
MySQL7 事务（一）
Enen_nenE的博客
11-27 1931
【代码】MySQL7 事务（一）
verilog中何时使用begin—end
最新发布
m0_62785875的博客
03-23 651
单条语句：不需要begin和end即可正常工作。多条语句必须用begin和end包裹起来以确保所有期望内的指令都被包含在同一上下文中被执行。
MySQL开启一个新的事务会话：START TRANSACTION 和 BEGIN 使用示例
学亮编程手记
11-07 807
在MySQL中，和BEGIN;是等价的，都可以用来显式地开始一个新的事务。这两个命令在功能上没有差异，都是用来标记事务处理的开始。
手动开启事务和事务的ACID特征与使用
ljm_99的博客
12-18 380
手动开启事务 事务默认提交被开启（@@autocommit=1）后，此时不能使用事务回滚，但我们可手动开启一个事务处理事件，这样就可以发生回滚。 使用begin 或者star transaction 手动开启一个事务 begin; update user set money=money-100 where name='a'; update user set money=money+100 wher...
oracle存储过程begin end；
u014644574的博客
03-15 7316
oracle存储过程begin end;
数据库原理与应用（SQL Server）笔记——第七章 流程控制语句、系统内置函数
小宇y的博客
05-23 854
您的指出和建议能给作者带来很大的动力！！！
Verilog基础语法--块语句
weixin_44834094的博客
07-27 1071
回顾Verilog语法基础
Verilog学习笔记基本语法篇（四）·········块语句
xs1326962515的博客
10-22 1197
http://www.cnblogs.com/SYoong/archive/2016/09/08/5852128.html 块语句是指将两条或者两条以上的语句组合在一起，使其在格式上更像一条语句。块语句分为两种： 1）用begin_end语句，通常用来标识顺序执行的语句，用它标识的块称作顺序块； 2）用fork_join语句，通常用来标识并行执行的语句，用它标识的
事务管理，事务的概念（原子性、一致性、隔离性和持久性（ACID特性））、事务的控制（BEGIN、COMMIT和ROLLBACK）
qq_52645134的博客
11-04 2849
事务是数据库管理系统（DBMS）中的一个重要概念，它具有四个基本特性，通常称为ACID特性，用于确保数据的一致性和完整性。
SQL 流程控制语句 之二 BEGIN…END语句介绍
热门推荐
对象本无根，类型亦无形。本来无一物，何处惹尘埃
07-10 1万+
SQL 流程控制语句 之二  BEGIN…END语句介绍 执行以下SQL  BEGIN…END语句:declare @r int ,@s int ,@t intselect @r=2,@s=3 print @rwhile @r  begin     select @t=100*@r+@s     print @t     select @r=@r+2  
mysql事务处理 begin_MYSQL--事务处理
weixin_39636176的博客
01-19 1403
事务处理在各种管理系统中都有着广泛的应用，比如人员管理系统，很多同步数据库操作大都需要用到事务处理。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务！删除的SQL语句delete from userinfo where ~~~delete from mail where ~~delete fr...
MySQL事务的启动和实现
Srodong的博客
03-26 3312
事务的实现 之前的文章说过事务隔离等级 https://blog.youkuaiyun.com/Srodong/article/details/88688084 现在说说事务等级为“可重复读”的事务怎么是实现的 在 MySQL 中，实际上每条记录在更新的时候都会同时记录一条回滚操作。记录上的最新值，通过回滚操作，都可以得到前一个状态的值。 假设一个值从 1 被按顺序改成了 2、3、4，在回滚日志里面就...
perl中的BEGIN和END语句块
@_囚徒-2018_的家园
10-06 3468
1.perl语言中的BEGIN和END语句块    Perl语言提供了两个关键字：BEGIN，END。它们可以分别包含一组脚本，用于程序体运行前或者运行后的执行。每个 BEGIN语句块在Perl脚本载入和编译后但在其他语句执行前执行。每个END语句块在解释器退出前执行。举例来说： #!/usr/bin/perl package Foo; print "Begin 和 Block 实例\n";
自己照抄的一个begin end语句块
半颗心
09-26 3058
declare test1 varchar2(50); begin DECLARE  CURSOR c IS SELECT   * FROM   user_tab_columns WHERE   Table_Name = 'SHIP_PROP'; BEGIN   for v_temp in c loop    execute immediate 'select instr('
Delphi图书管理系统实现与问题解决案例分析
abort; ``` 4. 遍历容器中的控件 在Delphi中，容器控件如Groupbox可以包含多种其他控件。通过遍历容器的Components集合，可以访问并操作其中的控件。以下代码展示了如何遍历Groupbox中的控件，并将其中的TEdit类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值