| blob | d331ab90d781ea717fd47dd5f0713cb723743803 |
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-2025, 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>
74 /*
75 * User-tweakable parameters
76 */
88 /*
89 * CheckXidAlive is a xid value pointing to a possibly ongoing (sub)
90 * transaction. Currently, it is used in logical decoding. It's possible
91 * that such transactions can get aborted while the decoding is ongoing in
92 * which case we skip decoding that particular transaction. To ensure that we
93 * check whether the CheckXidAlive is aborted after fetching the tuple from
94 * system tables. We also ensure that during logical decoding we never
95 * directly access the tableam or heap APIs because we are checking for the
96 * concurrent aborts only in systable_* APIs.
97 */
101 /*
102 * When running as a parallel worker, we place only a single
103 * TransactionStateData on the parallel worker's state stack, and the XID
104 * reflected there will be that of the *innermost* currently-active
105 * subtransaction in the backend that initiated parallelism. However,
106 * GetTopTransactionId() and TransactionIdIsCurrentTransactionId()
107 * need to return the same answers in the parallel worker as they would have
108 * in the user backend, so we need some additional bookkeeping.
109 *
110 * XactTopFullTransactionId stores the XID of our toplevel transaction, which
111 * will be the same as TopTransactionStateData.fullTransactionId in an
112 * ordinary backend; but in a parallel backend, which does not have the entire
113 * transaction state, it will instead be copied from the backend that started
114 * the parallel operation.
115 *
116 * nParallelCurrentXids will be 0 and ParallelCurrentXids NULL in an ordinary
117 * backend, but in a parallel backend, nParallelCurrentXids will contain the
118 * number of XIDs that need to be considered current, and ParallelCurrentXids
119 * will contain the XIDs themselves. This includes all XIDs that were current
120 * or sub-committed in the parent at the time the parallel operation began.
121 * The XIDs are stored sorted in numerical order (not logical order) to make
122 * lookups as fast as possible.
123 */
128 /*
129 * Miscellaneous flag bits to record events which occur on the top level
130 * transaction. These flags are only persisted in MyXactFlags and are intended
131 * so we remember to do certain things later on in the transaction. This is
132 * globally accessible, so can be set from anywhere in the code that requires
133 * recording flags.
134 */
137 /*
138 * transaction states - transaction state from server perspective
139 */
141 {
150 /*
151 * transaction block states - transaction state of client queries
152 *
153 * Note: the subtransaction states are used only for non-topmost
154 * transactions; the others appear only in the topmost transaction.
155 */
157 {
158 /* not-in-transaction-block states */
162 /* transaction block states */
173 /* subtransaction states */
185 /*
186 * transaction state structure
187 *
188 * Note: parallelModeLevel counts the number of unmatched EnterParallelMode
189 * calls done at this transaction level. parallelChildXact is true if any
190 * upper transaction level has nonzero parallelModeLevel.
191 */
193 {
222 /*
223 * Serialized representation used to transmit transaction state to parallel
224 * workers through shared memory.
225 */
227 {
230 FullTransactionId topFullTransactionId;
231 FullTransactionId currentFullTransactionId;
232 CommandId currentCommandId;
237 /* The size of SerializedTransactionState, not including the final array. */
238 #define SerializedTransactionStateHeaderSize \
239 offsetof(SerializedTransactionState, parallelCurrentXids)
241 /*
242 * CurrentTransactionState always points to the current transaction state
243 * block. It will point to TopTransactionStateData when not in a
244 * transaction at all, or when in a top-level transaction.
245 */
250 };
252 /*
253 * unreportedXids holds XIDs of all subtransactions that have not yet been
254 * reported in an XLOG_XACT_ASSIGNMENT record.
255 */
261 /*
262 * The subtransaction ID and command ID assignment counters are global
263 * to a whole transaction, so we do not keep them in the state stack.
264 */
269 /*
270 * xactStartTimestamp is the value of transaction_timestamp().
271 * stmtStartTimestamp is the value of statement_timestamp().
272 * xactStopTimestamp is the time at which we log a commit / abort WAL record,
273 * or if that was skipped, the time of the first subsequent
274 * GetCurrentTransactionStopTimestamp() call.
275 *
276 * These do not change as we enter and exit subtransactions, so we don't
277 * keep them inside the TransactionState stack.
278 */
283 /*
284 * GID to be used for preparing the current transaction. This is also
285 * global to a whole transaction, so we don't keep it in the state stack.
286 */
289 /*
290 * Some commands want to force synchronous commit.
291 */
294 /* Flag for logging statements in a transaction. */
297 /*
298 * Private context for transaction-abort work --- we reserve space for this
299 * at startup to ensure that AbortTransaction and AbortSubTransaction can work
300 * when we've run out of memory.
301 */
304 /*
305 * List of add-on start- and end-of-xact callbacks
306 */
308 {
310 XactCallback callback;
316 /*
317 * List of add-on start- and end-of-subxact callbacks
318 */
320 {
322 SubXactCallback callback;
329 /* local function prototypes */
342 SubTransactionId mySubid,
343 SubTransactionId parentSubid);
374 /* ----------------------------------------------------------------
375 * transaction state accessors
376 * ----------------------------------------------------------------
377 */
379 /*
380 * IsTransactionState
381 *
382 * This returns true if we are inside a valid transaction; that is,
383 * it is safe to initiate database access, take heavyweight locks, etc.
384 */
385 bool
387 {
390 /*
391 * TRANS_DEFAULT and TRANS_ABORT are obviously unsafe states. However, we
392 * also reject the startup/shutdown states TRANS_START, TRANS_COMMIT,
393 * TRANS_PREPARE since it might be too soon or too late within those
394 * transition states to do anything interesting. Hence, the only "valid"
395 * state is TRANS_INPROGRESS.
396 */
398 }
400 /*
401 * IsAbortedTransactionBlockState
402 *
403 * This returns true if we are within an aborted transaction block.
404 */
405 bool
407 {
415 }
418 /*
419 * GetTopTransactionId
420 *
421 * This will return the XID of the main transaction, assigning one if
422 * it's not yet set. Be careful to call this only inside a valid xact.
423 */
424 TransactionId
426 {
430 }
432 /*
433 * GetTopTransactionIdIfAny
434 *
435 * This will return the XID of the main transaction, if one is assigned.
436 * It will return InvalidTransactionId if we are not currently inside a
437 * transaction, or inside a transaction that hasn't yet been assigned an XID.
438 */
439 TransactionId
441 {
443 }
445 /*
446 * GetCurrentTransactionId
447 *
448 * This will return the XID of the current transaction (main or sub
449 * transaction), assigning one if it's not yet set. Be careful to call this
450 * only inside a valid xact.
451 */
452 TransactionId
454 {
460 }
462 /*
463 * GetCurrentTransactionIdIfAny
464 *
465 * This will return the XID of the current sub xact, if one is assigned.
466 * It will return InvalidTransactionId if we are not currently inside a
467 * transaction, or inside a transaction that hasn't been assigned an XID yet.
468 */
469 TransactionId
471 {
473 }
475 /*
476 * GetTopFullTransactionId
477 *
478 * This will return the FullTransactionId of the main transaction, assigning
479 * one if it's not yet set. Be careful to call this only inside a valid xact.
480 */
481 FullTransactionId
483 {
487 }
489 /*
490 * GetTopFullTransactionIdIfAny
491 *
492 * This will return the FullTransactionId of the main transaction, if one is
493 * assigned. It will return InvalidFullTransactionId if we are not currently
494 * inside a transaction, or inside a transaction that hasn't yet been assigned
495 * one.
496 */
497 FullTransactionId
499 {
501 }
503 /*
504 * GetCurrentFullTransactionId
505 *
506 * This will return the FullTransactionId of the current transaction (main or
507 * sub transaction), assigning one if it's not yet set. Be careful to call
508 * this only inside a valid xact.
509 */
510 FullTransactionId
512 {
518 }
520 /*
521 * GetCurrentFullTransactionIdIfAny
522 *
523 * This will return the FullTransactionId of the current sub xact, if one is
524 * assigned. It will return InvalidFullTransactionId if we are not currently
525 * inside a transaction, or inside a transaction that hasn't been assigned one
526 * yet.
527 */
528 FullTransactionId
530 {
532 }
534 /*
535 * MarkCurrentTransactionIdLoggedIfAny
536 *
537 * Remember that the current xid - if it is assigned - now has been wal logged.
538 */
539 void
541 {
544 }
546 /*
547 * IsSubxactTopXidLogPending
548 *
549 * This is used to decide whether we need to WAL log the top-level XID for
550 * operation in a subtransaction. We require that for logical decoding, see
551 * LogicalDecodingProcessRecord.
552 *
553 * This returns true if wal_level >= logical and we are inside a valid
554 * subtransaction, for which the assignment was not yet written to any WAL
555 * record.
556 */
557 bool
559 {
560 /* check whether it is already logged */
564 /* wal_level has to be logical */
568 /* we need to be in a transaction state */
572 /* it has to be a subtransaction */
576 /* the subtransaction has to have a XID assigned */
581 }
583 /*
584 * MarkSubxactTopXidLogged
585 *
586 * Remember that the top transaction id for the current subtransaction is WAL
587 * logged now.
588 */
589 void
591 {
595 }
597 /*
598 * GetStableLatestTransactionId
599 *
600 * Get the transaction's XID if it has one, else read the next-to-be-assigned
601 * XID. Once we have a value, return that same value for the remainder of the
602 * current transaction. This is meant to provide the reference point for the
603 * age(xid) function, but might be useful for other maintenance tasks as well.
604 */
605 TransactionId
607 {
612 {
617 }
622 }
624 /*
625 * AssignTransactionId
626 *
627 * Assigns a new permanent FullTransactionId to the given TransactionState.
628 * We do not assign XIDs to transactions until/unless this is called.
629 * Also, any parent TransactionStates that don't yet have XIDs are assigned
630 * one; this maintains the invariant that a child transaction has an XID
631 * following its parent's.
632 */
633 static void
635 {
637 ResourceOwner currentOwner;
640 /* Assert that caller didn't screw up */
644 /*
645 * Workers synchronize transaction state at the beginning of each parallel
646 * operation, so we can't account for new XIDs at this point.
647 */
653 /*
654 * Ensure parent(s) have XIDs, so that a child always has an XID later
655 * than its parent. Mustn't recurse here, or we might get a stack
656 * overflow if we're at the bottom of a huge stack of subtransactions none
657 * of which have XIDs yet.
658 */
660 {
667 {
670 }
672 /*
673 * This is technically a recursive call, but the recursion will never
674 * be more than one layer deep.
675 */
680 }
682 /*
683 * When wal_level=logical, guarantee that a subtransaction's xid can only
684 * be seen in the WAL stream if its toplevel xid has been logged before.
685 * If necessary we log an xact_assignment record with fewer than
686 * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
687 * for a transaction even though it appears in a WAL record, we just might
688 * superfluously log something. That can happen when an xid is included
689 * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
690 * xl_standby_locks.
691 */
696 /*
697 * Generate a new FullTransactionId and record its xid in PGPROC and
698 * pg_subtrans.
699 *
700 * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
701 * shared storage other than PGPROC; because if there's no room for it in
702 * PGPROC, the subtrans entry is needed to ensure that other backends see
703 * the Xid as "running". See GetNewTransactionId.
704 */
713 /*
714 * If it's a top-level transaction, the predicate locking system needs to
715 * be told about it too.
716 */
720 /*
721 * Acquire lock on the transaction XID. (We assume this cannot block.) We
722 * have to ensure that the lock is assigned to the transaction's own
723 * ResourceOwner.
724 */
732 /*
733 * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
734 * top-level transaction we issue a WAL record for the assignment. We
735 * include the top-level xid and all the subxids that have not yet been
736 * reported using XLOG_XACT_ASSIGNMENT records.
737 *
738 * This is required to limit the amount of shared memory required in a hot
739 * standby server to keep track of in-progress XIDs. See notes for
740 * RecordKnownAssignedTransactionIds().
741 *
742 * We don't keep track of the immediate parent of each subxid, only the
743 * top-level transaction that each subxact belongs to. This is correct in
744 * recovery only because aborted subtransactions are separately WAL
745 * logged.
746 *
747 * This is correct even for the case where several levels above us didn't
748 * have an xid assigned as we recursed up to them beforehand.
749 */
751 {
753 nUnreportedXids++;
755 /*
756 * ensure this test matches similar one in
757 * RecoverPreparedTransactions()
758 */
760 log_unknown_top)
761 {
762 xl_xact_assignment xlrec;
764 /*
765 * xtop is always set by now because we recurse up transaction
766 * stack to the highest unassigned xid and then come back down
767 */
780 /* mark top, not current xact as having been logged */
782 }
783 }
784 }
786 /*
787 * GetCurrentSubTransactionId
788 */
789 SubTransactionId
791 {
795 }
797 /*
798 * SubTransactionIsActive
799 *
800 * Test if the specified subxact ID is still active. Note caller is
801 * responsible for checking whether this ID is relevant to the current xact.
802 */
803 bool
805 {
806 TransactionState s;
809 {
814 }
816 }
819 /*
820 * GetCurrentCommandId
821 *
822 * "used" must be true if the caller intends to use the command ID to mark
823 * inserted/updated/deleted tuples. false means the ID is being fetched
824 * for read-only purposes (ie, as a snapshot validity cutoff). See
825 * CommandCounterIncrement() for discussion.
826 */
827 CommandId
829 {
830 /* this is global to a transaction, not subtransaction-local */
832 {
833 /*
834 * Forbid setting currentCommandIdUsed in a parallel worker, because
835 * we have no provision for communicating this back to the leader. We
836 * could relax this restriction when currentCommandIdUsed was already
837 * true at the start of the parallel operation.
838 */
845 }
847 }
849 /*
850 * SetParallelStartTimestamps
851 *
852 * In a parallel worker, we should inherit the parent transaction's
853 * timestamps rather than setting our own. The parallel worker
854 * infrastructure must call this to provide those values before
855 * calling StartTransaction() or SetCurrentStatementStartTimestamp().
856 */
857 void
859 {
863 }
865 /*
866 * GetCurrentTransactionStartTimestamp
867 */
868 TimestampTz
870 {
872 }
874 /*
875 * GetCurrentStatementStartTimestamp
876 */
877 TimestampTz
879 {
881 }
883 /*
884 * GetCurrentTransactionStopTimestamp
885 *
886 * If the transaction stop time hasn't already been set, which can happen if
887 * we decided we don't need to log an XLOG record, set xactStopTimestamp.
888 */
889 TimestampTz
891 {
894 /* should only be called after commit / abort processing */
904 }
906 /*
907 * SetCurrentStatementStartTimestamp
908 *
909 * In a parallel worker, this should already have been provided by a call
910 * to SetParallelStartTimestamps().
911 */
912 void
914 {
917 else
919 }
921 /*
922 * GetCurrentTransactionNestLevel
923 *
924 * Note: this will return zero when not inside any transaction, one when
925 * inside a top-level transaction, etc.
926 */
927 int
929 {
933 }
936 /*
937 * TransactionIdIsCurrentTransactionId
938 */
939 bool
941 {
942 TransactionState s;
944 /*
945 * We always say that BootstrapTransactionId is "not my transaction ID"
946 * even when it is (ie, during bootstrap). Along with the fact that
947 * transam.c always treats BootstrapTransactionId as already committed,
948 * this causes the heapam_visibility.c routines to see all tuples as
949 * committed, which is what we need during bootstrap. (Bootstrap mode
950 * only inserts tuples, it never updates or deletes them, so all tuples
951 * can be presumed good immediately.)
952 *
953 * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
954 * not my transaction ID, so we can just return "false" immediately for
955 * any non-normal XID.
956 */
963 /*
964 * In parallel workers, the XIDs we must consider as current are stored in
965 * ParallelCurrentXids rather than the transaction-state stack. Note that
966 * the XIDs in this array are sorted numerically rather than according to
967 * transactionIdPrecedes order.
968 */
970 {
972 high;
977 {
979 TransactionId probe;
987 else
989 }
991 }
993 /*
994 * We will return true for the Xid of the current subtransaction, any of
995 * its subcommitted children, any of its parents, or any of their
996 * previously subcommitted children. However, a transaction being aborted
997 * is no longer "current", even though it may still have an entry on the
998 * state stack.
999 */
1001 {
1003 high;
1011 /* As the childXids array is ordered, we can use binary search */
1015 {
1017 TransactionId probe;
1025 else
1027 }
1028 }
1031 }
1033 /*
1034 * TransactionStartedDuringRecovery
1035 *
1036 * Returns true if the current transaction started while recovery was still
1037 * in progress. Recovery might have ended since so RecoveryInProgress() might
1038 * return false already.
1039 */
1040 bool
1042 {
1044 }
1046 /*
1047 * EnterParallelMode
1048 */
1049 void
1051 {
1057 }
1059 /*
1060 * ExitParallelMode
1061 */
1062 void
1064 {
1072 }
1074 /*
1075 * IsInParallelMode
1076 *
1077 * Are we in a parallel operation, as either the leader or a worker? Check
1078 * this to prohibit operations that change backend-local state expected to
1079 * match across all workers. Mere caches usually don't require such a
1080 * restriction. State modified in a strict push/pop fashion, such as the
1081 * active snapshot stack, is often fine.
1082 *
1083 * We say we are in parallel mode if we are in a subxact of a transaction
1084 * that's initiated a parallel operation; for most purposes that context
1085 * has all the same restrictions.
1086 */
1087 bool
1089 {
1093 }
1095 /*
1096 * CommandCounterIncrement
1097 */
1098 void
1100 {
1101 /*
1102 * If the current value of the command counter hasn't been "used" to mark
1103 * tuples, we need not increment it, since there's no need to distinguish
1104 * a read-only command from others. This helps postpone command counter
1105 * overflow, and keeps no-op CommandCounterIncrement operations cheap.
1106 */
1108 {
1109 /*
1110 * Workers synchronize transaction state at the beginning of each
1111 * parallel operation, so we can't account for new commands after that
1112 * point.
1113 */
1121 {
1126 }
1129 /* Propagate new command ID into static snapshots */
1132 /*
1133 * Make any catalog changes done by the just-completed command visible
1134 * in the local syscache. We obviously don't need to do this after a
1135 * read-only command. (But see hacks in inval.c to make real sure we
1136 * don't think a command that queued inval messages was read-only.)
1137 */
1139 }
1140 }
1142 /*
1143 * ForceSyncCommit
1144 *
1145 * Interface routine to allow commands to force a synchronous commit of the
1146 * current top-level transaction. Currently, two-phase commit does not
1147 * persist and restore this variable. So long as all callers use
1148 * PreventInTransactionBlock(), that omission has no consequences.
1149 */
1150 void
1152 {
1154 }
1157 /* ----------------------------------------------------------------
1158 * StartTransaction stuff
1159 * ----------------------------------------------------------------
1160 */
1162 /*
1163 * AtStart_Cache
1164 */
1165 static void
1167 {
1169 }
1171 /*
1172 * AtStart_Memory
1173 */
1174 static void
1176 {
1179 /*
1180 * Remember the memory context that was active prior to transaction start.
1181 */
1184 /*
1185 * If this is the first time through, create a private context for
1186 * AbortTransaction to work in. By reserving some space now, we can
1187 * insulate AbortTransaction from out-of-memory scenarios. Like
1188 * ErrorContext, we set it up with slow growth rate and a nonzero minimum
1189 * size, so that space will be reserved immediately.
1190 */
1192 TransactionAbortContext =
1199 /*
1200 * Likewise, if this is the first time through, create a top-level context
1201 * for transaction-local data. This context will be reset at transaction
1202 * end, and then re-used in later transactions.
1203 */
1205 TopTransactionContext =
1208 ALLOCSET_DEFAULT_SIZES);
1210 /*
1211 * In a top-level transaction, CurTransactionContext is the same as
1212 * TopTransactionContext.
1213 */
1217 /* Make the CurTransactionContext active. */
1219 }
1221 /*
1222 * AtStart_ResourceOwner
1223 */
1224 static void
1226 {
1229 /*
1230 * We shouldn't have a transaction resource owner already.
1231 */
1234 /*
1235 * Create a toplevel resource owner for the transaction.
1236 */
1242 }
1244 /* ----------------------------------------------------------------
1245 * StartSubTransaction stuff
1246 * ----------------------------------------------------------------
1247 */
1249 /*
1250 * AtSubStart_Memory
1251 */
1252 static void
1254 {
1259 /*
1260 * Remember the context that was active prior to subtransaction start.
1261 */
1264 /*
1265 * Create a CurTransactionContext, which will be used to hold data that
1266 * survives subtransaction commit but disappears on subtransaction abort.
1267 * We make it a child of the immediate parent's CurTransactionContext.
1268 */
1271 ALLOCSET_DEFAULT_SIZES);
1274 /* Make the CurTransactionContext active. */
1276 }
1278 /*
1279 * AtSubStart_ResourceOwner
1280 */
1281 static void
1283 {
1288 /*
1289 * Create a resource owner for the subtransaction. We make it a child of
1290 * the immediate parent's resource owner.
1291 */
1298 }
1300 /* ----------------------------------------------------------------
1301 * CommitTransaction stuff
1302 * ----------------------------------------------------------------
1303 */
1305 /*
1306 * RecordTransactionCommit
1307 *
1308 * Returns latest XID among xact and its children, or InvalidTransactionId
1309 * if the xact has no XID. (We compute that here just because it's easier.)
1310 *
1311 * If you change this function, see RecordTransactionCommitPrepared also.
1312 */
1313 static TransactionId
1315 {
1330 /*
1331 * Log pending invalidations for logical decoding of in-progress
1332 * transactions. Normally for DDLs, we log this at each command end,
1333 * however, for certain cases where we directly update the system table
1334 * without a transaction block, the invalidations are not logged till this
1335 * time.
1336 */
1340 /* Get data needed for commit record */
1349 /*
1350 * If we haven't been assigned an XID yet, we neither can, nor do we want
1351 * to write a COMMIT record.
1352 */
1354 {
1355 /*
1356 * We expect that every RelationDropStorage is followed by a catalog
1357 * update, and hence XID assignment, so we shouldn't get here with any
1358 * pending deletes. Same is true for dropping stats.
1359 *
1360 * Use a real test not just an Assert to check this, since it's a bit
1361 * fragile.
1362 */
1366 /* Can't have child XIDs either; AssignTransactionId enforces this */
1369 /*
1370 * Transactions without an assigned xid can contain invalidation
1371 * messages. While inplace updates do this, this is not known to be
1372 * necessary; see comment at inplace CacheInvalidateHeapTuple().
1373 * Extensions might still rely on this capability, and standbys may
1374 * need to process those invals. We can't emit a commit record
1375 * without an xid, and we don't want to force assigning an xid,
1376 * because that'd be problematic for e.g. vacuum. Hence we emit a
1377 * bespoke record for the invalidations. We don't want to use that in
1378 * case a commit record is emitted, so they happen synchronously with
1379 * commits (besides not wanting to emit more WAL records).
1380 *
1381 * XXX Every known use of this capability is a defect. Since an XID
1382 * isn't controlling visibility of the change that prompted invals,
1383 * other sessions need the inval even if this transactions aborts.
1384 *
1385 * ON COMMIT DELETE ROWS does a nontransactional index_build(), which
1386 * queues a relcache inval, including in transactions without an xid
1387 * that had read the (empty) table. Standbys don't need any ON COMMIT
1388 * DELETE ROWS invals, but we've not done the work to withhold them.
1389 */
1391 {
1393 RelcacheInitFileInval);
1395 }
1397 /*
1398 * If we didn't create XLOG entries, we're done here; otherwise we
1399 * should trigger flushing those entries the same as a commit record
1400 * would. This will primarily happen for HOT pruning and the like; we
1401 * want these to be flushed to disk in due time.
1402 */
1405 }
1406 else
1407 {
1410 /*
1411 * Are we using the replication origins feature? Or, in other words,
1412 * are we replaying remote actions?
1413 */
1417 /*
1418 * Mark ourselves as within our "commit critical section". This
1419 * forces any concurrent checkpoint to wait until we've updated
1420 * pg_xact. Without this, it is possible for the checkpoint to set
1421 * REDO after the XLOG record but fail to flush the pg_xact update to
1422 * disk, leading to loss of the transaction commit if the system
1423 * crashes a little later.
1424 *
1425 * Note: we could, but don't bother to, set this flag in
1426 * RecordTransactionAbort. That's because loss of a transaction abort
1427 * is noncritical; the presumption would be that it aborted, anyway.
1428 *
1429 * It's safe to change the delayChkptFlags flag of our own backend
1430 * without holding the ProcArrayLock, since we're the only one
1431 * modifying it. This makes checkpoint's determination of which xacts
1432 * are delaying the checkpoint a bit fuzzy, but it doesn't matter.
1433 */
1438 /*
1439 * Insert the commit XLOG record.
1440 */
1445 RelcacheInitFileInval,
1446 MyXactFlags,
1450 /* Move LSNs forward for this replication origin */
1452 XactLastRecEnd);
1454 /*
1455 * Record commit timestamp. The value comes from plain commit
1456 * timestamp if there's no replication origin; otherwise, the
1457 * timestamp was already set in replorigin_session_origin_timestamp by
1458 * replication.
1459 *
1460 * We don't need to WAL-log anything here, as the commit record
1461 * written above already contains the data.
1462 */
1468 replorigin_session_origin_timestamp,
1469 replorigin_session_origin);
1470 }
1472 /*
1473 * Check if we want to commit asynchronously. We can allow the XLOG flush
1474 * to happen asynchronously if synchronous_commit=off, or if the current
1475 * transaction has not performed any WAL-logged operation or didn't assign
1476 * an xid. The transaction can end up not writing any WAL, even if it has
1477 * an xid, if it only wrote to temporary and/or unlogged tables. It can
1478 * end up having written WAL without an xid if it did HOT pruning. In
1479 * case of a crash, the loss of such a transaction will be irrelevant;
1480 * temp tables will be lost anyway, unlogged tables will be truncated and
1481 * HOT pruning will be done again later. (Given the foregoing, you might
1482 * think that it would be unnecessary to emit the XLOG record at all in
1483 * this case, but we don't currently try to do that. It would certainly
1484 * cause problems at least in Hot Standby mode, where the
1485 * KnownAssignedXids machinery requires tracking every XID assignment. It
1486 * might be OK to skip it only when wal_level < replica, but for now we
1487 * don't.)
1488 *
1489 * However, if we're doing cleanup of any non-temp rels or committing any
1490 * command that wanted to force sync commit, then we must flush XLOG
1491 * immediately. (We must not allow asynchronous commit if there are any
1492 * non-temp tables to be deleted, because we might delete the files before
1493 * the COMMIT record is flushed to disk. We do allow asynchronous commit
1494 * if all to-be-deleted tables are temporary though, since they are lost
1495 * anyway if we crash.)
1496 */
1500 {
1503 /*
1504 * Now we may update the CLOG, if we wrote a COMMIT record above
1505 */
1508 }
1509 else
1510 {
1511 /*
1512 * Asynchronous commit case:
1513 *
1514 * This enables possible committed transaction loss in the case of a
1515 * postmaster crash because WAL buffers are left unwritten. Ideally we
1516 * could issue the WAL write without the fsync, but some
1517 * wal_sync_methods do not allow separate write/fsync.
1518 *
1519 * Report the latest async commit LSN, so that the WAL writer knows to
1520 * flush this commit.
1521 */
1524 /*
1525 * We must not immediately update the CLOG, since we didn't flush the
1526 * XLOG. Instead, we store the LSN up to which the XLOG must be
1527 * flushed before the CLOG may be updated.
1528 */
1531 }
1533 /*
1534 * If we entered a commit critical section, leave it now, and let
1535 * checkpoints proceed.
1536 */
1538 {
1541 }
1543 /* Compute latestXid while we have the child XIDs handy */
1546 /*
1547 * Wait for synchronous replication, if required. Similar to the decision
1548 * above about using committing asynchronously we only want to wait if
1549 * this backend assigned an xid and wrote WAL. No need to wait if an xid
1550 * was assigned due to temporary/unlogged tables or due to HOT pruning.
1551 *
1552 * Note that at this stage we have marked clog, but still show as running
1553 * in the procarray and continue to hold locks.
1554 */
1558 /* remember end of last commit record */
1561 /* Reset XactLastRecEnd until the next transaction writes something */
1563 cleanup:
1564 /* Clean up local data */
1571 }
1574 /*
1575 * AtCCI_LocalCache
1576 */
1577 static void
1579 {
1580 /*
1581 * Make any pending relation map changes visible. We must do this before
1582 * processing local sinval messages, so that the map changes will get
1583 * reflected into the relcache when relcache invals are processed.
1584 */
1587 /*
1588 * Make catalog changes visible to me for the next command.
1589 */
1591 }
1593 /*
1594 * AtCommit_Memory
1595 */
1596 static void
1598 {
1601 /*
1602 * Return to the memory context that was current before we started the
1603 * transaction. (In principle, this could not be any of the contexts we
1604 * are about to delete. If it somehow is, assertions in mcxt.c will
1605 * complain.)
1606 */
1609 /*
1610 * Release all transaction-local memory. TopTransactionContext survives
1611 * but becomes empty; any sub-contexts go away.
1612 */
1616 /*
1617 * Clear these pointers as a pro-forma matter. (Notionally, while
1618 * TopTransactionContext still exists, it's currently not associated with
1619 * this TransactionState struct.)
1620 */
1623 }
1625 /* ----------------------------------------------------------------
1626 * CommitSubTransaction stuff
1627 * ----------------------------------------------------------------
1628 */
1630 /*
1631 * AtSubCommit_Memory
1632 */
1633 static void
1635 {
1640 /* Return to parent transaction level's memory context. */
1644 /*
1645 * Ordinarily we cannot throw away the child's CurTransactionContext,
1646 * since the data it contains will be needed at upper commit. However, if
1647 * there isn't actually anything in it, we can throw it away. This avoids
1648 * a small memory leak in the common case of "trivial" subxacts.
1649 */
1651 {
1654 }
1655 }
1657 /*
1658 * AtSubCommit_childXids
1659 *
1660 * Pass my own XID and my child XIDs up to my parent as committed children.
1661 */
1662 static void
1664 {
1670 /*
1671 * The parent childXids array will need to hold my XID and all my
1672 * childXids, in addition to the XIDs already there.
1673 */
1676 /* Allocate or enlarge the parent array if necessary */
1678 {
1682 /*
1683 * Make it 2x what's needed right now, to avoid having to enlarge it
1684 * repeatedly. But we can't go above MaxAllocSize. (The latter limit
1685 * is what ensures that we don't need to worry about integer overflow
1686 * here or in the calculation of new_nChildXids.)
1687 */
1697 /*
1698 * We keep the child-XID arrays in TopTransactionContext; this avoids
1699 * setting up child-transaction contexts for what might be just a few
1700 * bytes of grandchild XIDs.
1701 */
1703 new_childXids =
1706 else
1712 }
1714 /*
1715 * Copy all my XIDs to parent's array.
1716 *
1717 * Note: We rely on the fact that the XID of a child always follows that
1718 * of its parent. By copying the XID of this subtransaction before the
1719 * XIDs of its children, we ensure that the array stays ordered. Likewise,
1720 * all XIDs already in the array belong to subtransactions started and
1721 * subcommitted before us, so their XIDs must precede ours.
1722 */
1732 /* Release child's array to avoid leakage */
1735 /* We must reset these to avoid double-free if fail later in commit */
1739 }
1741 /* ----------------------------------------------------------------
1742 * AbortTransaction stuff
1743 * ----------------------------------------------------------------
1744 */
1746 /*
1747 * RecordTransactionAbort
1748 *
1749 * Returns latest XID among xact and its children, or InvalidTransactionId
1750 * if the xact has no XID. (We compute that here just because it's easier.)
1751 */
1752 static TransactionId
1754 {
1756 TransactionId latestXid;
1763 TimestampTz xact_time;
1766 /*
1767 * If we haven't been assigned an XID, nobody will care whether we aborted
1768 * or not. Hence, we're done in that case. It does not matter if we have
1769 * rels to delete (note that this routine is not responsible for actually
1770 * deleting 'em). We cannot have any child XIDs, either.
1771 */
1773 {
1774 /* Reset XactLastRecEnd until the next transaction writes something */
1778 }
1780 /*
1781 * We have a valid XID, so we should write an ABORT record for it.
1782 *
1783 * We do not flush XLOG to disk here, since the default assumption after a
1784 * crash would be that we aborted, anyway. For the same reason, we don't
1785 * need to worry about interlocking against checkpoint start.
1786 */
1788 /*
1789 * Check that we haven't aborted halfway through RecordTransactionCommit.
1790 */
1793 xid);
1795 /*
1796 * Are we using the replication origins feature? Or, in other words, are
1797 * we replaying remote actions?
1798 */
1802 /* Fetch the data we need for the abort record */
1807 /* XXX do we really need a critical section here? */
1810 /* Write the ABORT record */
1813 else
1814 {
1816 }
1823 NULL);
1826 /* Move LSNs forward for this replication origin */
1828 XactLastRecEnd);
1830 /*
1831 * Report the latest async abort LSN, so that the WAL writer knows to
1832 * flush this abort. There's nothing to be gained by delaying this, since
1833 * WALWriter may as well do this when it can. This is important with
1834 * streaming replication because if we don't flush WAL regularly we will
1835 * find that large aborts leave us with a long backlog for when commits
1836 * occur after the abort, increasing our window of data loss should
1837 * problems occur at that point.
1838 */
1842 /*
1843 * Mark the transaction aborted in clog. This is not absolutely necessary
1844 * but we may as well do it while we are here; also, in the subxact case
1845 * it is helpful because XactLockTableWait makes use of it to avoid
1846 * waiting for already-aborted subtransactions. It is OK to do it without
1847 * having flushed the ABORT record to disk, because in event of a crash
1848 * we'd be assumed to have aborted anyway.
1849 */
1854 /* Compute latestXid while we have the child XIDs handy */
1857 /*
1858 * If we're aborting a subtransaction, we can immediately remove failed
1859 * XIDs from PGPROC's cache of running child XIDs. We do that here for
1860 * subxacts, because we already have the child XID array at hand. For
1861 * main xacts, the equivalent happens just after this function returns.
1862 */
1866 /* Reset XactLastRecEnd until the next transaction writes something */
1870 /* And clean up local data */
1877 }
1879 /*
1880 * AtAbort_Memory
1881 */
1882 static void
1884 {
1885 /*
1886 * Switch into TransactionAbortContext, which should have some free space
1887 * even if nothing else does. We'll work in this context until we've
1888 * finished cleaning up.
1889 *
1890 * It is barely possible to get here when we've not been able to create
1891 * TransactionAbortContext yet; if so use TopMemoryContext.
1892 */
1895 else
1897 }
1899 /*
1900 * AtSubAbort_Memory
1901 */
1902 static void
1904 {
1908 }
1911 /*
1912 * AtAbort_ResourceOwner
1913 */
1914 static void
1916 {
1917 /*
1918 * Make sure we have a valid ResourceOwner, if possible (else it will be
1919 * NULL, which is OK)
1920 */
1922 }
1924 /*
1925 * AtSubAbort_ResourceOwner
1926 */
1927 static void
1929 {
1932 /* Make sure we have a valid ResourceOwner */
1934 }
1937 /*
1938 * AtSubAbort_childXids
1939 */
1940 static void
1942 {
1945 /*
1946 * We keep the child-XID arrays in TopTransactionContext (see
1947 * AtSubCommit_childXids). This means we'd better free the array
1948 * explicitly at abort to avoid leakage.
1949 */
1956 /*
1957 * We could prune the unreportedXids array here. But we don't bother. That
1958 * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
1959 * would likely introduce more CPU time into the more common paths, so we
1960 * choose not to do that.
1961 */
1962 }
1964 /* ----------------------------------------------------------------
1965 * CleanupTransaction stuff
1966 * ----------------------------------------------------------------
1967 */
1969 /*
1970 * AtCleanup_Memory
1971 */
1972 static void
1974 {
1977 /* Should be at top level */
1980 /*
1981 * Return to the memory context that was current before we started the
1982 * transaction. (In principle, this could not be any of the contexts we
1983 * are about to delete. If it somehow is, assertions in mcxt.c will
1984 * complain.)
1985 */
1988 /*
1989 * Clear the special abort context for next time.
1990 */
1994 /*
1995 * Release all transaction-local memory, the same as in AtCommit_Memory,
1996 * except we must cope with the possibility that we didn't get as far as
1997 * creating TopTransactionContext.
1998 */
2002 /*
2003 * Clear these pointers as a pro-forma matter. (Notionally, while
2004 * TopTransactionContext still exists, it's currently not associated with
2005 * this TransactionState struct.)
2006 */
2009 }
2012 /* ----------------------------------------------------------------
2013 * CleanupSubTransaction stuff
2014 * ----------------------------------------------------------------
2015 */
2017 /*
2018 * AtSubCleanup_Memory
2019 */
2020 static void
2022 {
2027 /*
2028 * Return to the memory context that was current before we started the
2029 * subtransaction. (In principle, this could not be any of the contexts
2030 * we are about to delete. If it somehow is, assertions in mcxt.c will
2031 * complain.)
2032 */
2035 /* Update CurTransactionContext (might not be same as priorContext) */
2038 /*
2039 * Clear the special abort context for next time.
2040 */
2044 /*
2045 * Delete the subxact local memory contexts. Its CurTransactionContext can
2046 * go too (note this also kills CurTransactionContexts from any children
2047 * of the subxact).
2048 */
2052 }
2054 /* ----------------------------------------------------------------
2055 * interface routines
2056 * ----------------------------------------------------------------
2057 */
2059 /*
2060 * StartTransaction
2061 */
2062 static void
2064 {
2065 TransactionState s;
2066 VirtualTransactionId vxid;
2068 /*
2069 * Let's just make sure the state stack is empty
2070 */
2076 /* check the current transaction state */
2079 /*
2080 * Set the current transaction state information appropriately during
2081 * start processing. Note that once the transaction status is switched
2082 * this process cannot fail until the user ID and the security context
2083 * flags are fetched below.
2084 */
2088 /* Determine if statements are logged in this transaction */
2093 /*
2094 * initialize current transaction state fields
2095 *
2096 * note: prevXactReadOnly is not used at the outermost level
2097 */
2104 /*
2105 * Once the current user ID and the security context flags are fetched,
2106 * both will be properly reset even if transaction startup fails.
2107 */
2110 /* SecurityRestrictionContext should never be set outside a transaction */
2113 /*
2114 * Make sure we've reset xact state variables
2115 *
2116 * If recovery is still in progress, mark this transaction as read-only.
2117 * We have lower level defences in XLogInsert and elsewhere to stop us
2118 * from modifying data during recovery, but this gives the normal
2119 * indication to the user that the transaction is read-only.
2120 */
2122 {
2125 }
2126 else
2127 {
2130 }
2136 /*
2137 * reinitialize within-transaction counters
2138 */
2144 /*
2145 * initialize reported xid accounting
2146 */
2150 /*
2151 * must initialize resource-management stuff first
2152 */
2156 /*
2157 * Assign a new LocalTransactionId, and combine it with the proc number to
2158 * form a virtual transaction id.
2159 */
2163 /*
2164 * Lock the virtual transaction id before we announce it in the proc array
2165 */
2168 /*
2169 * Advertise it in the proc array. We assume assignment of
2170 * localTransactionId is atomic, and the proc number should be set
2171 * already.
2172 */
2178 /*
2179 * set transaction_timestamp() (a/k/a now()). Normally, we want this to
2180 * be the same as the first command's statement_timestamp(), so don't do a
2181 * fresh GetCurrentTimestamp() call (which'd be expensive anyway). But
2182 * for transactions started inside procedures (i.e., nonatomic SPI
2183 * contexts), we do need to advance the timestamp. Also, in a parallel
2184 * worker, the timestamp should already have been provided by a call to
2185 * SetParallelStartTimestamps().
2186 */
2188 {
2191 else
2193 }
2194 else
2197 /* Mark xactStopTimestamp as unset. */
2200 /*
2201 * initialize other subsystems for new transaction
2202 */
2207 /*
2208 * done with start processing, set current transaction state to "in
2209 * progress"
2210 */
2213 /* Schedule transaction timeout */
2218 }
2221 /*
2222 * CommitTransaction
2223 *
2224 * NB: if you change this routine, better look at PrepareTransaction too!
2225 */
2226 static void
2228 {
2230 TransactionId latestXid;
2235 /* Enforce parallel mode restrictions during parallel worker commit. */
2241 /*
2242 * check the current transaction state
2243 */
2249 /*
2250 * Do pre-commit processing that involves calling user-defined code, such
2251 * as triggers. SECURITY_RESTRICTED_OPERATION contexts must not queue an
2252 * action that would run here, because that would bypass the sandbox.
2253 * Since closing cursors could queue trigger actions, triggers could open
2254 * cursors, etc, we have to keep looping until there's nothing left to do.
2255 */
2257 {
2258 /*
2259 * Fire all currently pending deferred triggers.
2260 */
2263 /*
2264 * Close open portals (converting holdable ones into static portals).
2265 * If there weren't any, we are done ... otherwise loop back to check
2266 * if they queued deferred triggers. Lather, rinse, repeat.
2267 */
2270 }
2272 /*
2273 * The remaining actions cannot call any user-defined code, so it's safe
2274 * to start shutting down within-transaction services. But note that most
2275 * of this stuff could still throw an error, which would switch us into
2276 * the transaction-abort path.
2277 */
2282 /*
2283 * If this xact has started any unfinished parallel operation, clean up
2284 * its workers, warning about leaked resources. (But we don't actually
2285 * reset parallelModeLevel till entering TRANS_COMMIT, a bit below. This
2286 * keeps parallel mode restrictions active as long as possible in a
2287 * parallel worker.)
2288 */
2291 {
2295 }
2296 else
2297 {
2301 }
2303 /* Shut down the deferred-trigger manager */
2306 /*
2307 * Let ON COMMIT management do its thing (must happen after closing
2308 * cursors, to avoid dangling-reference problems)
2309 */
2312 /*
2313 * Synchronize files that are created and not WAL-logged during this
2314 * transaction. This must happen before AtEOXact_RelationMap(), so that we
2315 * don't see committed-but-broken files after a crash.
2316 */
2319 /* close large objects before lower-level cleanup */
2322 /*
2323 * Insert notifications sent by NOTIFY commands into the queue. This
2324 * should be late in the pre-commit sequence to minimize time spent
2325 * holding the notify-insertion lock. However, this could result in
2326 * creating a snapshot, so we must do it before serializable cleanup.
2327 */
2330 /*
2331 * Mark serializable transaction as complete for predicate locking
2332 * purposes. This should be done as late as we can put it and still allow
2333 * errors to be raised for failure patterns found at commit. This is not
2334 * appropriate in a parallel worker however, because we aren't committing
2335 * the leader's transaction and its serializable state will live on.
2336 */
2340 /* Prevent cancel/die interrupt while cleaning up */
2343 /* Commit updates to the relation map --- do this as late as possible */
2346 /*
2347 * set the current transaction state information appropriately during
2348 * commit processing
2349 */
2354 /* Disable transaction timeout */
2359 {
2360 /*
2361 * We need to mark our XIDs as committed in pg_xact. This is where we
2362 * durably commit.
2363 */
2365 }
2366 else
2367 {
2368 /*
2369 * We must not mark our XID committed; the parallel leader is
2370 * responsible for that.
2371 */
2374 /*
2375 * Make sure the leader will know about any WAL we wrote before it
2376 * commits.
2377 */
2379 }
2383 /*
2384 * Let others know about no transaction in progress by me. Note that this
2385 * must be done _before_ releasing locks we hold and _after_
2386 * RecordTransactionCommit.
2387 */
2390 /*
2391 * This is all post-commit cleanup. Note that if an error is raised here,
2392 * it's too late to abort the transaction. This should be just
2393 * noncritical resource releasing.
2394 *
2395 * The ordering of operations is not entirely random. The idea is:
2396 * release resources visible to other backends (eg, files, buffer pins);
2397 * then release locks; then release backend-local resources. We want to
2398 * release locks at the point where any backend waiting for us will see
2399 * our transaction as being fully cleaned up.
2400 *
2401 * Resources that can be associated with individual queries are handled by
2402 * the ResourceOwner mechanism. The other calls here are for backend-wide
2403 * state.
2404 */
2411 RESOURCE_RELEASE_BEFORE_LOCKS,
2414 /* Check we've released all buffer pins */
2417 /* Clean up the relation cache */
2420 /* Clean up the type cache */
2423 /*
2424 * Make catalog changes visible to all backends. This has to happen after
2425 * relcache references are dropped (see comments for
2426 * AtEOXact_RelationCache), but before locks are released (if anyone is
2427 * waiting for lock on a relation we've modified, we want them to know
2428 * about the catalog change before they start using the relation).
2429 */
2435 RESOURCE_RELEASE_LOCKS,
2438 RESOURCE_RELEASE_AFTER_LOCKS,
2441 /*
2442 * Likewise, dropping of files deleted during the transaction is best done
2443 * after releasing relcache and buffer pins. (This is not strictly
2444 * necessary during commit, since such pins should have been released
2445 * already, but this ordering is definitely critical during abort.) Since
2446 * this may take many seconds, also delay until after releasing locks.
2447 * Other backends will observe the attendant catalog changes and not
2448 * attempt to access affected files.
2449 */
2452 /*
2453 * Send out notification signals to other backends (and do other
2454 * post-commit NOTIFY cleanup). This must not happen until after our
2455 * transaction is fully done from the viewpoint of other backends.
2456 */
2459 /*
2460 * Everything after this should be purely internal-to-this-backend
2461 * cleanup.
2462 */
2496 /*
2497 * done with commit processing, set current transaction state back to
2498 * default
2499 */
2503 }
2506 /*
2507 * PrepareTransaction
2508 *
2509 * NB: if you change this routine, better look at CommitTransaction too!
2510 */
2511 static void
2513 {
2516 GlobalTransaction gxact;
2517 TimestampTz prepared_at;
2523 /*
2524 * check the current transaction state
2525 */
2531 /*
2532 * Do pre-commit processing that involves calling user-defined code, such
2533 * as triggers. Since closing cursors could queue trigger actions,
2534 * triggers could open cursors, etc, we have to keep looping until there's
2535 * nothing left to do.
2536 */
2538 {
2539 /*
2540 * Fire all currently pending deferred triggers.
2541 */
2544 /*
2545 * Close open portals (converting holdable ones into static portals).
2546 * If there weren't any, we are done ... otherwise loop back to check
2547 * if they queued deferred triggers. Lather, rinse, repeat.
2548 */
2551 }
2555 /*
2556 * The remaining actions cannot call any user-defined code, so it's safe
2557 * to start shutting down within-transaction services. But note that most
2558 * of this stuff could still throw an error, which would switch us into
2559 * the transaction-abort path.
2560 */
2562 /* Shut down the deferred-trigger manager */
2565 /*
2566 * Let ON COMMIT management do its thing (must happen after closing
2567 * cursors, to avoid dangling-reference problems)
2568 */
2571 /*
2572 * Synchronize files that are created and not WAL-logged during this
2573 * transaction. This must happen before EndPrepare(), so that we don't see
2574 * committed-but-broken files after a crash and COMMIT PREPARED.
2575 */
2578 /* close large objects before lower-level cleanup */
2581 /* NOTIFY requires no work at this point */
2583 /*
2584 * Mark serializable transaction as complete for predicate locking
2585 * purposes. This should be done as late as we can put it and still allow
2586 * errors to be raised for failure patterns found at commit.
2587 */
2590 /*
2591 * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
2592 * this transaction. Having the prepared xact hold locks on another
2593 * backend's temp table seems a bad idea --- for instance it would prevent
2594 * the backend from exiting. There are other problems too, such as how to
2595 * clean up the source backend's local buffers and ON COMMIT state if the
2596 * prepared xact includes a DROP of a temp table.
2597 *
2598 * Other objects types, like functions, operators or extensions, share the
2599 * same restriction as they should not be created, locked or dropped as
2600 * this can mess up with this session or even a follow-up session trying
2601 * to use the same temporary namespace.
2602 *
2603 * We must check this after executing any ON COMMIT actions, because they
2604 * might still access a temp relation.
2605 *
2606 * XXX In principle this could be relaxed to allow some useful special
2607 * cases, such as a temp table created and dropped all within the
2608 * transaction. That seems to require much more bookkeeping though.
2609 */
2615 /*
2616 * Likewise, don't allow PREPARE after pg_export_snapshot. This could be
2617 * supported if we added cleanup logic to twophase.c, but for now it
2618 * doesn't seem worth the trouble.
2619 */
2625 /* Prevent cancel/die interrupt while cleaning up */
2628 /*
2629 * set the current transaction state information appropriately during
2630 * prepare processing
2631 */
2634 /* Disable transaction timeout */
2640 /*
2641 * Reserve the GID for this transaction. This could fail if the requested
2642 * GID is invalid or already in use.
2643 */
2648 /*
2649 * Collect data for the 2PC state file. Note that in general, no actual
2650 * state change should happen in the called modules during this step,
2651 * since it's still possible to fail before commit, and in that case we
2652 * want transaction abort to be able to clean up. (In particular, the
2653 * AtPrepare routines may error out if they find cases they cannot
2654 * handle.) State cleanup should happen in the PostPrepare routines
2655 * below. However, some modules can go ahead and clear state here because
2656 * they wouldn't do anything with it during abort anyway.
2657 *
2658 * Note: because the 2PC state file records will be replayed in the same
2659 * order they are made, the order of these calls has to match the order in
2660 * which we want things to happen during COMMIT PREPARED or ROLLBACK
2661 * PREPARED; in particular, pay attention to whether things should happen
2662 * before or after releasing the transaction's locks.
2663 */
2673 /*
2674 * Here is where we really truly prepare.
2675 *
2676 * We have to record transaction prepares even if we didn't make any
2677 * updates, because the transaction manager might get confused if we lose
2678 * a global transaction.
2679 */
2682 /*
2683 * Now we clean up backend-internal state and release internal resources.
2684 */
2686 /* Reset XactLastRecEnd until the next transaction writes something */
2689 /*
2690 * Transfer our locks to a dummy PGPROC. This has to be done before
2691 * ProcArrayClearTransaction(). Otherwise, a GetLockConflicts() would
2692 * conclude "xact already committed or aborted" for our locks.
2693 */
2696 /*
2697 * Let others know about no transaction in progress by me. This has to be
2698 * done *after* the prepared transaction has been marked valid, else
2699 * someone may think it is unlocked and recyclable.
2700 */
2703 /*
2704 * In normal commit-processing, this is all non-critical post-transaction
2705 * cleanup. When the transaction is prepared, however, it's important
2706 * that the locks and other per-backend resources are transferred to the
2707 * prepared transaction's PGPROC entry. Note that if an error is raised
2708 * here, it's too late to abort the transaction. XXX: This probably should
2709 * be in a critical section, to force a PANIC if any of this fails, but
2710 * that cure could be worse than the disease.
2711 */
2716 RESOURCE_RELEASE_BEFORE_LOCKS,
2719 /* Check we've released all buffer pins */
2722 /* Clean up the relation cache */
2725 /* Clean up the type cache */
2728 /* notify doesn't need a postprepare call */
2741 RESOURCE_RELEASE_LOCKS,
2744 RESOURCE_RELEASE_AFTER_LOCKS,
2747 /*
2748 * Allow another backend to finish the transaction. After
2749 * PostPrepare_Twophase(), the transaction is completely detached from our
2750 * backend. The rest is just non-critical cleanup of backend-local state.
2751 */
2754 /* PREPARE acts the same as COMMIT as far as GUC is concerned */
2764 /* don't call AtEOXact_PgStat here; we fixed pgstat state above */
2766 /* we treat PREPARE as ROLLBACK so far as waking workers goes */
2790 /*
2791 * done with 1st phase commit processing, set current transaction state
2792 * back to default
2793 */
2797 }
2800 /*
2801 * AbortTransaction
2802 */
2803 static void
2805 {
2807 TransactionId latestXid;
2810 /* Prevent cancel/die interrupt while cleaning up */
2813 /* Disable transaction timeout */
2817 /* Make sure we have a valid memory context and resource owner */
2821 /*
2822 * Release any LW locks we might be holding as quickly as possible.
2823 * (Regular locks, however, must be held till we finish aborting.)
2824 * Releasing LW locks is critical since we might try to grab them again
2825 * while cleaning up!
2826 */
2829 /* Clear wait information and command progress indicator */
2833 /* Clean up buffer content locks, too */
2836 /* Reset WAL record construction state */
2839 /* Cancel condition variable sleep */
2842 /*
2843 * Also clean up any open wait for lock, since the lock manager will choke
2844 * if we try to wait for another lock before doing this.
2845 */
2848 /*
2849 * If any timeout events are still active, make sure the timeout interrupt
2850 * is scheduled. This covers possible loss of a timeout interrupt due to
2851 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
2852 * We delay this till after LockErrorCleanup so that we don't uselessly
2853 * reschedule lock or deadlock check timeouts.
2854 */
2857 /*
2858 * Re-enable signals, in case we got here by longjmp'ing out of a signal
2859 * handler. We do this fairly early in the sequence so that the timeout
2860 * infrastructure will be functional if needed while aborting.
2861 */
2864 /*
2865 * check the current transaction state
2866 */
2873 /*
2874 * set the current transaction state information appropriately during the
2875 * abort processing
2876 */
2879 /*
2880 * Reset user ID which might have been changed transiently. We need this
2881 * to clean up in case control escaped out of a SECURITY DEFINER function
2882 * or other local change of CurrentUserId; therefore, the prior value of
2883 * SecurityRestrictionContext also needs to be restored.
2884 *
2885 * (Note: it is not necessary to restore session authorization or role
2886 * settings here because those can only be changed via GUC, and GUC will
2887 * take care of rolling them back if need be.)
2888 */
2891 /* Forget about any active REINDEX. */
2894 /* Reset logical streaming state. */
2897 /* Reset snapshot export state. */
2900 /*
2901 * If this xact has started any unfinished parallel operation, clean up
2902 * its workers and exit parallel mode. Don't warn about leaked resources.
2903 */
2908 /*
2909 * do abort processing
2910 */
2919 /*
2920 * Advertise the fact that we aborted in pg_xact (assuming that we got as
2921 * far as assigning an XID to advertise). But if we're inside a parallel
2922 * worker, skip this; the user backend must be the one to write the abort
2923 * record.
2924 */
2927 else
2928 {
2931 /*
2932 * Since the parallel leader won't get our value of XactLastRecEnd in
2933 * this case, we nudge WAL-writer ourselves in this case. See related
2934 * comments in RecordTransactionAbort for why this matters.
2935 */
2937 }
2941 /*
2942 * Let others know about no transaction in progress by me. Note that this
2943 * must be done _before_ releasing locks we hold and _after_
2944 * RecordTransactionAbort.
2945 */
2948 /*
2949 * Post-abort cleanup. See notes in CommitTransaction() concerning
2950 * ordering. We can skip all of it if the transaction failed before
2951 * creating a resource owner.
2952 */
2954 {
2957 else
2961 RESOURCE_RELEASE_BEFORE_LOCKS,
2969 RESOURCE_RELEASE_LOCKS,
2972 RESOURCE_RELEASE_AFTER_LOCKS,
2989 }
2991 /*
2992 * State remains TRANS_ABORT until CleanupTransaction().
2993 */
2995 }
2997 /*
2998 * CleanupTransaction
2999 */
3000 static void
3002 {
3005 /*
3006 * State should still be TRANS_ABORT from AbortTransaction().
3007 */
3012 /*
3013 * do abort cleanup processing
3014 */
3040 /*
3041 * done with abort processing, set current transaction state back to
3042 * default
3043 */
3045 }
3047 /*
3048 * StartTransactionCommand
3049 */
3050 void
3052 {
3056 {
3057 /*
3058 * if we aren't in a transaction block, we just do our usual start
3059 * transaction.
3060 */
3066 /*
3067 * We are somewhere in a transaction block or subtransaction and
3068 * about to start a new command. For now we do nothing, but
3069 * someday we may do command-local resource initialization. (Note
3070 * that any needed CommandCounterIncrement was done by the
3071 * previous CommitTransactionCommand.)
3072 */
3078 /*
3079 * Here we are in a failed transaction block (one of the commands
3080 * caused an abort) so we do nothing but remain in the abort
3081 * state. Eventually we will get a ROLLBACK command which will
3082 * get us out of this state. (It is up to other code to ensure
3083 * that no commands other than ROLLBACK will be processed in these
3084 * states.)
3085 */
3090 /* These cases are invalid. */
3108 }
3110 /*
3111 * We must switch to CurTransactionContext before returning. This is
3112 * already done if we called StartTransaction, otherwise not.
3113 */
3116 }
3119 /*
3120 * Simple system for saving and restoring transaction characteristics
3121 * (isolation level, read only, deferrable). We need this for transaction
3122 * chaining, so that we can set the characteristics of the new transaction to
3123 * be the same as the previous one. (We need something like this because the
3124 * GUC system resets the characteristics at transaction end, so for example
3125 * just skipping the reset in StartTransaction() won't work.)
3126 */
3127 void
3129 {
3133 }
3135 void
3137 {
3141 }
3143 /*
3144 * CommitTransactionCommand -- a wrapper function handling the
3145 * loop over subtransactions to avoid a potentially dangerous recursion
3146 * in CommitTransactionCommandInternal().
3147 */
3148 void
3150 {
3151 /*
3152 * Repeatedly call CommitTransactionCommandInternal() until all the work
3153 * is done.
3154 */
3156 {
3157 }
3158 }
3160 /*
3161 * CommitTransactionCommandInternal - a function doing an iteration of work
3162 * regarding handling the commit transaction command. In the case of
3163 * subtransactions more than one iterations could be required. Returns
3164 * true when no more iterations required, false otherwise.
3165 */
3166 static bool
3168 {
3170 SavedTransactionCharacteristics savetc;
3172 /* Must save in case we need to restore below */
3176 {
3177 /*
3178 * These shouldn't happen. TBLOCK_DEFAULT means the previous
3179 * StartTransactionCommand didn't set the STARTED state
3180 * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
3181 * by EndParallelWorkerTransaction(), not this function.
3182 */
3189 /*
3190 * If we aren't in a transaction block, just do our usual
3191 * transaction commit, and return to the idle state.
3192 */
3198 /*
3199 * We are completing a "BEGIN TRANSACTION" command, so we change
3200 * to the "transaction block in progress" state and return. (We
3201 * assume the BEGIN did nothing to the database, so we need no
3202 * CommandCounterIncrement.)
3203 */
3208 /*
3209 * This is the case when we have finished executing a command
3210 * someplace within a transaction block. We increment the command
3211 * counter and return.
3212 */
3219 /*
3220 * We are completing a "COMMIT" command. Do it and return to the
3221 * idle state.
3222 */
3227 {
3232 }
3235 /*
3236 * Here we are in the middle of a transaction block but one of the
3237 * commands caused an abort so we do nothing but remain in the
3238 * abort state. Eventually we will get a ROLLBACK command.
3239 */
3244 /*
3245 * Here we were in an aborted transaction block and we just got
3246 * the ROLLBACK command from the user, so clean up the
3247 * already-aborted transaction and return to the idle state.
3248 */
3253 {
3258 }
3261 /*
3262 * Here we were in a perfectly good transaction block but the user
3263 * told us to ROLLBACK anyway. We have to abort the transaction
3264 * and then clean up.
3265 */
3271 {
3276 }
3279 /*
3280 * We are completing a "PREPARE TRANSACTION" command. Do it and
3281 * return to the idle state.
3282 */
3288 /*
3289 * The user issued a SAVEPOINT inside a transaction block. Start a
3290 * subtransaction. (DefineSavepoint already did PushTransaction,
3291 * so as to have someplace to put the SUBBEGIN state.)
3292 */
3298 /*
3299 * The user issued a RELEASE command, so we end the current
3300 * subtransaction and return to the parent transaction. The parent
3301 * might be ended too, so repeat till we find an INPROGRESS
3302 * transaction or subtransaction.
3303 */
3305 do
3306 {
3315 /*
3316 * The user issued a COMMIT, so we end the current subtransaction
3317 * hierarchy and perform final commit. We do this by rolling up
3318 * any subtransactions into their parent, which leads to O(N^2)
3319 * operations with respect to resource owners - this isn't that
3320 * bad until we approach a thousands of savepoints but is
3321 * necessary for correctness should after triggers create new
3322 * resource owners.
3323 */
3325 do
3326 {
3330 /* If we had a COMMIT command, finish off the main xact too */
3332 {
3337 {
3342 }
3343 }
3345 {
3349 }
3350 else
3355 /*
3356 * The current already-failed subtransaction is ending due to a
3357 * ROLLBACK or ROLLBACK TO command, so pop it and recursively
3358 * examine the parent (which could be in any of several states).
3359 * As we need to examine the parent, return false to request the
3360 * caller to do the next iteration.
3361 */
3366 /*
3367 * As above, but it's not dead yet, so abort first.
3368 */
3374 /*
3375 * The current subtransaction is the target of a ROLLBACK TO
3376 * command. Abort and pop it, then start a new subtransaction
3377 * with the same name.
3378 */
3380 {
3384 /* save name and keep Cleanup from freeing it */
3397 /* This is the same as TBLOCK_SUBBEGIN case */
3401 }
3404 /*
3405 * Same as above, but the subtransaction had already failed, so we
3406 * don't need AbortSubTransaction.
3407 */
3409 {
3413 /* save name and keep Cleanup from freeing it */
3425 /* This is the same as TBLOCK_SUBBEGIN case */
3429 }
3431 }
3433 /* Done, no more iterations required */
3435 }
3437 /*
3438 * AbortCurrentTransaction -- a wrapper function handling the
3439 * loop over subtransactions to avoid potentially dangerous recursion in
3440 * AbortCurrentTransactionInternal().
3441 */
3442 void
3444 {
3445 /*
3446 * Repeatedly call AbortCurrentTransactionInternal() until all the work is
3447 * done.
3448 */
3450 {
3451 }
3452 }
3454 /*
3455 * AbortCurrentTransactionInternal - a function doing an iteration of work
3456 * regarding handling the current transaction abort. In the case of
3457 * subtransactions more than one iterations could be required. Returns
3458 * true when no more iterations required, false otherwise.
3459 */
3460 static bool
3462 {
3466 {
3469 {
3470 /* we are idle, so nothing to do */
3471 }
3472 else
3473 {
3474 /*
3475 * We can get here after an error during transaction start
3476 * (state will be TRANS_START). Need to clean up the
3477 * incompletely started transaction. First, adjust the
3478 * low-level state to suppress warning message from
3479 * AbortTransaction.
3480 */
3485 }
3488 /*
3489 * If we aren't in a transaction block, we just do the basic abort
3490 * & cleanup transaction. For this purpose, we treat an implicit
3491 * transaction block as if it were a simple statement.
3492 */
3500 /*
3501 * If we are in TBLOCK_BEGIN it means something screwed up right
3502 * after reading "BEGIN TRANSACTION". We assume that the user
3503 * will interpret the error as meaning the BEGIN failed to get him
3504 * into a transaction block, so we should abort and return to idle
3505 * state.
3506 */
3513 /*
3514 * We are somewhere in a transaction block and we've gotten a
3515 * failure, so we abort the transaction and set up the persistent
3516 * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3517 */
3522 /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3525 /*
3526 * Here, we failed while trying to COMMIT. Clean up the
3527 * transaction and return to idle state (we do not want to stay in
3528 * the transaction).
3529 */
3536 /*
3537 * Here, we are already in an aborted transaction state and are
3538 * waiting for a ROLLBACK, but for some reason we failed again! So
3539 * we just remain in the abort state.
3540 */
3545 /*
3546 * We are in a failed transaction and we got the ROLLBACK command.
3547 * We have already aborted, we just need to cleanup and go to idle
3548 * state.
3549 */
3555 /*
3556 * We are in a live transaction and we got a ROLLBACK command.
3557 * Abort, cleanup, go to idle state.
3558 */
3565 /*
3566 * Here, we failed while trying to PREPARE. Clean up the
3567 * transaction and return to idle state (we do not want to stay in
3568 * the transaction).
3569 */
3576 /*
3577 * We got an error inside a subtransaction. Abort just the
3578 * subtransaction, and go to the persistent SUBABORT state until
3579 * we get ROLLBACK.
3580 */
3586 /*
3587 * If we failed while trying to create a subtransaction, clean up
3588 * the broken subtransaction and abort the parent. The same
3589 * applies if we get a failure while ending a subtransaction. As
3590 * we need to abort the parent, return false to request the caller
3591 * to do the next iteration.
3592 */
3602 /*
3603 * Same as above, except the Abort() was already done.
3604 */
3609 }
3611 /* Done, no more iterations required */
3613 }
3615 /*
3616 * PreventInTransactionBlock
3617 *
3618 * This routine is to be called by statements that must not run inside
3619 * a transaction block, typically because they have non-rollback-able
3620 * side effects or do internal commits.
3621 *
3622 * If this routine completes successfully, then the calling statement is
3623 * guaranteed that if it completes without error, its results will be
3624 * committed immediately.
3625 *
3626 * If we have already started a transaction block, issue an error; also issue
3627 * an error if we appear to be running inside a user-defined function (which
3628 * could issue more commands and possibly cause a failure after the statement
3629 * completes). Subtransactions are verboten too.
3630 *
3631 * We must also set XACT_FLAGS_NEEDIMMEDIATECOMMIT in MyXactFlags, to ensure
3632 * that postgres.c follows through by committing after the statement is done.
3633 *
3634 * isTopLevel: passed down from ProcessUtility to determine whether we are
3635 * inside a function. (We will always fail if this is false, but it's
3636 * convenient to centralize the check here instead of making callers do it.)
3637 * stmtType: statement type name, for error messages.
3638 */
3639 void
3641 {
3642 /*
3643 * xact block already started?
3644 */
3648 /* translator: %s represents an SQL statement name */
3650 stmtType)));
3652 /*
3653 * subtransaction?
3654 */
3658 /* translator: %s represents an SQL statement name */
3660 stmtType)));
3662 /*
3663 * inside a function call?
3664 */
3668 /* translator: %s represents an SQL statement name */
3671 /* If we got past IsTransactionBlock test, should be in default state */
3676 /* All okay. Set the flag to make sure the right thing happens later. */
3678 }
3680 /*
3681 * WarnNoTransactionBlock
3682 * RequireTransactionBlock
3683 *
3684 * These two functions allow for warnings or errors if a command is executed
3685 * outside of a transaction block. This is useful for commands that have no
3686 * effects that persist past transaction end (and so calling them outside a
3687 * transaction block is presumably an error). DECLARE CURSOR is an example.
3688 * While top-level transaction control commands (BEGIN/COMMIT/ABORT) and SET
3689 * that have no effect issue warnings, all other no-effect commands generate
3690 * errors.
3691 *
3692 * If we appear to be running inside a user-defined function, we do not
3693 * issue anything, since the function could issue more commands that make
3694 * use of the current statement's results. Likewise subtransactions.
3695 * Thus these are inverses for PreventInTransactionBlock.
3696 *
3697 * isTopLevel: passed down from ProcessUtility to determine whether we are
3698 * inside a function.
3699 * stmtType: statement type name, for warning or error messages.
3700 */
3701 void
3703 {
3705 }
3707 void
3709 {
3711 }
3713 /*
3714 * This is the implementation of the above two.
3715 */
3716 static void
3718 {
3719 /*
3720 * xact block already started?
3721 */
3725 /*
3726 * subtransaction?
3727 */
3731 /*
3732 * inside a function call?
3733 */
3739 /* translator: %s represents an SQL statement name */
3741 stmtType)));
3742 }
3744 /*
3745 * IsInTransactionBlock
3746 *
3747 * This routine is for statements that need to behave differently inside
3748 * a transaction block than when running as single commands. ANALYZE is
3749 * currently the only example.
3750 *
3751 * If this routine returns "false", then the calling statement is allowed
3752 * to perform internal transaction-commit-and-start cycles; there is not a
3753 * risk of messing up any transaction already in progress. (Note that this
3754 * is not the identical guarantee provided by PreventInTransactionBlock,
3755 * since we will not force a post-statement commit.)
3756 *
3757 * isTopLevel: passed down from ProcessUtility to determine whether we are
3758 * inside a function.
3759 */
3760 bool
3762 {
3763 /*
3764 * Return true on same conditions that would make
3765 * PreventInTransactionBlock error out
3766 */
3781 }
3784 /*
3785 * Register or deregister callback functions for start- and end-of-xact
3786 * operations.
3787 *
3788 * These functions are intended for use by dynamically loaded modules.
3789 * For built-in modules we generally just hardwire the appropriate calls
3790 * (mainly because it's easier to control the order that way, where needed).
3791 *
3792 * At transaction end, the callback occurs post-commit or post-abort, so the
3793 * callback functions can only do noncritical cleanup.
3794 */
3795 void
3797 {
3806 }
3808 void
3810 {
3816 {
3818 {
3821 else
3825 }
3826 }
3827 }
3829 static void
3831 {
3836 {
3837 /* allow callbacks to unregister themselves when called */
3840 }
3841 }
3844 /*
3845 * Register or deregister callback functions for start- and end-of-subxact
3846 * operations.
3847 *
3848 * Pretty much same as above, but for subtransaction events.
3849 *
3850 * At subtransaction end, the callback occurs post-subcommit or post-subabort,
3851 * so the callback functions can only do noncritical cleanup. At
3852 * subtransaction start, the callback is called when the subtransaction has
3853 * finished initializing.
3854 */
3855 void
3857 {
3866 }
3868 void
3870 {
3876 {
3878 {
3881 else
3885 }
3886 }
3887 }
3889 static void
3891 SubTransactionId mySubid,
3892 SubTransactionId parentSubid)
3893 {
3898 {
3899 /* allow callbacks to unregister themselves when called */
3902 }
3903 }
3906 /* ----------------------------------------------------------------
3907 * transaction block support
3908 * ----------------------------------------------------------------
3909 */
3911 /*
3912 * BeginTransactionBlock
3913 * This executes a BEGIN command.
3914 */
3915 void
3917 {
3921 {
3922 /*
3923 * We are not inside a transaction block, so allow one to begin.
3924 */
3929 /*
3930 * BEGIN converts an implicit transaction block to a regular one.
3931 * (Note that we allow this even if we've already done some
3932 * commands, which is a bit odd but matches historical practice.)
3933 */
3938 /*
3939 * Already a transaction block in progress.
3940 */
3951 /* These cases are invalid. */
3968 }
3969 }
3971 /*
3972 * PrepareTransactionBlock
3973 * This executes a PREPARE command.
3974 *
3975 * Since PREPARE may actually do a ROLLBACK, the result indicates what
3976 * happened: true for PREPARE, false for ROLLBACK.
3977 *
3978 * Note that we don't actually do anything here except change blockState.
3979 * The real work will be done in the upcoming PrepareTransaction().
3980 * We do it this way because it's not convenient to change memory context,
3981 * resource owner, etc while executing inside a Portal.
3982 */
3983 bool
3985 {
3986 TransactionState s;
3989 /* Set up to commit the current transaction */
3992 /* If successful, change outer tblock state to PREPARE */
3994 {
4001 {
4002 /* Save GID where PrepareTransaction can find it again */
4006 }
4007 else
4008 {
4009 /*
4010 * ignore case where we are not in a transaction;
4011 * EndTransactionBlock already issued a warning.
4012 */
4015 /* Don't send back a PREPARE result tag... */
4017 }
4018 }
4021 }
4023 /*
4024 * EndTransactionBlock
4025 * This executes a COMMIT command.
4026 *
4027 * Since COMMIT may actually do a ROLLBACK, the result indicates what
4028 * happened: true for COMMIT, false for ROLLBACK.
4029 *
4030 * Note that we don't actually do anything here except change blockState.
4031 * The real work will be done in the upcoming CommitTransactionCommand().
4032 * We do it this way because it's not convenient to change memory context,
4033 * resource owner, etc while executing inside a Portal.
4034 */
4035 bool
4037 {
4042 {
4043 /*
4044 * We are in a transaction block, so tell CommitTransactionCommand
4045 * to COMMIT.
4046 */
4052 /*
4053 * We are in an implicit transaction block. If AND CHAIN was
4054 * specified, error. Otherwise commit, but issue a warning
4055 * because there was no explicit BEGIN before this.
4056 */
4061 /* translator: %s represents an SQL statement name */
4064 else
4072 /*
4073 * We are in a failed transaction block. Tell
4074 * CommitTransactionCommand it's time to exit the block.
4075 */
4080 /*
4081 * We are in a live subtransaction block. Set up to subcommit all
4082 * open subtransactions and then commit the main transaction.
4083 */
4086 {
4089 else
4093 }
4096 else
4102 /*
4103 * Here we are inside an aborted subtransaction. Treat the COMMIT
4104 * as ROLLBACK: set up to abort everything and exit the main
4105 * transaction.
4106 */
4109 {
4114 else
4118 }
4123 else
4128 /*
4129 * The user issued COMMIT when not inside a transaction. For
4130 * COMMIT without CHAIN, issue a WARNING, staying in
4131 * TBLOCK_STARTED state. The upcoming call to
4132 * CommitTransactionCommand() will then close the transaction and
4133 * put us back into the default state. For COMMIT AND CHAIN,
4134 * error.
4135 */
4140 /* translator: %s represents an SQL statement name */
4143 else
4150 /*
4151 * The user issued a COMMIT that somehow ran inside a parallel
4152 * worker. We can't cope with that.
4153 */
4160 /* These cases are invalid. */
4177 }
4187 }
4189 /*
4190 * UserAbortTransactionBlock
4191 * This executes a ROLLBACK command.
4192 *
4193 * As above, we don't actually do anything here except change blockState.
4194 */
4195 void
4197 {
4201 {
4202 /*
4203 * We are inside a transaction block and we got a ROLLBACK command
4204 * from the user, so tell CommitTransactionCommand to abort and
4205 * exit the transaction block.
4206 */
4211 /*
4212 * We are inside a failed transaction block and we got a ROLLBACK
4213 * command from the user. Abort processing is already done, so
4214 * CommitTransactionCommand just has to cleanup and go back to
4215 * idle state.
4216 */
4221 /*
4222 * We are inside a subtransaction. Mark everything up to top
4223 * level as exitable.
4224 */
4228 {
4233 else
4237 }
4242 else
4247 /*
4248 * The user issued ABORT when not inside a transaction. For
4249 * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4250 * The upcoming call to CommitTransactionCommand() will then put
4251 * us back into the default state. For ROLLBACK AND CHAIN, error.
4252 *
4253 * We do the same thing with ABORT inside an implicit transaction,
4254 * although in this case we might be rolling back actual database
4255 * state changes. (It's debatable whether we should issue a
4256 * WARNING in this case, but we have done so historically.)
4257 */
4263 /* translator: %s represents an SQL statement name */
4266 else
4273 /*
4274 * The user issued an ABORT that somehow ran inside a parallel
4275 * worker. We can't cope with that.
4276 */
4283 /* These cases are invalid. */
4300 }
4306 }
4308 /*
4309 * BeginImplicitTransactionBlock
4310 * Start an implicit transaction block if we're not already in one.
4311 *
4312 * Unlike BeginTransactionBlock, this is called directly from the main loop
4313 * in postgres.c, not within a Portal. So we can just change blockState
4314 * without a lot of ceremony. We do not expect caller to do
4315 * CommitTransactionCommand/StartTransactionCommand.
4316 */
4317 void
4319 {
4322 /*
4323 * If we are in STARTED state (that is, no transaction block is open),
4324 * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4325 * block.
4326 *
4327 * For caller convenience, we consider all other transaction states as
4328 * legal here; otherwise the caller would need its own state check, which
4329 * seems rather pointless.
4330 */
4333 }
4335 /*
4336 * EndImplicitTransactionBlock
4337 * End an implicit transaction block, if we're in one.
4338 *
4339 * Like EndTransactionBlock, we just make any needed blockState change here.
4340 * The real work will be done in the upcoming CommitTransactionCommand().
4341 */
4342 void
4344 {
4347 /*
4348 * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4349 * allowing CommitTransactionCommand to commit whatever happened during
4350 * the implicit transaction block as though it were a single statement.
4351 *
4352 * For caller convenience, we consider all other transaction states as
4353 * legal here; otherwise the caller would need its own state check, which
4354 * seems rather pointless.
4355 */
4358 }
4360 /*
4361 * DefineSavepoint
4362 * This executes a SAVEPOINT command.
4363 */
4364 void
4366 {
4369 /*
4370 * Workers synchronize transaction state at the beginning of each parallel
4371 * operation, so we can't account for new subtransactions after that
4372 * point. (Note that this check will certainly error out if s->blockState
4373 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4374 * below.)
4375 */
4382 {
4385 /* Normal subtransaction start */
4389 /*
4390 * Savepoint names, like the TransactionState block itself, live
4391 * in TopTransactionContext.
4392 */
4397 /*
4398 * We disallow savepoint commands in implicit transaction blocks.
4399 * There would be no great difficulty in allowing them so far as
4400 * this module is concerned, but a savepoint seems inconsistent
4401 * with exec_simple_query's behavior of abandoning the whole query
4402 * string upon error. Also, the point of an implicit transaction
4403 * block (as opposed to a regular one) is to automatically close
4404 * after an error, so it's hard to see how a savepoint would fit
4405 * into that.
4406 *
4407 * The error messages for this are phrased as if there were no
4408 * active transaction block at all, which is historical but
4409 * perhaps could be improved.
4410 */
4414 /* translator: %s represents an SQL statement name */
4419 /* These cases are invalid. */
4440 }
4441 }
4443 /*
4444 * ReleaseSavepoint
4445 * This executes a RELEASE command.
4446 *
4447 * As above, we don't actually do anything here except change blockState.
4448 */
4449 void
4451 {
4453 TransactionState target,
4454 xact;
4456 /*
4457 * Workers synchronize transaction state at the beginning of each parallel
4458 * operation, so we can't account for transaction state change after that
4459 * point. (Note that this check will certainly error out if s->blockState
4460 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4461 * below.)
4462 */
4469 {
4470 /*
4471 * We can't release a savepoint if there is no savepoint defined.
4472 */
4480 /* See comment about implicit transactions in DefineSavepoint */
4483 /* translator: %s represents an SQL statement name */
4488 /*
4489 * We are in a non-aborted subtransaction. This is the only valid
4490 * case.
4491 */
4495 /* These cases are invalid. */
4516 }
4519 {
4522 }
4529 /* disallow crossing savepoint level boundaries */
4535 /*
4536 * Mark "commit pending" all subtransactions up to the target
4537 * subtransaction. The actual commits will happen when control gets to
4538 * CommitTransactionCommand.
4539 */
4542 {
4549 }
4550 }
4552 /*
4553 * RollbackToSavepoint
4554 * This executes a ROLLBACK TO <savepoint> command.
4555 *
4556 * As above, we don't actually do anything here except change blockState.
4557 */
4558 void
4560 {
4562 TransactionState target,
4563 xact;
4565 /*
4566 * Workers synchronize transaction state at the beginning of each parallel
4567 * operation, so we can't account for transaction state change after that
4568 * point. (Note that this check will certainly error out if s->blockState
4569 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4570 * below.)
4571 */
4578 {
4579 /*
4580 * We can't rollback to a savepoint if there is no savepoint
4581 * defined.
4582 */
4591 /* See comment about implicit transactions in DefineSavepoint */
4594 /* translator: %s represents an SQL statement name */
4599 /*
4600 * There is at least one savepoint, so proceed.
4601 */
4606 /* These cases are invalid. */
4625 }
4628 {
4631 }
4638 /* disallow crossing savepoint level boundaries */
4644 /*
4645 * Mark "abort pending" all subtransactions up to the target
4646 * subtransaction. The actual aborts will happen when control gets to
4647 * CommitTransactionCommand.
4648 */
4651 {
4658 else
4663 }
4665 /* And mark the target as "restart pending" */
4670 else
4673 }
4675 /*
4676 * BeginInternalSubTransaction
4677 * This is the same as DefineSavepoint except it allows TBLOCK_STARTED,
4678 * TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_END,
4679 * and TBLOCK_PREPARE states, and therefore it can safely be used in
4680 * functions that might be called when not inside a BEGIN block or when
4681 * running deferred triggers at COMMIT/PREPARE time. Also, it
4682 * automatically does CommitTransactionCommand/StartTransactionCommand
4683 * instead of expecting the caller to do it.
4684 */
4685 void
4687 {
4691 /*
4692 * Errors within this function are improbable, but if one does happen we
4693 * force a FATAL exit. Callers generally aren't prepared to handle losing
4694 * control, and moreover our transaction state is probably corrupted if we
4695 * fail partway through; so an ordinary ERROR longjmp isn't okay.
4696 */
4699 /*
4700 * We do not check for parallel mode here. It's permissible to start and
4701 * end "internal" subtransactions while in parallel mode, so long as no
4702 * new XIDs or command IDs are assigned. Enforcement of that occurs in
4703 * AssignTransactionId() and CommandCounterIncrement().
4704 */
4707 {
4715 /* Normal subtransaction start */
4719 /*
4720 * Savepoint names, like the TransactionState block itself, live
4721 * in TopTransactionContext.
4722 */
4727 /* These cases are invalid. */
4744 }
4750 }
4752 /*
4753 * ReleaseCurrentSubTransaction
4754 *
4755 * RELEASE (ie, commit) the innermost subtransaction, regardless of its
4756 * savepoint name (if any).
4757 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4758 */
4759 void
4761 {
4764 /*
4765 * We do not check for parallel mode here. It's permissible to start and
4766 * end "internal" subtransactions while in parallel mode, so long as no
4767 * new XIDs or command IDs are assigned.
4768 */
4778 }
4780 /*
4781 * RollbackAndReleaseCurrentSubTransaction
4782 *
4783 * ROLLBACK and RELEASE (ie, abort) the innermost subtransaction, regardless
4784 * of its savepoint name (if any).
4785 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4786 */
4787 void
4789 {
4792 /*
4793 * We do not check for parallel mode here. It's permissible to start and
4794 * end "internal" subtransactions while in parallel mode, so long as no
4795 * new XIDs or command IDs are assigned.
4796 */
4799 {
4800 /* Must be in a subtransaction */
4805 /* These cases are invalid. */
4827 }
4829 /*
4830 * Abort the current subtransaction, if needed.
4831 */
4835 /* And clean it up, too */
4844 }
4846 /*
4847 * AbortOutOfAnyTransaction
4848 *
4849 * This routine is provided for error recovery purposes. It aborts any
4850 * active transaction or transaction block, leaving the system in a known
4851 * idle state.
4852 */
4853 void
4855 {
4858 /* Ensure we're not running in a doomed memory context */
4861 /*
4862 * Get out of any transaction or nested transaction
4863 */
4864 do
4865 {
4867 {
4870 {
4871 /* Not in a transaction, do nothing */
4872 }
4873 else
4874 {
4875 /*
4876 * We can get here after an error during transaction start
4877 * (state will be TRANS_START). Need to clean up the
4878 * incompletely started transaction. First, adjust the
4879 * low-level state to suppress warning message from
4880 * AbortTransaction.
4881 */
4886 }
4896 /* In a transaction, so clean up */
4904 /*
4905 * AbortTransaction is already done, still need Cleanup.
4906 * However, if we failed partway through running ROLLBACK,
4907 * there will be an active portal running that command, which
4908 * we need to shut down before doing CleanupTransaction.
4909 */
4915 /*
4916 * In a subtransaction, so clean it up and abort parent too
4917 */
4932 /* As above, but AbortSubTransaction already done */
4934 {
4935 /* As in TBLOCK_ABORT, might have a live portal to zap */
4940 }
4944 }
4947 /* Should be out of all subxacts now */
4950 /*
4951 * Revert to TopMemoryContext, to ensure we exit in a well-defined state
4952 * whether there were any transactions to close or not. (Callers that
4953 * don't intend to exit soon should switch to some other context to avoid
4954 * long-term memory leaks.)
4955 */
4957 }
4959 /*
4960 * IsTransactionBlock --- are we within a transaction block?
4961 */
4962 bool
4964 {
4971 }
4973 /*
4974 * IsTransactionOrTransactionBlock --- are we within either a transaction
4975 * or a transaction block? (The backend is only really "idle" when this
4976 * returns false.)
4977 *
4978 * This should match up with IsTransactionBlock and IsTransactionState.
4979 */
4980 bool
4982 {
4989 }
4991 /*
4992 * TransactionBlockStatusCode - return status code to send in ReadyForQuery
4993 */
4994 char
4996 {
5000 {
5024 }
5026 /* should never get here */
5030 }
5032 /*
5033 * IsSubTransaction
5034 */
5035 bool
5037 {
5044 }
5046 /*
5047 * StartSubTransaction
5048 *
5049 * If you're wondering why this is separate from PushTransaction: it's because
5050 * we can't conveniently do this stuff right inside DefineSavepoint. The
5051 * SAVEPOINT utility command will be executed inside a Portal, and if we
5052 * muck with CurrentMemoryContext or CurrentResourceOwner then exit from
5053 * the Portal will undo those settings. So we make DefineSavepoint just
5054 * push a dummy transaction block, and when control returns to the main
5055 * idle loop, CommitTransactionCommand will be called, and we'll come here
5056 * to finish starting the subtransaction.
5057 */
5058 static void
5060 {
5069 /*
5070 * Initialize subsystems for new subtransaction
5071 *
5072 * must initialize resource-management stuff first
5073 */
5080 /*
5081 * Call start-of-subxact callbacks
5082 */
5087 }
5089 /*
5090 * CommitSubTransaction
5091 *
5092 * The caller has to make sure to always reassign CurrentTransactionState
5093 * if it has a local pointer to it after calling this function.
5094 */
5095 static void
5097 {
5106 /* Pre-commit processing goes here */
5111 /*
5112 * If this subxact has started any unfinished parallel operation, clean up
5113 * its workers and exit parallel mode. Warn about leaked resources.
5114 */
5117 {
5121 }
5123 /* Do the actual "commit", such as it is */
5126 /* Must CCI to ensure commands of subtransaction are seen as done */
5129 /*
5130 * Prior to 8.4 we marked subcommit in clog at this point. We now only
5131 * perform that step, if required, as part of the atomic update of the
5132 * whole transaction tree at top level commit or abort.
5133 */
5135 /* Post-commit cleanup */
5151 RESOURCE_RELEASE_BEFORE_LOCKS,
5159 /*
5160 * The only lock we actually release here is the subtransaction XID lock.
5161 */
5166 /*
5167 * Other locks should get transferred to their parent resource owner.
5168 */
5170 RESOURCE_RELEASE_LOCKS,
5173 RESOURCE_RELEASE_AFTER_LOCKS,
5188 /*
5189 * We need to restore the upper transaction's read-only state, in case the
5190 * upper is read-write while the child is read-only; GUC will incorrectly
5191 * think it should leave the child state in place.
5192 */
5205 }
5207 /*
5208 * AbortSubTransaction
5209 */
5210 static void
5212 {
5215 /* Prevent cancel/die interrupt while cleaning up */
5218 /* Make sure we have a valid memory context and resource owner */
5222 /*
5223 * Release any LW locks we might be holding as quickly as possible.
5224 * (Regular locks, however, must be held till we finish aborting.)
5225 * Releasing LW locks is critical since we might try to grab them again
5226 * while cleaning up!
5227 *
5228 * FIXME This may be incorrect --- Are there some locks we should keep?
5229 * Buffer locks, for example? I don't think so but I'm not sure.
5230 */
5237 /* Reset WAL record construction state */
5240 /* Cancel condition variable sleep */
5243 /*
5244 * Also clean up any open wait for lock, since the lock manager will choke
5245 * if we try to wait for another lock before doing this.
5246 */
5249 /*
5250 * If any timeout events are still active, make sure the timeout interrupt
5251 * is scheduled. This covers possible loss of a timeout interrupt due to
5252 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
5253 * We delay this till after LockErrorCleanup so that we don't uselessly
5254 * reschedule lock or deadlock check timeouts.
5255 */
5258 /*
5259 * Re-enable signals, in case we got here by longjmp'ing out of a signal
5260 * handler. We do this fairly early in the sequence so that the timeout
5261 * infrastructure will be functional if needed while aborting.
5262 */
5265 /*
5266 * check the current transaction state
5267 */
5276 /*
5277 * Reset user ID which might have been changed transiently. (See notes in
5278 * AbortTransaction.)
5279 */
5282 /* Forget about any active REINDEX. */
5285 /* Reset logical streaming state. */
5288 /*
5289 * No need for SnapBuildResetExportedSnapshotState() here, snapshot
5290 * exports are not supported in subtransactions.
5291 */
5293 /*
5294 * If this subxact has started any unfinished parallel operation, clean up
5295 * its workers and exit parallel mode. Don't warn about leaked resources.
5296 */
5300 /*
5301 * We can skip all this stuff if the subxact failed before creating a
5302 * ResourceOwner...
5303 */
5305 {
5315 /* Advertise the fact that we aborted in pg_xact. */
5318 /* Post-abort cleanup */
5326 RESOURCE_RELEASE_BEFORE_LOCKS,
5334 RESOURCE_RELEASE_LOCKS,
5337 RESOURCE_RELEASE_AFTER_LOCKS,
5352 }
5354 /*
5355 * Restore the upper transaction's read-only state, too. This should be
5356 * redundant with GUC's cleanup but we may as well do it for consistency
5357 * with the commit case.
5358 */
5362 }
5364 /*
5365 * CleanupSubTransaction
5366 *
5367 * The caller has to make sure to always reassign CurrentTransactionState
5368 * if it has a local pointer to it after calling this function.
5369 */
5370 static void
5372 {
5394 }
5396 /*
5397 * PushTransaction
5398 * Create transaction state stack entry for a subtransaction
5399 *
5400 * The caller has to make sure to always reassign CurrentTransactionState
5401 * if it has a local pointer to it after calling this function.
5402 */
5403 static void
5405 {
5407 TransactionState s;
5409 /*
5410 * We keep subtransaction state nodes in TopTransactionContext.
5411 */
5416 /*
5417 * Assign a subtransaction ID, watching out for counter wraparound.
5418 */
5421 {
5427 }
5429 /*
5430 * We can now stack a minimally valid subtransaction without fear of
5431 * failure.
5432 */
5450 /*
5451 * AbortSubTransaction and CleanupSubTransaction have to be able to cope
5452 * with the subtransaction from here on out; in particular they should not
5453 * assume that it necessarily has a transaction context, resource owner,
5454 * or XID.
5455 */
5456 }
5458 /*
5459 * PopTransaction
5460 * Pop back to parent transaction state
5461 *
5462 * The caller has to make sure to always reassign CurrentTransactionState
5463 * if it has a local pointer to it after calling this function.
5464 */
5465 static void
5467 {
5479 /* Let's just make sure CurTransactionContext is good */
5483 /* Ditto for ResourceOwner links */
5487 /* Free the old child structure */
5491 }
5493 /*
5494 * EstimateTransactionStateSpace
5495 * Estimate the amount of space that will be needed by
5496 * SerializeTransactionState. It would be OK to overestimate slightly,
5497 * but it's simple for us to work out the precise value, so we do.
5498 */
5499 Size
5501 {
5502 TransactionState s;
5507 {
5511 }
5514 }
5516 /*
5517 * SerializeTransactionState
5518 * Write out relevant details of our transaction state that will be
5519 * needed by a parallel worker.
5520 *
5521 * We need to save and restore XactDeferrable, XactIsoLevel, and the XIDs
5522 * associated with this transaction. These are serialized into a
5523 * caller-supplied buffer big enough to hold the number of bytes reported by
5524 * EstimateTransactionStateSpace(). We emit the XIDs in sorted order for the
5525 * convenience of the receiving process.
5526 */
5527 void
5529 {
5530 TransactionState s;
5545 /*
5546 * If we're running in a parallel worker and launching a parallel worker
5547 * of our own, we can just pass along the information that was passed to
5548 * us.
5549 */
5551 {
5556 }
5558 /*
5559 * OK, we need to generate a sorted list of XIDs that our workers should
5560 * view as current. First, figure out how many there are.
5561 */
5563 {
5567 }
5571 /* Copy them to our scratch space. */
5574 {
5581 }
5584 /* Sort them. */
5587 /* Copy data into output area. */
5591 }
5593 /*
5594 * StartParallelWorkerTransaction
5595 * Start a parallel worker transaction, restoring the relevant
5596 * transaction state serialized by SerializeTransactionState.
5597 */
5598 void
5600 {
5617 }
5619 /*
5620 * EndParallelWorkerTransaction
5621 * End a parallel worker transaction.
5622 */
5623 void
5625 {
5629 }
5631 /*
5632 * ShowTransactionState
5633 * Debug support
5634 */
5635 static void
5637 {
5638 /* skip work if message will definitely not be printed */
5641 }
5643 /*
5644 * ShowTransactionStateRec
5645 * Recursive subroutine for ShowTransactionState
5646 */
5647 static void
5649 {
5650 StringInfoData buf;
5653 {
5654 /*
5655 * Since this function recurses, it could be driven to stack overflow.
5656 * This is just a debugging aid, so we can leave out some details
5657 * instead of erroring out with check_stack_depth().
5658 */
5663 else
5665 }
5669 {
5675 }
5688 }
5690 /*
5691 * BlockStateAsString
5692 * Debug support
5693 */
5696 {
5698 {
5739 }
5741 }
5743 /*
5744 * TransStateAsString
5745 * Debug support
5746 */
5749 {
5751 {
5764 }
5766 }
5768 /*
5769 * xactGetCommittedChildren
5770 *
5771 * Gets the list of committed children of the current transaction. The return
5772 * value is the number of child transactions. *ptr is set to point to an
5773 * array of TransactionIds. The array is allocated in TopTransactionContext;
5774 * the caller should *not* pfree() it (this is a change from pre-8.4 code!).
5775 * If there are no subxacts, *ptr is set to NULL.
5776 */
5777 int
5779 {
5784 else
5788 }
5790 /*
5791 * XLOG support routines
5792 */
5795 /*
5796 * Log the commit record for a plain or twophase transaction commit.
5797 *
5798 * A 2pc commit will be emitted when twophase_xid is valid, a plain one
5799 * otherwise.
5800 */
5801 XLogRecPtr
5810 {
5811 xl_xact_commit xlrec;
5812 xl_xact_xinfo xl_xinfo;
5813 xl_xact_dbinfo xl_dbinfo;
5814 xl_xact_subxacts xl_subxacts;
5815 xl_xact_relfilelocators xl_relfilelocators;
5816 xl_xact_stats_items xl_dropped_stats;
5817 xl_xact_invals xl_invals;
5818 xl_xact_twophase xl_twophase;
5819 xl_xact_origin xl_origin;
5820 uint8 info;
5826 /* decide between a plain and 2pc commit */
5829 else
5832 /* First figure out and collect all the information needed */
5843 /*
5844 * Check if the caller would like to ask standbys for immediate feedback
5845 * once this commit is applied.
5846 */
5850 /*
5851 * Relcache invalidations requires information about the current database
5852 * and so does logical decoding.
5853 */
5855 {
5859 }
5862 {
5865 }
5868 {
5872 }
5875 {
5878 }
5881 {
5884 }
5887 {
5894 }
5896 /* dump transaction origin information */
5898 {
5903 }
5908 /* Then include all the collected data into the commit record. */
5921 {
5923 MinSizeOfXactSubxacts);
5926 }
5929 {
5931 MinSizeOfXactRelfileLocators);
5934 }
5937 {
5939 MinSizeOfXactStatsItems);
5942 }
5945 {
5949 }
5952 {
5956 }
5961 /* we allow filtering by xacts */
5965 }
5967 /*
5968 * Log the commit record for a plain or twophase transaction abort.
5969 *
5970 * A 2pc abort will be emitted when twophase_xid is valid, a plain one
5971 * otherwise.
5972 */
5973 XLogRecPtr
5980 {
5981 xl_xact_abort xlrec;
5982 xl_xact_xinfo xl_xinfo;
5983 xl_xact_subxacts xl_subxacts;
5984 xl_xact_relfilelocators xl_relfilelocators;
5985 xl_xact_stats_items xl_dropped_stats;
5986 xl_xact_twophase xl_twophase;
5987 xl_xact_dbinfo xl_dbinfo;
5988 xl_xact_origin xl_origin;
5990 uint8 info;
5996 /* decide between a plain and 2pc abort */
5999 else
6003 /* First figure out and collect all the information needed */
6011 {
6014 }
6017 {
6021 }
6024 {
6027 }
6030 {
6037 }
6040 {
6044 }
6046 /*
6047 * Dump transaction origin information. We need this during recovery to
6048 * update the replication origin progress.
6049 */
6051 {
6056 }
6061 /* Then include all the collected data into the abort record. */
6074 {
6076 MinSizeOfXactSubxacts);
6079 }
6082 {
6084 MinSizeOfXactRelfileLocators);
6087 }
6090 {
6092 MinSizeOfXactStatsItems);
6095 }
6098 {
6102 }
6107 /* Include the replication origin */
6111 }
6113 /*
6114 * Before 9.0 this was a fairly short function, but now it performs many
6115 * actions for which the order of execution is critical.
6116 */
6117 static void
6119 TransactionId xid,
6120 XLogRecPtr lsn,
6121 RepOriginId origin_id)
6122 {
6123 TransactionId max_xid;
6124 TimestampTz commit_time;
6130 /* Make sure nextXid is beyond any XID mentioned in the record. */
6138 else
6141 /* Set the transaction commit timestamp and metadata */
6146 {
6147 /*
6148 * Mark the transaction committed in pg_xact.
6149 */
6151 }
6152 else
6153 {
6154 /*
6155 * If a transaction completion record arrives that has as-yet
6156 * unobserved subtransactions then this will not have been fully
6157 * handled by the call to RecordKnownAssignedTransactionIds() in the
6158 * main recovery loop in xlog.c. So we need to do bookkeeping again to
6159 * cover that case. This is confusing and it is easy to think this
6160 * call is irrelevant, which has happened three times in development
6161 * already. Leave it in.
6162 */
6165 /*
6166 * Mark the transaction committed in pg_xact. We use async commit
6167 * protocol during recovery to provide information on database
6168 * consistency for when users try to set hint bits. It is important
6169 * that we do not set hint bits until the minRecoveryPoint is past
6170 * this commit record. This ensures that if we crash we don't see hint
6171 * bits set on changes made by transactions that haven't yet
6172 * recovered. It's unlikely but it's good to be safe.
6173 */
6176 /*
6177 * We must mark clog before we update the ProcArray.
6178 */
6181 /*
6182 * Send any cache invalidations attached to the commit. We must
6183 * maintain the same order of invalidation then release locks as
6184 * occurs in CommitTransaction().
6185 */
6190 /*
6191 * Release locks, if any. We do this for both two phase and normal one
6192 * phase transactions. In effect we are ignoring the prepare phase and
6193 * just going straight to lock release.
6194 */
6197 }
6200 {
6201 /* recover apply progress */
6204 }
6206 /* Make sure files supposed to be dropped are dropped */
6208 {
6209 /*
6210 * First update minimum recovery point to cover this WAL record. Once
6211 * a relation is deleted, there's no going back. The buffer manager
6212 * enforces the WAL-first rule for normal updates to relation files,
6213 * so that the minimum recovery point is always updated before the
6214 * corresponding change in the data file is flushed to disk, but we
6215 * have to do the same here since we're bypassing the buffer manager.
6216 *
6217 * Doing this before deleting the files means that if a deletion fails
6218 * for some reason, you cannot start up the system even after restart,
6219 * until you fix the underlying situation so that the deletion will
6220 * succeed. Alternatively, we could update the minimum recovery point
6221 * after deletion, but that would leave a small window where the
6222 * WAL-first rule would be violated.
6223 */
6226 /* Make sure files supposed to be dropped are dropped */
6228 }
6231 {
6232 /* see equivalent call for relations above */
6236 }
6238 /*
6239 * We issue an XLogFlush() for the same reason we emit ForceSyncCommit()
6240 * in normal operation. For example, in CREATE DATABASE, we copy all files
6241 * from the template database, and then commit the transaction. If we
6242 * crash after all the files have been copied but before the commit, you
6243 * have files in the data directory without an entry in pg_database. To
6244 * minimize the window for that, we use ForceSyncCommit() to rush the
6245 * commit record to disk as quick as possible. We have the same window
6246 * during recovery, and forcing an XLogFlush() (which updates
6247 * minRecoveryPoint during recovery) helps to reduce that problem window,
6248 * for any user that requested ForceSyncCommit().
6249 */
6253 /*
6254 * If asked by the primary (because someone is waiting for a synchronous
6255 * commit = remote_apply), we will need to ask walreceiver to send a reply
6256 * immediately.
6257 */
6260 }
6262 /*
6263 * Be careful with the order of execution, as with xact_redo_commit().
6264 * The two functions are similar but differ in key places.
6265 *
6266 * Note also that an abort can be for a subtransaction and its children,
6267 * not just for a top level abort. That means we have to consider
6268 * topxid != xid, whereas in commit we would find topxid == xid always
6269 * because subtransaction commit is never WAL logged.
6270 */
6271 static void
6274 {
6275 TransactionId max_xid;
6279 /* Make sure nextXid is beyond any XID mentioned in the record. */
6286 {
6287 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6289 }
6290 else
6291 {
6292 /*
6293 * If a transaction completion record arrives that has as-yet
6294 * unobserved subtransactions then this will not have been fully
6295 * handled by the call to RecordKnownAssignedTransactionIds() in the
6296 * main recovery loop in xlog.c. So we need to do bookkeeping again to
6297 * cover that case. This is confusing and it is easy to think this
6298 * call is irrelevant, which has happened three times in development
6299 * already. Leave it in.
6300 */
6303 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6306 /*
6307 * We must update the ProcArray after we have marked clog.
6308 */
6311 /*
6312 * There are no invalidation messages to send or undo.
6313 */
6315 /*
6316 * Release locks, if any. There are no invalidations to send.
6317 */
6320 }
6323 {
6324 /* recover apply progress */
6327 }
6329 /* Make sure files supposed to be dropped are dropped */
6331 {
6332 /*
6333 * See comments about update of minimum recovery point on truncation,
6334 * in xact_redo_commit().
6335 */
6339 }
6342 {
6343 /* see equivalent call for relations above */
6347 }
6348 }
6350 void
6352 {
6355 /* Backup blocks are not used in xact records */
6359 {
6361 xl_xact_parsed_commit parsed;
6366 }
6368 {
6370 xl_xact_parsed_commit parsed;
6376 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6380 }
6382 {
6384 xl_xact_parsed_abort parsed;
6389 }
6391 {
6393 xl_xact_parsed_abort parsed;
6399 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6403 }
6405 {
6406 /*
6407 * Store xid and start/end pointers of the WAL record in TwoPhaseState
6408 * gxact entry.
6409 */
6416 }
6418 {
6424 }
6426 {
6427 /*
6428 * XXX we do ignore this for now, what matters are invalidations
6429 * written into the commit record.
6430 */
6431 }
6432 else
6434 }