| blob | d85e31390823c0e4de4c45907f90c199352211ed |
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-2023, 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>
75 /*
76 * User-tweakable parameters
77 */
89 /*
90 * CheckXidAlive is a xid value pointing to a possibly ongoing (sub)
91 * transaction. Currently, it is used in logical decoding. It's possible
92 * that such transactions can get aborted while the decoding is ongoing in
93 * which case we skip decoding that particular transaction. To ensure that we
94 * check whether the CheckXidAlive is aborted after fetching the tuple from
95 * system tables. We also ensure that during logical decoding we never
96 * directly access the tableam or heap APIs because we are checking for the
97 * concurrent aborts only in systable_* APIs.
98 */
102 /*
103 * When running as a parallel worker, we place only a single
104 * TransactionStateData on the parallel worker's state stack, and the XID
105 * reflected there will be that of the *innermost* currently-active
106 * subtransaction in the backend that initiated parallelism. However,
107 * GetTopTransactionId() and TransactionIdIsCurrentTransactionId()
108 * need to return the same answers in the parallel worker as they would have
109 * in the user backend, so we need some additional bookkeeping.
110 *
111 * XactTopFullTransactionId stores the XID of our toplevel transaction, which
112 * will be the same as TopTransactionStateData.fullTransactionId in an
113 * ordinary backend; but in a parallel backend, which does not have the entire
114 * transaction state, it will instead be copied from the backend that started
115 * the parallel operation.
116 *
117 * nParallelCurrentXids will be 0 and ParallelCurrentXids NULL in an ordinary
118 * backend, but in a parallel backend, nParallelCurrentXids will contain the
119 * number of XIDs that need to be considered current, and ParallelCurrentXids
120 * will contain the XIDs themselves. This includes all XIDs that were current
121 * or sub-committed in the parent at the time the parallel operation began.
122 * The XIDs are stored sorted in numerical order (not logical order) to make
123 * lookups as fast as possible.
124 */
129 /*
130 * Miscellaneous flag bits to record events which occur on the top level
131 * transaction. These flags are only persisted in MyXactFlags and are intended
132 * so we remember to do certain things later on in the transaction. This is
133 * globally accessible, so can be set from anywhere in the code that requires
134 * recording flags.
135 */
138 /*
139 * transaction states - transaction state from server perspective
140 */
142 {
148 TRANS_PREPARE /* prepare in progress */
151 /*
152 * transaction block states - transaction state of client queries
153 *
154 * Note: the subtransaction states are used only for non-topmost
155 * transactions; the others appear only in the topmost transaction.
156 */
158 {
159 /* not-in-transaction-block states */
163 /* transaction block states */
174 /* subtransaction states */
183 TBLOCK_SUBABORT_RESTART /* failed subxact, ROLLBACK TO received */
186 /*
187 * transaction state structure
188 */
190 {
217 /*
218 * Serialized representation used to transmit transaction state to parallel
219 * workers through shared memory.
220 */
222 {
225 FullTransactionId topFullTransactionId;
226 FullTransactionId currentFullTransactionId;
227 CommandId currentCommandId;
232 /* The size of SerializedTransactionState, not including the final array. */
233 #define SerializedTransactionStateHeaderSize \
234 offsetof(SerializedTransactionState, parallelCurrentXids)
236 /*
237 * CurrentTransactionState always points to the current transaction state
238 * block. It will point to TopTransactionStateData when not in a
239 * transaction at all, or when in a top-level transaction.
240 */
245 };
247 /*
248 * unreportedXids holds XIDs of all subtransactions that have not yet been
249 * reported in an XLOG_XACT_ASSIGNMENT record.
250 */
256 /*
257 * The subtransaction ID and command ID assignment counters are global
258 * to a whole transaction, so we do not keep them in the state stack.
259 */
264 /*
265 * xactStartTimestamp is the value of transaction_timestamp().
266 * stmtStartTimestamp is the value of statement_timestamp().
267 * xactStopTimestamp is the time at which we log a commit / abort WAL record,
268 * or if that was skipped, the time of the first subsequent
269 * GetCurrentTransactionStopTimestamp() call.
270 *
271 * These do not change as we enter and exit subtransactions, so we don't
272 * keep them inside the TransactionState stack.
273 */
278 /*
279 * GID to be used for preparing the current transaction. This is also
280 * global to a whole transaction, so we don't keep it in the state stack.
281 */
284 /*
285 * Some commands want to force synchronous commit.
286 */
289 /* Flag for logging statements in a transaction. */
292 /*
293 * Private context for transaction-abort work --- we reserve space for this
294 * at startup to ensure that AbortTransaction and AbortSubTransaction can work
295 * when we've run out of memory.
296 */
299 /*
300 * List of add-on start- and end-of-xact callbacks
301 */
303 {
305 XactCallback callback;
311 /*
312 * List of add-on start- and end-of-subxact callbacks
313 */
315 {
317 SubXactCallback callback;
324 /* local function prototypes */
337 SubTransactionId mySubid,
338 SubTransactionId parentSubid);
366 /* ----------------------------------------------------------------
367 * transaction state accessors
368 * ----------------------------------------------------------------
369 */
371 /*
372 * IsTransactionState
373 *
374 * This returns true if we are inside a valid transaction; that is,
375 * it is safe to initiate database access, take heavyweight locks, etc.
376 */
377 bool
379 {
382 /*
383 * TRANS_DEFAULT and TRANS_ABORT are obviously unsafe states. However, we
384 * also reject the startup/shutdown states TRANS_START, TRANS_COMMIT,
385 * TRANS_PREPARE since it might be too soon or too late within those
386 * transition states to do anything interesting. Hence, the only "valid"
387 * state is TRANS_INPROGRESS.
388 */
390 }
392 /*
393 * IsAbortedTransactionBlockState
394 *
395 * This returns true if we are within an aborted transaction block.
396 */
397 bool
399 {
407 }
410 /*
411 * GetTopTransactionId
412 *
413 * This will return the XID of the main transaction, assigning one if
414 * it's not yet set. Be careful to call this only inside a valid xact.
415 */
416 TransactionId
418 {
422 }
424 /*
425 * GetTopTransactionIdIfAny
426 *
427 * This will return the XID of the main transaction, if one is assigned.
428 * It will return InvalidTransactionId if we are not currently inside a
429 * transaction, or inside a transaction that hasn't yet been assigned an XID.
430 */
431 TransactionId
433 {
435 }
437 /*
438 * GetCurrentTransactionId
439 *
440 * This will return the XID of the current transaction (main or sub
441 * transaction), assigning one if it's not yet set. Be careful to call this
442 * only inside a valid xact.
443 */
444 TransactionId
446 {
452 }
454 /*
455 * GetCurrentTransactionIdIfAny
456 *
457 * This will return the XID of the current sub xact, if one is assigned.
458 * It will return InvalidTransactionId if we are not currently inside a
459 * transaction, or inside a transaction that hasn't been assigned an XID yet.
460 */
461 TransactionId
463 {
465 }
467 /*
468 * GetTopFullTransactionId
469 *
470 * This will return the FullTransactionId of the main transaction, assigning
471 * one if it's not yet set. Be careful to call this only inside a valid xact.
472 */
473 FullTransactionId
475 {
479 }
481 /*
482 * GetTopFullTransactionIdIfAny
483 *
484 * This will return the FullTransactionId of the main transaction, if one is
485 * assigned. It will return InvalidFullTransactionId if we are not currently
486 * inside a transaction, or inside a transaction that hasn't yet been assigned
487 * one.
488 */
489 FullTransactionId
491 {
493 }
495 /*
496 * GetCurrentFullTransactionId
497 *
498 * This will return the FullTransactionId of the current transaction (main or
499 * sub transaction), assigning one if it's not yet set. Be careful to call
500 * this only inside a valid xact.
501 */
502 FullTransactionId
504 {
510 }
512 /*
513 * GetCurrentFullTransactionIdIfAny
514 *
515 * This will return the FullTransactionId of the current sub xact, if one is
516 * assigned. It will return InvalidFullTransactionId if we are not currently
517 * inside a transaction, or inside a transaction that hasn't been assigned one
518 * yet.
519 */
520 FullTransactionId
522 {
524 }
526 /*
527 * MarkCurrentTransactionIdLoggedIfAny
528 *
529 * Remember that the current xid - if it is assigned - now has been wal logged.
530 */
531 void
533 {
536 }
538 /*
539 * IsSubxactTopXidLogPending
540 *
541 * This is used to decide whether we need to WAL log the top-level XID for
542 * operation in a subtransaction. We require that for logical decoding, see
543 * LogicalDecodingProcessRecord.
544 *
545 * This returns true if wal_level >= logical and we are inside a valid
546 * subtransaction, for which the assignment was not yet written to any WAL
547 * record.
548 */
549 bool
551 {
552 /* check whether it is already logged */
556 /* wal_level has to be logical */
560 /* we need to be in a transaction state */
564 /* it has to be a subtransaction */
568 /* the subtransaction has to have a XID assigned */
573 }
575 /*
576 * MarkSubxactTopXidLogged
577 *
578 * Remember that the top transaction id for the current subtransaction is WAL
579 * logged now.
580 */
581 void
583 {
587 }
589 /*
590 * GetStableLatestTransactionId
591 *
592 * Get the transaction's XID if it has one, else read the next-to-be-assigned
593 * XID. Once we have a value, return that same value for the remainder of the
594 * current transaction. This is meant to provide the reference point for the
595 * age(xid) function, but might be useful for other maintenance tasks as well.
596 */
597 TransactionId
599 {
604 {
609 }
614 }
616 /*
617 * AssignTransactionId
618 *
619 * Assigns a new permanent FullTransactionId to the given TransactionState.
620 * We do not assign XIDs to transactions until/unless this is called.
621 * Also, any parent TransactionStates that don't yet have XIDs are assigned
622 * one; this maintains the invariant that a child transaction has an XID
623 * following its parent's.
624 */
625 static void
627 {
629 ResourceOwner currentOwner;
632 /* Assert that caller didn't screw up */
636 /*
637 * Workers synchronize transaction state at the beginning of each parallel
638 * operation, so we can't account for new XIDs at this point.
639 */
643 /*
644 * Ensure parent(s) have XIDs, so that a child always has an XID later
645 * than its parent. Mustn't recurse here, or we might get a stack
646 * overflow if we're at the bottom of a huge stack of subtransactions none
647 * of which have XIDs yet.
648 */
650 {
657 {
660 }
662 /*
663 * This is technically a recursive call, but the recursion will never
664 * be more than one layer deep.
665 */
670 }
672 /*
673 * When wal_level=logical, guarantee that a subtransaction's xid can only
674 * be seen in the WAL stream if its toplevel xid has been logged before.
675 * If necessary we log an xact_assignment record with fewer than
676 * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
677 * for a transaction even though it appears in a WAL record, we just might
678 * superfluously log something. That can happen when an xid is included
679 * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
680 * xl_standby_locks.
681 */
686 /*
687 * Generate a new FullTransactionId and record its xid in PGPROC and
688 * pg_subtrans.
689 *
690 * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
691 * shared storage other than PGPROC; because if there's no room for it in
692 * PGPROC, the subtrans entry is needed to ensure that other backends see
693 * the Xid as "running". See GetNewTransactionId.
694 */
703 /*
704 * If it's a top-level transaction, the predicate locking system needs to
705 * be told about it too.
706 */
710 /*
711 * Acquire lock on the transaction XID. (We assume this cannot block.) We
712 * have to ensure that the lock is assigned to the transaction's own
713 * ResourceOwner.
714 */
722 /*
723 * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
724 * top-level transaction we issue a WAL record for the assignment. We
725 * include the top-level xid and all the subxids that have not yet been
726 * reported using XLOG_XACT_ASSIGNMENT records.
727 *
728 * This is required to limit the amount of shared memory required in a hot
729 * standby server to keep track of in-progress XIDs. See notes for
730 * RecordKnownAssignedTransactionIds().
731 *
732 * We don't keep track of the immediate parent of each subxid, only the
733 * top-level transaction that each subxact belongs to. This is correct in
734 * recovery only because aborted subtransactions are separately WAL
735 * logged.
736 *
737 * This is correct even for the case where several levels above us didn't
738 * have an xid assigned as we recursed up to them beforehand.
739 */
741 {
743 nUnreportedXids++;
745 /*
746 * ensure this test matches similar one in
747 * RecoverPreparedTransactions()
748 */
750 log_unknown_top)
751 {
752 xl_xact_assignment xlrec;
754 /*
755 * xtop is always set by now because we recurse up transaction
756 * stack to the highest unassigned xid and then come back down
757 */
770 /* mark top, not current xact as having been logged */
772 }
773 }
774 }
776 /*
777 * GetCurrentSubTransactionId
778 */
779 SubTransactionId
781 {
785 }
787 /*
788 * SubTransactionIsActive
789 *
790 * Test if the specified subxact ID is still active. Note caller is
791 * responsible for checking whether this ID is relevant to the current xact.
792 */
793 bool
795 {
796 TransactionState s;
799 {
804 }
806 }
809 /*
810 * GetCurrentCommandId
811 *
812 * "used" must be true if the caller intends to use the command ID to mark
813 * inserted/updated/deleted tuples. false means the ID is being fetched
814 * for read-only purposes (ie, as a snapshot validity cutoff). See
815 * CommandCounterIncrement() for discussion.
816 */
817 CommandId
819 {
820 /* this is global to a transaction, not subtransaction-local */
822 {
823 /*
824 * Forbid setting currentCommandIdUsed in a parallel worker, because
825 * we have no provision for communicating this back to the leader. We
826 * could relax this restriction when currentCommandIdUsed was already
827 * true at the start of the parallel operation.
828 */
831 }
833 }
835 /*
836 * SetParallelStartTimestamps
837 *
838 * In a parallel worker, we should inherit the parent transaction's
839 * timestamps rather than setting our own. The parallel worker
840 * infrastructure must call this to provide those values before
841 * calling StartTransaction() or SetCurrentStatementStartTimestamp().
842 */
843 void
845 {
849 }
851 /*
852 * GetCurrentTransactionStartTimestamp
853 */
854 TimestampTz
856 {
858 }
860 /*
861 * GetCurrentStatementStartTimestamp
862 */
863 TimestampTz
865 {
867 }
869 /*
870 * GetCurrentTransactionStopTimestamp
871 *
872 * If the transaction stop time hasn't already been set, which can happen if
873 * we decided we don't need to log an XLOG record, set xactStopTimestamp.
874 */
875 TimestampTz
877 {
880 /* should only be called after commit / abort processing */
890 }
892 /*
893 * SetCurrentStatementStartTimestamp
894 *
895 * In a parallel worker, this should already have been provided by a call
896 * to SetParallelStartTimestamps().
897 */
898 void
900 {
903 else
905 }
907 /*
908 * GetCurrentTransactionNestLevel
909 *
910 * Note: this will return zero when not inside any transaction, one when
911 * inside a top-level transaction, etc.
912 */
913 int
915 {
919 }
922 /*
923 * TransactionIdIsCurrentTransactionId
924 */
925 bool
927 {
928 TransactionState s;
930 /*
931 * We always say that BootstrapTransactionId is "not my transaction ID"
932 * even when it is (ie, during bootstrap). Along with the fact that
933 * transam.c always treats BootstrapTransactionId as already committed,
934 * this causes the heapam_visibility.c routines to see all tuples as
935 * committed, which is what we need during bootstrap. (Bootstrap mode
936 * only inserts tuples, it never updates or deletes them, so all tuples
937 * can be presumed good immediately.)
938 *
939 * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
940 * not my transaction ID, so we can just return "false" immediately for
941 * any non-normal XID.
942 */
949 /*
950 * In parallel workers, the XIDs we must consider as current are stored in
951 * ParallelCurrentXids rather than the transaction-state stack. Note that
952 * the XIDs in this array are sorted numerically rather than according to
953 * transactionIdPrecedes order.
954 */
956 {
958 high;
963 {
965 TransactionId probe;
973 else
975 }
977 }
979 /*
980 * We will return true for the Xid of the current subtransaction, any of
981 * its subcommitted children, any of its parents, or any of their
982 * previously subcommitted children. However, a transaction being aborted
983 * is no longer "current", even though it may still have an entry on the
984 * state stack.
985 */
987 {
989 high;
997 /* As the childXids array is ordered, we can use binary search */
1001 {
1003 TransactionId probe;
1011 else
1013 }
1014 }
1017 }
1019 /*
1020 * TransactionStartedDuringRecovery
1021 *
1022 * Returns true if the current transaction started while recovery was still
1023 * in progress. Recovery might have ended since so RecoveryInProgress() might
1024 * return false already.
1025 */
1026 bool
1028 {
1030 }
1032 /*
1033 * EnterParallelMode
1034 */
1035 void
1037 {
1043 }
1045 /*
1046 * ExitParallelMode
1047 */
1048 void
1050 {
1057 }
1059 /*
1060 * IsInParallelMode
1061 *
1062 * Are we in a parallel operation, as either the leader or a worker? Check
1063 * this to prohibit operations that change backend-local state expected to
1064 * match across all workers. Mere caches usually don't require such a
1065 * restriction. State modified in a strict push/pop fashion, such as the
1066 * active snapshot stack, is often fine.
1067 */
1068 bool
1070 {
1072 }
1074 /*
1075 * CommandCounterIncrement
1076 */
1077 void
1079 {
1080 /*
1081 * If the current value of the command counter hasn't been "used" to mark
1082 * tuples, we need not increment it, since there's no need to distinguish
1083 * a read-only command from others. This helps postpone command counter
1084 * overflow, and keeps no-op CommandCounterIncrement operations cheap.
1085 */
1087 {
1088 /*
1089 * Workers synchronize transaction state at the beginning of each
1090 * parallel operation, so we can't account for new commands after that
1091 * point.
1092 */
1098 {
1103 }
1106 /* Propagate new command ID into static snapshots */
1109 /*
1110 * Make any catalog changes done by the just-completed command visible
1111 * in the local syscache. We obviously don't need to do this after a
1112 * read-only command. (But see hacks in inval.c to make real sure we
1113 * don't think a command that queued inval messages was read-only.)
1114 */
1116 }
1117 }
1119 /*
1120 * ForceSyncCommit
1121 *
1122 * Interface routine to allow commands to force a synchronous commit of the
1123 * current top-level transaction. Currently, two-phase commit does not
1124 * persist and restore this variable. So long as all callers use
1125 * PreventInTransactionBlock(), that omission has no consequences.
1126 */
1127 void
1129 {
1131 }
1134 /* ----------------------------------------------------------------
1135 * StartTransaction stuff
1136 * ----------------------------------------------------------------
1137 */
1139 /*
1140 * AtStart_Cache
1141 */
1142 static void
1144 {
1146 }
1148 /*
1149 * AtStart_Memory
1150 */
1151 static void
1153 {
1156 /*
1157 * If this is the first time through, create a private context for
1158 * AbortTransaction to work in. By reserving some space now, we can
1159 * insulate AbortTransaction from out-of-memory scenarios. Like
1160 * ErrorContext, we set it up with slow growth rate and a nonzero minimum
1161 * size, so that space will be reserved immediately.
1162 */
1164 TransactionAbortContext =
1171 /*
1172 * We shouldn't have a transaction context already.
1173 */
1176 /*
1177 * Create a toplevel context for the transaction.
1178 */
1179 TopTransactionContext =
1182 ALLOCSET_DEFAULT_SIZES);
1184 /*
1185 * In a top-level transaction, CurTransactionContext is the same as
1186 * TopTransactionContext.
1187 */
1191 /* Make the CurTransactionContext active. */
1193 }
1195 /*
1196 * AtStart_ResourceOwner
1197 */
1198 static void
1200 {
1203 /*
1204 * We shouldn't have a transaction resource owner already.
1205 */
1208 /*
1209 * Create a toplevel resource owner for the transaction.
1210 */
1216 }
1218 /* ----------------------------------------------------------------
1219 * StartSubTransaction stuff
1220 * ----------------------------------------------------------------
1221 */
1223 /*
1224 * AtSubStart_Memory
1225 */
1226 static void
1228 {
1233 /*
1234 * Create a CurTransactionContext, which will be used to hold data that
1235 * survives subtransaction commit but disappears on subtransaction abort.
1236 * We make it a child of the immediate parent's CurTransactionContext.
1237 */
1240 ALLOCSET_DEFAULT_SIZES);
1243 /* Make the CurTransactionContext active. */
1245 }
1247 /*
1248 * AtSubStart_ResourceOwner
1249 */
1250 static void
1252 {
1257 /*
1258 * Create a resource owner for the subtransaction. We make it a child of
1259 * the immediate parent's resource owner.
1260 */
1267 }
1269 /* ----------------------------------------------------------------
1270 * CommitTransaction stuff
1271 * ----------------------------------------------------------------
1272 */
1274 /*
1275 * RecordTransactionCommit
1276 *
1277 * Returns latest XID among xact and its children, or InvalidTransactionId
1278 * if the xact has no XID. (We compute that here just because it's easier.)
1279 *
1280 * If you change this function, see RecordTransactionCommitPrepared also.
1281 */
1282 static TransactionId
1284 {
1299 /*
1300 * Log pending invalidations for logical decoding of in-progress
1301 * transactions. Normally for DDLs, we log this at each command end,
1302 * however, for certain cases where we directly update the system table
1303 * without a transaction block, the invalidations are not logged till this
1304 * time.
1305 */
1309 /* Get data needed for commit record */
1318 /*
1319 * If we haven't been assigned an XID yet, we neither can, nor do we want
1320 * to write a COMMIT record.
1321 */
1323 {
1324 /*
1325 * We expect that every RelationDropStorage is followed by a catalog
1326 * update, and hence XID assignment, so we shouldn't get here with any
1327 * pending deletes. Same is true for dropping stats.
1328 *
1329 * Use a real test not just an Assert to check this, since it's a bit
1330 * fragile.
1331 */
1335 /* Can't have child XIDs either; AssignTransactionId enforces this */
1338 /*
1339 * Transactions without an assigned xid can contain invalidation
1340 * messages (e.g. explicit relcache invalidations or catcache
1341 * invalidations for inplace updates); standbys need to process those.
1342 * We can't emit a commit record without an xid, and we don't want to
1343 * force assigning an xid, because that'd be problematic for e.g.
1344 * vacuum. Hence we emit a bespoke record for the invalidations. We
1345 * don't want to use that in case a commit record is emitted, so they
1346 * happen synchronously with commits (besides not wanting to emit more
1347 * WAL records).
1348 */
1350 {
1352 RelcacheInitFileInval);
1354 }
1356 /*
1357 * If we didn't create XLOG entries, we're done here; otherwise we
1358 * should trigger flushing those entries the same as a commit record
1359 * would. This will primarily happen for HOT pruning and the like; we
1360 * want these to be flushed to disk in due time.
1361 */
1364 }
1365 else
1366 {
1369 /*
1370 * Are we using the replication origins feature? Or, in other words,
1371 * are we replaying remote actions?
1372 */
1376 /*
1377 * Begin commit critical section and insert the commit XLOG record.
1378 */
1379 /* Tell bufmgr and smgr to prepare for commit */
1382 /*
1383 * Mark ourselves as within our "commit critical section". This
1384 * forces any concurrent checkpoint to wait until we've updated
1385 * pg_xact. Without this, it is possible for the checkpoint to set
1386 * REDO after the XLOG record but fail to flush the pg_xact update to
1387 * disk, leading to loss of the transaction commit if the system
1388 * crashes a little later.
1389 *
1390 * Note: we could, but don't bother to, set this flag in
1391 * RecordTransactionAbort. That's because loss of a transaction abort
1392 * is noncritical; the presumption would be that it aborted, anyway.
1393 *
1394 * It's safe to change the delayChkptFlags flag of our own backend
1395 * without holding the ProcArrayLock, since we're the only one
1396 * modifying it. This makes checkpoint's determination of which xacts
1397 * are delaying the checkpoint a bit fuzzy, but it doesn't matter.
1398 */
1407 RelcacheInitFileInval,
1408 MyXactFlags,
1412 /* Move LSNs forward for this replication origin */
1414 XactLastRecEnd);
1416 /*
1417 * Record commit timestamp. The value comes from plain commit
1418 * timestamp if there's no replication origin; otherwise, the
1419 * timestamp was already set in replorigin_session_origin_timestamp by
1420 * replication.
1421 *
1422 * We don't need to WAL-log anything here, as the commit record
1423 * written above already contains the data.
1424 */
1430 replorigin_session_origin_timestamp,
1431 replorigin_session_origin);
1432 }
1434 /*
1435 * Check if we want to commit asynchronously. We can allow the XLOG flush
1436 * to happen asynchronously if synchronous_commit=off, or if the current
1437 * transaction has not performed any WAL-logged operation or didn't assign
1438 * an xid. The transaction can end up not writing any WAL, even if it has
1439 * an xid, if it only wrote to temporary and/or unlogged tables. It can
1440 * end up having written WAL without an xid if it did HOT pruning. In
1441 * case of a crash, the loss of such a transaction will be irrelevant;
1442 * temp tables will be lost anyway, unlogged tables will be truncated and
1443 * HOT pruning will be done again later. (Given the foregoing, you might
1444 * think that it would be unnecessary to emit the XLOG record at all in
1445 * this case, but we don't currently try to do that. It would certainly
1446 * cause problems at least in Hot Standby mode, where the
1447 * KnownAssignedXids machinery requires tracking every XID assignment. It
1448 * might be OK to skip it only when wal_level < replica, but for now we
1449 * don't.)
1450 *
1451 * However, if we're doing cleanup of any non-temp rels or committing any
1452 * command that wanted to force sync commit, then we must flush XLOG
1453 * immediately. (We must not allow asynchronous commit if there are any
1454 * non-temp tables to be deleted, because we might delete the files before
1455 * the COMMIT record is flushed to disk. We do allow asynchronous commit
1456 * if all to-be-deleted tables are temporary though, since they are lost
1457 * anyway if we crash.)
1458 */
1462 {
1465 /*
1466 * Now we may update the CLOG, if we wrote a COMMIT record above
1467 */
1470 }
1471 else
1472 {
1473 /*
1474 * Asynchronous commit case:
1475 *
1476 * This enables possible committed transaction loss in the case of a
1477 * postmaster crash because WAL buffers are left unwritten. Ideally we
1478 * could issue the WAL write without the fsync, but some
1479 * wal_sync_methods do not allow separate write/fsync.
1480 *
1481 * Report the latest async commit LSN, so that the WAL writer knows to
1482 * flush this commit.
1483 */
1486 /*
1487 * We must not immediately update the CLOG, since we didn't flush the
1488 * XLOG. Instead, we store the LSN up to which the XLOG must be
1489 * flushed before the CLOG may be updated.
1490 */
1493 }
1495 /*
1496 * If we entered a commit critical section, leave it now, and let
1497 * checkpoints proceed.
1498 */
1500 {
1503 }
1505 /* Compute latestXid while we have the child XIDs handy */
1508 /*
1509 * Wait for synchronous replication, if required. Similar to the decision
1510 * above about using committing asynchronously we only want to wait if
1511 * this backend assigned an xid and wrote WAL. No need to wait if an xid
1512 * was assigned due to temporary/unlogged tables or due to HOT pruning.
1513 *
1514 * Note that at this stage we have marked clog, but still show as running
1515 * in the procarray and continue to hold locks.
1516 */
1520 /* remember end of last commit record */
1523 /* Reset XactLastRecEnd until the next transaction writes something */
1525 cleanup:
1526 /* Clean up local data */
1533 }
1536 /*
1537 * AtCCI_LocalCache
1538 */
1539 static void
1541 {
1542 /*
1543 * Make any pending relation map changes visible. We must do this before
1544 * processing local sinval messages, so that the map changes will get
1545 * reflected into the relcache when relcache invals are processed.
1546 */
1549 /*
1550 * Make catalog changes visible to me for the next command.
1551 */
1553 }
1555 /*
1556 * AtCommit_Memory
1557 */
1558 static void
1560 {
1561 /*
1562 * Now that we're "out" of a transaction, have the system allocate things
1563 * in the top memory context instead of per-transaction contexts.
1564 */
1567 /*
1568 * Release all transaction-local memory.
1569 */
1575 }
1577 /* ----------------------------------------------------------------
1578 * CommitSubTransaction stuff
1579 * ----------------------------------------------------------------
1580 */
1582 /*
1583 * AtSubCommit_Memory
1584 */
1585 static void
1587 {
1592 /* Return to parent transaction level's memory context. */
1596 /*
1597 * Ordinarily we cannot throw away the child's CurTransactionContext,
1598 * since the data it contains will be needed at upper commit. However, if
1599 * there isn't actually anything in it, we can throw it away. This avoids
1600 * a small memory leak in the common case of "trivial" subxacts.
1601 */
1603 {
1606 }
1607 }
1609 /*
1610 * AtSubCommit_childXids
1611 *
1612 * Pass my own XID and my child XIDs up to my parent as committed children.
1613 */
1614 static void
1616 {
1622 /*
1623 * The parent childXids array will need to hold my XID and all my
1624 * childXids, in addition to the XIDs already there.
1625 */
1628 /* Allocate or enlarge the parent array if necessary */
1630 {
1634 /*
1635 * Make it 2x what's needed right now, to avoid having to enlarge it
1636 * repeatedly. But we can't go above MaxAllocSize. (The latter limit
1637 * is what ensures that we don't need to worry about integer overflow
1638 * here or in the calculation of new_nChildXids.)
1639 */
1649 /*
1650 * We keep the child-XID arrays in TopTransactionContext; this avoids
1651 * setting up child-transaction contexts for what might be just a few
1652 * bytes of grandchild XIDs.
1653 */
1655 new_childXids =
1658 else
1664 }
1666 /*
1667 * Copy all my XIDs to parent's array.
1668 *
1669 * Note: We rely on the fact that the XID of a child always follows that
1670 * of its parent. By copying the XID of this subtransaction before the
1671 * XIDs of its children, we ensure that the array stays ordered. Likewise,
1672 * all XIDs already in the array belong to subtransactions started and
1673 * subcommitted before us, so their XIDs must precede ours.
1674 */
1684 /* Release child's array to avoid leakage */
1687 /* We must reset these to avoid double-free if fail later in commit */
1691 }
1693 /* ----------------------------------------------------------------
1694 * AbortTransaction stuff
1695 * ----------------------------------------------------------------
1696 */
1698 /*
1699 * RecordTransactionAbort
1700 *
1701 * Returns latest XID among xact and its children, or InvalidTransactionId
1702 * if the xact has no XID. (We compute that here just because it's easier.)
1703 */
1704 static TransactionId
1706 {
1708 TransactionId latestXid;
1715 TimestampTz xact_time;
1718 /*
1719 * If we haven't been assigned an XID, nobody will care whether we aborted
1720 * or not. Hence, we're done in that case. It does not matter if we have
1721 * rels to delete (note that this routine is not responsible for actually
1722 * deleting 'em). We cannot have any child XIDs, either.
1723 */
1725 {
1726 /* Reset XactLastRecEnd until the next transaction writes something */
1730 }
1732 /*
1733 * We have a valid XID, so we should write an ABORT record for it.
1734 *
1735 * We do not flush XLOG to disk here, since the default assumption after a
1736 * crash would be that we aborted, anyway. For the same reason, we don't
1737 * need to worry about interlocking against checkpoint start.
1738 */
1740 /*
1741 * Check that we haven't aborted halfway through RecordTransactionCommit.
1742 */
1745 xid);
1747 /*
1748 * Are we using the replication origins feature? Or, in other words, are
1749 * we replaying remote actions?
1750 */
1754 /* Fetch the data we need for the abort record */
1759 /* XXX do we really need a critical section here? */
1762 /* Write the ABORT record */
1765 else
1766 {
1768 }
1775 NULL);
1778 /* Move LSNs forward for this replication origin */
1780 XactLastRecEnd);
1782 /*
1783 * Report the latest async abort LSN, so that the WAL writer knows to
1784 * flush this abort. There's nothing to be gained by delaying this, since
1785 * WALWriter may as well do this when it can. This is important with
1786 * streaming replication because if we don't flush WAL regularly we will
1787 * find that large aborts leave us with a long backlog for when commits
1788 * occur after the abort, increasing our window of data loss should
1789 * problems occur at that point.
1790 */
1794 /*
1795 * Mark the transaction aborted in clog. This is not absolutely necessary
1796 * but we may as well do it while we are here; also, in the subxact case
1797 * it is helpful because XactLockTableWait makes use of it to avoid
1798 * waiting for already-aborted subtransactions. It is OK to do it without
1799 * having flushed the ABORT record to disk, because in event of a crash
1800 * we'd be assumed to have aborted anyway.
1801 */
1806 /* Compute latestXid while we have the child XIDs handy */
1809 /*
1810 * If we're aborting a subtransaction, we can immediately remove failed
1811 * XIDs from PGPROC's cache of running child XIDs. We do that here for
1812 * subxacts, because we already have the child XID array at hand. For
1813 * main xacts, the equivalent happens just after this function returns.
1814 */
1818 /* Reset XactLastRecEnd until the next transaction writes something */
1822 /* And clean up local data */
1829 }
1831 /*
1832 * AtAbort_Memory
1833 */
1834 static void
1836 {
1837 /*
1838 * Switch into TransactionAbortContext, which should have some free space
1839 * even if nothing else does. We'll work in this context until we've
1840 * finished cleaning up.
1841 *
1842 * It is barely possible to get here when we've not been able to create
1843 * TransactionAbortContext yet; if so use TopMemoryContext.
1844 */
1847 else
1849 }
1851 /*
1852 * AtSubAbort_Memory
1853 */
1854 static void
1856 {
1860 }
1863 /*
1864 * AtAbort_ResourceOwner
1865 */
1866 static void
1868 {
1869 /*
1870 * Make sure we have a valid ResourceOwner, if possible (else it will be
1871 * NULL, which is OK)
1872 */
1874 }
1876 /*
1877 * AtSubAbort_ResourceOwner
1878 */
1879 static void
1881 {
1884 /* Make sure we have a valid ResourceOwner */
1886 }
1889 /*
1890 * AtSubAbort_childXids
1891 */
1892 static void
1894 {
1897 /*
1898 * We keep the child-XID arrays in TopTransactionContext (see
1899 * AtSubCommit_childXids). This means we'd better free the array
1900 * explicitly at abort to avoid leakage.
1901 */
1908 /*
1909 * We could prune the unreportedXids array here. But we don't bother. That
1910 * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
1911 * would likely introduce more CPU time into the more common paths, so we
1912 * choose not to do that.
1913 */
1914 }
1916 /* ----------------------------------------------------------------
1917 * CleanupTransaction stuff
1918 * ----------------------------------------------------------------
1919 */
1921 /*
1922 * AtCleanup_Memory
1923 */
1924 static void
1926 {
1929 /*
1930 * Now that we're "out" of a transaction, have the system allocate things
1931 * in the top memory context instead of per-transaction contexts.
1932 */
1935 /*
1936 * Clear the special abort context for next time.
1937 */
1941 /*
1942 * Release all transaction-local memory.
1943 */
1949 }
1952 /* ----------------------------------------------------------------
1953 * CleanupSubTransaction stuff
1954 * ----------------------------------------------------------------
1955 */
1957 /*
1958 * AtSubCleanup_Memory
1959 */
1960 static void
1962 {
1967 /* Make sure we're not in an about-to-be-deleted context */
1971 /*
1972 * Clear the special abort context for next time.
1973 */
1977 /*
1978 * Delete the subxact local memory contexts. Its CurTransactionContext can
1979 * go too (note this also kills CurTransactionContexts from any children
1980 * of the subxact).
1981 */
1985 }
1987 /* ----------------------------------------------------------------
1988 * interface routines
1989 * ----------------------------------------------------------------
1990 */
1992 /*
1993 * StartTransaction
1994 */
1995 static void
1997 {
1998 TransactionState s;
1999 VirtualTransactionId vxid;
2001 /*
2002 * Let's just make sure the state stack is empty
2003 */
2009 /* check the current transaction state */
2012 /*
2013 * Set the current transaction state information appropriately during
2014 * start processing. Note that once the transaction status is switched
2015 * this process cannot fail until the user ID and the security context
2016 * flags are fetched below.
2017 */
2021 /* Determine if statements are logged in this transaction */
2026 /*
2027 * initialize current transaction state fields
2028 *
2029 * note: prevXactReadOnly is not used at the outermost level
2030 */
2037 /*
2038 * Once the current user ID and the security context flags are fetched,
2039 * both will be properly reset even if transaction startup fails.
2040 */
2043 /* SecurityRestrictionContext should never be set outside a transaction */
2046 /*
2047 * Make sure we've reset xact state variables
2048 *
2049 * If recovery is still in progress, mark this transaction as read-only.
2050 * We have lower level defences in XLogInsert and elsewhere to stop us
2051 * from modifying data during recovery, but this gives the normal
2052 * indication to the user that the transaction is read-only.
2053 */
2055 {
2058 }
2059 else
2060 {
2063 }
2069 /*
2070 * reinitialize within-transaction counters
2071 */
2077 /*
2078 * initialize reported xid accounting
2079 */
2083 /*
2084 * must initialize resource-management stuff first
2085 */
2089 /*
2090 * Assign a new LocalTransactionId, and combine it with the backendId to
2091 * form a virtual transaction id.
2092 */
2096 /*
2097 * Lock the virtual transaction id before we announce it in the proc array
2098 */
2101 /*
2102 * Advertise it in the proc array. We assume assignment of
2103 * localTransactionId is atomic, and the backendId should be set already.
2104 */
2110 /*
2111 * set transaction_timestamp() (a/k/a now()). Normally, we want this to
2112 * be the same as the first command's statement_timestamp(), so don't do a
2113 * fresh GetCurrentTimestamp() call (which'd be expensive anyway). But
2114 * for transactions started inside procedures (i.e., nonatomic SPI
2115 * contexts), we do need to advance the timestamp. Also, in a parallel
2116 * worker, the timestamp should already have been provided by a call to
2117 * SetParallelStartTimestamps().
2118 */
2120 {
2123 else
2125 }
2126 else
2129 /* Mark xactStopTimestamp as unset. */
2132 /*
2133 * initialize other subsystems for new transaction
2134 */
2139 /*
2140 * done with start processing, set current transaction state to "in
2141 * progress"
2142 */
2146 }
2149 /*
2150 * CommitTransaction
2151 *
2152 * NB: if you change this routine, better look at PrepareTransaction too!
2153 */
2154 static void
2156 {
2158 TransactionId latestXid;
2163 /* Enforce parallel mode restrictions during parallel worker commit. */
2169 /*
2170 * check the current transaction state
2171 */
2177 /*
2178 * Do pre-commit processing that involves calling user-defined code, such
2179 * as triggers. SECURITY_RESTRICTED_OPERATION contexts must not queue an
2180 * action that would run here, because that would bypass the sandbox.
2181 * Since closing cursors could queue trigger actions, triggers could open
2182 * cursors, etc, we have to keep looping until there's nothing left to do.
2183 */
2185 {
2186 /*
2187 * Fire all currently pending deferred triggers.
2188 */
2191 /*
2192 * Close open portals (converting holdable ones into static portals).
2193 * If there weren't any, we are done ... otherwise loop back to check
2194 * if they queued deferred triggers. Lather, rinse, repeat.
2195 */
2198 }
2200 /*
2201 * The remaining actions cannot call any user-defined code, so it's safe
2202 * to start shutting down within-transaction services. But note that most
2203 * of this stuff could still throw an error, which would switch us into
2204 * the transaction-abort path.
2205 */
2210 /* If we might have parallel workers, clean them up now. */
2214 /* Shut down the deferred-trigger manager */
2217 /*
2218 * Let ON COMMIT management do its thing (must happen after closing
2219 * cursors, to avoid dangling-reference problems)
2220 */
2223 /*
2224 * Synchronize files that are created and not WAL-logged during this
2225 * transaction. This must happen before AtEOXact_RelationMap(), so that we
2226 * don't see committed-but-broken files after a crash.
2227 */
2230 /* close large objects before lower-level cleanup */
2233 /*
2234 * Insert notifications sent by NOTIFY commands into the queue. This
2235 * should be late in the pre-commit sequence to minimize time spent
2236 * holding the notify-insertion lock. However, this could result in
2237 * creating a snapshot, so we must do it before serializable cleanup.
2238 */
2241 /*
2242 * Mark serializable transaction as complete for predicate locking
2243 * purposes. This should be done as late as we can put it and still allow
2244 * errors to be raised for failure patterns found at commit. This is not
2245 * appropriate in a parallel worker however, because we aren't committing
2246 * the leader's transaction and its serializable state will live on.
2247 */
2251 /* Prevent cancel/die interrupt while cleaning up */
2254 /* Commit updates to the relation map --- do this as late as possible */
2257 /*
2258 * set the current transaction state information appropriately during
2259 * commit processing
2260 */
2265 {
2266 /*
2267 * We need to mark our XIDs as committed in pg_xact. This is where we
2268 * durably commit.
2269 */
2271 }
2272 else
2273 {
2274 /*
2275 * We must not mark our XID committed; the parallel leader is
2276 * responsible for that.
2277 */
2280 /*
2281 * Make sure the leader will know about any WAL we wrote before it
2282 * commits.
2283 */
2285 }
2289 /*
2290 * Let others know about no transaction in progress by me. Note that this
2291 * must be done _before_ releasing locks we hold and _after_
2292 * RecordTransactionCommit.
2293 */
2296 /*
2297 * This is all post-commit cleanup. Note that if an error is raised here,
2298 * it's too late to abort the transaction. This should be just
2299 * noncritical resource releasing.
2300 *
2301 * The ordering of operations is not entirely random. The idea is:
2302 * release resources visible to other backends (eg, files, buffer pins);
2303 * then release locks; then release backend-local resources. We want to
2304 * release locks at the point where any backend waiting for us will see
2305 * our transaction as being fully cleaned up.
2306 *
2307 * Resources that can be associated with individual queries are handled by
2308 * the ResourceOwner mechanism. The other calls here are for backend-wide
2309 * state.
2310 */
2316 RESOURCE_RELEASE_BEFORE_LOCKS,
2319 /* Check we've released all buffer pins */
2322 /* Clean up the relation cache */
2325 /*
2326 * Make catalog changes visible to all backends. This has to happen after
2327 * relcache references are dropped (see comments for
2328 * AtEOXact_RelationCache), but before locks are released (if anyone is
2329 * waiting for lock on a relation we've modified, we want them to know
2330 * about the catalog change before they start using the relation).
2331 */
2337 RESOURCE_RELEASE_LOCKS,
2340 RESOURCE_RELEASE_AFTER_LOCKS,
2343 /*
2344 * Likewise, dropping of files deleted during the transaction is best done
2345 * after releasing relcache and buffer pins. (This is not strictly
2346 * necessary during commit, since such pins should have been released
2347 * already, but this ordering is definitely critical during abort.) Since
2348 * this may take many seconds, also delay until after releasing locks.
2349 * Other backends will observe the attendant catalog changes and not
2350 * attempt to access affected files.
2351 */
2354 /*
2355 * Send out notification signals to other backends (and do other
2356 * post-commit NOTIFY cleanup). This must not happen until after our
2357 * transaction is fully done from the viewpoint of other backends.
2358 */
2361 /*
2362 * Everything after this should be purely internal-to-this-backend
2363 * cleanup.
2364 */
2399 /*
2400 * done with commit processing, set current transaction state back to
2401 * default
2402 */
2406 }
2409 /*
2410 * PrepareTransaction
2411 *
2412 * NB: if you change this routine, better look at CommitTransaction too!
2413 */
2414 static void
2416 {
2419 GlobalTransaction gxact;
2420 TimestampTz prepared_at;
2426 /*
2427 * check the current transaction state
2428 */
2434 /*
2435 * Do pre-commit processing that involves calling user-defined code, such
2436 * as triggers. Since closing cursors could queue trigger actions,
2437 * triggers could open cursors, etc, we have to keep looping until there's
2438 * nothing left to do.
2439 */
2441 {
2442 /*
2443 * Fire all currently pending deferred triggers.
2444 */
2447 /*
2448 * Close open portals (converting holdable ones into static portals).
2449 * If there weren't any, we are done ... otherwise loop back to check
2450 * if they queued deferred triggers. Lather, rinse, repeat.
2451 */
2454 }
2458 /*
2459 * The remaining actions cannot call any user-defined code, so it's safe
2460 * to start shutting down within-transaction services. But note that most
2461 * of this stuff could still throw an error, which would switch us into
2462 * the transaction-abort path.
2463 */
2465 /* Shut down the deferred-trigger manager */
2468 /*
2469 * Let ON COMMIT management do its thing (must happen after closing
2470 * cursors, to avoid dangling-reference problems)
2471 */
2474 /*
2475 * Synchronize files that are created and not WAL-logged during this
2476 * transaction. This must happen before EndPrepare(), so that we don't see
2477 * committed-but-broken files after a crash and COMMIT PREPARED.
2478 */
2481 /* close large objects before lower-level cleanup */
2484 /* NOTIFY requires no work at this point */
2486 /*
2487 * Mark serializable transaction as complete for predicate locking
2488 * purposes. This should be done as late as we can put it and still allow
2489 * errors to be raised for failure patterns found at commit.
2490 */
2493 /*
2494 * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
2495 * this transaction. Having the prepared xact hold locks on another
2496 * backend's temp table seems a bad idea --- for instance it would prevent
2497 * the backend from exiting. There are other problems too, such as how to
2498 * clean up the source backend's local buffers and ON COMMIT state if the
2499 * prepared xact includes a DROP of a temp table.
2500 *
2501 * Other objects types, like functions, operators or extensions, share the
2502 * same restriction as they should not be created, locked or dropped as
2503 * this can mess up with this session or even a follow-up session trying
2504 * to use the same temporary namespace.
2505 *
2506 * We must check this after executing any ON COMMIT actions, because they
2507 * might still access a temp relation.
2508 *
2509 * XXX In principle this could be relaxed to allow some useful special
2510 * cases, such as a temp table created and dropped all within the
2511 * transaction. That seems to require much more bookkeeping though.
2512 */
2518 /*
2519 * Likewise, don't allow PREPARE after pg_export_snapshot. This could be
2520 * supported if we added cleanup logic to twophase.c, but for now it
2521 * doesn't seem worth the trouble.
2522 */
2528 /* Prevent cancel/die interrupt while cleaning up */
2531 /*
2532 * set the current transaction state information appropriately during
2533 * prepare processing
2534 */
2539 /* Tell bufmgr and smgr to prepare for commit */
2542 /*
2543 * Reserve the GID for this transaction. This could fail if the requested
2544 * GID is invalid or already in use.
2545 */
2550 /*
2551 * Collect data for the 2PC state file. Note that in general, no actual
2552 * state change should happen in the called modules during this step,
2553 * since it's still possible to fail before commit, and in that case we
2554 * want transaction abort to be able to clean up. (In particular, the
2555 * AtPrepare routines may error out if they find cases they cannot
2556 * handle.) State cleanup should happen in the PostPrepare routines
2557 * below. However, some modules can go ahead and clear state here because
2558 * they wouldn't do anything with it during abort anyway.
2559 *
2560 * Note: because the 2PC state file records will be replayed in the same
2561 * order they are made, the order of these calls has to match the order in
2562 * which we want things to happen during COMMIT PREPARED or ROLLBACK
2563 * PREPARED; in particular, pay attention to whether things should happen
2564 * before or after releasing the transaction's locks.
2565 */
2575 /*
2576 * Here is where we really truly prepare.
2577 *
2578 * We have to record transaction prepares even if we didn't make any
2579 * updates, because the transaction manager might get confused if we lose
2580 * a global transaction.
2581 */
2584 /*
2585 * Now we clean up backend-internal state and release internal resources.
2586 */
2588 /* Reset XactLastRecEnd until the next transaction writes something */
2591 /*
2592 * Transfer our locks to a dummy PGPROC. This has to be done before
2593 * ProcArrayClearTransaction(). Otherwise, a GetLockConflicts() would
2594 * conclude "xact already committed or aborted" for our locks.
2595 */
2598 /*
2599 * Let others know about no transaction in progress by me. This has to be
2600 * done *after* the prepared transaction has been marked valid, else
2601 * someone may think it is unlocked and recyclable.
2602 */
2605 /*
2606 * In normal commit-processing, this is all non-critical post-transaction
2607 * cleanup. When the transaction is prepared, however, it's important
2608 * that the locks and other per-backend resources are transferred to the
2609 * prepared transaction's PGPROC entry. Note that if an error is raised
2610 * here, it's too late to abort the transaction. XXX: This probably should
2611 * be in a critical section, to force a PANIC if any of this fails, but
2612 * that cure could be worse than the disease.
2613 */
2618 RESOURCE_RELEASE_BEFORE_LOCKS,
2621 /* Check we've released all buffer pins */
2624 /* Clean up the relation cache */
2627 /* notify doesn't need a postprepare call */
2640 RESOURCE_RELEASE_LOCKS,
2643 RESOURCE_RELEASE_AFTER_LOCKS,
2646 /*
2647 * Allow another backend to finish the transaction. After
2648 * PostPrepare_Twophase(), the transaction is completely detached from our
2649 * backend. The rest is just non-critical cleanup of backend-local state.
2650 */
2653 /* PREPARE acts the same as COMMIT as far as GUC is concerned */
2663 /* don't call AtEOXact_PgStat here; we fixed pgstat state above */
2665 /* we treat PREPARE as ROLLBACK so far as waking workers goes */
2689 /*
2690 * done with 1st phase commit processing, set current transaction state
2691 * back to default
2692 */
2696 }
2699 /*
2700 * AbortTransaction
2701 */
2702 static void
2704 {
2706 TransactionId latestXid;
2709 /* Prevent cancel/die interrupt while cleaning up */
2712 /* Make sure we have a valid memory context and resource owner */
2716 /*
2717 * Release any LW locks we might be holding as quickly as possible.
2718 * (Regular locks, however, must be held till we finish aborting.)
2719 * Releasing LW locks is critical since we might try to grab them again
2720 * while cleaning up!
2721 */
2724 /* Clear wait information and command progress indicator */
2728 /* Clean up buffer I/O and buffer context locks, too */
2732 /* Reset WAL record construction state */
2735 /* Cancel condition variable sleep */
2738 /*
2739 * Also clean up any open wait for lock, since the lock manager will choke
2740 * if we try to wait for another lock before doing this.
2741 */
2744 /*
2745 * If any timeout events are still active, make sure the timeout interrupt
2746 * is scheduled. This covers possible loss of a timeout interrupt due to
2747 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
2748 * We delay this till after LockErrorCleanup so that we don't uselessly
2749 * reschedule lock or deadlock check timeouts.
2750 */
2753 /*
2754 * Re-enable signals, in case we got here by longjmp'ing out of a signal
2755 * handler. We do this fairly early in the sequence so that the timeout
2756 * infrastructure will be functional if needed while aborting.
2757 */
2760 /*
2761 * check the current transaction state
2762 */
2769 /*
2770 * set the current transaction state information appropriately during the
2771 * abort processing
2772 */
2775 /*
2776 * Reset user ID which might have been changed transiently. We need this
2777 * to clean up in case control escaped out of a SECURITY DEFINER function
2778 * or other local change of CurrentUserId; therefore, the prior value of
2779 * SecurityRestrictionContext also needs to be restored.
2780 *
2781 * (Note: it is not necessary to restore session authorization or role
2782 * settings here because those can only be changed via GUC, and GUC will
2783 * take care of rolling them back if need be.)
2784 */
2787 /* Forget about any active REINDEX. */
2790 /* Reset logical streaming state. */
2793 /* Reset snapshot export state. */
2796 /* If in parallel mode, clean up workers and exit parallel mode. */
2798 {
2801 }
2803 /*
2804 * do abort processing
2805 */
2814 /*
2815 * Advertise the fact that we aborted in pg_xact (assuming that we got as
2816 * far as assigning an XID to advertise). But if we're inside a parallel
2817 * worker, skip this; the user backend must be the one to write the abort
2818 * record.
2819 */
2822 else
2823 {
2826 /*
2827 * Since the parallel leader won't get our value of XactLastRecEnd in
2828 * this case, we nudge WAL-writer ourselves in this case. See related
2829 * comments in RecordTransactionAbort for why this matters.
2830 */
2832 }
2836 /*
2837 * Let others know about no transaction in progress by me. Note that this
2838 * must be done _before_ releasing locks we hold and _after_
2839 * RecordTransactionAbort.
2840 */
2843 /*
2844 * Post-abort cleanup. See notes in CommitTransaction() concerning
2845 * ordering. We can skip all of it if the transaction failed before
2846 * creating a resource owner.
2847 */
2849 {
2852 else
2856 RESOURCE_RELEASE_BEFORE_LOCKS,
2863 RESOURCE_RELEASE_LOCKS,
2866 RESOURCE_RELEASE_AFTER_LOCKS,
2883 }
2885 /*
2886 * State remains TRANS_ABORT until CleanupTransaction().
2887 */
2889 }
2891 /*
2892 * CleanupTransaction
2893 */
2894 static void
2896 {
2899 /*
2900 * State should still be TRANS_ABORT from AbortTransaction().
2901 */
2906 /*
2907 * do abort cleanup processing
2908 */
2933 /*
2934 * done with abort processing, set current transaction state back to
2935 * default
2936 */
2938 }
2940 /*
2941 * StartTransactionCommand
2942 */
2943 void
2945 {
2949 {
2950 /*
2951 * if we aren't in a transaction block, we just do our usual start
2952 * transaction.
2953 */
2959 /*
2960 * We are somewhere in a transaction block or subtransaction and
2961 * about to start a new command. For now we do nothing, but
2962 * someday we may do command-local resource initialization. (Note
2963 * that any needed CommandCounterIncrement was done by the
2964 * previous CommitTransactionCommand.)
2965 */
2971 /*
2972 * Here we are in a failed transaction block (one of the commands
2973 * caused an abort) so we do nothing but remain in the abort
2974 * state. Eventually we will get a ROLLBACK command which will
2975 * get us out of this state. (It is up to other code to ensure
2976 * that no commands other than ROLLBACK will be processed in these
2977 * states.)
2978 */
2983 /* These cases are invalid. */
3001 }
3003 /*
3004 * We must switch to CurTransactionContext before returning. This is
3005 * already done if we called StartTransaction, otherwise not.
3006 */
3009 }
3012 /*
3013 * Simple system for saving and restoring transaction characteristics
3014 * (isolation level, read only, deferrable). We need this for transaction
3015 * chaining, so that we can set the characteristics of the new transaction to
3016 * be the same as the previous one. (We need something like this because the
3017 * GUC system resets the characteristics at transaction end, so for example
3018 * just skipping the reset in StartTransaction() won't work.)
3019 */
3020 void
3022 {
3026 }
3028 void
3030 {
3034 }
3037 /*
3038 * CommitTransactionCommand
3039 */
3040 void
3042 {
3044 SavedTransactionCharacteristics savetc;
3049 {
3050 /*
3051 * These shouldn't happen. TBLOCK_DEFAULT means the previous
3052 * StartTransactionCommand didn't set the STARTED state
3053 * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
3054 * by EndParallelWorkerTransaction(), not this function.
3055 */
3062 /*
3063 * If we aren't in a transaction block, just do our usual
3064 * transaction commit, and return to the idle state.
3065 */
3071 /*
3072 * We are completing a "BEGIN TRANSACTION" command, so we change
3073 * to the "transaction block in progress" state and return. (We
3074 * assume the BEGIN did nothing to the database, so we need no
3075 * CommandCounterIncrement.)
3076 */
3081 /*
3082 * This is the case when we have finished executing a command
3083 * someplace within a transaction block. We increment the command
3084 * counter and return.
3085 */
3092 /*
3093 * We are completing a "COMMIT" command. Do it and return to the
3094 * idle state.
3095 */
3100 {
3105 }
3108 /*
3109 * Here we are in the middle of a transaction block but one of the
3110 * commands caused an abort so we do nothing but remain in the
3111 * abort state. Eventually we will get a ROLLBACK command.
3112 */
3117 /*
3118 * Here we were in an aborted transaction block and we just got
3119 * the ROLLBACK command from the user, so clean up the
3120 * already-aborted transaction and return to the idle state.
3121 */
3126 {
3131 }
3134 /*
3135 * Here we were in a perfectly good transaction block but the user
3136 * told us to ROLLBACK anyway. We have to abort the transaction
3137 * and then clean up.
3138 */
3144 {
3149 }
3152 /*
3153 * We are completing a "PREPARE TRANSACTION" command. Do it and
3154 * return to the idle state.
3155 */
3161 /*
3162 * The user issued a SAVEPOINT inside a transaction block.
3163 * Start a subtransaction. (DefineSavepoint already did
3164 * PushTransaction, so as to have someplace to put the SUBBEGIN
3165 * state.)
3166 */
3172 /*
3173 * The user issued a RELEASE command, so we end the current
3174 * subtransaction and return to the parent transaction. The parent
3175 * might be ended too, so repeat till we find an INPROGRESS
3176 * transaction or subtransaction.
3177 */
3179 do
3180 {
3189 /*
3190 * The user issued a COMMIT, so we end the current subtransaction
3191 * hierarchy and perform final commit. We do this by rolling up
3192 * any subtransactions into their parent, which leads to O(N^2)
3193 * operations with respect to resource owners - this isn't that
3194 * bad until we approach a thousands of savepoints but is
3195 * necessary for correctness should after triggers create new
3196 * resource owners.
3197 */
3199 do
3200 {
3204 /* If we had a COMMIT command, finish off the main xact too */
3206 {
3211 {
3216 }
3217 }
3219 {
3223 }
3224 else
3229 /*
3230 * The current already-failed subtransaction is ending due to a
3231 * ROLLBACK or ROLLBACK TO command, so pop it and recursively
3232 * examine the parent (which could be in any of several states).
3233 */
3239 /*
3240 * As above, but it's not dead yet, so abort first.
3241 */
3248 /*
3249 * The current subtransaction is the target of a ROLLBACK TO
3250 * command. Abort and pop it, then start a new subtransaction
3251 * with the same name.
3252 */
3254 {
3258 /* save name and keep Cleanup from freeing it */
3271 /* This is the same as TBLOCK_SUBBEGIN case */
3275 }
3278 /*
3279 * Same as above, but the subtransaction had already failed, so we
3280 * don't need AbortSubTransaction.
3281 */
3283 {
3287 /* save name and keep Cleanup from freeing it */
3299 /* This is the same as TBLOCK_SUBBEGIN case */
3303 }
3305 }
3306 }
3308 /*
3309 * AbortCurrentTransaction
3310 */
3311 void
3313 {
3317 {
3320 {
3321 /* we are idle, so nothing to do */
3322 }
3323 else
3324 {
3325 /*
3326 * We can get here after an error during transaction start
3327 * (state will be TRANS_START). Need to clean up the
3328 * incompletely started transaction. First, adjust the
3329 * low-level state to suppress warning message from
3330 * AbortTransaction.
3331 */
3336 }
3339 /*
3340 * If we aren't in a transaction block, we just do the basic abort
3341 * & cleanup transaction. For this purpose, we treat an implicit
3342 * transaction block as if it were a simple statement.
3343 */
3351 /*
3352 * If we are in TBLOCK_BEGIN it means something screwed up right
3353 * after reading "BEGIN TRANSACTION". We assume that the user
3354 * will interpret the error as meaning the BEGIN failed to get him
3355 * into a transaction block, so we should abort and return to idle
3356 * state.
3357 */
3364 /*
3365 * We are somewhere in a transaction block and we've gotten a
3366 * failure, so we abort the transaction and set up the persistent
3367 * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3368 */
3373 /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3376 /*
3377 * Here, we failed while trying to COMMIT. Clean up the
3378 * transaction and return to idle state (we do not want to stay in
3379 * the transaction).
3380 */
3387 /*
3388 * Here, we are already in an aborted transaction state and are
3389 * waiting for a ROLLBACK, but for some reason we failed again! So
3390 * we just remain in the abort state.
3391 */
3396 /*
3397 * We are in a failed transaction and we got the ROLLBACK command.
3398 * We have already aborted, we just need to cleanup and go to idle
3399 * state.
3400 */
3406 /*
3407 * We are in a live transaction and we got a ROLLBACK command.
3408 * Abort, cleanup, go to idle state.
3409 */
3416 /*
3417 * Here, we failed while trying to PREPARE. Clean up the
3418 * transaction and return to idle state (we do not want to stay in
3419 * the transaction).
3420 */
3427 /*
3428 * We got an error inside a subtransaction. Abort just the
3429 * subtransaction, and go to the persistent SUBABORT state until
3430 * we get ROLLBACK.
3431 */
3437 /*
3438 * If we failed while trying to create a subtransaction, clean up
3439 * the broken subtransaction and abort the parent. The same
3440 * applies if we get a failure while ending a subtransaction.
3441 */
3452 /*
3453 * Same as above, except the Abort() was already done.
3454 */
3460 }
3461 }
3463 /*
3464 * PreventInTransactionBlock
3465 *
3466 * This routine is to be called by statements that must not run inside
3467 * a transaction block, typically because they have non-rollback-able
3468 * side effects or do internal commits.
3469 *
3470 * If this routine completes successfully, then the calling statement is
3471 * guaranteed that if it completes without error, its results will be
3472 * committed immediately.
3473 *
3474 * If we have already started a transaction block, issue an error; also issue
3475 * an error if we appear to be running inside a user-defined function (which
3476 * could issue more commands and possibly cause a failure after the statement
3477 * completes). Subtransactions are verboten too.
3478 *
3479 * We must also set XACT_FLAGS_NEEDIMMEDIATECOMMIT in MyXactFlags, to ensure
3480 * that postgres.c follows through by committing after the statement is done.
3481 *
3482 * isTopLevel: passed down from ProcessUtility to determine whether we are
3483 * inside a function. (We will always fail if this is false, but it's
3484 * convenient to centralize the check here instead of making callers do it.)
3485 * stmtType: statement type name, for error messages.
3486 */
3487 void
3489 {
3490 /*
3491 * xact block already started?
3492 */
3496 /* translator: %s represents an SQL statement name */
3498 stmtType)));
3500 /*
3501 * subtransaction?
3502 */
3506 /* translator: %s represents an SQL statement name */
3508 stmtType)));
3510 /*
3511 * inside a pipeline that has started an implicit transaction?
3512 */
3516 /* translator: %s represents an SQL statement name */
3518 stmtType)));
3520 /*
3521 * inside a function call?
3522 */
3526 /* translator: %s represents an SQL statement name */
3529 /* If we got past IsTransactionBlock test, should be in default state */
3534 /* All okay. Set the flag to make sure the right thing happens later. */
3536 }
3538 /*
3539 * WarnNoTransactionBlock
3540 * RequireTransactionBlock
3541 *
3542 * These two functions allow for warnings or errors if a command is executed
3543 * outside of a transaction block. This is useful for commands that have no
3544 * effects that persist past transaction end (and so calling them outside a
3545 * transaction block is presumably an error). DECLARE CURSOR is an example.
3546 * While top-level transaction control commands (BEGIN/COMMIT/ABORT) and SET
3547 * that have no effect issue warnings, all other no-effect commands generate
3548 * errors.
3549 *
3550 * If we appear to be running inside a user-defined function, we do not
3551 * issue anything, since the function could issue more commands that make
3552 * use of the current statement's results. Likewise subtransactions.
3553 * Thus these are inverses for PreventInTransactionBlock.
3554 *
3555 * isTopLevel: passed down from ProcessUtility to determine whether we are
3556 * inside a function.
3557 * stmtType: statement type name, for warning or error messages.
3558 */
3559 void
3561 {
3563 }
3565 void
3567 {
3569 }
3571 /*
3572 * This is the implementation of the above two.
3573 */
3574 static void
3576 {
3577 /*
3578 * xact block already started?
3579 */
3583 /*
3584 * subtransaction?
3585 */
3589 /*
3590 * inside a function call?
3591 */
3597 /* translator: %s represents an SQL statement name */
3599 stmtType)));
3600 }
3602 /*
3603 * IsInTransactionBlock
3604 *
3605 * This routine is for statements that need to behave differently inside
3606 * a transaction block than when running as single commands. ANALYZE is
3607 * currently the only example.
3608 *
3609 * If this routine returns "false", then the calling statement is allowed
3610 * to perform internal transaction-commit-and-start cycles; there is not a
3611 * risk of messing up any transaction already in progress. (Note that this
3612 * is not the identical guarantee provided by PreventInTransactionBlock,
3613 * since we will not force a post-statement commit.)
3614 *
3615 * isTopLevel: passed down from ProcessUtility to determine whether we are
3616 * inside a function.
3617 */
3618 bool
3620 {
3621 /*
3622 * Return true on same conditions that would make
3623 * PreventInTransactionBlock error out
3624 */
3642 }
3645 /*
3646 * Register or deregister callback functions for start- and end-of-xact
3647 * operations.
3648 *
3649 * These functions are intended for use by dynamically loaded modules.
3650 * For built-in modules we generally just hardwire the appropriate calls
3651 * (mainly because it's easier to control the order that way, where needed).
3652 *
3653 * At transaction end, the callback occurs post-commit or post-abort, so the
3654 * callback functions can only do noncritical cleanup.
3655 */
3656 void
3658 {
3667 }
3669 void
3671 {
3677 {
3679 {
3682 else
3686 }
3687 }
3688 }
3690 static void
3692 {
3697 {
3698 /* allow callbacks to unregister themselves when called */
3701 }
3702 }
3705 /*
3706 * Register or deregister callback functions for start- and end-of-subxact
3707 * operations.
3708 *
3709 * Pretty much same as above, but for subtransaction events.
3710 *
3711 * At subtransaction end, the callback occurs post-subcommit or post-subabort,
3712 * so the callback functions can only do noncritical cleanup. At
3713 * subtransaction start, the callback is called when the subtransaction has
3714 * finished initializing.
3715 */
3716 void
3718 {
3727 }
3729 void
3731 {
3737 {
3739 {
3742 else
3746 }
3747 }
3748 }
3750 static void
3752 SubTransactionId mySubid,
3753 SubTransactionId parentSubid)
3754 {
3759 {
3760 /* allow callbacks to unregister themselves when called */
3763 }
3764 }
3767 /* ----------------------------------------------------------------
3768 * transaction block support
3769 * ----------------------------------------------------------------
3770 */
3772 /*
3773 * BeginTransactionBlock
3774 * This executes a BEGIN command.
3775 */
3776 void
3778 {
3782 {
3783 /*
3784 * We are not inside a transaction block, so allow one to begin.
3785 */
3790 /*
3791 * BEGIN converts an implicit transaction block to a regular one.
3792 * (Note that we allow this even if we've already done some
3793 * commands, which is a bit odd but matches historical practice.)
3794 */
3799 /*
3800 * Already a transaction block in progress.
3801 */
3812 /* These cases are invalid. */
3829 }
3830 }
3832 /*
3833 * PrepareTransactionBlock
3834 * This executes a PREPARE command.
3835 *
3836 * Since PREPARE may actually do a ROLLBACK, the result indicates what
3837 * happened: true for PREPARE, false for ROLLBACK.
3838 *
3839 * Note that we don't actually do anything here except change blockState.
3840 * The real work will be done in the upcoming PrepareTransaction().
3841 * We do it this way because it's not convenient to change memory context,
3842 * resource owner, etc while executing inside a Portal.
3843 */
3844 bool
3846 {
3847 TransactionState s;
3850 /* Set up to commit the current transaction */
3853 /* If successful, change outer tblock state to PREPARE */
3855 {
3862 {
3863 /* Save GID where PrepareTransaction can find it again */
3867 }
3868 else
3869 {
3870 /*
3871 * ignore case where we are not in a transaction;
3872 * EndTransactionBlock already issued a warning.
3873 */
3876 /* Don't send back a PREPARE result tag... */
3878 }
3879 }
3882 }
3884 /*
3885 * EndTransactionBlock
3886 * This executes a COMMIT command.
3887 *
3888 * Since COMMIT may actually do a ROLLBACK, the result indicates what
3889 * happened: true for COMMIT, false for ROLLBACK.
3890 *
3891 * Note that we don't actually do anything here except change blockState.
3892 * The real work will be done in the upcoming CommitTransactionCommand().
3893 * We do it this way because it's not convenient to change memory context,
3894 * resource owner, etc while executing inside a Portal.
3895 */
3896 bool
3898 {
3903 {
3904 /*
3905 * We are in a transaction block, so tell CommitTransactionCommand
3906 * to COMMIT.
3907 */
3913 /*
3914 * We are in an implicit transaction block. If AND CHAIN was
3915 * specified, error. Otherwise commit, but issue a warning
3916 * because there was no explicit BEGIN before this.
3917 */
3922 /* translator: %s represents an SQL statement name */
3925 else
3933 /*
3934 * We are in a failed transaction block. Tell
3935 * CommitTransactionCommand it's time to exit the block.
3936 */
3941 /*
3942 * We are in a live subtransaction block. Set up to subcommit all
3943 * open subtransactions and then commit the main transaction.
3944 */
3947 {
3950 else
3954 }
3957 else
3963 /*
3964 * Here we are inside an aborted subtransaction. Treat the COMMIT
3965 * as ROLLBACK: set up to abort everything and exit the main
3966 * transaction.
3967 */
3970 {
3975 else
3979 }
3984 else
3989 /*
3990 * The user issued COMMIT when not inside a transaction. For
3991 * COMMIT without CHAIN, issue a WARNING, staying in
3992 * TBLOCK_STARTED state. The upcoming call to
3993 * CommitTransactionCommand() will then close the transaction and
3994 * put us back into the default state. For COMMIT AND CHAIN,
3995 * error.
3996 */
4001 /* translator: %s represents an SQL statement name */
4004 else
4011 /*
4012 * The user issued a COMMIT that somehow ran inside a parallel
4013 * worker. We can't cope with that.
4014 */
4021 /* These cases are invalid. */
4038 }
4048 }
4050 /*
4051 * UserAbortTransactionBlock
4052 * This executes a ROLLBACK command.
4053 *
4054 * As above, we don't actually do anything here except change blockState.
4055 */
4056 void
4058 {
4062 {
4063 /*
4064 * We are inside a transaction block and we got a ROLLBACK command
4065 * from the user, so tell CommitTransactionCommand to abort and
4066 * exit the transaction block.
4067 */
4072 /*
4073 * We are inside a failed transaction block and we got a ROLLBACK
4074 * command from the user. Abort processing is already done, so
4075 * CommitTransactionCommand just has to cleanup and go back to
4076 * idle state.
4077 */
4082 /*
4083 * We are inside a subtransaction. Mark everything up to top
4084 * level as exitable.
4085 */
4089 {
4094 else
4098 }
4103 else
4108 /*
4109 * The user issued ABORT when not inside a transaction. For
4110 * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4111 * The upcoming call to CommitTransactionCommand() will then put
4112 * us back into the default state. For ROLLBACK AND CHAIN, error.
4113 *
4114 * We do the same thing with ABORT inside an implicit transaction,
4115 * although in this case we might be rolling back actual database
4116 * state changes. (It's debatable whether we should issue a
4117 * WARNING in this case, but we have done so historically.)
4118 */
4124 /* translator: %s represents an SQL statement name */
4127 else
4134 /*
4135 * The user issued an ABORT that somehow ran inside a parallel
4136 * worker. We can't cope with that.
4137 */
4144 /* These cases are invalid. */
4161 }
4167 }
4169 /*
4170 * BeginImplicitTransactionBlock
4171 * Start an implicit transaction block if we're not already in one.
4172 *
4173 * Unlike BeginTransactionBlock, this is called directly from the main loop
4174 * in postgres.c, not within a Portal. So we can just change blockState
4175 * without a lot of ceremony. We do not expect caller to do
4176 * CommitTransactionCommand/StartTransactionCommand.
4177 */
4178 void
4180 {
4183 /*
4184 * If we are in STARTED state (that is, no transaction block is open),
4185 * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4186 * block.
4187 *
4188 * For caller convenience, we consider all other transaction states as
4189 * legal here; otherwise the caller would need its own state check, which
4190 * seems rather pointless.
4191 */
4194 }
4196 /*
4197 * EndImplicitTransactionBlock
4198 * End an implicit transaction block, if we're in one.
4199 *
4200 * Like EndTransactionBlock, we just make any needed blockState change here.
4201 * The real work will be done in the upcoming CommitTransactionCommand().
4202 */
4203 void
4205 {
4208 /*
4209 * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4210 * allowing CommitTransactionCommand to commit whatever happened during
4211 * the implicit transaction block as though it were a single statement.
4212 *
4213 * For caller convenience, we consider all other transaction states as
4214 * legal here; otherwise the caller would need its own state check, which
4215 * seems rather pointless.
4216 */
4219 }
4221 /*
4222 * DefineSavepoint
4223 * This executes a SAVEPOINT command.
4224 */
4225 void
4227 {
4230 /*
4231 * Workers synchronize transaction state at the beginning of each parallel
4232 * operation, so we can't account for new subtransactions after that
4233 * point. (Note that this check will certainly error out if s->blockState
4234 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4235 * below.)
4236 */
4243 {
4246 /* Normal subtransaction start */
4250 /*
4251 * Savepoint names, like the TransactionState block itself, live
4252 * in TopTransactionContext.
4253 */
4258 /*
4259 * We disallow savepoint commands in implicit transaction blocks.
4260 * There would be no great difficulty in allowing them so far as
4261 * this module is concerned, but a savepoint seems inconsistent
4262 * with exec_simple_query's behavior of abandoning the whole query
4263 * string upon error. Also, the point of an implicit transaction
4264 * block (as opposed to a regular one) is to automatically close
4265 * after an error, so it's hard to see how a savepoint would fit
4266 * into that.
4267 *
4268 * The error messages for this are phrased as if there were no
4269 * active transaction block at all, which is historical but
4270 * perhaps could be improved.
4271 */
4275 /* translator: %s represents an SQL statement name */
4280 /* These cases are invalid. */
4301 }
4302 }
4304 /*
4305 * ReleaseSavepoint
4306 * This executes a RELEASE command.
4307 *
4308 * As above, we don't actually do anything here except change blockState.
4309 */
4310 void
4312 {
4314 TransactionState target,
4315 xact;
4317 /*
4318 * Workers synchronize transaction state at the beginning of each parallel
4319 * operation, so we can't account for transaction state change after that
4320 * point. (Note that this check will certainly error out if s->blockState
4321 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4322 * below.)
4323 */
4330 {
4331 /*
4332 * We can't release a savepoint if there is no savepoint defined.
4333 */
4341 /* See comment about implicit transactions in DefineSavepoint */
4344 /* translator: %s represents an SQL statement name */
4349 /*
4350 * We are in a non-aborted subtransaction. This is the only valid
4351 * case.
4352 */
4356 /* These cases are invalid. */
4377 }
4380 {
4383 }
4390 /* disallow crossing savepoint level boundaries */
4396 /*
4397 * Mark "commit pending" all subtransactions up to the target
4398 * subtransaction. The actual commits will happen when control gets to
4399 * CommitTransactionCommand.
4400 */
4403 {
4410 }
4411 }
4413 /*
4414 * RollbackToSavepoint
4415 * This executes a ROLLBACK TO <savepoint> command.
4416 *
4417 * As above, we don't actually do anything here except change blockState.
4418 */
4419 void
4421 {
4423 TransactionState target,
4424 xact;
4426 /*
4427 * Workers synchronize transaction state at the beginning of each parallel
4428 * operation, so we can't account for transaction state change after that
4429 * point. (Note that this check will certainly error out if s->blockState
4430 * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4431 * below.)
4432 */
4439 {
4440 /*
4441 * We can't rollback to a savepoint if there is no savepoint
4442 * defined.
4443 */
4452 /* See comment about implicit transactions in DefineSavepoint */
4455 /* translator: %s represents an SQL statement name */
4460 /*
4461 * There is at least one savepoint, so proceed.
4462 */
4467 /* These cases are invalid. */
4486 }
4489 {
4492 }
4499 /* disallow crossing savepoint level boundaries */
4505 /*
4506 * Mark "abort pending" all subtransactions up to the target
4507 * subtransaction. The actual aborts will happen when control gets to
4508 * CommitTransactionCommand.
4509 */
4512 {
4519 else
4524 }
4526 /* And mark the target as "restart pending" */
4531 else
4534 }
4536 /*
4537 * BeginInternalSubTransaction
4538 * This is the same as DefineSavepoint except it allows TBLOCK_STARTED,
4539 * TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_END, and TBLOCK_PREPARE states,
4540 * and therefore it can safely be used in functions that might be called
4541 * when not inside a BEGIN block or when running deferred triggers at
4542 * COMMIT/PREPARE time. Also, it automatically does
4543 * CommitTransactionCommand/StartTransactionCommand instead of expecting
4544 * the caller to do it.
4545 */
4546 void
4548 {
4551 /*
4552 * Workers synchronize transaction state at the beginning of each parallel
4553 * operation, so we can't account for new subtransactions after that
4554 * point. We might be able to make an exception for the type of
4555 * subtransaction established by this function, which is typically used in
4556 * contexts where we're going to release or roll back the subtransaction
4557 * before proceeding further, so that no enduring change to the
4558 * transaction state occurs. For now, however, we prohibit this case along
4559 * with all the others.
4560 */
4567 {
4574 /* Normal subtransaction start */
4578 /*
4579 * Savepoint names, like the TransactionState block itself, live
4580 * in TopTransactionContext.
4581 */
4586 /* These cases are invalid. */
4604 }
4608 }
4610 /*
4611 * ReleaseCurrentSubTransaction
4612 *
4613 * RELEASE (ie, commit) the innermost subtransaction, regardless of its
4614 * savepoint name (if any).
4615 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4616 */
4617 void
4619 {
4622 /*
4623 * Workers synchronize transaction state at the beginning of each parallel
4624 * operation, so we can't account for commit of subtransactions after that
4625 * point. This should not happen anyway. Code calling this would
4626 * typically have called BeginInternalSubTransaction() first, failing
4627 * there.
4628 */
4642 }
4644 /*
4645 * RollbackAndReleaseCurrentSubTransaction
4646 *
4647 * ROLLBACK and RELEASE (ie, abort) the innermost subtransaction, regardless
4648 * of its savepoint name (if any).
4649 * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4650 */
4651 void
4653 {
4656 /*
4657 * Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
4658 * during parallel operations. That's because we may be in the leader,
4659 * recovering from an error thrown while we were in parallel mode. We
4660 * won't reach here in a worker, because BeginInternalSubTransaction()
4661 * will have failed.
4662 */
4665 {
4666 /* Must be in a subtransaction */
4671 /* These cases are invalid. */
4693 }
4695 /*
4696 * Abort the current subtransaction, if needed.
4697 */
4701 /* And clean it up, too */
4709 }
4711 /*
4712 * AbortOutOfAnyTransaction
4713 *
4714 * This routine is provided for error recovery purposes. It aborts any
4715 * active transaction or transaction block, leaving the system in a known
4716 * idle state.
4717 */
4718 void
4720 {
4723 /* Ensure we're not running in a doomed memory context */
4726 /*
4727 * Get out of any transaction or nested transaction
4728 */
4729 do
4730 {
4732 {
4735 {
4736 /* Not in a transaction, do nothing */
4737 }
4738 else
4739 {
4740 /*
4741 * We can get here after an error during transaction start
4742 * (state will be TRANS_START). Need to clean up the
4743 * incompletely started transaction. First, adjust the
4744 * low-level state to suppress warning message from
4745 * AbortTransaction.
4746 */
4751 }
4761 /* In a transaction, so clean up */
4769 /*
4770 * AbortTransaction is already done, still need Cleanup.
4771 * However, if we failed partway through running ROLLBACK,
4772 * there will be an active portal running that command, which
4773 * we need to shut down before doing CleanupTransaction.
4774 */
4780 /*
4781 * In a subtransaction, so clean it up and abort parent too
4782 */
4797 /* As above, but AbortSubTransaction already done */
4799 {
4800 /* As in TBLOCK_ABORT, might have a live portal to zap */
4805 }
4809 }
4812 /* Should be out of all subxacts now */
4815 /* If we didn't actually have anything to do, revert to TopMemoryContext */
4817 }
4819 /*
4820 * IsTransactionBlock --- are we within a transaction block?
4821 */
4822 bool
4824 {
4831 }
4833 /*
4834 * IsTransactionOrTransactionBlock --- are we within either a transaction
4835 * or a transaction block? (The backend is only really "idle" when this
4836 * returns false.)
4837 *
4838 * This should match up with IsTransactionBlock and IsTransactionState.
4839 */
4840 bool
4842 {
4849 }
4851 /*
4852 * TransactionBlockStatusCode - return status code to send in ReadyForQuery
4853 */
4854 char
4856 {
4860 {
4884 }
4886 /* should never get here */
4890 }
4892 /*
4893 * IsSubTransaction
4894 */
4895 bool
4897 {
4904 }
4906 /*
4907 * StartSubTransaction
4908 *
4909 * If you're wondering why this is separate from PushTransaction: it's because
4910 * we can't conveniently do this stuff right inside DefineSavepoint. The
4911 * SAVEPOINT utility command will be executed inside a Portal, and if we
4912 * muck with CurrentMemoryContext or CurrentResourceOwner then exit from
4913 * the Portal will undo those settings. So we make DefineSavepoint just
4914 * push a dummy transaction block, and when control returns to the main
4915 * idle loop, CommitTransactionCommand will be called, and we'll come here
4916 * to finish starting the subtransaction.
4917 */
4918 static void
4920 {
4929 /*
4930 * Initialize subsystems for new subtransaction
4931 *
4932 * must initialize resource-management stuff first
4933 */
4940 /*
4941 * Call start-of-subxact callbacks
4942 */
4947 }
4949 /*
4950 * CommitSubTransaction
4951 *
4952 * The caller has to make sure to always reassign CurrentTransactionState
4953 * if it has a local pointer to it after calling this function.
4954 */
4955 static void
4957 {
4966 /* Pre-commit processing goes here */
4971 /* If in parallel mode, clean up workers and exit parallel mode. */
4973 {
4976 }
4978 /* Do the actual "commit", such as it is */
4981 /* Must CCI to ensure commands of subtransaction are seen as done */
4984 /*
4985 * Prior to 8.4 we marked subcommit in clog at this point. We now only
4986 * perform that step, if required, as part of the atomic update of the
4987 * whole transaction tree at top level commit or abort.
4988 */
4990 /* Post-commit cleanup */
5006 RESOURCE_RELEASE_BEFORE_LOCKS,
5013 /*
5014 * The only lock we actually release here is the subtransaction XID lock.
5015 */
5020 /*
5021 * Other locks should get transferred to their parent resource owner.
5022 */
5024 RESOURCE_RELEASE_LOCKS,
5027 RESOURCE_RELEASE_AFTER_LOCKS,
5042 /*
5043 * We need to restore the upper transaction's read-only state, in case the
5044 * upper is read-write while the child is read-only; GUC will incorrectly
5045 * think it should leave the child state in place.
5046 */
5059 }
5061 /*
5062 * AbortSubTransaction
5063 */
5064 static void
5066 {
5069 /* Prevent cancel/die interrupt while cleaning up */
5072 /* Make sure we have a valid memory context and resource owner */
5076 /*
5077 * Release any LW locks we might be holding as quickly as possible.
5078 * (Regular locks, however, must be held till we finish aborting.)
5079 * Releasing LW locks is critical since we might try to grab them again
5080 * while cleaning up!
5081 *
5082 * FIXME This may be incorrect --- Are there some locks we should keep?
5083 * Buffer locks, for example? I don't think so but I'm not sure.
5084 */
5092 /* Reset WAL record construction state */
5095 /* Cancel condition variable sleep */
5098 /*
5099 * Also clean up any open wait for lock, since the lock manager will choke
5100 * if we try to wait for another lock before doing this.
5101 */
5104 /*
5105 * If any timeout events are still active, make sure the timeout interrupt
5106 * is scheduled. This covers possible loss of a timeout interrupt due to
5107 * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
5108 * We delay this till after LockErrorCleanup so that we don't uselessly
5109 * reschedule lock or deadlock check timeouts.
5110 */
5113 /*
5114 * Re-enable signals, in case we got here by longjmp'ing out of a signal
5115 * handler. We do this fairly early in the sequence so that the timeout
5116 * infrastructure will be functional if needed while aborting.
5117 */
5120 /*
5121 * check the current transaction state
5122 */
5131 /*
5132 * Reset user ID which might have been changed transiently. (See notes in
5133 * AbortTransaction.)
5134 */
5137 /* Forget about any active REINDEX. */
5140 /* Reset logical streaming state. */
5143 /*
5144 * No need for SnapBuildResetExportedSnapshotState() here, snapshot
5145 * exports are not supported in subtransactions.
5146 */
5148 /* Exit from parallel mode, if necessary. */
5150 {
5153 }
5155 /*
5156 * We can skip all this stuff if the subxact failed before creating a
5157 * ResourceOwner...
5158 */
5160 {
5170 /* Advertise the fact that we aborted in pg_xact. */
5173 /* Post-abort cleanup */
5181 RESOURCE_RELEASE_BEFORE_LOCKS,
5187 RESOURCE_RELEASE_LOCKS,
5190 RESOURCE_RELEASE_AFTER_LOCKS,
5205 }
5207 /*
5208 * Restore the upper transaction's read-only state, too. This should be
5209 * redundant with GUC's cleanup but we may as well do it for consistency
5210 * with the commit case.
5211 */
5215 }
5217 /*
5218 * CleanupSubTransaction
5219 *
5220 * The caller has to make sure to always reassign CurrentTransactionState
5221 * if it has a local pointer to it after calling this function.
5222 */
5223 static void
5225 {
5247 }
5249 /*
5250 * PushTransaction
5251 * Create transaction state stack entry for a subtransaction
5252 *
5253 * The caller has to make sure to always reassign CurrentTransactionState
5254 * if it has a local pointer to it after calling this function.
5255 */
5256 static void
5258 {
5260 TransactionState s;
5262 /*
5263 * We keep subtransaction state nodes in TopTransactionContext.
5264 */
5269 /*
5270 * Assign a subtransaction ID, watching out for counter wraparound.
5271 */
5274 {
5280 }
5282 /*
5283 * We can now stack a minimally valid subtransaction without fear of
5284 * failure.
5285 */
5301 /*
5302 * AbortSubTransaction and CleanupSubTransaction have to be able to cope
5303 * with the subtransaction from here on out; in particular they should not
5304 * assume that it necessarily has a transaction context, resource owner,
5305 * or XID.
5306 */
5307 }
5309 /*
5310 * PopTransaction
5311 * Pop back to parent transaction state
5312 *
5313 * The caller has to make sure to always reassign CurrentTransactionState
5314 * if it has a local pointer to it after calling this function.
5315 */
5316 static void
5318 {
5330 /* Let's just make sure CurTransactionContext is good */
5334 /* Ditto for ResourceOwner links */
5338 /* Free the old child structure */
5342 }
5344 /*
5345 * EstimateTransactionStateSpace
5346 * Estimate the amount of space that will be needed by
5347 * SerializeTransactionState. It would be OK to overestimate slightly,
5348 * but it's simple for us to work out the precise value, so we do.
5349 */
5350 Size
5352 {
5353 TransactionState s;
5358 {
5362 }
5365 }
5367 /*
5368 * SerializeTransactionState
5369 * Write out relevant details of our transaction state that will be
5370 * needed by a parallel worker.
5371 *
5372 * We need to save and restore XactDeferrable, XactIsoLevel, and the XIDs
5373 * associated with this transaction. These are serialized into a
5374 * caller-supplied buffer big enough to hold the number of bytes reported by
5375 * EstimateTransactionStateSpace(). We emit the XIDs in sorted order for the
5376 * convenience of the receiving process.
5377 */
5378 void
5380 {
5381 TransactionState s;
5396 /*
5397 * If we're running in a parallel worker and launching a parallel worker
5398 * of our own, we can just pass along the information that was passed to
5399 * us.
5400 */
5402 {
5407 }
5409 /*
5410 * OK, we need to generate a sorted list of XIDs that our workers should
5411 * view as current. First, figure out how many there are.
5412 */
5414 {
5418 }
5422 /* Copy them to our scratch space. */
5425 {
5432 }
5435 /* Sort them. */
5438 /* Copy data into output area. */
5442 }
5444 /*
5445 * StartParallelWorkerTransaction
5446 * Start a parallel worker transaction, restoring the relevant
5447 * transaction state serialized by SerializeTransactionState.
5448 */
5449 void
5451 {
5468 }
5470 /*
5471 * EndParallelWorkerTransaction
5472 * End a parallel worker transaction.
5473 */
5474 void
5476 {
5480 }
5482 /*
5483 * ShowTransactionState
5484 * Debug support
5485 */
5486 static void
5488 {
5489 /* skip work if message will definitely not be printed */
5492 }
5494 /*
5495 * ShowTransactionStateRec
5496 * Recursive subroutine for ShowTransactionState
5497 */
5498 static void
5500 {
5501 StringInfoData buf;
5506 {
5512 }
5530 }
5532 /*
5533 * BlockStateAsString
5534 * Debug support
5535 */
5538 {
5540 {
5581 }
5583 }
5585 /*
5586 * TransStateAsString
5587 * Debug support
5588 */
5591 {
5593 {
5606 }
5608 }
5610 /*
5611 * xactGetCommittedChildren
5612 *
5613 * Gets the list of committed children of the current transaction. The return
5614 * value is the number of child transactions. *ptr is set to point to an
5615 * array of TransactionIds. The array is allocated in TopTransactionContext;
5616 * the caller should *not* pfree() it (this is a change from pre-8.4 code!).
5617 * If there are no subxacts, *ptr is set to NULL.
5618 */
5619 int
5621 {
5626 else
5630 }
5632 /*
5633 * XLOG support routines
5634 */
5637 /*
5638 * Log the commit record for a plain or twophase transaction commit.
5639 *
5640 * A 2pc commit will be emitted when twophase_xid is valid, a plain one
5641 * otherwise.
5642 */
5643 XLogRecPtr
5652 {
5653 xl_xact_commit xlrec;
5654 xl_xact_xinfo xl_xinfo;
5655 xl_xact_dbinfo xl_dbinfo;
5656 xl_xact_subxacts xl_subxacts;
5657 xl_xact_relfilelocators xl_relfilelocators;
5658 xl_xact_stats_items xl_dropped_stats;
5659 xl_xact_invals xl_invals;
5660 xl_xact_twophase xl_twophase;
5661 xl_xact_origin xl_origin;
5662 uint8 info;
5668 /* decide between a plain and 2pc commit */
5671 else
5674 /* First figure out and collect all the information needed */
5685 /*
5686 * Check if the caller would like to ask standbys for immediate feedback
5687 * once this commit is applied.
5688 */
5692 /*
5693 * Relcache invalidations requires information about the current database
5694 * and so does logical decoding.
5695 */
5697 {
5701 }
5704 {
5707 }
5710 {
5714 }
5717 {
5720 }
5723 {
5726 }
5729 {
5736 }
5738 /* dump transaction origin information */
5740 {
5745 }
5750 /* Then include all the collected data into the commit record. */
5763 {
5765 MinSizeOfXactSubxacts);
5768 }
5771 {
5773 MinSizeOfXactRelfileLocators);
5776 }
5779 {
5781 MinSizeOfXactStatsItems);
5784 }
5787 {
5791 }
5794 {
5798 }
5803 /* we allow filtering by xacts */
5807 }
5809 /*
5810 * Log the commit record for a plain or twophase transaction abort.
5811 *
5812 * A 2pc abort will be emitted when twophase_xid is valid, a plain one
5813 * otherwise.
5814 */
5815 XLogRecPtr
5822 {
5823 xl_xact_abort xlrec;
5824 xl_xact_xinfo xl_xinfo;
5825 xl_xact_subxacts xl_subxacts;
5826 xl_xact_relfilelocators xl_relfilelocators;
5827 xl_xact_stats_items xl_dropped_stats;
5828 xl_xact_twophase xl_twophase;
5829 xl_xact_dbinfo xl_dbinfo;
5830 xl_xact_origin xl_origin;
5832 uint8 info;
5838 /* decide between a plain and 2pc abort */
5841 else
5845 /* First figure out and collect all the information needed */
5853 {
5856 }
5859 {
5863 }
5866 {
5869 }
5872 {
5879 }
5882 {
5886 }
5888 /*
5889 * Dump transaction origin information. We need this during recovery to
5890 * update the replication origin progress.
5891 */
5893 {
5898 }
5903 /* Then include all the collected data into the abort record. */
5916 {
5918 MinSizeOfXactSubxacts);
5921 }
5924 {
5926 MinSizeOfXactRelfileLocators);
5929 }
5932 {
5934 MinSizeOfXactStatsItems);
5937 }
5940 {
5944 }
5949 /* Include the replication origin */
5953 }
5955 /*
5956 * Before 9.0 this was a fairly short function, but now it performs many
5957 * actions for which the order of execution is critical.
5958 */
5959 static void
5961 TransactionId xid,
5962 XLogRecPtr lsn,
5963 RepOriginId origin_id)
5964 {
5965 TransactionId max_xid;
5966 TimestampTz commit_time;
5972 /* Make sure nextXid is beyond any XID mentioned in the record. */
5980 else
5983 /* Set the transaction commit timestamp and metadata */
5988 {
5989 /*
5990 * Mark the transaction committed in pg_xact.
5991 */
5993 }
5994 else
5995 {
5996 /*
5997 * If a transaction completion record arrives that has as-yet
5998 * unobserved subtransactions then this will not have been fully
5999 * handled by the call to RecordKnownAssignedTransactionIds() in the
6000 * main recovery loop in xlog.c. So we need to do bookkeeping again to
6001 * cover that case. This is confusing and it is easy to think this
6002 * call is irrelevant, which has happened three times in development
6003 * already. Leave it in.
6004 */
6007 /*
6008 * Mark the transaction committed in pg_xact. We use async commit
6009 * protocol during recovery to provide information on database
6010 * consistency for when users try to set hint bits. It is important
6011 * that we do not set hint bits until the minRecoveryPoint is past
6012 * this commit record. This ensures that if we crash we don't see hint
6013 * bits set on changes made by transactions that haven't yet
6014 * recovered. It's unlikely but it's good to be safe.
6015 */
6018 /*
6019 * We must mark clog before we update the ProcArray.
6020 */
6023 /*
6024 * Send any cache invalidations attached to the commit. We must
6025 * maintain the same order of invalidation then release locks as
6026 * occurs in CommitTransaction().
6027 */
6032 /*
6033 * Release locks, if any. We do this for both two phase and normal one
6034 * phase transactions. In effect we are ignoring the prepare phase and
6035 * just going straight to lock release.
6036 */
6039 }
6042 {
6043 /* recover apply progress */
6046 }
6048 /* Make sure files supposed to be dropped are dropped */
6050 {
6051 /*
6052 * First update minimum recovery point to cover this WAL record. Once
6053 * a relation is deleted, there's no going back. The buffer manager
6054 * enforces the WAL-first rule for normal updates to relation files,
6055 * so that the minimum recovery point is always updated before the
6056 * corresponding change in the data file is flushed to disk, but we
6057 * have to do the same here since we're bypassing the buffer manager.
6058 *
6059 * Doing this before deleting the files means that if a deletion fails
6060 * for some reason, you cannot start up the system even after restart,
6061 * until you fix the underlying situation so that the deletion will
6062 * succeed. Alternatively, we could update the minimum recovery point
6063 * after deletion, but that would leave a small window where the
6064 * WAL-first rule would be violated.
6065 */
6068 /* Make sure files supposed to be dropped are dropped */
6070 }
6073 {
6074 /* see equivalent call for relations above */
6078 }
6080 /*
6081 * We issue an XLogFlush() for the same reason we emit ForceSyncCommit()
6082 * in normal operation. For example, in CREATE DATABASE, we copy all files
6083 * from the template database, and then commit the transaction. If we
6084 * crash after all the files have been copied but before the commit, you
6085 * have files in the data directory without an entry in pg_database. To
6086 * minimize the window for that, we use ForceSyncCommit() to rush the
6087 * commit record to disk as quick as possible. We have the same window
6088 * during recovery, and forcing an XLogFlush() (which updates
6089 * minRecoveryPoint during recovery) helps to reduce that problem window,
6090 * for any user that requested ForceSyncCommit().
6091 */
6095 /*
6096 * If asked by the primary (because someone is waiting for a synchronous
6097 * commit = remote_apply), we will need to ask walreceiver to send a reply
6098 * immediately.
6099 */
6102 }
6104 /*
6105 * Be careful with the order of execution, as with xact_redo_commit().
6106 * The two functions are similar but differ in key places.
6107 *
6108 * Note also that an abort can be for a subtransaction and its children,
6109 * not just for a top level abort. That means we have to consider
6110 * topxid != xid, whereas in commit we would find topxid == xid always
6111 * because subtransaction commit is never WAL logged.
6112 */
6113 static void
6116 {
6117 TransactionId max_xid;
6121 /* Make sure nextXid is beyond any XID mentioned in the record. */
6128 {
6129 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6131 }
6132 else
6133 {
6134 /*
6135 * If a transaction completion record arrives that has as-yet
6136 * unobserved subtransactions then this will not have been fully
6137 * handled by the call to RecordKnownAssignedTransactionIds() in the
6138 * main recovery loop in xlog.c. So we need to do bookkeeping again to
6139 * cover that case. This is confusing and it is easy to think this
6140 * call is irrelevant, which has happened three times in development
6141 * already. Leave it in.
6142 */
6145 /* Mark the transaction aborted in pg_xact, no need for async stuff */
6148 /*
6149 * We must update the ProcArray after we have marked clog.
6150 */
6153 /*
6154 * There are no invalidation messages to send or undo.
6155 */
6157 /*
6158 * Release locks, if any. There are no invalidations to send.
6159 */
6162 }
6165 {
6166 /* recover apply progress */
6169 }
6171 /* Make sure files supposed to be dropped are dropped */
6173 {
6174 /*
6175 * See comments about update of minimum recovery point on truncation,
6176 * in xact_redo_commit().
6177 */
6181 }
6184 {
6185 /* see equivalent call for relations above */
6189 }
6190 }
6192 void
6194 {
6197 /* Backup blocks are not used in xact records */
6201 {
6203 xl_xact_parsed_commit parsed;
6208 }
6210 {
6212 xl_xact_parsed_commit parsed;
6218 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6222 }
6224 {
6226 xl_xact_parsed_abort parsed;
6231 }
6233 {
6235 xl_xact_parsed_abort parsed;
6241 /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6245 }
6247 {
6248 /*
6249 * Store xid and start/end pointers of the WAL record in TwoPhaseState
6250 * gxact entry.
6251 */
6258 }
6260 {
6266 }
6268 {
6269 /*
6270 * XXX we do ignore this for now, what matters are invalidations
6271 * written into the commit record.
6272 */
6273 }
6274 else
6276 }