| blob | c9516e03faee70171b5f718bd5b7d4c5e291ae4f |
1 /*-------------------------------------------------------------------------
2 *
3 * xact.c
4 * top level transaction system support routines
5 *
6 * See src/backend/access/transam/README for more information.
7 *
8 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
9 * Portions Copyright (c) 1994, Regents of the University of California
10 *
11 *
12 * IDENTIFICATION
13 * src/backend/access/transam/xact.c
14 *
15 *-------------------------------------------------------------------------
16 */
20 #include <time.h>
21 #include <unistd.h>
73 /*
74 * User-tweakable parameters
75 */
87 /*
88 * CheckXidAlive is a xid value pointing to a possibly ongoing (sub)
89 * transaction. Currently, it is used in logical decoding. It's possible
90 * that such transactions can get aborted while the decoding is ongoing in
91 * which case we skip decoding that particular transaction. To ensure that we
92 * check whether the CheckXidAlive is aborted after fetching the tuple from
93 * system tables. We also ensure that during logical decoding we never
94 * directly access the tableam or heap APIs because we are checking for the
95 * concurrent aborts only in systable_* APIs.
96 */
100 /*
101 * When running as a parallel worker, we place only a single
102 * TransactionStateData on the parallel worker's state stack, and the XID
103 * reflected there will be that of the *innermost* currently-active
104 * subtransaction in the backend that initiated parallelism. However,
105 * GetTopTransactionId() and TransactionIdIsCurrentTransactionId()
106 * need to return the same answers in the parallel worker as they would have
107 * in the user backend, so we need some additional bookkeeping.
108 *
109 * XactTopFullTransactionId stores the XID of our toplevel transaction, which
110 * will be the same as TopTransactionStateData.fullTransactionId in an
111 * ordinary backend; but in a parallel backend, which does not have the entire
112 * transaction state, it will instead be copied from the backend that started
113 * the parallel operation.
114 *
115 * nParallelCurrentXids will be 0 and ParallelCurrentXids NULL in an ordinary
116 * backend, but in a parallel backend, nParallelCurrentXids will contain the
117 * number of XIDs that need to be considered current, and ParallelCurrentXids
118 * will contain the XIDs themselves. This includes all XIDs that were current
119 * or sub-committed in the parent at the time the parallel operation began.
120 * The XIDs are stored sorted in numerical order (not logical order) to make
121 * lookups as fast as possible.
122 */
127 /*
128 * Miscellaneous flag bits to record events which occur on the top level
129 * transaction. These flags are only persisted in MyXactFlags and are intended
130 * so we remember to do certain things later on in the transaction. This is
131 * globally accessible, so can be set from anywhere in the code that requires
132 * recording flags.
133 */
136 /*
137 * transaction states - transaction state from server perspective
138 */
140 {
146 TRANS_PREPARE /* prepare in progress */
149 /*
150 * transaction block states - transaction state of client queries
151 *
152 * Note: the subtransaction states are used only for non-topmost
153 * transactions; the others appear only in the topmost transaction.
154 */
156 {
157 /* not-in-transaction-block states */
161 /* transaction block states */
172 /* subtransaction states */
181 TBLOCK_SUBABORT_RESTART /* failed subxact, ROLLBACK TO received */
184 /*
185 * transaction state structure
186 */
188 {
215 /*
216 * Serialized representation used to transmit transaction state to parallel
217 * workers through shared memory.
218 */
220 {
223 FullTransactionId topFullTransactionId;
224 FullTransactionId currentFullTransactionId;
225 CommandId currentCommandId;
230 /* The size of SerializedTransactionState, not including the final array. */
231 #define SerializedTransactionStateHeaderSize \
232 offsetof(SerializedTransactionState, parallelCurrentXids)
234 /*
235 * CurrentTransactionState always points to the current transaction state
236 * block. It will point to TopTransactionStateData when not in a
237 * transaction at all, or when in a top-level transaction.
238 */
243 };
245 /*
246 * unreportedXids holds XIDs of all subtransactions that have not yet been
247 * reported in an XLOG_XACT_ASSIGNMENT record.
248 */
254 /*
255 * The subtransaction ID and command ID assignment counters are global
256 * to a whole transaction, so we do not keep them in the state stack.
257 */
262 /*
263 * xactStartTimestamp is the value of transaction_timestamp().
264 * stmtStartTimestamp is the value of statement_timestamp().
265 * xactStopTimestamp is the time at which we log a commit or abort WAL record.
266 * These do not change as we enter and exit subtransactions, so we don't
267 * keep them inside the TransactionState stack.
268 */
273 /*
274 * GID to be used for preparing the current transaction. This is also
275 * global to a whole transaction, so we don't keep it in the state stack.
276 */
279 /*
280 * Some commands want to force synchronous commit.
281 */
284 /* Flag for logging statements in a transaction. */
287 /*
288 * Private context for transaction-abort work --- we reserve space for this
289 * at startup to ensure that AbortTransaction and AbortSubTransaction can work
290 * when we've run out of memory.
291 */
294 /*
295 * List of add-on start- and end-of-xact callbacks
296 */
298 {
300 XactCallback callback;
306 /*
307 * List of add-on start- and end-of-subxact callbacks
308 */
310 {
312 SubXactCallback callback;
319 /* local function prototypes */
332 SubTransactionId mySubid,
333 SubTransactionId parentSubid);
361 /* ----------------------------------------------------------------
362 * transaction state accessors
363 * ----------------------------------------------------------------
364 */
366 /*
367 * IsTransactionState
368 *
369 * This returns true if we are inside a valid transaction; that is,
370 * it is safe to initiate database access, take heavyweight locks, etc.
371 */
372 bool
374 {
377 /*
378 * TRANS_DEFAULT and TRANS_ABORT are obviously unsafe states. However, we
379 * also reject the startup/shutdown states TRANS_START, TRANS_COMMIT,
380 * TRANS_PREPARE since it might be too soon or too late within those
381 * transition states to do anything interesting. Hence, the only "valid"
382 * state is TRANS_INPROGRESS.
383 */
385 }
387 /*
388 * IsAbortedTransactionBlockState
389 *
390 * This returns true if we are within an aborted transaction block.
391 */
392 bool
394 {
402 }
405 /*
406 * GetTopTransactionId
407 *
408 * This will return the XID of the main transaction, assigning one if
409 * it's not yet set. Be careful to call this only inside a valid xact.
410 */
411 TransactionId
413 {
417 }
419 /*
420 * GetTopTransactionIdIfAny
421 *
422 * This will return the XID of the main transaction, if one is assigned.
423 * It will return InvalidTransactionId if we are not currently inside a
424 * transaction, or inside a transaction that hasn't yet been assigned an XID.
425 */
426 TransactionId
428 {
430 }
432 /*
433 * GetCurrentTransactionId
434 *
435 * This will return the XID of the current transaction (main or sub
436 * transaction), assigning one if it's not yet set. Be careful to call this
437 * only inside a valid xact.
438 */
439 TransactionId
441 {
447 }
449 /*
450 * GetCurrentTransactionIdIfAny
451 *
452 * This will return the XID of the current sub xact, if one is assigned.
453 * It will return InvalidTransactionId if we are not currently inside a
454 * transaction, or inside a transaction that hasn't been assigned an XID yet.
455 */
456 TransactionId
458 {
460 }
462 /*
463 * GetTopFullTransactionId
464 *
465 * This will return the FullTransactionId of the main transaction, assigning
466 * one if it's not yet set. Be careful to call this only inside a valid xact.
467 */
468 FullTransactionId
470 {
474 }
476 /*
477 * GetTopFullTransactionIdIfAny
478 *
479 * This will return the FullTransactionId of the main transaction, if one is
480 * assigned. It will return InvalidFullTransactionId if we are not currently
481 * inside a transaction, or inside a transaction that hasn't yet been assigned
482 * one.
483 */
484 FullTransactionId
486 {
488 }
490 /*
491 * GetCurrentFullTransactionId
492 *
493 * This will return the FullTransactionId of the current transaction (main or
494 * sub transaction), assigning one if it's not yet set. Be careful to call
495 * this only inside a valid xact.
496 */
497 FullTransactionId
499 {
505 }
507 /*
508 * GetCurrentFullTransactionIdIfAny
509 *
510 * This will return the FullTransactionId of the current sub xact, if one is
511 * assigned. It will return InvalidFullTransactionId if we are not currently
512 * inside a transaction, or inside a transaction that hasn't been assigned one
513 * yet.
514 */
515 FullTransactionId
517 {
519 }
521 /*
522 * MarkCurrentTransactionIdLoggedIfAny
523 *
524 * Remember that the current xid - if it is assigned - now has been wal logged.
525 */
526 void
528 {
531 }
533 /*
534 * IsSubxactTopXidLogPending
535 *
536 * This is used to decide whether we need to WAL log the top-level XID for
537 * operation in a subtransaction. We require that for logical decoding, see
538 * LogicalDecodingProcessRecord.
539 *
540 * This returns true if wal_level >= logical and we are inside a valid
541 * subtransaction, for which the assignment was not yet written to any WAL
542 * record.
543 */
544 bool
546 {
547 /* check whether it is already logged */
551 /* wal_level has to be logical */
555 /* we need to be in a transaction state */
559 /* it has to be a subtransaction */
563 /* the subtransaction has to have a XID assigned */
568 }
570 /*
571 * MarkSubxactTopXidLogged
572 *
573 * Remember that the top transaction id for the current subtransaction is WAL
574 * logged now.
575 */
576 void
578 {
582 }
584 /*
585 * GetStableLatestTransactionId
586 *
587 * Get the transaction's XID if it has one, else read the next-to-be-assigned
588 * XID. Once we have a value, return that same value for the remainder of the
589 * current transaction. This is meant to provide the reference point for the
590 * age(xid) function, but might be useful for other maintenance tasks as well.
591 */
592 TransactionId
594 {
599 {
604 }
609 }
611 /*
612 * AssignTransactionId
613 *
614 * Assigns a new permanent FullTransactionId to the given TransactionState.
615 * We do not assign XIDs to transactions until/unless this is called.
616 * Also, any parent TransactionStates that don't yet have XIDs are assigned
617 * one; this maintains the invariant that a child transaction has an XID
618 * following its parent's.
619 */
620 static void
622 {
624 ResourceOwner currentOwner;
627 /* Assert that caller didn't screw up */
631 /*
632 * Workers synchronize transaction state at the beginning of each parallel
633 * operation, so we can't account for new XIDs at this point.
634 */
638 /*
639 * Ensure parent(s) have XIDs, so that a child always has an XID later
640 * than its parent. Mustn't recurse here, or we might get a stack
641 * overflow if we're at the bottom of a huge stack of subtransactions none
642 * of which have XIDs yet.
643 */
645 {
652 {
655 }
657 /*
658 * This is technically a recursive call, but the recursion will never
659 * be more than one layer deep.
660 */
665 }
667 /*
668 * When wal_level=logical, guarantee that a subtransaction's xid can only
669 * be seen in the WAL stream if its toplevel xid has been logged before.
670 * If necessary we log an xact_assignment record with fewer than
671 * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
672 * for a transaction even though it appears in a WAL record, we just might
673 * superfluously log something. That can happen when an xid is included
674 * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
675 * xl_standby_locks.
676 */
681 /*
682 * Generate a new FullTransactionId and record its xid in PG_PROC and
683 * pg_subtrans.
684 *
685 * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
686 * shared storage other than PG_PROC; because if there's no room for it in
687 * PG_PROC, the subtrans entry is needed to ensure that other backends see
688 * the Xid as "running". See GetNewTransactionId.
689 */
698 /*
699 * If it's a top-level transaction, the predicate locking system needs to
700 * be told about it too.
701 */
705 /*
706 * Acquire lock on the transaction XID. (We assume this cannot block.) We
707 * have to ensure that the lock is assigned to the transaction's own
708 * ResourceOwner.
709 */
717 /*
718 * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
719 * top-level transaction we issue a WAL record for the assignment. We
720 * include the top-level xid and all the subxids that have not yet been
721 * reported using XLOG_XACT_ASSIGNMENT records.
722 *
723 * This is required to limit the amount of shared memory required in a hot
724 * standby server to keep track of in-progress XIDs. See notes for
725 * RecordKnownAssignedTransactionIds().
726 *
727 * We don't keep track of the immediate parent of each subxid, only the
728 * top-level transaction that each subxact belongs to. This is correct in
729 * recovery only because aborted subtransactions are separately WAL
730 * logged.
731 *
732 * This is correct even for the case where several levels above us didn't
733 * have an xid assigned as we recursed up to them beforehand.
734 */
736 {
738 nUnreportedXids++;
740 /*
741 * ensure this test matches similar one in
742 * RecoverPreparedTransactions()
743 */
745 log_unknown_top)
746 {
747 xl_xact_assignment xlrec;
749 /*
750 * xtop is always set by now because we recurse up transaction
751 * stack to the highest unassigned xid and then come back down
752 */
765 /* mark top, not current xact as having been logged */
767 }
768 }
769 }
771 /*
772 * GetCurrentSubTransactionId
773 */
774 SubTransactionId
776 {
780 }
782 /*
783 * SubTransactionIsActive
784 *
785 * Test if the specified subxact ID is still active. Note caller is
786 * responsible for checking whether this ID is relevant to the current xact.
787 */
788 bool
790 {
791 TransactionState s;
794 {
799 }
801 }
804 /*
805 * GetCurrentCommandId
806 *
807 * "used" must be true if the caller intends to use the command ID to mark
808 * inserted/updated/deleted tuples. false means the ID is being fetched
809 * for read-only purposes (ie, as a snapshot validity cutoff). See
810 * CommandCounterIncrement() for discussion.
811 */
812 CommandId
814 {
815 /* this is global to a transaction, not subtransaction-local */
817 {
818 /*
819 * Forbid setting currentCommandIdUsed in a parallel worker, because
820 * we have no provision for communicating this back to the leader. We
821 * could relax this restriction when currentCommandIdUsed was already
822 * true at the start of the parallel operation.
823 */
826 }
828 }
830 /*
831 * SetParallelStartTimestamps
832 *
833 * In a parallel worker, we should inherit the parent transaction's
834 * timestamps rather than setting our own. The parallel worker
835 * infrastructure must call this to provide those values before
836 * calling StartTransaction() or SetCurrentStatementStartTimestamp().
837 */
838 void
840 {
844 }
846 /*
847 * GetCurrentTransactionStartTimestamp
848 */
849 TimestampTz
851 {
853 }
855 /*
856 * GetCurrentStatementStartTimestamp
857 */
858 TimestampTz
860 {
862 }
864 /*
865 * GetCurrentTransactionStopTimestamp
866 *
867 * We return current time if the transaction stop time hasn't been set
868 * (which can happen if we decide we don't need to log an XLOG record).
869 */
870 TimestampTz
872 {
876 }
878 /*
879 * SetCurrentStatementStartTimestamp
880 *
881 * In a parallel worker, this should already have been provided by a call
882 * to SetParallelStartTimestamps().
883 */
884 void
886 {
889 else
891 }
893 /*
894 * SetCurrentTransactionStopTimestamp
895 */
898 {
900 }
902 /*
903 * GetCurrentTransactionNestLevel
904 *
905 * Note: this will return zero when not inside any transaction, one when
906 * inside a top-level transaction, etc.
907 */
908 int
910 {
914 }
917 /*
918 * TransactionIdIsCurrentTransactionId
919 */
920 bool
922 {
923 TransactionState s;
925 /*
926 * We always say that BootstrapTransactionId is "not my transaction ID"
927 * even when it is (ie, during bootstrap). Along with the fact that
928 * transam.c always treats BootstrapTransactionId as already committed,
929 * this causes the heapam_visibility.c routines to see all tuples as
930 * committed, which is what we need during bootstrap. (Bootstrap mode
931 * only inserts tuples, it never updates or deletes them, so all tuples
932 * can be presumed good immediately.)
933 *
934 * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
935 * not my transaction ID, so we can just return "false" immediately for
936 * any non-normal XID.
937 */
944 /*
945 * In parallel workers, the XIDs we must consider as current are stored in
946 * ParallelCurrentXids rather than the transaction-state stack. Note that
947 * the XIDs in this array are sorted numerically rather than according to
948 * transactionIdPrecedes order.
949 */
951 {
953 high;
958 {
960 TransactionId probe;
968 else
970 }
972 }
974 /*
975 * We will return true for the Xid of the current subtransaction, any of
976 * its subcommitted children, any of its parents, or any of their
977 * previously subcommitted children. However, a transaction being aborted
978 * is no longer "current", even though it may still have an entry on the
979 * state stack.
980 */
982 {
984 high;
992 /* As the childXids array is ordered, we can use binary search */
996 {
998 TransactionId probe;
1006 else
1008 }
1009 }
1012 }
1014 /*
1015 * TransactionStartedDuringRecovery
1016 *
1017 * Returns true if the current transaction started while recovery was still
1018 * in progress. Recovery might have ended since so RecoveryInProgress() might
1019 * return false already.
1020 */
1021 bool
1023 {
1025 }
1027 /*
1028 * EnterParallelMode
1029 */
1030 void
1032 {
1038 }
1040 /*
1041 * ExitParallelMode
1042 */
1043 void
1045 {
1052 }
1054 /*
1055 * IsInParallelMode
1056 *
1057 * Are we in a parallel operation, as either the leader or a worker? Check
1058 * this to prohibit operations that change backend-local state expected to
1059 * match across all workers. Mere caches usually don't require such a
1060 * restriction. State modified in a strict push/pop fashion, such as the
1061 * active snapshot stack, is often fine.
1062 */
1063 bool
1065 {
1067 }
1069 /*
1070 * CommandCounterIncrement
1071 */
1072 void
1074 {
1075 /*
1076 * If the current value of the command counter hasn't been "used" to mark
1077 * tuples, we need not increment it, since there's no need to distinguish
1078 * a read-only command from others. This helps postpone command counter
1079 * overflow, and keeps no-op CommandCounterIncrement operations cheap.
1080 */
1082 {
1083 /*
1084 * Workers synchronize transaction state at the beginning of each
1085 * parallel operation, so we can't account for new commands after that
1086 * point.
1087 */
1093 {
1098 }
1101 /* Propagate new command ID into static snapshots */
1104 /*
1105 * Make any catalog changes done by the just-completed command visible
1106 * in the local syscache. We obviously don't need to do this after a
1107 * read-only command. (But see hacks in inval.c to make real sure we
1108 * don't think a command that queued inval messages was read-only.)
1109 */
1111 }
1112 }
1114 /*
1115 * ForceSyncCommit
1116 *
1117 * Interface routine to allow commands to force a synchronous commit of the
1118 * current top-level transaction. Currently, two-phase commit does not
1119 * persist and restore this variable. So long as all callers use
1120 * PreventInTransactionBlock(), that omission has no consequences.
1121 */
1122 void
1124 {
1126 }
1129 /* ----------------------------------------------------------------
1130 * StartTransaction stuff
1131 * ----------------------------------------------------------------
1132 */
1134 /*
1135 * AtStart_Cache
1136 */
1137 static void
1139 {
1141 }
1143 /*
1144 * AtStart_Memory
1145 */
1146 static void
1148 {
1151 /*
1152 * If this is the first time through, create a private context for
1153 * AbortTransaction to work in. By reserving some space now, we can
1154 * insulate AbortTransaction from out-of-memory scenarios. Like
1155 * ErrorContext, we set it up with slow growth rate and a nonzero minimum
1156 * size, so that space will be reserved immediately.
1157 */
1159 TransactionAbortContext =
1166 /*
1167 * We shouldn't have a transaction context already.
1168 */
1171 /*
1172 * Create a toplevel context for the transaction.
1173 */
1174 TopTransactionContext =
1177 ALLOCSET_DEFAULT_SIZES);
1179 /*
1180 * In a top-level transaction, CurTransactionContext is the same as
1181 * TopTransactionContext.
1182 */
1186 /* Make the CurTransactionContext active. */
1188 }
1190 /*
1191 * AtStart_ResourceOwner
1192 */
1193 static void
1195 {
1198 /*
1199 * We shouldn't have a transaction resource owner already.
1200 */
1203 /*
1204 * Create a toplevel resource owner for the transaction.
1205 */
1211 }
1213 /* ----------------------------------------------------------------
1214 * StartSubTransaction stuff
1215 * ----------------------------------------------------------------
1216 */
1218 /*
1219 * AtSubStart_Memory
1220 */
1221 static void
1223 {
1228 /*
1229 * Create a CurTransactionContext, which will be used to hold data that
1230 * survives subtransaction commit but disappears on subtransaction abort.
1231 * We make it a child of the immediate parent's CurTransactionContext.
1232 */
1235 ALLOCSET_DEFAULT_SIZES);
1238 /* Make the CurTransactionContext active. */
1240 }
1242 /*
1243 * AtSubStart_ResourceOwner
1244 */
1245 static void
1247 {
1252 /*
1253 * Create a resource owner for the subtransaction. We make it a child of
1254 * the immediate parent's resource owner.
1255 */
1262 }
1264 /* ----------------------------------------------------------------
1265 * CommitTransaction stuff
1266 * ----------------------------------------------------------------
1267 */
1269 /*
1270 * RecordTransactionCommit
1271 *
1272 * Returns latest XID among xact and its children, or InvalidTransactionId
1273 * if the xact has no XID. (We compute that here just because it's easier.)
1274 *
1275 * If you change this function, see RecordTransactionCommitPrepared also.
1276 */
1277 static TransactionId
1279 {
1292 /*
1293 * Log pending invalidations for logical decoding of in-progress
1294 * transactions. Normally for DDLs, we log this at each command end,
1295 * however, for certain cases where we directly update the system table
1296 * without a transaction block, the invalidations are not logged till this
1297 * time.
1298 */
1302 /* Get data needed for commit record */
1310 /*
1311 * If we haven't been assigned an XID yet, we neither can, nor do we want
1312 * to write a COMMIT record.
1313 */
1315 {
1316 /*
1317 * We expect that every RelationDropStorage is followed by a catalog
1318 * update, and hence XID assignment, so we shouldn't get here with any
1319 * pending deletes. Use a real test not just an Assert to check this,
1320 * since it's a bit fragile.
1321 */
1325 /* Can't have child XIDs either; AssignTransactionId enforces this */
1328 /*
1329 * Transactions without an assigned xid can contain invalidation
1330 * messages (e.g. explicit relcache invalidations or catcache
1331 * invalidations for inplace updates); standbys need to process those.
1332 * We can't emit a commit record without an xid, and we don't want to
1333 * force assigning an xid, because that'd be problematic for e.g.
1334 * vacuum. Hence we emit a bespoke record for the invalidations. We
1335 * don't want to use that in case a commit record is emitted, so they
1336 * happen synchronously with commits (besides not wanting to emit more
1337 * WAL records).
1338 */
1340 {
1342 RelcacheInitFileInval);
1344 }
1346 /*
1347 * If we didn't create XLOG entries, we're done here; otherwise we
1348 * should trigger flushing those entries the same as a commit record
1349 * would. This will primarily happen for HOT pruning and the like; we
1350 * want these to be flushed to disk in due time.
1351 */
1354 }
1355 else
1356 {
1359 /*
1360 * Are we using the replication origins feature? Or, in other words,
1361 * are we replaying remote actions?
1362 */
1366 /*
1367 * Begin commit critical section and insert the commit XLOG record.
1368 */
1369 /* Tell bufmgr and smgr to prepare for commit */
1372 /*
1373 * Mark ourselves as within our "commit critical section". This
1374 * forces any concurrent checkpoint to wait until we've updated
1375 * pg_xact. Without this, it is possible for the checkpoint to set
1376 * REDO after the XLOG record but fail to flush the pg_xact update to
1377 * disk, leading to loss of the transaction commit if the system
1378 * crashes a little later.
1379 *
1380 * Note: we could, but don't bother to, set this flag in
1381 * RecordTransactionAbort. That's because loss of a transaction abort
1382 * is noncritical; the presumption would be that it aborted, anyway.
1383 *
1384 * It's safe to change the delayChkpt flag of our own backend without
1385 * holding the ProcArrayLock, since we're the only one modifying it.
1386 * This makes checkpoint's determination of which xacts are delayChkpt
1387 * a bit fuzzy, but it doesn't matter.
1388 */
1397 RelcacheInitFileInval,
1398 MyXactFlags,
1402 /* Move LSNs forward for this replication origin */
1404 XactLastRecEnd);
1406 /*
1407 * Record commit timestamp. The value comes from plain commit
1408 * timestamp if there's no replication origin; otherwise, the
1409 * timestamp was already set in replorigin_session_origin_timestamp by
1410 * replication.
1411 *
1412 * We don't need to WAL-log anything here, as the commit record
1413 * written above already contains the data.
1414 */
1420 replorigin_session_origin_timestamp,
1421 replorigin_session_origin);
1422 }
1424 /*
1425 * Check if we want to commit asynchronously. We can allow the XLOG flush
1426 * to happen asynchronously if synchronous_commit=off, or if the current
1427 * transaction has not performed any WAL-logged operation or didn't assign
1428 * an xid. The transaction can end up not writing any WAL, even if it has
1429 * an xid, if it only wrote to temporary and/or unlogged tables. It can
1430 * end up having written WAL without an xid if it did HOT pruning. In
1431 * case of a crash, the loss of such a transaction will be irrelevant;
1432 * temp tables will be lost anyway, unlogged tables will be truncated and
1433 * HOT pruning will be done again later. (Given the foregoing, you might
1434 * think that it would be unnecessary to emit the XLOG record at all in
1435 * this case, but we don't currently try to do that. It would certainly
1436 * cause problems at least in Hot Standby mode, where the
1437 * KnownAssignedXids machinery requires tracking every XID assignment. It
1438 * might be OK to skip it only when wal_level < replica, but for now we
1439 * don't.)
1440 *
1441 * However, if we're doing cleanup of any non-temp rels or committing any
1442 * command that wanted to force sync commit, then we must flush XLOG
1443 * immediately. (We must not allow asynchronous commit if there are any
1444 * non-temp tables to be deleted, because we might delete the files before
1445 * the COMMIT record is flushed to disk. We do allow asynchronous commit
1446 * if all to-be-deleted tables are temporary though, since they are lost
1447 * anyway if we crash.)
1448 */
1452 {
1455 /*
1456 * Now we may update the CLOG, if we wrote a COMMIT record above
1457 */
1460 }
1461 else
1462 {
1463 /*
1464 * Asynchronous commit case:
1465 *
1466 * This enables possible committed transaction loss in the case of a
1467 * postmaster crash because WAL buffers are left unwritten. Ideally we
1468 * could issue the WAL write without the fsync, but some
1469 * wal_sync_methods do not allow separate write/fsync.
1470 *
1471 * Report the latest async commit LSN, so that the WAL writer knows to
1472 * flush this commit.
1473 */
1476 /*
1477 * We must not immediately update the CLOG, since we didn't flush the
1478 * XLOG. Instead, we store the LSN up to which the XLOG must be
1479 * flushed before the CLOG may be updated.
1480 */
1483 }
1485 /*
1486 * If we entered a commit critical section, leave it now, and let
1487 * checkpoints proceed.
1488 */
1490 {
1493 }
1495 /* Compute latestXid while we have the child XIDs handy */
1498 /*
1499 * Wait for synchronous replication, if required. Similar to the decision
1500 * above about using committing asynchronously we only want to wait if
1501 * this backend assigned an xid and wrote WAL. No need to wait if an xid
1502 * was assigned due to temporary/unlogged tables or due to HOT pruning.
1503 *
1504 * Note that at this stage we have marked clog, but still show as running
1505 * in the procarray and continue to hold locks.
1506 */
1510 /* remember end of last commit record */
1513 /* Reset XactLastRecEnd until the next transaction writes something */
1515 cleanup:
1516 /* Clean up local data */
1521 }
1524 /*
1525 * AtCCI_LocalCache
1526 */
1527 static void
1529 {
1530 /*
1531 * Make any pending relation map changes visible. We must do this before
1532 * processing local sinval messages, so that the map changes will get
1533 * reflected into the relcache when relcache invals are processed.
1534 */
1537 /*
1538 * Make catalog changes visible to me for the next command.
1539 */
1541 }
1543 /*
1544 * AtCommit_Memory
1545 */
1546 static void
1548 {
1549 /*
1550 * Now that we're "out" of a transaction, have the system allocate things
1551 * in the top memory context instead of per-transaction contexts.
1552 */
1555 /*
1556 * Release all transaction-local memory.
1557 */
1563 }
1565 /* ----------------------------------------------------------------
1566 * CommitSubTransaction stuff
1567 * ----------------------------------------------------------------
1568 */
1570 /*
1571 * AtSubCommit_Memory
1572 */
1573 static void
1575 {
1580 /* Return to parent transaction level's memory context. */
1584 /*
1585 * Ordinarily we cannot throw away the child's CurTransactionContext,
1586 * since the data it contains will be needed at upper commit. However, if
1587 * there isn't actually anything in it, we can throw it away. This avoids
1588 * a small memory leak in the common case of "trivial" subxacts.
1589 */
1591 {
1594 }
1595 }
1597 /*
1598 * AtSubCommit_childXids
1599 *
1600 * Pass my own XID and my child XIDs up to my parent as committed children.
1601 */
1602 static void
1604 {
1610 /*
1611 * The parent childXids array will need to hold my XID and all my
1612 * childXids, in addition to the XIDs already there.
1613 */
1616 /* Allocate or enlarge the parent array if necessary */
1618 {
1622 /*
1623 * Make it 2x what's needed right now, to avoid having to enlarge it
1624 * repeatedly. But we can't go above MaxAllocSize. (The latter limit
1625 * is what ensures that we don't need to worry about integer overflow
1626 * here or in the calculation of new_nChildXids.)
1627 */
1637 /*
1638 * We keep the child-XID arrays in TopTransactionContext; this avoids
1639 * setting up child-transaction contexts for what might be just a few
1640 * bytes of grandchild XIDs.
1641 */
1643 new_childXids =
1646 else
1652 }
1654 /*
1655 * Copy all my XIDs to parent's array.
1656 *
1657 * Note: We rely on the fact that the XID of a child always follows that
1658 * of its parent. By copying the XID of this subtransaction before the
1659 * XIDs of its children, we ensure that the array stays ordered. Likewise,
1660 * all XIDs already in the array belong to subtransactions started and
1661 * subcommitted before us, so their XIDs must precede ours.
1662 */
1672 /* Release child's array to avoid leakage */
1675 /* We must reset these to avoid double-free if fail later in commit */
1679 }
1681 /* ----------------------------------------------------------------
1682 * AbortTransaction stuff
1683 * ----------------------------------------------------------------
1684 */
1686 /*
1687 * RecordTransactionAbort
1688 *
1689 * Returns latest XID among xact and its children, or InvalidTransactionId
1690 * if the xact has no XID. (We compute that here just because it's easier.)
1691 */
1692 static TransactionId
1694 {
1696 TransactionId latestXid;
1701 TimestampTz xact_time;
1703 /*
1704 * If we haven't been assigned an XID, nobody will care whether we aborted
1705 * or not. Hence, we're done in that case. It does not matter if we have
1706 * rels to delete (note that this routine is not responsible for actually
1707 * deleting 'em). We cannot have any child XIDs, either.
1708 */
1710 {
1711 /* Reset XactLastRecEnd until the next transaction writes something */
1715 }
1717 /*
1718 * We have a valid XID, so we should write an ABORT record for it.
1719 *
1720 * We do not flush XLOG to disk here, since the default assumption after a
1721 * crash would be that we aborted, anyway. For the same reason, we don't
1722 * need to worry about interlocking against checkpoint start.
1723 */
1725 /*
1726 * Check that we haven't aborted halfway through RecordTransactionCommit.
1727 */
1730 xid);
1732 /* Fetch the data we need for the abort record */
1736 /* XXX do we really need a critical section here? */
1739 /* Write the ABORT record */
1742 else
1743 {
1746 }
1752 NULL);
1754 /*
1755 * Report the latest async abort LSN, so that the WAL writer knows to
1756 * flush this abort. There's nothing to be gained by delaying this, since
1757 * WALWriter may as well do this when it can. This is important with
1758 * streaming replication because if we don't flush WAL regularly we will
1759 * find that large aborts leave us with a long backlog for when commits
1760 * occur after the abort, increasing our window of data loss should
1761 * problems occur at that point.
1762 */
1766 /*
1767 * Mark the transaction aborted in clog. This is not absolutely necessary
1768 * but we may as well do it while we are here; also, in the subxact case
1769 * it is helpful because XactLockTableWait makes use of it to avoid
1770 * waiting for already-aborted subtransactions. It is OK to do it without
1771 * having flushed the ABORT record to disk, because in event of a crash
1772 * we'd be assumed to have aborted anyway.
1773 */
1778 /* Compute latestXid while we have the child XIDs handy */
1781 /*
1782 * If we're aborting a subtransaction, we can immediately remove failed
1783 * XIDs from PGPROC's cache of running child XIDs. We do that here for
1784 * subxacts, because we already have the child XID array at hand. For
1785 * main xacts, the equivalent happens just after this function returns.
1786 */
1790 /* Reset XactLastRecEnd until the next transaction writes something */
1794 /* And clean up local data */
1799 }
1801 /*
1802 * AtAbort_Memory
1803 */
1804 static void
1806 {
1807 /*
1808 * Switch into TransactionAbortContext, which should have some free space
1809 * even if nothing else does. We'll work in this context until we've
1810 * finished cleaning up.
1811 *
1812 * It is barely possible to get here when we've not been able to create
1813 * TransactionAbortContext yet; if so use TopMemoryContext.
1814 */
1817 else
1819 }
1821 /*
1822 * AtSubAbort_Memory
1823 */
1824 static void
1826 {
1830 }
1833 /*
1834 * AtAbort_ResourceOwner
1835 */
1836 static void
1838 {
1839 /*
1840 * Make sure we have a valid ResourceOwner, if possible (else it will be
1841 * NULL, which is OK)
1842 */
1844 }
1846 /*
1847 * AtSubAbort_ResourceOwner
1848 */
1849 static void
1851 {
1854 /* Make sure we have a valid ResourceOwner */
1856 }
1859 /*
1860 * AtSubAbort_childXids
1861 */
1862 static void
1864 {
1867 /*
1868 * We keep the child-XID arrays in TopTransactionContext (see
1869 * AtSubCommit_childXids). This means we'd better free the array
1870 * explicitly at abort to avoid leakage.
1871 */
1878 /*
1879 * We could prune the unreportedXids array here. But we don't bother. That
1880 * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
1881 * would likely introduce more CPU time into the more common paths, so we
1882 * choose not to do that.
1883 */
1884 }
1886 /* ----------------------------------------------------------------
1887 * CleanupTransaction stuff
1888 * ----------------------------------------------------------------
1889 */
1891 /*
1892 * AtCleanup_Memory
1893 */
1894 static void
1896 {
1899 /*
1900 * Now that we're "out" of a transaction, have the system allocate things
1901 * in the top memory context instead of per-transaction contexts.
1902 */
1905 /*
1906 * Clear the special abort context for next time.
1907 */
1911 /*
1912 * Release all transaction-local memory.
1913 */
1919 }
1922 /* ----------------------------------------------------------------
1923 * CleanupSubTransaction stuff
1924 * ----------------------------------------------------------------
1925 */
1927 /*
1928 * AtSubCleanup_Memory
1929 */
1930 static void
1932 {
1937 /* Make sure we're not in an about-to-be-deleted context */
1941 /*
1942 * Clear the special abort context for next time.
1943 */
1947 /*
1948 * Delete the subxact local memory contexts. Its CurTransactionContext can
1949 * go too (note this also kills CurTransactionContexts from any children
1950 * of the subxact).
1951 */
1955 }
1957 /* ----------------------------------------------------------------
1958 * interface routines
1959 * ----------------------------------------------------------------
1960 */
1962 /*
1963 * StartTransaction
1964 */
1965 static void
1967 {
1968 TransactionState s;
1969 VirtualTransactionId vxid;
1971 /*
1972 * Let's just make sure the state stack is empty
1973 */
1979 /* check the current transaction state */
1982 /*
1983 * Set the current transaction state information appropriately during
1984 * start processing. Note that once the transaction status is switched
1985 * this process cannot fail until the user ID and the security context
1986 * flags are fetched below.
1987 */
1991 /* Determine if statements are logged in this transaction */
1996 /*
1997 * initialize current transaction state fields
1998 *
1999 * note: prevXactReadOnly is not used at the outermost level
2000 */
2007 /*
2008 * Once the current user ID and the security context flags are fetched,
2009 * both will be properly reset even if transaction startup fails.
2010 */
2013 /* SecurityRestrictionContext should never be set outside a transaction */
2016 /*
2017 * Make sure we've reset xact state variables
2018 *
2019 * If recovery is still in progress, mark this transaction as read-only.
2020 * We have lower level defences in XLogInsert and elsewhere to stop us
2021 * from modifying data during recovery, but this gives the normal
2022 * indication to the user that the transaction is read-only.
2023 */
2025 {
2028 }
2029 else
2030 {
2033 }
2039 /*
2040 * reinitialize within-transaction counters
2041 */
2047 /*
2048 * initialize reported xid accounting
2049 */
2053 /*
2054 * must initialize resource-management stuff first
2055 */
2059 /*
2060 * Assign a new LocalTransactionId, and combine it with the backendId to
2061 * form a virtual transaction id.
2062 */
2066 /*
2067 * Lock the virtual transaction id before we announce it in the proc array
2068 */
2071 /*
2072 * Advertise it in the proc array. We assume assignment of
2073 * localTransactionId is atomic, and the backendId should be set already.
2074 */
2080 /*
2081 * set transaction_timestamp() (a/k/a now()). Normally, we want this to
2082 * be the same as the first command's statement_timestamp(), so don't do a
2083 * fresh GetCurrentTimestamp() call (which'd be expensive anyway). But
2084 * for transactions started inside procedures (i.e., nonatomic SPI
2085 * contexts), we do need to advance the timestamp. Also, in a parallel
2086 * worker, the timestamp should already have been provided by a call to
2087 * SetParallelStartTimestamps().
2088 */
2090 {
2093 else
2095 }
2096 else
2099 /* Mark xactStopTimestamp as unset. */
2102 /*
2103 * initialize other subsystems for new transaction
2104 */
2109 /*
2110 * done with start processing, set current transaction state to "in
2111 * progress"
2112 */
2116 }
2119 /*
2120 * CommitTransaction
2121 *
2122 * NB: if you change this routine, better look at PrepareTransaction too!
2123 */
2124 static void
2126 {
2128 TransactionId latestXid;
2133 /* Enforce parallel mode restrictions during parallel worker commit. */
2139 /*
2140 * check the current transaction state
2141 */
2147 /*
2148 * Do pre-commit processing that involves calling user-defined code, such
2149 * as triggers. SECURITY_RESTRICTED_OPERATION contexts must not queue an
2150 * action that would run here, because that would bypass the sandbox.
2151 * Since closing cursors could queue trigger actions, triggers could open
2152 * cursors, etc, we have to keep looping until there's nothing left to do.
2153 */
2155 {
2156 /*
2157 * Fire all currently pending deferred triggers.
2158 */
2161 /*
2162 * Close open portals (converting holdable ones into static portals).
2163 * If there weren't any, we are done ... otherwise loop back to check
2164 * if they queued deferred triggers. Lather, rinse, repeat.
2165 */
2168 }
2170 /*
2171 * The remaining actions cannot call any user-defined code, so it's safe
2172 * to start shutting down within-transaction services. But note that most
2173 * of this stuff could still throw an error, which would switch us into
2174 * the transaction-abort path.
2175 */
2180 /* If we might have parallel workers, clean them up now. */
2184 /* Shut down the deferred-trigger manager */
2187 /*
2188 * Let ON COMMIT management do its thing (must happen after closing
2189 * cursors, to avoid dangling-reference problems)
2190 */
2193 /*
2194 * Synchronize files that are created and not WAL-logged during this
2195 * transaction. This must happen before AtEOXact_RelationMap(), so that we
2196 * don't see committed-but-broken files after a crash.
2197 */
2200 /* close large objects before lower-level cleanup */
2203 /*
2204 * Insert notifications sent by NOTIFY commands into the queue. This
2205 * should be late in the pre-commit sequence to minimize time spent
2206 * holding the notify-insertion lock. However, this could result in
2207 * creating a snapshot, so we must do it before serializable cleanup.
2208 */
2211 /*
2212 * Mark serializable transaction as complete for predicate locking
2213 * purposes. This should be done as late as we can put it and still allow
2214 * errors to be raised for failure patterns found at commit. This is not
2215 * appropriate in a parallel worker however, because we aren't committing
2216 * the leader's transaction and its serializable state will live on.
2217 */
2221 /* Prevent cancel/die interrupt while cleaning up */
2224 /* Commit updates to the relation map --- do this as late as possible */
2227 /*
2228 * set the current transaction state information appropriately during
2229 * commit processing
2230 */
2235 {
2236 /*
2237 * We need to mark our XIDs as committed in pg_xact. This is where we
2238 * durably commit.
2239 */
2241 }
2242 else
2243 {
2244 /*
2245 * We must not mark our XID committed; the parallel leader is
2246 * responsible for that.
2247 */
2250 /*
2251 * Make sure the leader will know about any WAL we wrote before it
2252 * commits.
2253 */
2255 }
2259 /*
2260 * Let others know about no transaction in progress by me. Note that this
2261 * must be done _before_ releasing locks we hold and _after_
2262 * RecordTransactionCommit.
2263 */
2266 /*
2267 * This is all post-commit cleanup. Note that if an error is raised here,
2268 * it's too late to abort the transaction. This should be just
2269 * noncritical resource releasing.
2270 *
2271 * The ordering of operations is not entirely random. The idea is:
2272 * release resources visible to other backends (eg, files, buffer pins);
2273 * then release locks; then release backend-local resources. We want to
2274 * release locks at the point where any backend waiting for us will see
2275 * our transaction as being fully cleaned up.
2276 *
2277 * Resources that can be associated with individual queries are handled by
2278 * the ResourceOwner mechanism. The other calls here are for backend-wide
2279 * state.
2280 */
2286 RESOURCE_RELEASE_BEFORE_LOCKS,
2289 /* Check we've released all buffer pins */
2292 /* Clean up the relation cache */
2295 /*
2296 * Make catalog changes visible to all backends. This has to happen after
2297 * relcache references are dropped (see comments for
2298 * AtEOXact_RelationCache), but before locks are released (if anyone is
2299 * waiting for lock on a relation we've modified, we want them to know
2300 * about the catalog change before they start using the relation).
2301 */
2307 RESOURCE_RELEASE_LOCKS,
2310 RESOURCE_RELEASE_AFTER_LOCKS,
2313 /*
2314 * Likewise, dropping of files deleted during the transaction is best done
2315 * after releasing relcache and buffer pins. (This is not strictly
2316 * necessary during commit, since such pins should have been released
2317 * already, but this ordering is definitely critical during abort.) Since
2318 * this may take many seconds, also delay until after releasing locks.
2319 * Other backends will observe the attendant catalog changes and not
2320 * attempt to access affected files.
2321 */
2324 /*
2325 * Send out notification signals to other backends (and do other
2326 * post-commit NOTIFY cleanup). This must not happen until after our
2327 * transaction is fully done from the viewpoint of other backends.
2328 */
2331 /*
2332 * Everything after this should be purely internal-to-this-backend
2333 * cleanup.
2334 */
2368 /*
2369 * done with commit processing, set current transaction state back to
2370 * default
2371 */
2375 }
2378 /*
2379 * PrepareTransaction
2380 *
2381 * NB: if you change this routine, better look at CommitTransaction too!
2382 */
2383 static void
2385 {
2388 GlobalTransaction gxact;
2389 TimestampTz prepared_at;
2395 /*
2396 * check the current transaction state
2397 */
2403 /*
2404 * Do pre-commit processing that involves calling user-defined code, such
2405 * as triggers. Since closing cursors could queue trigger actions,
2406 * triggers could open cursors, etc, we have to keep looping until there's
2407 * nothing left to do.
2408 */
2410 {
2411 /*
2412 * Fire all currently pending deferred triggers.
2413 */
2416 /*
2417 * Close open portals (converting holdable ones into static portals).
2418 * If there weren't any, we are done ... otherwise loop back to check
2419 * if they queued deferred triggers. Lather, rinse, repeat.
2420 */
2423 }
2427 /*
2428 * The remaining actions cannot call any user-defined code, so it's safe
2429 * to start shutting down within-transaction services. But note that most
2430 * of this stuff could still throw an error, which would switch us into
2431 * the transaction-abort path.
2432 */
2434 /* Shut down the deferred-trigger manager */
2437 /*
2438 * Let ON COMMIT management do its thing (must happen after closing
2439 * cursors, to avoid dangling-reference problems)
2440 */
2443 /*
2444 * Synchronize files that are created and not WAL-logged during this
2445 * transaction. This must happen before EndPrepare(), so that we don't see
2446 * committed-but-broken files after a crash and COMMIT PREPARED.
2447 */
2450 /* close large objects before lower-level cleanup */
2453 /* NOTIFY requires no work at this point */
2455 /*
2456 * Mark serializable transaction as complete for predicate locking
2457 * purposes. This should be done as late as we can put it and still allow
2458 * errors to be raised for failure patterns found at commit.
2459 */
2462 /*
2463 * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
2464 * this transaction. Having the prepared xact hold locks on another
2465 * backend's temp table seems a bad idea --- for instance it would prevent
2466 * the backend from exiting. There are other problems too, such as how to
2467 * clean up the source backend's local buffers and ON COMMIT state if the
2468 * prepared xact includes a DROP of a temp table.
2469 *
2470 * Other objects types, like functions, operators or extensions, share the
2471 * same restriction as they should not be created, locked or dropped as
2472 * this can mess up with this session or even a follow-up session trying
2473 * to use the same temporary namespace.
2474 *
2475 * We must check this after executing any ON COMMIT actions, because they
2476 * might still access a temp relation.
2477 *
2478 * XXX In principle this could be relaxed to allow some useful special
2479 * cases, such as a temp table created and dropped all within the
2480 * transaction. That seems to require much more bookkeeping though.
2481 */
2487 /*
2488 * Likewise, don't allow PREPARE after pg_export_snapshot. This could be
2489 * supported if we added cleanup logic to twophase.c, but for now it
2490 * doesn't seem worth the trouble.
2491 */
2497 /* Prevent cancel/die interrupt while cleaning up */
2500 /*
2501 * set the current transaction state information appropriately during
2502 * prepare processing
2503 */
2508 /* Tell bufmgr and smgr to prepare for commit */
2511 /*
2512 * Reserve the GID for this transaction. This could fail if the requested
2513 * GID is invalid or already in use.
2514 */
2519 /*
2520 * Collect data for the 2PC state file. Note that in general, no actual
2521 * state change should happen in the called modules during this step,
2522 * since it's still possible to fail before commit, and in that case we
2523 * want transaction abort to be able to clean up. (In particular, the
2524 * AtPrepare routines may error out if they find cases they cannot
2525 * handle.) State cleanup should happen in the PostPrepare routines
2526 * below. However, some modules can go ahead and clear state here because
2527 * they wouldn't do anything with it during abort anyway.
2528 *
2529 * Note: because the 2PC state file records will be replayed in the same
2530 * order they are made, the order of these calls has to match the order in
2531 * which we want things to happen during COMMIT PREPARED or ROLLBACK
2532 * PREPARED; in particular, pay attention to whether things should happen
2533 * before or after releasing the transaction's locks.
2534 */
2544 /*
2545 * Here is where we really truly prepare.
2546 *
2547 * We have to record transaction prepares even if we didn't make any
2548 * updates, because the transaction manager might get confused if we lose
2549 * a global transaction.
2550 */
2553 /*
2554 * Now we clean up backend-internal state and release internal resources.
2555 */
2557 /* Reset XactLastRecEnd until the next transaction writes something */
2560 /*
2561 * Transfer our locks to a dummy PGPROC. This has to be done before
2562 * ProcArrayClearTransaction(). Otherwise, a GetLockConflicts() would
2563 * conclude "xact already committed or aborted" for our locks.
2564 */
2567 /*
2568 * Let others know about no transaction in progress by me. This has to be
2569 * done *after* the prepared transaction has been marked valid, else
2570 * someone may think it is unlocked and recyclable.
2571 */
2574 /*
2575 * In normal commit-processing, this is all non-critical post-transaction
2576 * cleanup. When the transaction is prepared, however, it's important
2577 * that the locks and other per-backend resources are transferred to the
2578 * prepared transaction's PGPROC entry. Note that if an error is raised
2579 * here, it's too late to abort the transaction. XXX: This probably should
2580 * be in a critical section, to force a PANIC if any of this fails, but
2581 * that cure could be worse than the disease.
2582 */
2587 RESOURCE_RELEASE_BEFORE_LOCKS,
2590 /* Check we've released all buffer pins */
2593 /* Clean up the relation cache */
2596 /* notify doesn't need a postprepare call */
2609 RESOURCE_RELEASE_LOCKS,
2612 RESOURCE_RELEASE_AFTER_LOCKS,
2615 /*
2616 * Allow another backend to finish the transaction. After
2617 * PostPrepare_Twophase(), the transaction is completely detached from our
2618 * backend. The rest is just non-critical cleanup of backend-local state.
2619 */
2622 /* PREPARE acts the same as COMMIT as far as GUC is concerned */
2632 /* don't call AtEOXact_PgStat here; we fixed pgstat state above */
2655 /*
2656 * done with 1st phase commit processing, set current transaction state
2657 * back to default
2658 */
2662 }
2665 /*
2666 * AbortTransaction
2667 */
2668 static void
2670 {
2672 TransactionId latestXid;
2675 /* Prevent cancel/die interrupt while cleaning up */
2678 /* Make sure we have a valid memory context and resource owner */
2682 /*
2683 * Release any LW locks we might be holding as quickly as possible.
2684 * (Regular locks, however, must be held till we finish aborting.)
2685 * Releasing LW locks is critical since we might try to grab them again
2686 * while cleaning up!
2687 */
2690 /* Clear wait information and command progress indicator */
2694 /* Clean up buffer I/O and buffer context locks, too */
2698 /* Reset WAL record construction state */
2701 /* Cancel condition variable sleep */
2704 /*
2705 * Also clean up any open wait for lock, since the lock manager will choke
2706 * if we try to wait for another lock before doing this.
2707 */
2710 /*
2711 * If any timeout events are still active, make sure the timeout interrupt
2712 * is scheduled. This covers possible loss of a timeout interrupt due to
2713 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
2714 * We delay this till after LockErrorCleanup so that we don't uselessly
2715 * reschedule lock or deadlock check timeouts.
2716 */
2719 /*
2720 * Re-enable signals, in case we got here by longjmp'ing out of a signal
2721 * handler. We do this fairly early in the sequence so that the timeout
2722 * infrastructure will be functional if needed while aborting.
2723 */
2726 /*
2727 * check the current transaction state
2728 */
2735 /*
2736 * set the current transaction state information appropriately during the
2737 * abort processing
2738 */
2741 /*
2742 * Reset user ID which might have been changed transiently. We need this
2743 * to clean up in case control escaped out of a SECURITY DEFINER function
2744 * or other local change of CurrentUserId; therefore, the prior value of
2745 * SecurityRestrictionContext also needs to be restored.
2746 *
2747 * (Note: it is not necessary to restore session authorization or role
2748 * settings here because those can only be changed via GUC, and GUC will
2749 * take care of rolling them back if need be.)
2750 */
2753 /* Forget about any active REINDEX. */
2756 /* Reset logical streaming state. */
2759 /* Reset snapshot export state. */
2762 /* If in parallel mode, clean up workers and exit parallel mode. */
2764 {
2767 }
2769 /*
2770 * do abort processing
2771 */
2780 /*
2781 * Advertise the fact that we aborted in pg_xact (assuming that we got as
2782 * far as assigning an XID to advertise). But if we're inside a parallel
2783 * worker, skip this; the user backend must be the one to write the abort
2784 * record.
2785 */
2788 else
2789 {
2792 /*
2793 * Since the parallel leader won't get our value of XactLastRecEnd in
2794 * this case, we nudge WAL-writer ourselves in this case. See related
2795 * comments in RecordTransactionAbort for why this matters.
2796 */
2798 }
2802 /*
2803 * Let others know about no transaction in progress by me. Note that this
2804 * must be done _before_ releasing locks we hold and _after_
2805 * RecordTransactionAbort.
2806 */
2809 /*
2810 * Post-abort cleanup. See notes in CommitTransaction() concerning
2811 * ordering. We can skip all of it if the transaction failed before
2812 * creating a resource owner.
2813 */
2815 {
2818 else
2822 RESOURCE_RELEASE_BEFORE_LOCKS,
2829 RESOURCE_RELEASE_LOCKS,
2832 RESOURCE_RELEASE_AFTER_LOCKS,
2848 }
2850 /*
2851 * State remains TRANS_ABORT until CleanupTransaction().
2852 */
2854 }
2856 /*
2857 * CleanupTransaction
2858 */
2859 static void
2861 {
2864 /*
2865 * State should still be TRANS_ABORT from AbortTransaction().
2866 */
2871 /*
2872 * do abort cleanup processing
2873 */
2898 /*
2899 * done with abort processing, set current transaction state back to
2900 * default
2901 */
2903 }
2905 /*
2906 * StartTransactionCommand
2907 */
2908 void
2910 {
2914 {
2915 /*
2916 * if we aren't in a transaction block, we just do our usual start
2917 * transaction.
2918 */
2924 /*
2925 * We are somewhere in a transaction block or subtransaction and
2926 * about to start a new command. For now we do nothing, but
2927 * someday we may do command-local resource initialization. (Note
2928 * that any needed CommandCounterIncrement was done by the
2929 * previous CommitTransactionCommand.)
2930 */
2936 /*
2937 * Here we are in a failed transaction block (one of the commands
2938 * caused an abort) so we do nothing but remain in the abort
2939 * state. Eventually we will get a ROLLBACK command which will
2940 * get us out of this state. (It is up to other code to ensure
2941 * that no commands other than ROLLBACK will be processed in these
2942 * states.)
2943 */
2948 /* These cases are invalid. */
2966 }
2968 /*
2969 * We must switch to CurTransactionContext before returning. This is
2970 * already done if we called StartTransaction, otherwise not.
2971 */
2974 }
2977 /*
2978 * Simple system for saving and restoring transaction characteristics
2979 * (isolation level, read only, deferrable). We need this for transaction
2980 * chaining, so that we can set the characteristics of the new transaction to
2981 * be the same as the previous one. (We need something like this because the
2982 * GUC system resets the characteristics at transaction end, so for example
2983 * just skipping the reset in StartTransaction() won't work.)
2984 */
2989 void
2991 {
2995 }
2997 void
2999 {
3003 }
3006 /*
3007 * CommitTransactionCommand
3008 */
3009 void
3011 {
3018 {
3019 /*
3020 * These shouldn't happen. TBLOCK_DEFAULT means the previous
3021 * StartTransactionCommand didn't set the STARTED state
3022 * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
3023 * by EndParallelWorkerTransaction(), not this function.
3024 */
3031 /*
3032 * If we aren't in a transaction block, just do our usual
3033 * transaction commit, and return to the idle state.
3034 */
3040 /*
3041 * We are completing a "BEGIN TRANSACTION" command, so we change
3042 * to the "transaction block in progress" state and return. (We
3043 * assume the BEGIN did nothing to the database, so we need no
3044 * CommandCounterIncrement.)
3045 */
3050 /*
3051 * This is the case when we have finished executing a command
3052 * someplace within a transaction block. We increment the command
3053 * counter and return.
3054 */
3061 /*
3062 * We are completing a "COMMIT" command. Do it and return to the
3063 * idle state.
3064 */
3069 {
3074 }
3077 /*
3078 * Here we are in the middle of a transaction block but one of the
3079 * commands caused an abort so we do nothing but remain in the
3080 * abort state. Eventually we will get a ROLLBACK command.
3081 */
3086 /*
3087 * Here we were in an aborted transaction block and we just got
3088 * the ROLLBACK command from the user, so clean up the
3089 * already-aborted transaction and return to the idle state.
3090 */
3095 {
3100 }
3103 /*
3104 * Here we were in a perfectly good transaction block but the user
3105 * told us to ROLLBACK anyway. We have to abort the transaction
3106 * and then clean up.
3107 */
3113 {
3118 }
3121 /*
3122 * We are completing a "PREPARE TRANSACTION" command. Do it and
3123 * return to the idle state.
3124 */
3130 /*
3131 * We were just issued a SAVEPOINT inside a transaction block.
3132 * Start a subtransaction. (DefineSavepoint already did
3133 * PushTransaction, so as to have someplace to put the SUBBEGIN
3134 * state.)
3135 */
3141 /*
3142 * We were issued a RELEASE command, so we end the current
3143 * subtransaction and return to the parent transaction. The parent
3144 * might be ended too, so repeat till we find an INPROGRESS
3145 * transaction or subtransaction.
3146 */
3148 do
3149 {
3158 /*
3159 * We were issued a COMMIT, so we end the current subtransaction
3160 * hierarchy and perform final commit. We do this by rolling up
3161 * any subtransactions into their parent, which leads to O(N^2)
3162 * operations with respect to resource owners - this isn't that
3163 * bad until we approach a thousands of savepoints but is
3164 * necessary for correctness should after triggers create new
3165 * resource owners.
3166 */
3168 do
3169 {
3173 /* If we had a COMMIT command, finish off the main xact too */
3175 {
3180 {
3185 }
3186 }
3188 {
3192 }
3193 else
3198 /*
3199 * The current already-failed subtransaction is ending due to a
3200 * ROLLBACK or ROLLBACK TO command, so pop it and recursively
3201 * examine the parent (which could be in any of several states).
3202 */
3208 /*
3209 * As above, but it's not dead yet, so abort first.
3210 */
3217 /*
3218 * The current subtransaction is the target of a ROLLBACK TO
3219 * command. Abort and pop it, then start a new subtransaction
3220 * with the same name.
3221 */
3223 {
3227 /* save name and keep Cleanup from freeing it */
3240 /* This is the same as TBLOCK_SUBBEGIN case */
3244 }
3247 /*
3248 * Same as above, but the subtransaction had already failed, so we
3249 * don't need AbortSubTransaction.
3250 */
3252 {
3256 /* save name and keep Cleanup from freeing it */
3268 /* This is the same as TBLOCK_SUBBEGIN case */
3272 }
3274 }
3275 }
3277 /*
3278 * AbortCurrentTransaction
3279 */
3280 void
3282 {
3286 {
3289 {
3290 /* we are idle, so nothing to do */
3291 }
3292 else
3293 {
3294 /*
3295 * We can get here after an error during transaction start
3296 * (state will be TRANS_START). Need to clean up the
3297 * incompletely started transaction. First, adjust the
3298 * low-level state to suppress warning message from
3299 * AbortTransaction.
3300 */
3305 }
3308 /*
3309 * If we aren't in a transaction block, we just do the basic abort
3310 * & cleanup transaction. For this purpose, we treat an implicit
3311 * transaction block as if it were a simple statement.
3312 */
3320 /*
3321 * If we are in TBLOCK_BEGIN it means something screwed up right
3322 * after reading "BEGIN TRANSACTION". We assume that the user
3323 * will interpret the error as meaning the BEGIN failed to get him
3324 * into a transaction block, so we should abort and return to idle
3325 * state.
3326 */
3333 /*
3334 * We are somewhere in a transaction block and we've gotten a
3335 * failure, so we abort the transaction and set up the persistent
3336 * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3337 */
3342 /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3345 /*
3346 * Here, we failed while trying to COMMIT. Clean up the
3347 * transaction and return to idle state (we do not want to stay in
3348 * the transaction).
3349 */
3356 /*
3357 * Here, we are already in an aborted transaction state and are
3358 * waiting for a ROLLBACK, but for some reason we failed again! So
3359 * we just remain in the abort state.
3360 */
3365 /*
3366 * We are in a failed transaction and we got the ROLLBACK command.
3367 * We have already aborted, we just need to cleanup and go to idle
3368 * state.
3369 */
3375 /*
3376 * We are in a live transaction and we got a ROLLBACK command.
3377 * Abort, cleanup, go to idle state.
3378 */
3385 /*
3386 * Here, we failed while trying to PREPARE. Clean up the
3387 * transaction and return to idle state (we do not want to stay in
3388 * the transaction).
3389 */
3396 /*
3397 * We got an error inside a subtransaction. Abort just the
3398 * subtransaction, and go to the persistent SUBABORT state until
3399 * we get ROLLBACK.
3400 */
3406 /*
3407 * If we failed while trying to create a subtransaction, clean up
3408 * the broken subtransaction and abort the parent. The same
3409 * applies if we get a failure while ending a subtransaction.
3410 */
3421 /*
3422 * Same as above, except the Abort() was already done.
3423 */
3429 }
3430 }
3432 /*
3433 * PreventInTransactionBlock
3434 *
3435 * This routine is to be called by statements that must not run inside
3436 * a transaction block, typically because they have non-rollback-able
3437 * side effects or do internal commits.
3438 *
3439 * If we have already started a transaction block, issue an error; also issue
3440 * an error if we appear to be running inside a user-defined function (which
3441 * could issue more commands and possibly cause a failure after the statement
3442 * completes). Subtransactions are verboten too.
3443 *
3444 * isTopLevel: passed down from ProcessUtility to determine whether we are
3445 * inside a function. (We will always fail if this is false, but it's
3446 * convenient to centralize the check here instead of making callers do it.)
3447 * stmtType: statement type name, for error messages.
3448 */
3449 void
3451 {
3452 /*
3453 * xact block already started?
3454 */
3458 /* translator: %s represents an SQL statement name */
3460 stmtType)));
3462 /*
3463 * subtransaction?
3464 */
3468 /* translator: %s represents an SQL statement name */
3470 stmtType)));
3472 /*
3473 * inside a function call?
3474 */
3478 /* translator: %s represents an SQL statement name */
3481 /* If we got past IsTransactionBlock test, should be in default state */
3485 /* all okay */
3486 }
3488 /*
3489 * WarnNoTransactionBlock
3490 * RequireTransactionBlock
3491 *
3492 * These two functions allow for warnings or errors if a command is executed
3493 * outside of a transaction block. This is useful for commands that have no
3494 * effects that persist past transaction end (and so calling them outside a
3495 * transaction block is presumably an error). DECLARE CURSOR is an example.
3496 * While top-level transaction control commands (BEGIN/COMMIT/ABORT) and SET
3497 * that have no effect issue warnings, all other no-effect commands generate
3498 * errors.
3499 *
3500 * If we appear to be running inside a user-defined function, we do not
3501 * issue anything, since the function could issue more commands that make
3502 * use of the current statement's results. Likewise subtransactions.
3503 * Thus these are inverses for PreventInTransactionBlock.
3504 *
3505 * isTopLevel: passed down from ProcessUtility to determine whether we are
3506 * inside a function.
3507 * stmtType: statement type name, for warning or error messages.
3508 */
3509 void
3511 {
3513 }
3515 void
3517 {
3519 }
3521 /*
3522 * This is the implementation of the above two.
3523 */
3524 static void
3526 {
3527 /*
3528 * xact block already started?
3529 */
3533 /*
3534 * subtransaction?
3535 */
3539 /*
3540 * inside a function call?
3541 */
3547 /* translator: %s represents an SQL statement name */
3549 stmtType)));
3550 }
3552 /*
3553 * IsInTransactionBlock
3554 *
3555 * This routine is for statements that need to behave differently inside
3556 * a transaction block than when running as single commands. ANALYZE is
3557 * currently the only example.
3558 *
3559 * isTopLevel: passed down from ProcessUtility to determine whether we are
3560 * inside a function.
3561 */
3562 bool
3564 {
3565 /*
3566 * Return true on same conditions that would make
3567 * PreventInTransactionBlock error out
3568 */
3583 }
3586 /*
3587 * Register or deregister callback functions for start- and end-of-xact
3588 * operations.
3589 *
3590 * These functions are intended for use by dynamically loaded modules.
3591 * For built-in modules we generally just hardwire the appropriate calls
3592 * (mainly because it's easier to control the order that way, where needed).
3593 *
3594 * At transaction end, the callback occurs post-commit or post-abort, so the
3595 * callback functions can only do noncritical cleanup.
3596 */
3597 void
3599 {
3608 }
3610 void
3612 {
3618 {
3620 {
3623 else
3627 }
3628 }
3629 }
3631 static void
3633 {
3638 }
3641 /*
3642 * Register or deregister callback functions for start- and end-of-subxact
3643 * operations.
3644 *
3645 * Pretty much same as above, but for subtransaction events.
3646 *
3647 * At subtransaction end, the callback occurs post-subcommit or post-subabort,
3648 * so the callback functions can only do noncritical cleanup. At
3649 * subtransaction start, the callback is called when the subtransaction has
3650 * finished initializing.
3651 */
3652 void
3654 {
3663 }
3665 void
3667 {
3673 {
3675 {
3678 else
3682 }
3683 }
3684 }
3686 static void
3688 SubTransactionId mySubid,
3689 SubTransactionId parentSubid)
3690 {
3695 }
3698 /* ----------------------------------------------------------------
3699 * transaction block support
3700 * ----------------------------------------------------------------
3701 */
3703 /*
3704 * BeginTransactionBlock
3705 * This executes a BEGIN command.
3706 */
3707 void
3709 {
3713 {
3714 /*
3715 * We are not inside a transaction block, so allow one to begin.
3716 */
3721 /*
3722 * BEGIN converts an implicit transaction block to a regular one.
3723 * (Note that we allow this even if we've already done some
3724 * commands, which is a bit odd but matches historical practice.)
3725 */
3730 /*
3731 * Already a transaction block in progress.
3732 */
3743 /* These cases are invalid. */
3760 }
3761 }
3763 /*
3764 * PrepareTransactionBlock
3765 * This executes a PREPARE command.
3766 *
3767 * Since PREPARE may actually do a ROLLBACK, the result indicates what
3768 * happened: true for PREPARE, false for ROLLBACK.
3769 *
3770 * Note that we don't actually do anything here except change blockState.
3771 * The real work will be done in the upcoming PrepareTransaction().
3772 * We do it this way because it's not convenient to change memory context,
3773 * resource owner, etc while executing inside a Portal.
3774 */
3775 bool
3777 {
3778 TransactionState s;
3781 /* Set up to commit the current transaction */
3784 /* If successful, change outer tblock state to PREPARE */
3786 {
3793 {
3794 /* Save GID where PrepareTransaction can find it again */
3798 }
3799 else
3800 {
3801 /*
3802 * ignore case where we are not in a transaction;
3803 * EndTransactionBlock already issued a warning.
3804 */
3807 /* Don't send back a PREPARE result tag... */
3809 }
3810 }
3813 }
3815 /*
3816 * EndTransactionBlock
3817 * This executes a COMMIT command.
3818 *
3819 * Since COMMIT may actually do a ROLLBACK, the result indicates what
3820 * happened: true for COMMIT, false for ROLLBACK.
3821 *
3822 * Note that we don't actually do anything here except change blockState.
3823 * The real work will be done in the upcoming CommitTransactionCommand().
3824 * We do it this way because it's not convenient to change memory context,
3825 * resource owner, etc while executing inside a Portal.
3826 */
3827 bool
3829 {
3834 {
3835 /*
3836 * We are in a transaction block, so tell CommitTransactionCommand
3837 * to COMMIT.
3838 */
3844 /*
3845 * We are in an implicit transaction block. If AND CHAIN was
3846 * specified, error. Otherwise commit, but issue a warning
3847 * because there was no explicit BEGIN before this.
3848 */
3853 /* translator: %s represents an SQL statement name */
3856 else
3864 /*
3865 * We are in a failed transaction block. Tell
3866 * CommitTransactionCommand it's time to exit the block.
3867 */
3872 /*
3873 * We are in a live subtransaction block. Set up to subcommit all
3874 * open subtransactions and then commit the main transaction.
3875 */
3878 {
3881 else
3885 }
3888 else
3894 /*
3895 * Here we are inside an aborted subtransaction. Treat the COMMIT
3896 * as ROLLBACK: set up to abort everything and exit the main
3897 * transaction.
3898 */
3901 {
3906 else
3910 }
3915 else
3920 /*
3921 * The user issued COMMIT when not inside a transaction. For
3922 * COMMIT without CHAIN, issue a WARNING, staying in
3923 * TBLOCK_STARTED state. The upcoming call to
3924 * CommitTransactionCommand() will then close the transaction and
3925 * put us back into the default state. For COMMIT AND CHAIN,
3926 * error.
3927 */
3932 /* translator: %s represents an SQL statement name */
3935 else
3942 /*
3943 * The user issued a COMMIT that somehow ran inside a parallel
3944 * worker. We can't cope with that.
3945 */
3952 /* These cases are invalid. */
3969 }
3979 }
3981 /*
3982 * UserAbortTransactionBlock
3983 * This executes a ROLLBACK command.
3984 *
3985 * As above, we don't actually do anything here except change blockState.
3986 */
3987 void
3989 {
3993 {
3994 /*
3995 * We are inside a transaction block and we got a ROLLBACK command
3996 * from the user, so tell CommitTransactionCommand to abort and
3997 * exit the transaction block.
3998 */
4003 /*
4004 * We are inside a failed transaction block and we got a ROLLBACK
4005 * command from the user. Abort processing is already done, so
4006 * CommitTransactionCommand just has to cleanup and go back to
4007 * idle state.
4008 */
4013 /*
4014 * We are inside a subtransaction. Mark everything up to top
4015 * level as exitable.
4016 */
4020 {
4025 else
4029 }
4034 else
4039 /*
4040 * The user issued ABORT when not inside a transaction. For
4041 * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4042 * The upcoming call to CommitTransactionCommand() will then put
4043 * us back into the default state. For ROLLBACK AND CHAIN, error.
4044 *
4045 * We do the same thing with ABORT inside an implicit transaction,
4046 * although in this case we might be rolling back actual database
4047 * state changes. (It's debatable whether we should issue a
4048 * WARNING in this case, but we have done so historically.)
4049 */
4055 /* translator: %s represents an SQL statement name */
4058 else
4065 /*
4066 * The user issued an ABORT that somehow ran inside a parallel
4067 * worker. We can't cope with that.
4068 */
4075 /* These cases are invalid. */
4092 }
4098 }
4100 /*
4101 * BeginImplicitTransactionBlock
4102 * Start an implicit transaction block if we're not already in one.
4103 *
4104 * Unlike BeginTransactionBlock, this is called directly from the main loop
4105 * in postgres.c, not within a Portal. So we can just change blockState
4106 * without a lot of ceremony. We do not expect caller to do
4107 * CommitTransactionCommand/StartTransactionCommand.
4108 */
4109 void
4111 {
4114 /*
4115 * If we are in STARTED state (that is, no transaction block is open),
4116 * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4117 * block.
4118 *
4119 * For caller convenience, we consider all other transaction states as
4120 * legal here; otherwise the caller would need its own state check, which
4121 * seems rather pointless.
4122 */
4125 }
4127 /*
4128 * EndImplicitTransactionBlock
4129 * End an implicit transaction block, if we're in one.
4130 *
4131 * Like EndTransactionBlock, we just make any needed blockState change here.
4132 * The real work will be done in the upcoming CommitTransactionCommand().
4133 */
4134 void
4136 {
4139 /*
4140 * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4141 * allowing CommitTransactionCommand to commit whatever happened during
4142 * the implicit transaction block as though it were a single statement.
4143 *
4144 * For caller convenience, we consider all other transaction states as
4145 * legal here; otherwise the caller would need its own state check, which
4146 * seems rather pointless.
4147 */
4150 }
4152 /*
4153 * DefineSavepoint
4154 * This executes a SAVEPOINT command.
4155 */
4156 void
4158 {
4161 /*
4162 * Workers synchronize transaction state at the beginning of each parallel
4163 * operation, so we can't account for new subtransactions after that
4164 * point. (Note that this check will certainly error out if s->blockState
4165 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4166 * below.)
4167 */
4174 {
4177 /* Normal subtransaction start */
4181 /*
4182 * Savepoint names, like the TransactionState block itself, live
4183 * in TopTransactionContext.
4184 */
4189 /*
4190 * We disallow savepoint commands in implicit transaction blocks.
4191 * There would be no great difficulty in allowing them so far as
4192 * this module is concerned, but a savepoint seems inconsistent
4193 * with exec_simple_query's behavior of abandoning the whole query
4194 * string upon error. Also, the point of an implicit transaction
4195 * block (as opposed to a regular one) is to automatically close
4196 * after an error, so it's hard to see how a savepoint would fit
4197 * into that.
4198 *
4199 * The error messages for this are phrased as if there were no
4200 * active transaction block at all, which is historical but
4201 * perhaps could be improved.
4202 */
4206 /* translator: %s represents an SQL statement name */
4211 /* These cases are invalid. */
4232 }
4233 }
4235 /*
4236 * ReleaseSavepoint
4237 * This executes a RELEASE command.
4238 *
4239 * As above, we don't actually do anything here except change blockState.
4240 */
4241 void
4243 {
4245 TransactionState target,
4246 xact;
4248 /*
4249 * Workers synchronize transaction state at the beginning of each parallel
4250 * operation, so we can't account for transaction state change after that
4251 * point. (Note that this check will certainly error out if s->blockState
4252 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4253 * below.)
4254 */
4261 {
4262 /*
4263 * We can't release a savepoint if there is no savepoint defined.
4264 */
4272 /* See comment about implicit transactions in DefineSavepoint */
4275 /* translator: %s represents an SQL statement name */
4280 /*
4281 * We are in a non-aborted subtransaction. This is the only valid
4282 * case.
4283 */
4287 /* These cases are invalid. */
4308 }
4311 {
4314 }
4321 /* disallow crossing savepoint level boundaries */
4327 /*
4328 * Mark "commit pending" all subtransactions up to the target
4329 * subtransaction. The actual commits will happen when control gets to
4330 * CommitTransactionCommand.
4331 */
4334 {
4341 }
4342 }
4344 /*
4345 * RollbackToSavepoint
4346 * This executes a ROLLBACK TO <savepoint> command.
4347 *
4348 * As above, we don't actually do anything here except change blockState.
4349 */
4350 void
4352 {
4354 TransactionState target,
4355 xact;
4357 /*
4358 * Workers synchronize transaction state at the beginning of each parallel
4359 * operation, so we can't account for transaction state change after that
4360 * point. (Note that this check will certainly error out if s->blockState
4361 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4362 * below.)
4363 */
4370 {
4371 /*
4372 * We can't rollback to a savepoint if there is no savepoint
4373 * defined.
4374 */
4383 /* See comment about implicit transactions in DefineSavepoint */
4386 /* translator: %s represents an SQL statement name */
4391 /*
4392 * There is at least one savepoint, so proceed.
4393 */
4398 /* These cases are invalid. */
4417 }
4420 {
4423 }
4430 /* disallow crossing savepoint level boundaries */
4436 /*
4437 * Mark "abort pending" all subtransactions up to the target
4438 * subtransaction. The actual aborts will happen when control gets to
4439 * CommitTransactionCommand.
4440 */
4443 {
4450 else
4455 }
4457 /* And mark the target as "restart pending" */
4462 else
4465 }
4467 /*
4468 * BeginInternalSubTransaction
4469 * This is the same as DefineSavepoint except it allows TBLOCK_STARTED,
4470 * TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_END, and TBLOCK_PREPARE states,
4471 * and therefore it can safely be used in functions that might be called
4472 * when not inside a BEGIN block or when running deferred triggers at
4473 * COMMIT/PREPARE time. Also, it automatically does
4474 * CommitTransactionCommand/StartTransactionCommand instead of expecting
4475 * the caller to do it.
4476 */
4477 void
4479 {
4482 /*
4483 * Workers synchronize transaction state at the beginning of each parallel
4484 * operation, so we can't account for new subtransactions after that
4485 * point. We might be able to make an exception for the type of
4486 * subtransaction established by this function, which is typically used in
4487 * contexts where we're going to release or roll back the subtransaction
4488 * before proceeding further, so that no enduring change to the
4489 * transaction state occurs. For now, however, we prohibit this case along
4490 * with all the others.
4491 */
4498 {
4505 /* Normal subtransaction start */
4509 /*
4510 * Savepoint names, like the TransactionState block itself, live
4511 * in TopTransactionContext.
4512 */
4517 /* These cases are invalid. */
4535 }
4539 }
4541 /*
4542 * ReleaseCurrentSubTransaction
4543 *
4544 * RELEASE (ie, commit) the innermost subtransaction, regardless of its
4545 * savepoint name (if any).
4546 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4547 */
4548 void
4550 {
4553 /*
4554 * Workers synchronize transaction state at the beginning of each parallel
4555 * operation, so we can't account for commit of subtransactions after that
4556 * point. This should not happen anyway. Code calling this would
4557 * typically have called BeginInternalSubTransaction() first, failing
4558 * there.
4559 */
4573 }
4575 /*
4576 * RollbackAndReleaseCurrentSubTransaction
4577 *
4578 * ROLLBACK and RELEASE (ie, abort) the innermost subtransaction, regardless
4579 * of its savepoint name (if any).
4580 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4581 */
4582 void
4584 {
4587 /*
4588 * Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
4589 * during parallel operations. That's because we may be in the leader,
4590 * recovering from an error thrown while we were in parallel mode. We
4591 * won't reach here in a worker, because BeginInternalSubTransaction()
4592 * will have failed.
4593 */
4596 {
4597 /* Must be in a subtransaction */
4602 /* These cases are invalid. */
4624 }
4626 /*
4627 * Abort the current subtransaction, if needed.
4628 */
4632 /* And clean it up, too */
4640 }
4642 /*
4643 * AbortOutOfAnyTransaction
4644 *
4645 * This routine is provided for error recovery purposes. It aborts any
4646 * active transaction or transaction block, leaving the system in a known
4647 * idle state.
4648 */
4649 void
4651 {
4654 /* Ensure we're not running in a doomed memory context */
4657 /*
4658 * Get out of any transaction or nested transaction
4659 */
4660 do
4661 {
4663 {
4666 {
4667 /* Not in a transaction, do nothing */
4668 }
4669 else
4670 {
4671 /*
4672 * We can get here after an error during transaction start
4673 * (state will be TRANS_START). Need to clean up the
4674 * incompletely started transaction. First, adjust the
4675 * low-level state to suppress warning message from
4676 * AbortTransaction.
4677 */
4682 }
4692 /* In a transaction, so clean up */
4700 /*
4701 * AbortTransaction is already done, still need Cleanup.
4702 * However, if we failed partway through running ROLLBACK,
4703 * there will be an active portal running that command, which
4704 * we need to shut down before doing CleanupTransaction.
4705 */
4711 /*
4712 * In a subtransaction, so clean it up and abort parent too
4713 */
4728 /* As above, but AbortSubTransaction already done */
4730 {
4731 /* As in TBLOCK_ABORT, might have a live portal to zap */
4736 }
4740 }
4743 /* Should be out of all subxacts now */
4746 /* If we didn't actually have anything to do, revert to TopMemoryContext */
4748 }
4750 /*
4751 * IsTransactionBlock --- are we within a transaction block?
4752 */
4753 bool
4755 {
4762 }
4764 /*
4765 * IsTransactionOrTransactionBlock --- are we within either a transaction
4766 * or a transaction block? (The backend is only really "idle" when this
4767 * returns false.)
4768 *
4769 * This should match up with IsTransactionBlock and IsTransactionState.
4770 */
4771 bool
4773 {
4780 }
4782 /*
4783 * TransactionBlockStatusCode - return status code to send in ReadyForQuery
4784 */
4785 char
4787 {
4791 {
4815 }
4817 /* should never get here */
4821 }
4823 /*
4824 * IsSubTransaction
4825 */
4826 bool
4828 {
4835 }
4837 /*
4838 * StartSubTransaction
4839 *
4840 * If you're wondering why this is separate from PushTransaction: it's because
4841 * we can't conveniently do this stuff right inside DefineSavepoint. The
4842 * SAVEPOINT utility command will be executed inside a Portal, and if we
4843 * muck with CurrentMemoryContext or CurrentResourceOwner then exit from
4844 * the Portal will undo those settings. So we make DefineSavepoint just
4845 * push a dummy transaction block, and when control returns to the main
4846 * idle loop, CommitTransactionCommand will be called, and we'll come here
4847 * to finish starting the subtransaction.
4848 */
4849 static void
4851 {
4860 /*
4861 * Initialize subsystems for new subtransaction
4862 *
4863 * must initialize resource-management stuff first
4864 */
4871 /*
4872 * Call start-of-subxact callbacks
4873 */
4878 }
4880 /*
4881 * CommitSubTransaction
4882 *
4883 * The caller has to make sure to always reassign CurrentTransactionState
4884 * if it has a local pointer to it after calling this function.
4885 */
4886 static void
4888 {
4897 /* Pre-commit processing goes here */
4902 /* If in parallel mode, clean up workers and exit parallel mode. */
4904 {
4907 }
4909 /* Do the actual "commit", such as it is */
4912 /* Must CCI to ensure commands of subtransaction are seen as done */
4915 /*
4916 * Prior to 8.4 we marked subcommit in clog at this point. We now only
4917 * perform that step, if required, as part of the atomic update of the
4918 * whole transaction tree at top level commit or abort.
4919 */
4921 /* Post-commit cleanup */
4937 RESOURCE_RELEASE_BEFORE_LOCKS,
4944 /*
4945 * The only lock we actually release here is the subtransaction XID lock.
4946 */
4951 /*
4952 * Other locks should get transferred to their parent resource owner.
4953 */
4955 RESOURCE_RELEASE_LOCKS,
4958 RESOURCE_RELEASE_AFTER_LOCKS,
4973 /*
4974 * We need to restore the upper transaction's read-only state, in case the
4975 * upper is read-write while the child is read-only; GUC will incorrectly
4976 * think it should leave the child state in place.
4977 */
4990 }
4992 /*
4993 * AbortSubTransaction
4994 */
4995 static void
4997 {
5000 /* Prevent cancel/die interrupt while cleaning up */
5003 /* Make sure we have a valid memory context and resource owner */
5007 /*
5008 * Release any LW locks we might be holding as quickly as possible.
5009 * (Regular locks, however, must be held till we finish aborting.)
5010 * Releasing LW locks is critical since we might try to grab them again
5011 * while cleaning up!
5012 *
5013 * FIXME This may be incorrect --- Are there some locks we should keep?
5014 * Buffer locks, for example? I don't think so but I'm not sure.
5015 */
5023 /* Reset WAL record construction state */
5026 /* Cancel condition variable sleep */
5029 /*
5030 * Also clean up any open wait for lock, since the lock manager will choke
5031 * if we try to wait for another lock before doing this.
5032 */
5035 /*
5036 * If any timeout events are still active, make sure the timeout interrupt
5037 * is scheduled. This covers possible loss of a timeout interrupt due to
5038 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
5039 * We delay this till after LockErrorCleanup so that we don't uselessly
5040 * reschedule lock or deadlock check timeouts.
5041 */
5044 /*
5045 * Re-enable signals, in case we got here by longjmp'ing out of a signal
5046 * handler. We do this fairly early in the sequence so that the timeout
5047 * infrastructure will be functional if needed while aborting.
5048 */
5051 /*
5052 * check the current transaction state
5053 */
5062 /*
5063 * Reset user ID which might have been changed transiently. (See notes in
5064 * AbortTransaction.)
5065 */
5068 /* Forget about any active REINDEX. */
5071 /* Reset logical streaming state. */
5074 /*
5075 * No need for SnapBuildResetExportedSnapshotState() here, snapshot
5076 * exports are not supported in subtransactions.
5077 */
5079 /* Exit from parallel mode, if necessary. */
5081 {
5084 }
5086 /*
5087 * We can skip all this stuff if the subxact failed before creating a
5088 * ResourceOwner...
5089 */
5091 {
5101 /* Advertise the fact that we aborted in pg_xact. */
5104 /* Post-abort cleanup */
5112 RESOURCE_RELEASE_BEFORE_LOCKS,
5118 RESOURCE_RELEASE_LOCKS,
5121 RESOURCE_RELEASE_AFTER_LOCKS,
5136 }
5138 /*
5139 * Restore the upper transaction's read-only state, too. This should be
5140 * redundant with GUC's cleanup but we may as well do it for consistency
5141 * with the commit case.
5142 */
5146 }
5148 /*
5149 * CleanupSubTransaction
5150 *
5151 * The caller has to make sure to always reassign CurrentTransactionState
5152 * if it has a local pointer to it after calling this function.
5153 */
5154 static void
5156 {
5178 }
5180 /*
5181 * PushTransaction
5182 * Create transaction state stack entry for a subtransaction
5183 *
5184 * The caller has to make sure to always reassign CurrentTransactionState
5185 * if it has a local pointer to it after calling this function.
5186 */
5187 static void
5189 {
5191 TransactionState s;
5193 /*
5194 * We keep subtransaction state nodes in TopTransactionContext.
5195 */
5200 /*
5201 * Assign a subtransaction ID, watching out for counter wraparound.
5202 */
5205 {
5211 }
5213 /*
5214 * We can now stack a minimally valid subtransaction without fear of
5215 * failure.
5216 */
5232 /*
5233 * AbortSubTransaction and CleanupSubTransaction have to be able to cope
5234 * with the subtransaction from here on out; in particular they should not
5235 * assume that it necessarily has a transaction context, resource owner,
5236 * or XID.
5237 */
5238 }
5240 /*
5241 * PopTransaction
5242 * Pop back to parent transaction state
5243 *
5244 * The caller has to make sure to always reassign CurrentTransactionState
5245 * if it has a local pointer to it after calling this function.
5246 */
5247 static void
5249 {
5261 /* Let's just make sure CurTransactionContext is good */
5265 /* Ditto for ResourceOwner links */
5269 /* Free the old child structure */
5273 }
5275 /*
5276 * EstimateTransactionStateSpace
5277 * Estimate the amount of space that will be needed by
5278 * SerializeTransactionState. It would be OK to overestimate slightly,
5279 * but it's simple for us to work out the precise value, so we do.
5280 */
5281 Size
5283 {
5284 TransactionState s;
5289 {
5293 }
5296 }
5298 /*
5299 * SerializeTransactionState
5300 * Write out relevant details of our transaction state that will be
5301 * needed by a parallel worker.
5302 *
5303 * We need to save and restore XactDeferrable, XactIsoLevel, and the XIDs
5304 * associated with this transaction. These are serialized into a
5305 * caller-supplied buffer big enough to hold the number of bytes reported by
5306 * EstimateTransactionStateSpace(). We emit the XIDs in sorted order for the
5307 * convenience of the receiving process.
5308 */
5309 void
5311 {
5312 TransactionState s;
5327 /*
5328 * If we're running in a parallel worker and launching a parallel worker
5329 * of our own, we can just pass along the information that was passed to
5330 * us.
5331 */
5333 {
5338 }
5340 /*
5341 * OK, we need to generate a sorted list of XIDs that our workers should
5342 * view as current. First, figure out how many there are.
5343 */
5345 {
5349 }
5353 /* Copy them to our scratch space. */
5356 {
5362 }
5365 /* Sort them. */
5368 /* Copy data into output area. */
5372 }
5374 /*
5375 * StartParallelWorkerTransaction
5376 * Start a parallel worker transaction, restoring the relevant
5377 * transaction state serialized by SerializeTransactionState.
5378 */
5379 void
5381 {
5398 }
5400 /*
5401 * EndParallelWorkerTransaction
5402 * End a parallel worker transaction.
5403 */
5404 void
5406 {
5410 }
5412 /*
5413 * ShowTransactionState
5414 * Debug support
5415 */
5416 static void
5418 {
5419 /* skip work if message will definitely not be printed */
5422 }
5424 /*
5425 * ShowTransactionStateRec
5426 * Recursive subroutine for ShowTransactionState
5427 */
5428 static void
5430 {
5431 StringInfoData buf;
5436 {
5442 }
5460 }
5462 /*
5463 * BlockStateAsString
5464 * Debug support
5465 */
5468 {
5470 {
5511 }
5513 }
5515 /*
5516 * TransStateAsString
5517 * Debug support
5518 */
5521 {
5523 {
5536 }
5538 }
5540 /*
5541 * xactGetCommittedChildren
5542 *
5543 * Gets the list of committed children of the current transaction. The return
5544 * value is the number of child transactions. *ptr is set to point to an
5545 * array of TransactionIds. The array is allocated in TopTransactionContext;
5546 * the caller should *not* pfree() it (this is a change from pre-8.4 code!).
5547 * If there are no subxacts, *ptr is set to NULL.
5548 */
5549 int
5551 {
5556 else
5560 }
5562 /*
5563 * XLOG support routines
5564 */
5567 /*
5568 * Log the commit record for a plain or twophase transaction commit.
5569 *
5570 * A 2pc commit will be emitted when twophase_xid is valid, a plain one
5571 * otherwise.
5572 */
5573 XLogRecPtr
5581 {
5582 xl_xact_commit xlrec;
5583 xl_xact_xinfo xl_xinfo;
5584 xl_xact_dbinfo xl_dbinfo;
5585 xl_xact_subxacts xl_subxacts;
5586 xl_xact_relfilenodes xl_relfilenodes;
5587 xl_xact_invals xl_invals;
5588 xl_xact_twophase xl_twophase;
5589 xl_xact_origin xl_origin;
5590 uint8 info;
5596 /* decide between a plain and 2pc commit */
5599 else
5602 /* First figure out and collect all the information needed */
5613 /*
5614 * Check if the caller would like to ask standbys for immediate feedback
5615 * once this commit is applied.
5616 */
5620 /*
5621 * Relcache invalidations requires information about the current database
5622 * and so does logical decoding.
5623 */
5625 {
5629 }
5632 {
5635 }
5638 {
5642 }
5645 {
5648 }
5651 {
5658 }
5660 /* dump transaction origin information */
5662 {
5667 }
5672 /* Then include all the collected data into the commit record. */
5685 {
5687 MinSizeOfXactSubxacts);
5690 }
5693 {
5695 MinSizeOfXactRelfilenodes);
5698 }
5701 {
5705 }
5708 {
5712 }
5717 /* we allow filtering by xacts */
5721 }
5723 /*
5724 * Log the commit record for a plain or twophase transaction abort.
5725 *
5726 * A 2pc abort will be emitted when twophase_xid is valid, a plain one
5727 * otherwise.
5728 */
5729 XLogRecPtr
5735 {
5736 xl_xact_abort xlrec;
5737 xl_xact_xinfo xl_xinfo;
5738 xl_xact_subxacts xl_subxacts;
5739 xl_xact_relfilenodes xl_relfilenodes;
5740 xl_xact_twophase xl_twophase;
5741 xl_xact_dbinfo xl_dbinfo;
5742 xl_xact_origin xl_origin;
5744 uint8 info;
5750 /* decide between a plain and 2pc abort */
5753 else
5757 /* First figure out and collect all the information needed */
5765 {
5768 }
5771 {
5775 }
5778 {
5785 }
5788 {
5792 }
5794 /*
5795 * Dump transaction origin information only for abort prepared. We need
5796 * this during recovery to update the replication origin progress.
5797 */
5800 {
5805 }
5810 /* Then include all the collected data into the abort record. */
5823 {
5825 MinSizeOfXactSubxacts);
5828 }
5831 {
5833 MinSizeOfXactRelfilenodes);
5836 }
5839 {
5843 }
5852 }
5854 /*
5855 * Before 9.0 this was a fairly short function, but now it performs many
5856 * actions for which the order of execution is critical.
5857 */
5858 static void
5860 TransactionId xid,
5861 XLogRecPtr lsn,
5862 RepOriginId origin_id)
5863 {
5864 TransactionId max_xid;
5865 TimestampTz commit_time;
5871 /* Make sure nextXid is beyond any XID mentioned in the record. */
5879 else
5882 /* Set the transaction commit timestamp and metadata */
5887 {
5888 /*
5889 * Mark the transaction committed in pg_xact.
5890 */
5892 }
5893 else
5894 {
5895 /*
5896 * If a transaction completion record arrives that has as-yet
5897 * unobserved subtransactions then this will not have been fully
5898 * handled by the call to RecordKnownAssignedTransactionIds() in the
5899 * main recovery loop in xlog.c. So we need to do bookkeeping again to
5900 * cover that case. This is confusing and it is easy to think this
5901 * call is irrelevant, which has happened three times in development
5902 * already. Leave it in.
5903 */
5906 /*
5907 * Mark the transaction committed in pg_xact. We use async commit
5908 * protocol during recovery to provide information on database
5909 * consistency for when users try to set hint bits. It is important
5910 * that we do not set hint bits until the minRecoveryPoint is past
5911 * this commit record. This ensures that if we crash we don't see hint
5912 * bits set on changes made by transactions that haven't yet
5913 * recovered. It's unlikely but it's good to be safe.
5914 */
5917 /*
5918 * We must mark clog before we update the ProcArray.
5919 */
5922 /*
5923 * Send any cache invalidations attached to the commit. We must
5924 * maintain the same order of invalidation then release locks as
5925 * occurs in CommitTransaction().
5926 */
5931 /*
5932 * Release locks, if any. We do this for both two phase and normal one
5933 * phase transactions. In effect we are ignoring the prepare phase and
5934 * just going straight to lock release.
5935 */
5938 }
5941 {
5942 /* recover apply progress */
5945 }
5947 /* Make sure files supposed to be dropped are dropped */
5949 {
5950 /*
5951 * First update minimum recovery point to cover this WAL record. Once
5952 * a relation is deleted, there's no going back. The buffer manager
5953 * enforces the WAL-first rule for normal updates to relation files,
5954 * so that the minimum recovery point is always updated before the
5955 * corresponding change in the data file is flushed to disk, but we
5956 * have to do the same here since we're bypassing the buffer manager.
5957 *
5958 * Doing this before deleting the files means that if a deletion fails
5959 * for some reason, you cannot start up the system even after restart,
5960 * until you fix the underlying situation so that the deletion will
5961 * succeed. Alternatively, we could update the minimum recovery point
5962 * after deletion, but that would leave a small window where the
5963 * WAL-first rule would be violated.
5964 */
5967 /* Make sure files supposed to be dropped are dropped */
5969 }
5971 /*
5972 * We issue an XLogFlush() for the same reason we emit ForceSyncCommit()
5973 * in normal operation. For example, in CREATE DATABASE, we copy all files
5974 * from the template database, and then commit the transaction. If we
5975 * crash after all the files have been copied but before the commit, you
5976 * have files in the data directory without an entry in pg_database. To
5977 * minimize the window for that, we use ForceSyncCommit() to rush the
5978 * commit record to disk as quick as possible. We have the same window
5979 * during recovery, and forcing an XLogFlush() (which updates
5980 * minRecoveryPoint during recovery) helps to reduce that problem window,
5981 * for any user that requested ForceSyncCommit().
5982 */
5986 /*
5987 * If asked by the primary (because someone is waiting for a synchronous
5988 * commit = remote_apply), we will need to ask walreceiver to send a reply
5989 * immediately.
5990 */
5993 }
5995 /*
5996 * Be careful with the order of execution, as with xact_redo_commit().
5997 * The two functions are similar but differ in key places.
5998 *
5999 * Note also that an abort can be for a subtransaction and its children,
6000 * not just for a top level abort. That means we have to consider
6001 * topxid != xid, whereas in commit we would find topxid == xid always
6002 * because subtransaction commit is never WAL logged.
6003 */
6004 static void
6007 {
6008 TransactionId max_xid;
6012 /* Make sure nextXid is beyond any XID mentioned in the record. */
6019 {
6020 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6022 }
6023 else
6024 {
6025 /*
6026 * If a transaction completion record arrives that has as-yet
6027 * unobserved subtransactions then this will not have been fully
6028 * handled by the call to RecordKnownAssignedTransactionIds() in the
6029 * main recovery loop in xlog.c. So we need to do bookkeeping again to
6030 * cover that case. This is confusing and it is easy to think this
6031 * call is irrelevant, which has happened three times in development
6032 * already. Leave it in.
6033 */
6036 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6039 /*
6040 * We must update the ProcArray after we have marked clog.
6041 */
6044 /*
6045 * There are no invalidation messages to send or undo.
6046 */
6048 /*
6049 * Release locks, if any. There are no invalidations to send.
6050 */
6053 }
6056 {
6057 /* recover apply progress */
6060 }
6062 /* Make sure files supposed to be dropped are dropped */
6064 {
6065 /*
6066 * See comments about update of minimum recovery point on truncation,
6067 * in xact_redo_commit().
6068 */
6072 }
6073 }
6075 void
6077 {
6080 /* Backup blocks are not used in xact records */
6084 {
6086 xl_xact_parsed_commit parsed;
6091 }
6093 {
6095 xl_xact_parsed_commit parsed;
6101 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6105 }
6107 {
6109 xl_xact_parsed_abort parsed;
6114 }
6116 {
6118 xl_xact_parsed_abort parsed;
6124 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6128 }
6130 {
6131 /*
6132 * Store xid and start/end pointers of the WAL record in TwoPhaseState
6133 * gxact entry.
6134 */
6141 }
6143 {
6149 }
6151 {
6152 /*
6153 * XXX we do ignore this for now, what matters are invalidations
6154 * written into the commit record.
6155 */
6156 }
6157 else
6159 }