#include "postgres.h"
#include "access/clog.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "utils/snapmgr.h"

Include dependency graph for transam.c:

Functions
static XidStatus	TransactionLogFetch (TransactionId transactionId)

bool	TransactionIdDidCommit (TransactionId transactionId)

bool	TransactionIdDidAbort (TransactionId transactionId)

void	TransactionIdCommitTree (TransactionId xid, int nxids, TransactionId *xids)

void	TransactionIdAsyncCommitTree (TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn)

void	TransactionIdAbortTree (TransactionId xid, int nxids, TransactionId *xids)

bool	TransactionIdPrecedes (TransactionId id1, TransactionId id2)

bool	TransactionIdPrecedesOrEquals (TransactionId id1, TransactionId id2)

bool	TransactionIdFollows (TransactionId id1, TransactionId id2)

bool	TransactionIdFollowsOrEquals (TransactionId id1, TransactionId id2)

TransactionId	TransactionIdLatest (TransactionId mainxid, int nxids, const TransactionId *xids)

XLogRecPtr	TransactionIdGetCommitLSN (TransactionId xid)

Variables
static TransactionId	cachedFetchXid = InvalidTransactionId

static XidStatus	cachedFetchXidStatus

static XLogRecPtr	cachedCommitLSN

Function Documentation

◆ TransactionIdAbortTree()

void TransactionIdAbortTree	(	TransactionId	xid,
		int	nxids,
		TransactionId *	xids
	)

Definition at line 270 of file transam.c.

 {
     TransactionIdSetTreeStatus(xid, nxids, xids,
                                TRANSACTION_STATUS_ABORTED, InvalidXLogRecPtr);
 }

References InvalidXLogRecPtr, TRANSACTION_STATUS_ABORTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionAbort(), RecordTransactionAbortPrepared(), and xact_redo_abort().

◆ TransactionIdAsyncCommitTree()

void TransactionIdAsyncCommitTree	(	TransactionId	xid,
		int	nxids,
		TransactionId *	xids,
		XLogRecPtr	lsn
	)

Definition at line 252 of file transam.c.

 {
     TransactionIdSetTreeStatus(xid, nxids, xids,
                                TRANSACTION_STATUS_COMMITTED, lsn);
 }

References TRANSACTION_STATUS_COMMITTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionCommit(), and xact_redo_commit().

◆ TransactionIdCommitTree()

void TransactionIdCommitTree	(	TransactionId	xid,
		int	nxids,
		TransactionId *	xids
	)

Definition at line 240 of file transam.c.

 {
     TransactionIdSetTreeStatus(xid, nxids, xids,
                                TRANSACTION_STATUS_COMMITTED,
                                InvalidXLogRecPtr);
 }

References InvalidXLogRecPtr, TRANSACTION_STATUS_COMMITTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionCommit(), RecordTransactionCommitPrepared(), and xact_redo_commit().

◆ TransactionIdDidAbort()

bool TransactionIdDidAbort ( TransactionId transactionId )

Definition at line 188 of file transam.c.

 {
     XidStatus   xidstatus;
  
     xidstatus = TransactionLogFetch(transactionId);
  
     /*
      * If it's marked aborted, it's aborted.
      */
     if (xidstatus == TRANSACTION_STATUS_ABORTED)
         return true;
  
     /*
      * If it's marked subcommitted, we have to check the parent recursively.
      * However, if it's older than TransactionXmin, we can't look at
      * pg_subtrans; instead assume that the parent crashed without cleaning up
      * its children.
      */
     if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
     {
         TransactionId parentXid;
  
         if (TransactionIdPrecedes(transactionId, TransactionXmin))
             return true;
         parentXid = SubTransGetParent(transactionId);
         if (!TransactionIdIsValid(parentXid))
         {
             /* see notes in TransactionIdDidCommit */
             elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
                  transactionId);
             return true;
         }
         return TransactionIdDidAbort(parentXid);
     }
  
     /*
      * It's not aborted.
      */
     return false;
 }

References elog, SubTransGetParent(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by DoesMultiXactIdConflict(), heap_lock_updated_tuple_rec(), heap_update(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), and TransactionIdIsInProgress().

◆ TransactionIdDidCommit()

bool TransactionIdDidCommit ( TransactionId transactionId )

Definition at line 126 of file transam.c.

 {
     XidStatus   xidstatus;
  
     xidstatus = TransactionLogFetch(transactionId);
  
     /*
      * If it's marked committed, it's committed.
      */
     if (xidstatus == TRANSACTION_STATUS_COMMITTED)
         return true;
  
     /*
      * If it's marked subcommitted, we have to check the parent recursively.
      * However, if it's older than TransactionXmin, we can't look at
      * pg_subtrans; instead assume that the parent crashed without cleaning up
      * its children.
      *
      * Originally we Assert'ed that the result of SubTransGetParent was not
      * zero. However with the introduction of prepared transactions, there can
      * be a window just after database startup where we do not have complete
      * knowledge in pg_subtrans of the transactions after TransactionXmin.
      * StartupSUBTRANS() has ensured that any missing information will be
      * zeroed.  Since this case should not happen under normal conditions, it
      * seems reasonable to emit a WARNING for it.
      */
     if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
     {
         TransactionId parentXid;
  
         if (TransactionIdPrecedes(transactionId, TransactionXmin))
             return false;
         parentXid = SubTransGetParent(transactionId);
         if (!TransactionIdIsValid(parentXid))
         {
             elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
                  transactionId);
             return false;
         }
         return TransactionIdDidCommit(parentXid);
     }
  
     /*
      * It's not committed.
      */
     return false;
 }

References elog, SubTransGetParent(), TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by asyncQueueProcessPageEntries(), check_safe_enum_use(), compute_new_xmax_infomask(), FreezeMultiXactId(), HandleConcurrentAbort(), heap_pre_freeze_checks(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), MultiXactIdExpand(), pg_xact_status(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), SetupCheckXidLive(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), UpdateLogicalMappings(), and UpdateXmaxHintBits().

◆ TransactionIdFollows()

bool TransactionIdFollows	(	TransactionId	id1,
		TransactionId	id2
	)

Definition at line 314 of file transam.c.

 {
     int32       diff;
  
     if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
         return (id1 > id2);
  
     diff = (int32) (id1 - id2);
     return (diff > 0);
 }

References TransactionIdIsNormal.

Referenced by find_inheritance_children_extended(), GetConflictingVirtualXIDs(), GetSerializableTransactionSnapshotInt(), heap_page_is_all_visible(), heap_page_prune_and_freeze(), heap_prune_record_unchanged_lp_normal(), HeapTupleHeaderAdvanceConflictHorizon(), predicatelock_twophase_recover(), ProcessTwoPhaseBuffer(), RecordKnownAssignedTransactionIds(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialSetActiveSerXmin(), SnapBuildInitialSnapshot(), SnapBuildWaitSnapshot(), SubTransSetParent(), update_local_synced_slot(), and xmin_cmp().

◆ TransactionIdFollowsOrEquals()

bool TransactionIdFollowsOrEquals	(	TransactionId	id1,
		TransactionId	id2
	)

Definition at line 329 of file transam.c.

 {
     int32       diff;
  
     if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
         return (id1 >= id2);
  
     diff = (int32) (id1 - id2);
     return (diff >= 0);
 }

References TransactionIdIsNormal.

Referenced by AdvanceNextFullTransactionIdPastXid(), ForceTransactionIdLimitUpdate(), GetNewTransactionId(), HeapCheckForSerializableConflictOut(), HeapTupleSatisfiesHistoricMVCC(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsRemovePreceding(), ProcessTwoPhaseBuffer(), SetTransactionIdLimit(), SnapBuildCommitTxn(), SnapBuildPurgeOlderTxn(), SubTransGetParent(), SubTransGetTopmostTransaction(), vacuumLeafPage(), XidInMVCCSnapshot(), and XidIsConcurrent().

◆ TransactionIdGetCommitLSN()

XLogRecPtr TransactionIdGetCommitLSN ( TransactionId xid )

Definition at line 382 of file transam.c.

 {
     XLogRecPtr  result;
  
     /*
      * Currently, all uses of this function are for xids that were just
      * reported to be committed by TransactionLogFetch, so we expect that
      * checking TransactionLogFetch's cache will usually succeed and avoid an
      * extra trip to shared memory.
      */
     if (TransactionIdEquals(xid, cachedFetchXid))
         return cachedCommitLSN;
  
     /* Special XIDs are always known committed */
     if (!TransactionIdIsNormal(xid))
         return InvalidXLogRecPtr;
  
     /*
      * Get the transaction status.
      */
     (void) TransactionIdGetStatus(xid, &result);
  
     return result;
 }

References cachedCommitLSN, cachedFetchXid, InvalidXLogRecPtr, TransactionIdEquals, TransactionIdGetStatus(), and TransactionIdIsNormal.

Referenced by SetHintBits().

◆ TransactionIdLatest()

TransactionId TransactionIdLatest	(	TransactionId	mainxid,
		int	nxids,
		const TransactionId *	xids
	)

Definition at line 345 of file transam.c.

 {
     TransactionId result;
  
     /*
      * In practice it is highly likely that the xids[] array is sorted, and so
      * we could save some cycles by just taking the last child XID, but this
      * probably isn't so performance-critical that it's worth depending on
      * that assumption.  But just to show we're not totally stupid, scan the
      * array back-to-front to avoid useless assignments.
      */
     result = mainxid;
     while (--nxids >= 0)
     {
         if (TransactionIdPrecedes(result, xids[nxids]))
             result = xids[nxids];
     }
     return result;
 }

References TransactionIdPrecedes().

Referenced by FinishPreparedTransaction(), ProcArrayApplyXidAssignment(), RecordTransactionAbort(), RecordTransactionCommit(), xact_redo_abort(), and xact_redo_commit().

◆ TransactionIdPrecedes()

bool TransactionIdPrecedes	(	TransactionId	id1,
		TransactionId	id2
	)

Definition at line 280 of file transam.c.

 {
     /*
      * If either ID is a permanent XID then we can just do unsigned
      * comparison.  If both are normal, do a modulo-2^32 comparison.
      */
     int32       diff;
  
     if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
         return (id1 < id2);
  
     diff = (int32) (id1 - id2);
     return (diff < 0);
 }

References TransactionIdIsNormal.

Referenced by AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), bt_check_every_level(), check_exclusion_or_unique_constraint(), check_tuple_visibility(), CheckTargetForConflictsIn(), CLOGPagePrecedes(), collect_corrupt_items(), CommitTsPagePrecedes(), copy_table_data(), do_start_worker(), ExpireOldKnownAssignedTransactionIds(), ExportSnapshot(), FreezeMultiXactId(), get_relation_info(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), heap_abort_speculative(), heap_page_is_all_visible(), heap_prepare_freeze_tuple(), heap_prune_record_prunable(), heap_prune_record_unchanged_lp_normal(), heap_tuple_should_freeze(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesVacuum(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsSearch(), logical_rewrite_heap_tuple(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), multixact_redo(), PhysicalReplicationSlotNewXmin(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcessStandbyHSFeedbackMessage(), RecordKnownAssignedTransactionIds(), relation_needs_vacanalyze(), ReorderBufferAbortOld(), ReplicationSlotsComputeRequiredXmin(), rewrite_heap_tuple(), SerialGetMinConflictCommitSeqNo(), SerialPagePrecedesLogically(), SerialSetActiveSerXmin(), SetCommitTsLimit(), SetNewSxactGlobalXmin(), SnapBuildCommitTxn(), SnapBuildProcessChange(), SnapBuildRestore(), SnapshotResetXmin(), StandbyReleaseOldLocks(), SubTransGetTopmostTransaction(), SubTransPagePrecedes(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdGetCommitTsData(), TransactionIdIsActive(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdLatest(), TransactionIdOlder(), TransactionTreeSetCommitTsData(), tuple_all_visible(), update_local_synced_slot(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), vacuum_xid_failsafe_check(), vacuumRedirectAndPlaceholder(), XidInMVCCSnapshot(), XidIsConcurrent(), xidLogicalComparator(), xlog_redo(), and xmin_cmp().

◆ TransactionIdPrecedesOrEquals()

bool TransactionIdPrecedesOrEquals	(	TransactionId	id1,
		TransactionId	id2
	)

Definition at line 299 of file transam.c.

 {
     int32       diff;
  
     if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
         return (id1 <= id2);
  
     diff = (int32) (id1 - id2);
     return (diff <= 0);
 }

References TransactionIdIsNormal.

Referenced by ClearOldPredicateLocks(), ComputeXidHorizons(), GetCurrentVirtualXIDs(), GetSnapshotData(), GetSnapshotDataReuse(), heap_prepare_freeze_tuple(), heap_tuple_should_freeze(), heap_vacuum_rel(), InvalidatePossiblyObsoleteSlot(), KnownAssignedXidsAdd(), LogicalIncreaseXminForSlot(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SnapBuildFindSnapshot(), TransactionIdInRecentPast(), TransactionIdIsInProgress(), and vacuum_get_cutoffs().

◆ TransactionLogFetch()

static XidStatus TransactionLogFetch ( TransactionId transactionId )

static

Definition at line 52 of file transam.c.

 {
     XidStatus   xidstatus;
     XLogRecPtr  xidlsn;
  
     /*
      * Before going to the commit log manager, check our single item cache to
      * see if we didn't just check the transaction status a moment ago.
      */
     if (TransactionIdEquals(transactionId, cachedFetchXid))
         return cachedFetchXidStatus;
  
     /*
      * Also, check to see if the transaction ID is a permanent one.
      */
     if (!TransactionIdIsNormal(transactionId))
     {
         if (TransactionIdEquals(transactionId, BootstrapTransactionId))
             return TRANSACTION_STATUS_COMMITTED;
         if (TransactionIdEquals(transactionId, FrozenTransactionId))
             return TRANSACTION_STATUS_COMMITTED;
         return TRANSACTION_STATUS_ABORTED;
     }
  
     /*
      * Get the transaction status.
      */
     xidstatus = TransactionIdGetStatus(transactionId, &xidlsn);
  
     /*
      * Cache it, but DO NOT cache status for unfinished or sub-committed
      * transactions!  We only cache status that is guaranteed not to change.
      */
     if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS &&
         xidstatus != TRANSACTION_STATUS_SUB_COMMITTED)
     {
         cachedFetchXid = transactionId;
         cachedFetchXidStatus = xidstatus;
         cachedCommitLSN = xidlsn;
     }
  
     return xidstatus;
 }