MVCC（7）--事务提交

引言

在上一篇博客MVCC(6)中，我们分析了MVCC数据可见性机制的元组可见性判断函数SetXact2CommitInProgress，给对应XID设置相应的CSNLOG的函数CSNLogSetCommitSeqNo 本篇博客将会分析MVCC机制可见性判断的主体函数中的最后一个函数RecordTransactionCommit。 文件路径 D:\opengauss-server\src\gausskernel\storage\access\transam\csnlog.cpp 记录事务提交，主要是写CLOG,CSNLOG以及他们的XLOG

一、名词介绍

IsPostmasterEnvironment

IsPostmasterEnvironment是一个全局变量，用于判断当前进程是否在Postmaster环境中。在PostgreSQL中，Postmaster是主进程，负责监听和接收客户端连接请求，为其派生服务进程。

GTM_FREE_MODE

GTM_FREE_MODE则是GaussDB数据库中的一个模式。GaussDB提供了两种不同的GTM模式，GTM-Lite和GTM-Free。在GTM-Free模式下，中心事务管理节点不再参与事务管理，消除了GTM单点瓶颈，可以达到更高的事务处理性能。但在一致性方面，支持所有事务运行完后，保证读的外部一致性，不支持分布式事务强一致性读，不支持依赖于查询结果的事务一致性。

Paxos协议

Paxos协议是一种基于消息传递且具有高度容错特性的一致性算法，是目前公认的解决分布式一致性问题最有效的算法之一，其解决的问题就是在分布式系统中如何就某个值（决议）达成一致。 Paxos协议运行在允许消息重复、丢失、延迟或乱序，但没有拜占庭式错误的网络环境中，它利用“大多数 (Majority)机制”保证了 2F+1 的容错能力，即 2F+1 个节点的系统最多允许 F 个节点同时出现故障。 在Paxos协议中，有三种角色：提出者（Proposer）、接受者（Acceptor）和学习者（Learner）。提出者提交一个提案，等待大家批准为结案；接受者负责对提案进行投票，提议超过半数的接受者投票及被选中；学习者被告知提案结果，并与之统一，不参与投票过程。

二、函数介绍

RecordTransactionCommit

RecordTransactionCommit是openGauss数据库中的一个函数，它用于记录事务的提交。这个函数包括写入Clogs（事务提交日志）、CSNlog（事务提交序列号日志）和Xlogs（事务日志）。Clogs仅记录事务执行结果，CSNlogs记录提交日志的顺序以确定可见性，Xlogs是用于数据恢复和持久性的重做日志。这个函数是openGauss事务模块实现数据库事务基本属性的一部分，确保用户数据不丢失，正确修改，并正确查询。在并发执行事务时，事务并发控制机制用于确保openGauss的ACID属性。总的来说，RecordTransactionCommit函数在openGauss中起着关键的作用，它确保了数据库事务的正确性和一致性。

这个函数涉及到Clogs（事务提交日志）、CSNlog（事务提交序列号日志）和Xlogs（事务日志）。下面是对这三个概念的简介：

Clogs

• Clogs（事务提交日志）：事务提交日志（CLOG）记录所有事务的状态，是并发控制机制的一部分。它分配给共享内存并在整个事务处理过程中使用。如果系统发生故障，您将需要该日志将数据库恢复到一致状态。

CSNlogs

• CSNlog（事务提交序列号日志）：Commit Sequence Number (CSN) 是 Oracle GoldenGate 构造的标识符，用于标识事务，以维护事务一致性和数据完整性。它唯一地标识了事务提交到数据库的时间点。任何两个 CSN 数字的比较，每个数字都绑定到同一日志流中的事务提交记录，可靠地指示了两个事务完成的顺序。

Xlogs

• Xlogs（事务日志）：每个数据库都有一个记录所有事务和每个事务所做的数据库修改的事务日志。如果系统发生故障，您将需要该日志将数据库恢复到一致状态。

这些日志在数据库管理中起着至关重要的作用，确保数据的一致性和完整性。

相关结构体、预定义

文件路径：opengauss-server\src\include\access\clog.h

1. #define CLOG_XID_STATUS_IN_PROGRESS 0x00
2. #define CLOG_XID_STATUS_COMMITTED 0x01
3. #define CLOG_XID_STATUS_ABORTED 0x02
4. #define CLOG_XID_STATUS_SUB_COMMITTED 0x03

这里定义的宏分别表示了CLOG四种状态：分别表示在进程中，已经提交，禁止，子事务提交。这样定义状态的好处是只需要两个bit就可以存储事务状态

1. #define TransactionIdToPage(xid) ((xid) / (TransactionId)CLOG_XACTS_PER_PAGE)
2. #define TransactionIdToPgIndex(xid) ((xid) % (TransactionId)CLOG_XACTS_PER_PAGE)
3. #define TransactionIdToByte(xid) (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)
4. #define TransactionIdToBIndex(xid) ((xid) % (TransactionId)CLOG_XACTS_PER_BYTE)

这里的宏定义分别给出了XID是如何映射到文件上的，是一种典型的哈希表的应用，对于事务定位效率有着极高的提升。

• Xid到页面位置
• 页面上的偏移量
• 页面上第几个字节
• 字节上哪一个bit

1. #define CLOG_BITS_PER_XACT 2
2. #define CLOG_XACTS_PER_BYTE 4
3. #define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)
4. #define CLOG_XACT_BITMASK ((1 << CLOG_BITS_PER_XACT) - 1)

此处BLCKSZ默认值为8k，即8192

三、代码分析

我们还是同以前一样，先对函数做简单的代码块划分，然后再对每个模块进行详细分析

我们将会对其上划分的的变量初始化简单分析，事务主体处理部分逐一分析。事务主体部分涵盖了大量的预定义处理，对于全局数据库，内存引擎进行了仔细的检查，但是不是本文分析的主体，且笔者能力有限，为了防止本篇博客过于冗杂，所以将会跳过这些预定义处理，默认为#else下的情况进行分析

变量初始化

1. TransactionId xid = GetTopTransactionIdIfAny();
2. bool markXidCommitted = TransactionIdIsValid(xid);
3. TransactionId latestXid = InvalidTransactionId;
4. int nrels;
5. int temp_nrels = 0;
6. ColFileNodeRel *rels = NULL;
7. int nchildren;
8. TransactionId *children = NULL;
9. int nmsgs = 0;
10. SharedInvalidationMessage *invalMessages = NULL;
11. int nlibrary = 0;
12. char *library_name = NULL;
13. int library_length = 0;
14. bool RelcacheInitFileInval = false;
15. bool wrote_xlog = false;
16. bool isExecCN = (IS_PGXC_COORDINATOR && !IsConnFromCoord());
17. XLogRecPtr globalDelayDDLLSN = InvalidXLogRecPtr;
18. XLogRecPtr commitRecLSN = InvalidXLogRecPtr;
19. nrels = smgrGetPendingDeletes(true, &rels, false, &temp_nrels);
20. nchildren = xactGetCommittedChildren(&children);

将上面的变量做一个简单的概括如下图所示：

可以看到除了简单的赋值初始化变量，简单的宏函数调用以外，变量初始化还用到了两个函数： xactGetCommittedChildren()–将失效消息添加到提交记录中。 返回值由nchildren接收，是失效的子事务数量

smgrGetPendingDeletes() – 获取待删除的非临时关系列表。 返回值由nrels接受，是预定的删除事务数量， 通过传入实参，rels被设置为指向一个新分配的RelFileNodes数组,temp_nrels被设置为临时关系的数量

事务处理主体

检查是否有提交XID标记

2. if (!markXidCommitted) {
4. if (nrels != 0)
5. ereport(ERROR, (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
6. errmsg("cannot commit a transaction that deleted files but has no xid")));
9. Assert(nchildren == 0);
11. #ifdef ENABLE_MOT
13. CallXactCallbacks(XACT_EVENT_RECORD_COMMIT);
15. if (t_thrd.xlog_cxt.XactLastRecEnd != 0) {
16. wrote_xlog = true;
17. }
18. #endif
21. if (!wrote_xlog) {
22. goto cleanup;
23. }
24. }

检查是否有提交XID标记，对于没有标记提交XID，但是nrels！=0的的情况进行报错，因为不能提交一项没有XID却还要删除文件的事项。如果提交了，将会对数据库文件恢复造成困难，事务回滚操作找不到对应的 xid

如果没有定义内存引擎的使用，此时将会直接跳转到函数结尾——clean up，而此时的reles指针若为NULL(),否则会释放它所指向的文件

1. else {
3. if (TransactionIdDidAbort(xid))
4. ereport(PANIC, (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
5. errmsg("cannot commit transaction %lu, it was already aborted", xid)));
8. BufmgrCommit();
10. START_CRIT_SECTION();
11. t_thrd.pgxact->delayChkpt = true;
13. if (useLocalXid || !IsPostmasterEnvironment || GTM_FREE_MODE) {
14. #ifndef ENABLE_MULTIPLE_NODES
16. CommitSeqNo csn = SetXact2CommitInProgress(xid, 0);
17. XLogInsertStandbyCSNCommitting(xid, csn, children, nchildren);
18. #else
20. SetXact2CommitInProgress(xid, 0);
21. #endif
22. setCommitCsn(getLocalNextCSN());
23. } else {
24. if (TransactionIdIsNormal(xid) &&
25. (!(useLocalXid || !IsPostmasterEnvironment || GTM_FREE_MODE || GetForceXidFromGTM())) &&
26. (GetCommitCsn() == 0)) {
27. CommitSeqNo csn = SetXact2CommitInProgress(xid, 0);
28. XLogInsertStandbyCSNCommitting(xid, csn, children, nchildren);
29. END_CRIT_SECTION();
30. PG_TRY();
31. {
33. ereport(LOG, (errmsg("Set a new csn from gtm for auto commit transactions.")));
34. setCommitCsn(CommitCSNGTM(true));
35. }
36. PG_CATCH();
37. {
39. t_thrd.pgxact->delayChkpt = false;
40. PG_RE_THROW();
41. }
42. PG_END_TRY();
43. START_CRIT_SECTION();
44. }
45. }
47. #ifdef ENABLE_MOT
49. CallXactCallbacks(XACT_EVENT_RECORD_COMMIT);
50. #endif
53. UpdateNextMaxKnownCSN(GetCommitCsn());
55. SetCurrentTransactionStopTimestamp();
57. #ifdef ENABLE_MULTIPLE_NODES
58. bool hasOrigin = false;
59. #else
60. bool hasOrigin = u_sess->reporigin_cxt.originId != InvalidRepOriginId &&
61. u_sess->reporigin_cxt.originId != DoNotReplicateId;
62. #endif

对于没有标记XID提交的，先对事务ID是否已经取消，不能对取消的事务进行操作。 然后调用BufmgrCommit()为提交XLOG做准备，这里是一个空函数，所有对于bufmgr层面的提交事务都需要调用这个空函数，给系统确认的时间。

然后将自己标记为处于提交关键区域内这强制任何并发的检查点等待，直到我们更新pg_clog。如果没有这个，检查点可能会在XLOG记录之后设置REDO，但未能将pg_clog更新刷新到磁盘，如果系统稍后崩溃，可能会导致事务提交丢失。注意：我们可以，但不需要在 RecordTransactionAbort中设置此标志。这是因为丢失一个事务中止是非关键的；假设它反正已经中止了。 在不持有ProcArrayLock的情况下，更改我们自己后台的delayChkpt标志是安全的， 因为我们是唯一修改它的人。 这使得检查点确定哪些xacts是delayChkpt有点模糊， 但这并不重要。

事务环境检查

1. if (nrels > 0 || nmsgs > 0 || RelcacheInitFileInval || t_thrd.xact_cxt.forceSyncCommit ||
2. XLogLogicalInfoActive() || hasOrigin) {
3. xl_xact_commit xlrec;
4. xl_xact_origin origin;
7. xlrec.xinfo = 0;
8. if (RelcacheInitFileInval)
9. xlrec.xinfo |= XACT_COMPLETION_UPDATE_RELCACHE_FILE;
10. if (t_thrd.xact_cxt.forceSyncCommit)
11. xlrec.xinfo |= XACT_COMPLETION_FORCE_SYNC_COMMIT;
12. #ifdef ENABLE_MOT
13. if (IsMOTEngineUsed() || IsMixedEngineUsed()) {
14. xlrec.xinfo |= XACT_MOT_ENGINE_USED;
15. }
16. #endif
17. if (hasOrigin) {
18. xlrec.xinfo |= XACT_HAS_ORIGIN;
19. }
21. xlrec.dbId = u_sess->proc_cxt.MyDatabaseId;
22. xlrec.tsId = u_sess->proc_cxt.MyDatabaseTableSpace;
23. xlrec.csn = GetCommitCsn();
25. #ifdef PGXC
27. xlrec.xact_time = t_thrd.xact_cxt.xactStopTimestamp + t_thrd.xact_cxt.GTMdeltaTimestamp;
28. #else
29. xlrec.xact_time = t_thrd.xact_cxt.xactStopTimestamp;
30. #endif
31. xlrec.nrels = nrels;
32. xlrec.nsubxacts = nchildren;
33. xlrec.nmsgs = nmsgs;
34. xlrec.nlibrary = nlibrary;
36. XLogBeginInsert();
37. XLogRegisterData((char *)(&xlrec), MinSizeOfXactCommit);
38. if (nrels > 0) {
39. XLogRegisterData((char *)rels, nrels * sizeof(ColFileNodeRel));
40. (void)LWLockAcquire(DelayDDLLock, LW_SHARED);
41. }
42. if (nchildren > 0) {
43. XLogRegisterData((char *)children, nchildren * sizeof(TransactionId));
44. }
45. if (nmsgs > 0) {
46. XLogRegisterData((char *)invalMessages, nmsgs * sizeof(SharedInvalidationMessage));
47. }
49. #ifndef ENABLE_MULTIPLE_NODES
50. XLogRegisterData((char *) &u_sess->utils_cxt.RecentXmin, sizeof(TransactionId));
51. #endif
53. if (nlibrary > 0) {
54. XLogRegisterData((char *)library_name, library_length);
55. }
57. if (hasOrigin) {
58. origin.origin_lsn = u_sess->reporigin_cxt.originLsn;
59. origin.origin_timestamp = u_sess->reporigin_cxt.originTs;
60. XLogRegisterData((char*)&origin, sizeof(xl_xact_origin));
61. }
62. XLogIncludeOrigin();
64. commitRecLSN = XLogInsert(RM_XACT_ID, XLOG_XACT_COMMIT);
66. if (nrels > 0) {
67. globalDelayDDLLSN = GetDDLDelayStartPtr();
68. if (!XLogRecPtrIsInvalid(globalDelayDDLLSN) && XLByteLT(globalDelayDDLLSN, commitRecLSN))
69. t_thrd.xact_cxt.xactDelayDDL = true;
70. else
71. t_thrd.xact_cxt.xactDelayDDL = false;
73. LWLockRelease(DelayDDLLock);
74. }
75. if (hasOrigin) {
76. replorigin_session_advance(u_sess->reporigin_cxt.originLsn, t_thrd.xlog_cxt.XactLastRecEnd);
77. }
78. } else {
79. xl_xact_commit_compact xlrec;
80. xlrec.xact_time = t_thrd.xact_cxt.xactStopTimestamp;
81. xlrec.csn = GetCommitCsn();
82. xlrec.nsubxacts = nchildren;
83. XLogBeginInsert();
84. XLogRegisterData((char *)(&xlrec), MinSizeOfXactCommitCompact);
85. if (nchildren > 0) {
86. XLogRegisterData((char *)children, nchildren * sizeof(TransactionId));
87. }
89. #ifndef ENABLE_MULTIPLE_NODES
90. XLogRegisterData((char *) &u_sess->utils_cxt.RecentXmin, sizeof(TransactionId));
91. #endif
93. XLogIncludeOrigin();
95. (void)XLogInsert(RM_XACT_ID, XLOG_XACT_COMMIT_COMPACT);
96. }
97. }

这段代码涉及到数据库系统中的事务处理、日志记录、缓存管理等多个方面，在这一部分首先对如下关系进行检查

变量名	含义
nrels	需要处理的关系
nmsgs	无效消息
RelcacheInitFileInval	关系缓存无效标志
t_thrd.xact_cxt.forceSyncCommi	强制同步提交标志
XLogLogicalInfoActive()	逻辑日志信息活动
hasOrigin	原始事务

如果满足任一条件，然后它会执行以下操作：

1. 初始化一个xl_xact_commit结构体，用于记录事务提交的信息。
2. 根据不同的条件设置xlrec.xinfo的不同位。
3. 设置数据库ID、表空间ID和提交序列号（CSN）。
4. 设置事务时间戳。
5. 设置关系数、子事务数、无效消息数和库数。
6. 调用XLogBeginInsert()开始一个新的日志记录。
7. 调用XLogRegisterData()将各种数据注册到日志记录中。
8. 如果有原始事务，还会将原始事务的LSN和时间戳注册到日志记录中。
9. 调用XLogInsert()将日志记录插入到WAL中。
10. 如果有关系需要处理，还会更新全局的DDL延迟LSN，并根据需要设置事务的DDL延迟标志。
11. 如果有原始事务，还会更新会话的原始LSN。

1. if ((wrote_xlog && u_sess->attr.attr_storage.guc_synchronous_commit > SYNCHRONOUS_COMMIT_OFF) ||
2. t_thrd.xact_cxt.forceSyncCommit || nrels > 0) {
3. if (!IsInitdb && g_instance.attr.attr_storage.dcf_attr.enable_dcf) {
4. SyncPaxosWaitForLSN(t_thrd.xlog_cxt.XactLastRecEnd);
5. } else {
6. XLogWaitFlush(t_thrd.xlog_cxt.XactLastRecEnd);
7. if (wrote_xlog && u_sess->attr.attr_storage.guc_synchronous_commit > SYNCHRONOUS_COMMIT_LOCAL_FLUSH) {
8. SyncRepWaitForLSN(t_thrd.xlog_cxt.XactLastRecEnd, !markXidCommitted);
9. g_instance.comm_cxt.localinfo_cxt.set_term = true;
10. }
11. }
12. if (markXidCommitted) {
13. t_thrd.pgxact->needToSyncXid |= SNAPSHOT_UPDATE_NEED_SYNC;
14. TransactionIdCommitTree(xid, nchildren, children, GetCommitCsn());
15. }
16. } else {
18. if (markXidCommitted) {
19. t_thrd.pgxact->needToSyncXid |= SNAPSHOT_UPDATE_NEED_SYNC;
20. TransactionIdAsyncCommitTree(xid, nchildren, children, t_thrd.xlog_cxt.XactLastRecEnd, GetCommitCsn());
21. }
22. }

它首先检查是否满足以下任一条件：写入了XLOG、设置了强制同步提交标志，或者有关系需要处理。

变量名	含义
wrote_xlo，guc_synchronous_commit > SYNCHRONOUS_COMMIT_OFF	写入了XLOG，设置了强制同步提交标志
t_thrd.xact_cxt.forceSyncCommit	设置了强制同步提交标志
nrels	有关系需要处理

1. 如果不是在初始化数据库，并且启用了DCF（Distributed Consensus Framework），则调用SyncPaxosWaitForLSN()等待Paxos协议同步。
2. 否则，调用XLogWaitFlush()等待XLOG刷新。如果写入了XLOG并且设置了同步提交标志，则调用SyncRepWaitForLSN()等待同步复制，并设置本地信息上下文的set_term标志。
3. 如果需要标记事务ID为已提交，则设置进程的needToSyncXid标志，并调用TransactionIdCommitTree()提交事务。

如果不满足上述任一条件，但需要标记事务ID为已提交，则设置进程的needToSyncXid标志，并调用TransactionIdAsyncCommitTree()异步提交事务。

清理工作

1. if (markXidCommitted) {
2. t_thrd.pgxact->delayChkpt = false;
3. END_CRIT_SECTION();
4. }
5. latestXid = TransactionIdLatest(xid, nchildren, children);
6. t_thrd.xlog_cxt.XactLastCommitEnd = t_thrd.xlog_cxt.XactLastRecEnd;
7. t_thrd.xlog_cxt.XactLastRecEnd = 0;
8. cleanup:
9. if (rels != NULL)
10. pfree(rels);
11. return latestXid;

最后进行处理数据库事务提交后的清理工作。它首先检查是否需要标记事务ID为已提交。如果需要，它会将进程的delayChkpt标志设置为假，并结束关键区域。然后，它会计算最新的事务ID，并将最后一次提交的结束位置保存到XactLastCommitEnd中，同时将XactLastRecEnd重置为0。

在cleanup:标签下，它会检查是否有关系需要处理。如果有，它会释放关系数组的内存。最后，它返回最新的事务ID。

四、小结

RecordTransactionCommit是一个非常复杂的函数，它调用的函数之多，涉及的数据库概念之综合，是我之前解读的函数所远不能及的。刚开始他让我无从下手，因为他实在是太长了，调用函数太多了，然我陷入了一个陷阱——无止境的分析其调用函数，后面我决定不求甚解，只去了解调用函数的作用，而非实现，终于走出了怪圈。诚然如此，他的逻辑却并不显得复杂，对事务的标记与否，阻塞与否，同步提交与否每一个进行了逐一判断，庞杂而不凌乱，在这里我们可以看到数据库事务提交的全而精。笔者能力有限，本次分析没有对预定义的条件分支进行详尽解读，希望以后有机会能够更精细的学习。如有错漏，烦请指正。