#include "postgres.h"
#include <time.h>
#include <unistd.h>
#include "access/commit_ts.h"
#include "access/multixact.h"
#include "access/parallel.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/pg_enum.h"
#include "catalog/storage.h"
#include "commands/async.h"
#include "commands/tablecmds.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "libpq/be-fsstubs.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "replication/logical.h"
#include "replication/logicallauncher.h"
#include "replication/origin.h"
#include "replication/syncrep.h"
#include "replication/walsender.h"
#include "storage/condition_variable.h"
#include "storage/fd.h"
#include "storage/lmgr.h"
#include "storage/md.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/combocid.h"
#include "utils/guc.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/relmapper.h"
#include "utils/snapmgr.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"

Include dependency graph for xact.c:

Data Structures
struct	TransactionStateData

struct	SerializedTransactionState

struct	XactCallbackItem

struct	SubXactCallbackItem

Macros
#define	SerializedTransactionStateHeaderSize offsetof(SerializedTransactionState, parallelCurrentXids)

Typedefs
typedef enum TransState	TransState

typedef enum TBlockState	TBlockState

typedef struct TransactionStateData	TransactionStateData

typedef TransactionStateData *	TransactionState

typedef struct SerializedTransactionState	SerializedTransactionState

typedef struct XactCallbackItem	XactCallbackItem

typedef struct SubXactCallbackItem	SubXactCallbackItem

Functions
static void	AssignTransactionId (TransactionState s)

static void	AbortTransaction (void)

static void	AtAbort_Memory (void)

static void	AtCleanup_Memory (void)

static void	AtAbort_ResourceOwner (void)

static void	AtCCI_LocalCache (void)

static void	AtCommit_Memory (void)

static void	AtStart_Cache (void)

static void	AtStart_Memory (void)

static void	AtStart_ResourceOwner (void)

static void	CallXactCallbacks (XactEvent event)

static void	CallSubXactCallbacks (SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid)

static void	CleanupTransaction (void)

static void	CheckTransactionBlock (bool isTopLevel, bool throwError, const char *stmtType)

static void	CommitTransaction (void)

static TransactionId	RecordTransactionAbort (bool isSubXact)

static void	StartTransaction (void)

static void	StartSubTransaction (void)

static void	CommitSubTransaction (void)

static void	AbortSubTransaction (void)

static void	CleanupSubTransaction (void)

static void	PushTransaction (void)

static void	PopTransaction (void)

static void	AtSubAbort_Memory (void)

static void	AtSubCleanup_Memory (void)

static void	AtSubAbort_ResourceOwner (void)

static void	AtSubCommit_Memory (void)

static void	AtSubStart_Memory (void)

static void	AtSubStart_ResourceOwner (void)

static void	ShowTransactionState (const char *str)

static void	ShowTransactionStateRec (const char *str, TransactionState state)

static const char *	BlockStateAsString (TBlockState blockState)

static const char *	TransStateAsString (TransState state)

bool	IsTransactionState (void)

bool	IsAbortedTransactionBlockState (void)

TransactionId	GetTopTransactionId (void)

TransactionId	GetTopTransactionIdIfAny (void)

TransactionId	GetCurrentTransactionId (void)

TransactionId	GetCurrentTransactionIdIfAny (void)

FullTransactionId	GetTopFullTransactionId (void)

FullTransactionId	GetTopFullTransactionIdIfAny (void)

FullTransactionId	GetCurrentFullTransactionId (void)

FullTransactionId	GetCurrentFullTransactionIdIfAny (void)

void	MarkCurrentTransactionIdLoggedIfAny (void)

TransactionId	GetStableLatestTransactionId (void)

SubTransactionId	GetCurrentSubTransactionId (void)

bool	SubTransactionIsActive (SubTransactionId subxid)

CommandId	GetCurrentCommandId (bool used)

void	SetParallelStartTimestamps (TimestampTz xact_ts, TimestampTz stmt_ts)

TimestampTz	GetCurrentTransactionStartTimestamp (void)

TimestampTz	GetCurrentStatementStartTimestamp (void)

TimestampTz	GetCurrentTransactionStopTimestamp (void)

void	SetCurrentStatementStartTimestamp (void)

static void	SetCurrentTransactionStopTimestamp (void)

int	GetCurrentTransactionNestLevel (void)

bool	TransactionIdIsCurrentTransactionId (TransactionId xid)

bool	TransactionStartedDuringRecovery (void)

void	EnterParallelMode (void)

void	ExitParallelMode (void)

bool	IsInParallelMode (void)

void	CommandCounterIncrement (void)

void	ForceSyncCommit (void)

static TransactionId	RecordTransactionCommit (void)

static void	AtSubCommit_childXids (void)

static void	AtSubAbort_childXids (void)

static void	PrepareTransaction (void)

void	StartTransactionCommand (void)

void	SaveTransactionCharacteristics (void)

void	RestoreTransactionCharacteristics (void)

void	CommitTransactionCommand (void)

void	AbortCurrentTransaction (void)

void	PreventInTransactionBlock (bool isTopLevel, const char *stmtType)

void	WarnNoTransactionBlock (bool isTopLevel, const char *stmtType)

void	RequireTransactionBlock (bool isTopLevel, const char *stmtType)

bool	IsInTransactionBlock (bool isTopLevel)

void	RegisterXactCallback (XactCallback callback, void *arg)

void	UnregisterXactCallback (XactCallback callback, void *arg)

void	RegisterSubXactCallback (SubXactCallback callback, void *arg)

void	UnregisterSubXactCallback (SubXactCallback callback, void *arg)

void	BeginTransactionBlock (void)

bool	PrepareTransactionBlock (const char *gid)

bool	EndTransactionBlock (bool chain)

void	UserAbortTransactionBlock (bool chain)

void	BeginImplicitTransactionBlock (void)

void	EndImplicitTransactionBlock (void)

void	DefineSavepoint (const char *name)

void	ReleaseSavepoint (const char *name)

void	RollbackToSavepoint (const char *name)

void	BeginInternalSubTransaction (const char *name)

void	ReleaseCurrentSubTransaction (void)

void	RollbackAndReleaseCurrentSubTransaction (void)

void	AbortOutOfAnyTransaction (void)

bool	IsTransactionBlock (void)

bool	IsTransactionOrTransactionBlock (void)

char	TransactionBlockStatusCode (void)

bool	IsSubTransaction (void)

Size	EstimateTransactionStateSpace (void)

void	SerializeTransactionState (Size maxsize, char *start_address)

void	StartParallelWorkerTransaction (char *tstatespace)

void	EndParallelWorkerTransaction (void)

int	xactGetCommittedChildren (TransactionId **ptr)

XLogRecPtr	XactLogCommitRecord (TimestampTz commit_time, int nsubxacts, TransactionId subxacts, int nrels, RelFileNode rels, int nmsgs, SharedInvalidationMessage msgs, bool relcacheInval, int xactflags, TransactionId twophase_xid, const char twophase_gid)

XLogRecPtr	XactLogAbortRecord (TimestampTz abort_time, int nsubxacts, TransactionId subxacts, int nrels, RelFileNode rels, int xactflags, TransactionId twophase_xid, const char *twophase_gid)

static void	xact_redo_commit (xl_xact_parsed_commit *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)

static void	xact_redo_abort (xl_xact_parsed_abort *parsed, TransactionId xid)

void	xact_redo (XLogReaderState *record)

bool	IsSubTransactionAssignmentPending (void)

void	MarkSubTransactionAssigned (void)

Variables
int	DefaultXactIsoLevel = XACT_READ_COMMITTED

int	XactIsoLevel

bool	DefaultXactReadOnly = false

bool	XactReadOnly

bool	DefaultXactDeferrable = false

bool	XactDeferrable

int	synchronous_commit = SYNCHRONOUS_COMMIT_ON

TransactionId	CheckXidAlive = InvalidTransactionId

bool	bsysscan = false

FullTransactionId	XactTopFullTransactionId = {InvalidTransactionId}

int	nParallelCurrentXids = 0

TransactionId *	ParallelCurrentXids

int	MyXactFlags

static TransactionStateData	TopTransactionStateData

static int	nUnreportedXids

static TransactionId	unreportedXids [PGPROC_MAX_CACHED_SUBXIDS]

static TransactionState	CurrentTransactionState = &TopTransactionStateData

static SubTransactionId	currentSubTransactionId

static CommandId	currentCommandId

static bool	currentCommandIdUsed

static TimestampTz	xactStartTimestamp

static TimestampTz	stmtStartTimestamp

static TimestampTz	xactStopTimestamp

static char *	prepareGID

static bool	forceSyncCommit = false

bool	xact_is_sampled = false

static MemoryContext	TransactionAbortContext = NULL

static XactCallbackItem *	Xact_callbacks = NULL

static SubXactCallbackItem *	SubXact_callbacks = NULL

static int	save_XactIsoLevel

static bool	save_XactReadOnly

static bool	save_XactDeferrable

Macro Definition Documentation

◆ SerializedTransactionStateHeaderSize

#define SerializedTransactionStateHeaderSize offsetof(SerializedTransactionState, parallelCurrentXids)

Definition at line 229 of file xact.c.

Referenced by EstimateTransactionStateSpace(), and SerializeTransactionState().

Typedef Documentation

◆ SerializedTransactionState

typedef struct SerializedTransactionState SerializedTransactionState

◆ SubXactCallbackItem

typedef struct SubXactCallbackItem SubXactCallbackItem

◆ TBlockState

typedef enum TBlockState TBlockState

◆ TransactionState

typedef TransactionStateData* TransactionState

Definition at line 211 of file xact.c.

◆ TransactionStateData

typedef struct TransactionStateData TransactionStateData

◆ TransState

typedef enum TransState TransState

◆ XactCallbackItem

typedef struct XactCallbackItem XactCallbackItem

Enumeration Type Documentation

◆ TBlockState

enum TBlockState

Enumerator
TBLOCK_DEFAULT
TBLOCK_STARTED
TBLOCK_BEGIN
TBLOCK_INPROGRESS
TBLOCK_IMPLICIT_INPROGRESS
TBLOCK_PARALLEL_INPROGRESS
TBLOCK_END
TBLOCK_ABORT
TBLOCK_ABORT_END
TBLOCK_ABORT_PENDING
TBLOCK_PREPARE
TBLOCK_SUBBEGIN
TBLOCK_SUBINPROGRESS
TBLOCK_SUBRELEASE
TBLOCK_SUBCOMMIT
TBLOCK_SUBABORT
TBLOCK_SUBABORT_END
TBLOCK_SUBABORT_PENDING
TBLOCK_SUBRESTART
TBLOCK_SUBABORT_RESTART

Definition at line 153 of file xact.c.

 {
     /* not-in-transaction-block states */
     TBLOCK_DEFAULT,             /* idle */
     TBLOCK_STARTED,             /* running single-query transaction */
 
     /* transaction block states */
     TBLOCK_BEGIN,               /* starting transaction block */
     TBLOCK_INPROGRESS,          /* live transaction */
     TBLOCK_IMPLICIT_INPROGRESS, /* live transaction after implicit BEGIN */
     TBLOCK_PARALLEL_INPROGRESS, /* live transaction inside parallel worker */
     TBLOCK_END,                 /* COMMIT received */
     TBLOCK_ABORT,               /* failed xact, awaiting ROLLBACK */
     TBLOCK_ABORT_END,           /* failed xact, ROLLBACK received */
     TBLOCK_ABORT_PENDING,       /* live xact, ROLLBACK received */
     TBLOCK_PREPARE,             /* live xact, PREPARE received */
 
     /* subtransaction states */
     TBLOCK_SUBBEGIN,            /* starting a subtransaction */
     TBLOCK_SUBINPROGRESS,       /* live subtransaction */
     TBLOCK_SUBRELEASE,          /* RELEASE received */
     TBLOCK_SUBCOMMIT,           /* COMMIT received while TBLOCK_SUBINPROGRESS */
     TBLOCK_SUBABORT,            /* failed subxact, awaiting ROLLBACK */
     TBLOCK_SUBABORT_END,        /* failed subxact, ROLLBACK received */
     TBLOCK_SUBABORT_PENDING,    /* live subxact, ROLLBACK received */
     TBLOCK_SUBRESTART,          /* live subxact, ROLLBACK TO received */
     TBLOCK_SUBABORT_RESTART     /* failed subxact, ROLLBACK TO received */
 } TBlockState;

◆ TransState

enum TransState

Enumerator
TRANS_DEFAULT
TRANS_START
TRANS_INPROGRESS
TRANS_COMMIT
TRANS_ABORT
TRANS_PREPARE

Definition at line 137 of file xact.c.

 {
     TRANS_DEFAULT,              /* idle */
     TRANS_START,                /* transaction starting */
     TRANS_INPROGRESS,           /* inside a valid transaction */
     TRANS_COMMIT,               /* commit in progress */
     TRANS_ABORT,                /* abort in progress */
     TRANS_PREPARE               /* prepare in progress */
 } TransState;

Function Documentation

◆ AbortCurrentTransaction()

void AbortCurrentTransaction ( void )

Definition at line 3211 of file xact.c.

References AbortCurrentTransaction(), AbortSubTransaction(), AbortTransaction(), TransactionStateData::blockState, CleanupSubTransaction(), CleanupTransaction(), CurrentTransactionState, TransactionStateData::state, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, TRANS_DEFAULT, TRANS_INPROGRESS, and TRANS_START.

Referenced by _SPI_rollback(), AbortCurrentTransaction(), AutoVacLauncherMain(), PostgresMain(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), and SnapBuildClearExportedSnapshot().

 {
     TransactionState s = CurrentTransactionState;
 
     switch (s->blockState)
     {
         case TBLOCK_DEFAULT:
             if (s->state == TRANS_DEFAULT)
             {
                 /* we are idle, so nothing to do */
             }
             else
             {
                 /*
                  * We can get here after an error during transaction start
                  * (state will be TRANS_START).  Need to clean up the
                  * incompletely started transaction.  First, adjust the
                  * low-level state to suppress warning message from
                  * AbortTransaction.
                  */
                 if (s->state == TRANS_START)
                     s->state = TRANS_INPROGRESS;
                 AbortTransaction();
                 CleanupTransaction();
             }
             break;
 
             /*
              * If we aren't in a transaction block, we just do the basic abort
              * & cleanup transaction.  For this purpose, we treat an implicit
              * transaction block as if it were a simple statement.
              */
         case TBLOCK_STARTED:
         case TBLOCK_IMPLICIT_INPROGRESS:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * If we are in TBLOCK_BEGIN it means something screwed up right
              * after reading "BEGIN TRANSACTION".  We assume that the user
              * will interpret the error as meaning the BEGIN failed to get him
              * into a transaction block, so we should abort and return to idle
              * state.
              */
         case TBLOCK_BEGIN:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are somewhere in a transaction block and we've gotten a
              * failure, so we abort the transaction and set up the persistent
              * ABORT state.  We will stay in ABORT until we get a ROLLBACK.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_PARALLEL_INPROGRESS:
             AbortTransaction();
             s->blockState = TBLOCK_ABORT;
             /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
             break;
 
             /*
              * Here, we failed while trying to COMMIT.  Clean up the
              * transaction and return to idle state (we do not want to stay in
              * the transaction).
              */
         case TBLOCK_END:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here, we are already in an aborted transaction state and are
              * waiting for a ROLLBACK, but for some reason we failed again! So
              * we just remain in the abort state.
              */
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             break;
 
             /*
              * We are in a failed transaction and we got the ROLLBACK command.
              * We have already aborted, we just need to cleanup and go to idle
              * state.
              */
         case TBLOCK_ABORT_END:
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are in a live transaction and we got a ROLLBACK command.
              * Abort, cleanup, go to idle state.
              */
         case TBLOCK_ABORT_PENDING:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here, we failed while trying to PREPARE.  Clean up the
              * transaction and return to idle state (we do not want to stay in
              * the transaction).
              */
         case TBLOCK_PREPARE:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We got an error inside a subtransaction.  Abort just the
              * subtransaction, and go to the persistent SUBABORT state until
              * we get ROLLBACK.
              */
         case TBLOCK_SUBINPROGRESS:
             AbortSubTransaction();
             s->blockState = TBLOCK_SUBABORT;
             break;
 
             /*
              * If we failed while trying to create a subtransaction, clean up
              * the broken subtransaction and abort the parent.  The same
              * applies if we get a failure while ending a subtransaction.
              */
         case TBLOCK_SUBBEGIN:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
             AbortSubTransaction();
             CleanupSubTransaction();
             AbortCurrentTransaction();
             break;
 
             /*
              * Same as above, except the Abort() was already done.
              */
         case TBLOCK_SUBABORT_END:
         case TBLOCK_SUBABORT_RESTART:
             CleanupSubTransaction();
             AbortCurrentTransaction();
             break;
     }
 }

◆ AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction ( void )

Definition at line 4580 of file xact.c.

References AbortSubTransaction(), AbortTransaction(), Assert, AtAbort_Memory(), AtAbort_Portals(), AtCleanup_Memory(), AtSubAbort_Portals(), TransactionStateData::blockState, CleanupSubTransaction(), CleanupTransaction(), CurrentTransactionState, TransactionStateData::curTransactionOwner, TransactionStateData::parent, TransactionStateData::state, TransactionStateData::subTransactionId, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, TRANS_DEFAULT, TRANS_INPROGRESS, and TRANS_START.

Referenced by do_autovacuum(), perform_work_item(), RemoveTempRelationsCallback(), and ShutdownPostgres().

 {
     TransactionState s = CurrentTransactionState;
 
     /* Ensure we're not running in a doomed memory context */
     AtAbort_Memory();
 
     /*
      * Get out of any transaction or nested transaction
      */
     do
     {
         switch (s->blockState)
         {
             case TBLOCK_DEFAULT:
                 if (s->state == TRANS_DEFAULT)
                 {
                     /* Not in a transaction, do nothing */
                 }
                 else
                 {
                     /*
                      * We can get here after an error during transaction start
                      * (state will be TRANS_START).  Need to clean up the
                      * incompletely started transaction.  First, adjust the
                      * low-level state to suppress warning message from
                      * AbortTransaction.
                      */
                     if (s->state == TRANS_START)
                         s->state = TRANS_INPROGRESS;
                     AbortTransaction();
                     CleanupTransaction();
                 }
                 break;
             case TBLOCK_STARTED:
             case TBLOCK_BEGIN:
             case TBLOCK_INPROGRESS:
             case TBLOCK_IMPLICIT_INPROGRESS:
             case TBLOCK_PARALLEL_INPROGRESS:
             case TBLOCK_END:
             case TBLOCK_ABORT_PENDING:
             case TBLOCK_PREPARE:
                 /* In a transaction, so clean up */
                 AbortTransaction();
                 CleanupTransaction();
                 s->blockState = TBLOCK_DEFAULT;
                 break;
             case TBLOCK_ABORT:
             case TBLOCK_ABORT_END:
 
                 /*
                  * AbortTransaction is already done, still need Cleanup.
                  * However, if we failed partway through running ROLLBACK,
                  * there will be an active portal running that command, which
                  * we need to shut down before doing CleanupTransaction.
                  */
                 AtAbort_Portals();
                 CleanupTransaction();
                 s->blockState = TBLOCK_DEFAULT;
                 break;
 
                 /*
                  * In a subtransaction, so clean it up and abort parent too
                  */
             case TBLOCK_SUBBEGIN:
             case TBLOCK_SUBINPROGRESS:
             case TBLOCK_SUBRELEASE:
             case TBLOCK_SUBCOMMIT:
             case TBLOCK_SUBABORT_PENDING:
             case TBLOCK_SUBRESTART:
                 AbortSubTransaction();
                 CleanupSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
                 break;
 
             case TBLOCK_SUBABORT:
             case TBLOCK_SUBABORT_END:
             case TBLOCK_SUBABORT_RESTART:
                 /* As above, but AbortSubTransaction already done */
                 if (s->curTransactionOwner)
                 {
                     /* As in TBLOCK_ABORT, might have a live portal to zap */
                     AtSubAbort_Portals(s->subTransactionId,
                                        s->parent->subTransactionId,
                                        s->curTransactionOwner,
                                        s->parent->curTransactionOwner);
                 }
                 CleanupSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
                 break;
         }
     } while (s->blockState != TBLOCK_DEFAULT);
 
     /* Should be out of all subxacts now */
     Assert(s->parent == NULL);
 
     /* If we didn't actually have anything to do, revert to TopMemoryContext */
     AtCleanup_Memory();
 }

◆ AbortSubTransaction()

static void AbortSubTransaction ( void )

static

Definition at line 4926 of file xact.c.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), CommitTransactionCommand(), and RollbackAndReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Make sure we have a valid memory context and resource owner */
     AtSubAbort_Memory();
     AtSubAbort_ResourceOwner();
 
     /*
      * Release any LW locks we might be holding as quickly as possible.
      * (Regular locks, however, must be held till we finish aborting.)
      * Releasing LW locks is critical since we might try to grab them again
      * while cleaning up!
      *
      * FIXME This may be incorrect --- Are there some locks we should keep?
      * Buffer locks, for example?  I don't think so but I'm not sure.
      */
     LWLockReleaseAll();
 
     pgstat_report_wait_end();
     pgstat_progress_end_command();
     AbortBufferIO();
     UnlockBuffers();
 
     /* Reset WAL record construction state */
     XLogResetInsertion();
 
     /* Cancel condition variable sleep */
     ConditionVariableCancelSleep();
 
     /*
      * Also clean up any open wait for lock, since the lock manager will choke
      * if we try to wait for another lock before doing this.
      */
     LockErrorCleanup();
 
     /*
      * If any timeout events are still active, make sure the timeout interrupt
      * is scheduled.  This covers possible loss of a timeout interrupt due to
      * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
      * We delay this till after LockErrorCleanup so that we don't uselessly
      * reschedule lock or deadlock check timeouts.
      */
     reschedule_timeouts();
 
     /*
      * Re-enable signals, in case we got here by longjmp'ing out of a signal
      * handler.  We do this fairly early in the sequence so that the timeout
      * infrastructure will be functional if needed while aborting.
      */
     PG_SETMASK(&UnBlockSig);
 
     /*
      * check the current transaction state
      */
     ShowTransactionState("AbortSubTransaction");
 
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "AbortSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     s->state = TRANS_ABORT;
 
     /*
      * Reset user ID which might have been changed transiently.  (See notes in
      * AbortTransaction.)
      */
     SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
 
     /* Forget about any active REINDEX. */
     ResetReindexState(s->nestingLevel);
 
     /* Reset logical streaming state. */
     ResetLogicalStreamingState();
 
     /* Exit from parallel mode, if necessary. */
     if (IsInParallelMode())
     {
         AtEOSubXact_Parallel(false, s->subTransactionId);
         s->parallelModeLevel = 0;
     }
 
     /*
      * We can skip all this stuff if the subxact failed before creating a
      * ResourceOwner...
      */
     if (s->curTransactionOwner)
     {
         AfterTriggerEndSubXact(false);
         AtSubAbort_Portals(s->subTransactionId,
                            s->parent->subTransactionId,
                            s->curTransactionOwner,
                            s->parent->curTransactionOwner);
         AtEOSubXact_LargeObject(false, s->subTransactionId,
                                 s->parent->subTransactionId);
         AtSubAbort_Notify();
 
         /* Advertise the fact that we aborted in pg_xact. */
         (void) RecordTransactionAbort(true);
 
         /* Post-abort cleanup */
         if (FullTransactionIdIsValid(s->fullTransactionId))
             AtSubAbort_childXids();
 
         CallSubXactCallbacks(SUBXACT_EVENT_ABORT_SUB, s->subTransactionId,
                              s->parent->subTransactionId);
 
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_BEFORE_LOCKS,
                              false, false);
         AtEOSubXact_RelationCache(false, s->subTransactionId,
                                   s->parent->subTransactionId);
         AtEOSubXact_Inval(false);
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_LOCKS,
                              false, false);
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_AFTER_LOCKS,
                              false, false);
         AtSubAbort_smgr();
 
         AtEOXact_GUC(false, s->gucNestLevel);
         AtEOSubXact_SPI(false, s->subTransactionId);
         AtEOSubXact_on_commit_actions(false, s->subTransactionId,
                                       s->parent->subTransactionId);
         AtEOSubXact_Namespace(false, s->subTransactionId,
                               s->parent->subTransactionId);
         AtEOSubXact_Files(false, s->subTransactionId,
                           s->parent->subTransactionId);
         AtEOSubXact_HashTables(false, s->nestingLevel);
         AtEOSubXact_PgStat(false, s->nestingLevel);
         AtSubAbort_Snapshot(s->nestingLevel);
         AtEOSubXact_ApplyLauncher(false, s->nestingLevel);
     }
 
     /*
      * Restore the upper transaction's read-only state, too.  This should be
      * redundant with GUC's cleanup but we may as well do it for consistency
      * with the commit case.
      */
     XactReadOnly = s->prevXactReadOnly;
 
     RESUME_INTERRUPTS();
 }

◆ AbortTransaction()

static void AbortTransaction ( void )

static

Definition at line 2609 of file xact.c.

References AbortBufferIO(), AfterTriggerEndXact(), Assert, AtAbort_Memory(), AtAbort_Notify(), AtAbort_Portals(), AtAbort_ResourceOwner(), AtAbort_Twophase(), AtEOXact_ApplyLauncher(), AtEOXact_Buffers(), AtEOXact_ComboCid(), AtEOXact_Enum(), AtEOXact_Files(), AtEOXact_GUC(), AtEOXact_HashTables(), AtEOXact_Inval(), AtEOXact_LargeObject(), AtEOXact_MultiXact(), AtEOXact_Namespace(), AtEOXact_on_commit_actions(), AtEOXact_Parallel(), AtEOXact_PgStat(), AtEOXact_RelationCache(), AtEOXact_RelationMap(), AtEOXact_SMgr(), AtEOXact_SPI(), TransactionStateData::blockState, CallXactCallbacks(), ConditionVariableCancelSleep(), CurrentTransactionState, elog, HOLD_INTERRUPTS, InvalidTransactionId, IsInParallelMode(), LockErrorCleanup(), LWLockReleaseAll(), PGPROC::lxid, MyProc, TransactionStateData::nestingLevel, TransactionStateData::parallelModeLevel, TransactionStateData::parent, PG_SETMASK, pgstat_progress_end_command(), pgstat_report_wait_end(), pgstat_report_xact_timestamp(), TransactionStateData::prevSecContext, TransactionStateData::prevUser, ProcArrayEndTransaction(), RecordTransactionAbort(), reschedule_timeouts(), ResetLogicalStreamingState(), ResetReindexState(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerRelease(), RESUME_INTERRUPTS, SetUserIdAndSecContext(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), TransactionStateData::state, TBLOCK_PARALLEL_INPROGRESS, TopTransactionResourceOwner, TRANS_ABORT, TRANS_INPROGRESS, TRANS_PREPARE, TransStateAsString(), UnBlockSig, UnlockBuffers(), WARNING, XACT_EVENT_ABORT, XACT_EVENT_PARALLEL_ABORT, XactLastRecEnd, XLogResetInsertion(), and XLogSetAsyncXactLSN().

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), and CommitTransactionCommand().

 {
     TransactionState s = CurrentTransactionState;
     TransactionId latestXid;
     bool        is_parallel_worker;
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Make sure we have a valid memory context and resource owner */
     AtAbort_Memory();
     AtAbort_ResourceOwner();
 
     /*
      * Release any LW locks we might be holding as quickly as possible.
      * (Regular locks, however, must be held till we finish aborting.)
      * Releasing LW locks is critical since we might try to grab them again
      * while cleaning up!
      */
     LWLockReleaseAll();
 
     /* Clear wait information and command progress indicator */
     pgstat_report_wait_end();
     pgstat_progress_end_command();
 
     /* Clean up buffer I/O and buffer context locks, too */
     AbortBufferIO();
     UnlockBuffers();
 
     /* Reset WAL record construction state */
     XLogResetInsertion();
 
     /* Cancel condition variable sleep */
     ConditionVariableCancelSleep();
 
     /*
      * Also clean up any open wait for lock, since the lock manager will choke
      * if we try to wait for another lock before doing this.
      */
     LockErrorCleanup();
 
     /*
      * If any timeout events are still active, make sure the timeout interrupt
      * is scheduled.  This covers possible loss of a timeout interrupt due to
      * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
      * We delay this till after LockErrorCleanup so that we don't uselessly
      * reschedule lock or deadlock check timeouts.
      */
     reschedule_timeouts();
 
     /*
      * Re-enable signals, in case we got here by longjmp'ing out of a signal
      * handler.  We do this fairly early in the sequence so that the timeout
      * infrastructure will be functional if needed while aborting.
      */
     PG_SETMASK(&UnBlockSig);
 
     /*
      * check the current transaction state
      */
     is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
     if (s->state != TRANS_INPROGRESS && s->state != TRANS_PREPARE)
         elog(WARNING, "AbortTransaction while in %s state",
              TransStateAsString(s->state));
     Assert(s->parent == NULL);
 
     /*
      * set the current transaction state information appropriately during the
      * abort processing
      */
     s->state = TRANS_ABORT;
 
     /*
      * Reset user ID which might have been changed transiently.  We need this
      * to clean up in case control escaped out of a SECURITY DEFINER function
      * or other local change of CurrentUserId; therefore, the prior value of
      * SecurityRestrictionContext also needs to be restored.
      *
      * (Note: it is not necessary to restore session authorization or role
      * settings here because those can only be changed via GUC, and GUC will
      * take care of rolling them back if need be.)
      */
     SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
 
     /* Forget about any active REINDEX. */
     ResetReindexState(s->nestingLevel);
 
     /* Reset logical streaming state. */
     ResetLogicalStreamingState();
 
     /* If in parallel mode, clean up workers and exit parallel mode. */
     if (IsInParallelMode())
     {
         AtEOXact_Parallel(false);
         s->parallelModeLevel = 0;
     }
 
     /*
      * do abort processing
      */
     AfterTriggerEndXact(false); /* 'false' means it's abort */
     AtAbort_Portals();
     smgrDoPendingSyncs(false, is_parallel_worker);
     AtEOXact_LargeObject(false);
     AtAbort_Notify();
     AtEOXact_RelationMap(false, is_parallel_worker);
     AtAbort_Twophase();
 
     /*
      * Advertise the fact that we aborted in pg_xact (assuming that we got as
      * far as assigning an XID to advertise).  But if we're inside a parallel
      * worker, skip this; the user backend must be the one to write the abort
      * record.
      */
     if (!is_parallel_worker)
         latestXid = RecordTransactionAbort(false);
     else
     {
         latestXid = InvalidTransactionId;
 
         /*
          * Since the parallel leader won't get our value of XactLastRecEnd in
          * this case, we nudge WAL-writer ourselves in this case.  See related
          * comments in RecordTransactionAbort for why this matters.
          */
         XLogSetAsyncXactLSN(XactLastRecEnd);
     }
 
     TRACE_POSTGRESQL_TRANSACTION_ABORT(MyProc->lxid);
 
     /*
      * Let others know about no transaction in progress by me. Note that this
      * must be done _before_ releasing locks we hold and _after_
      * RecordTransactionAbort.
      */
     ProcArrayEndTransaction(MyProc, latestXid);
 
     /*
      * Post-abort cleanup.  See notes in CommitTransaction() concerning
      * ordering.  We can skip all of it if the transaction failed before
      * creating a resource owner.
      */
     if (TopTransactionResourceOwner != NULL)
     {
         if (is_parallel_worker)
             CallXactCallbacks(XACT_EVENT_PARALLEL_ABORT);
         else
             CallXactCallbacks(XACT_EVENT_ABORT);
 
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_BEFORE_LOCKS,
                              false, true);
         AtEOXact_Buffers(false);
         AtEOXact_RelationCache(false);
         AtEOXact_Inval(false);
         AtEOXact_MultiXact();
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_LOCKS,
                              false, true);
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_AFTER_LOCKS,
                              false, true);
         smgrDoPendingDeletes(false);
 
         AtEOXact_GUC(false, 1);
         AtEOXact_SPI(false);
         AtEOXact_Enum();
         AtEOXact_on_commit_actions(false);
         AtEOXact_Namespace(false, is_parallel_worker);
         AtEOXact_SMgr();
         AtEOXact_Files(false);
         AtEOXact_ComboCid();
         AtEOXact_HashTables(false);
         AtEOXact_PgStat(false, is_parallel_worker);
         AtEOXact_ApplyLauncher(false);
         pgstat_report_xact_timestamp(0);
     }
 
     /*
      * State remains TRANS_ABORT until CleanupTransaction().
      */
     RESUME_INTERRUPTS();
 }

◆ AssignTransactionId()

static void AssignTransactionId ( TransactionState s )

static

Definition at line 569 of file xact.c.

References Assert, CurrentResourceOwner, TransactionStateData::curTransactionOwner, TransactionStateData::didLogXid, elog, ERROR, TransactionStateData::fullTransactionId, FullTransactionIdIsValid, GetNewTransactionId(), GetTopTransactionId(), IsInParallelMode(), IsParallelWorker, MinSizeOfXactAssignment, TransactionStateData::nestingLevel, xl_xact_assignment::nsubxacts, nUnreportedXids, palloc(), TransactionStateData::parent, pfree(), PGPROC_MAX_CACHED_SUBXIDS, RegisterPredicateLockingXid(), TransactionStateData::state, SubTransSetParent(), TRANS_INPROGRESS, TransactionIdIsValid, unreportedXids, XactLockTableInsert(), XidFromFullTransactionId, XLOG_XACT_ASSIGNMENT, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogStandbyInfoActive, and xl_xact_assignment::xtop.

Referenced by GetCurrentFullTransactionId(), GetCurrentTransactionId(), GetTopFullTransactionId(), and GetTopTransactionId().

 {
     bool        isSubXact = (s->parent != NULL);
     ResourceOwner currentOwner;
     bool        log_unknown_top = false;
 
     /* Assert that caller didn't screw up */
     Assert(!FullTransactionIdIsValid(s->fullTransactionId));
     Assert(s->state == TRANS_INPROGRESS);
 
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for new XIDs at this point.
      */
     if (IsInParallelMode() || IsParallelWorker())
         elog(ERROR, "cannot assign XIDs during a parallel operation");
 
     /*
      * Ensure parent(s) have XIDs, so that a child always has an XID later
      * than its parent.  Mustn't recurse here, or we might get a stack
      * overflow if we're at the bottom of a huge stack of subtransactions none
      * of which have XIDs yet.
      */
     if (isSubXact && !FullTransactionIdIsValid(s->parent->fullTransactionId))
     {
         TransactionState p = s->parent;
         TransactionState *parents;
         size_t      parentOffset = 0;
 
         parents = palloc(sizeof(TransactionState) * s->nestingLevel);
         while (p != NULL && !FullTransactionIdIsValid(p->fullTransactionId))
         {
             parents[parentOffset++] = p;
             p = p->parent;
         }
 
         /*
          * This is technically a recursive call, but the recursion will never
          * be more than one layer deep.
          */
         while (parentOffset != 0)
             AssignTransactionId(parents[--parentOffset]);
 
         pfree(parents);
     }
 
     /*
      * When wal_level=logical, guarantee that a subtransaction's xid can only
      * be seen in the WAL stream if its toplevel xid has been logged before.
      * If necessary we log an xact_assignment record with fewer than
      * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
      * for a transaction even though it appears in a WAL record, we just might
      * superfluously log something. That can happen when an xid is included
      * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
      * xl_standby_locks.
      */
     if (isSubXact && XLogLogicalInfoActive() &&
         !TopTransactionStateData.didLogXid)
         log_unknown_top = true;
 
     /*
      * Generate a new FullTransactionId and record its xid in PG_PROC and
      * pg_subtrans.
      *
      * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
      * shared storage other than PG_PROC; because if there's no room for it in
      * PG_PROC, the subtrans entry is needed to ensure that other backends see
      * the Xid as "running".  See GetNewTransactionId.
      */
     s->fullTransactionId = GetNewTransactionId(isSubXact);
     if (!isSubXact)
         XactTopFullTransactionId = s->fullTransactionId;
 
     if (isSubXact)
         SubTransSetParent(XidFromFullTransactionId(s->fullTransactionId),
                           XidFromFullTransactionId(s->parent->fullTransactionId));
 
     /*
      * If it's a top-level transaction, the predicate locking system needs to
      * be told about it too.
      */
     if (!isSubXact)
         RegisterPredicateLockingXid(XidFromFullTransactionId(s->fullTransactionId));
 
     /*
      * Acquire lock on the transaction XID.  (We assume this cannot block.) We
      * have to ensure that the lock is assigned to the transaction's own
      * ResourceOwner.
      */
     currentOwner = CurrentResourceOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 
     XactLockTableInsert(XidFromFullTransactionId(s->fullTransactionId));
 
     CurrentResourceOwner = currentOwner;
 
     /*
      * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
      * top-level transaction we issue a WAL record for the assignment. We
      * include the top-level xid and all the subxids that have not yet been
      * reported using XLOG_XACT_ASSIGNMENT records.
      *
      * This is required to limit the amount of shared memory required in a hot
      * standby server to keep track of in-progress XIDs. See notes for
      * RecordKnownAssignedTransactionIds().
      *
      * We don't keep track of the immediate parent of each subxid, only the
      * top-level transaction that each subxact belongs to. This is correct in
      * recovery only because aborted subtransactions are separately WAL
      * logged.
      *
      * This is correct even for the case where several levels above us didn't
      * have an xid assigned as we recursed up to them beforehand.
      */
     if (isSubXact && XLogStandbyInfoActive())
     {
         unreportedXids[nUnreportedXids] = XidFromFullTransactionId(s->fullTransactionId);
         nUnreportedXids++;
 
         /*
          * ensure this test matches similar one in
          * RecoverPreparedTransactions()
          */
         if (nUnreportedXids >= PGPROC_MAX_CACHED_SUBXIDS ||
             log_unknown_top)
         {
             xl_xact_assignment xlrec;
 
             /*
              * xtop is always set by now because we recurse up transaction
              * stack to the highest unassigned xid and then come back down
              */
             xlrec.xtop = GetTopTransactionId();
             Assert(TransactionIdIsValid(xlrec.xtop));
             xlrec.nsubxacts = nUnreportedXids;
 
             XLogBeginInsert();
             XLogRegisterData((char *) &xlrec, MinSizeOfXactAssignment);
             XLogRegisterData((char *) unreportedXids,
                              nUnreportedXids * sizeof(TransactionId));
 
             (void) XLogInsert(RM_XACT_ID, XLOG_XACT_ASSIGNMENT);
 
             nUnreportedXids = 0;
             /* mark top, not current xact as having been logged */
             TopTransactionStateData.didLogXid = true;
         }
     }
 }

◆ AtAbort_Memory()

static void AtAbort_Memory ( void )

static

Definition at line 1753 of file xact.c.

References MemoryContextSwitchTo(), and TopMemoryContext.

Referenced by AbortOutOfAnyTransaction(), and AbortTransaction().

 {
     /*
      * Switch into TransactionAbortContext, which should have some free space
      * even if nothing else does.  We'll work in this context until we've
      * finished cleaning up.
      *
      * It is barely possible to get here when we've not been able to create
      * TransactionAbortContext yet; if so use TopMemoryContext.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextSwitchTo(TransactionAbortContext);
     else
         MemoryContextSwitchTo(TopMemoryContext);
 }

◆ AtAbort_ResourceOwner()

static void AtAbort_ResourceOwner ( void )

static

Definition at line 1785 of file xact.c.

References CurrentResourceOwner, and TopTransactionResourceOwner.

Referenced by AbortTransaction().

 {
     /*
      * Make sure we have a valid ResourceOwner, if possible (else it will be
      * NULL, which is OK)
      */
     CurrentResourceOwner = TopTransactionResourceOwner;
 }

◆ AtCCI_LocalCache()

static void AtCCI_LocalCache ( void )

static

Definition at line 1476 of file xact.c.

References AtCCI_RelationMap(), and CommandEndInvalidationMessages().

Referenced by CommandCounterIncrement().

 {
     /*
      * Make any pending relation map changes visible.  We must do this before
      * processing local sinval messages, so that the map changes will get
      * reflected into the relcache when relcache invals are processed.
      */
     AtCCI_RelationMap();
 
     /*
      * Make catalog changes visible to me for the next command.
      */
     CommandEndInvalidationMessages();
 }

◆ AtCleanup_Memory()

static void AtCleanup_Memory ( void )

static

Definition at line 1843 of file xact.c.

References Assert, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), TransactionStateData::parent, TopMemoryContext, and TopTransactionContext.

Referenced by AbortOutOfAnyTransaction(), and CleanupTransaction().

 {
     Assert(CurrentTransactionState->parent == NULL);
 
     /*
      * Now that we're "out" of a transaction, have the system allocate things
      * in the top memory context instead of per-transaction contexts.
      */
     MemoryContextSwitchTo(TopMemoryContext);
 
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextResetAndDeleteChildren(TransactionAbortContext);
 
     /*
      * Release all transaction-local memory.
      */
     if (TopTransactionContext != NULL)
         MemoryContextDelete(TopTransactionContext);
     TopTransactionContext = NULL;
     CurTransactionContext = NULL;
     CurrentTransactionState->curTransactionContext = NULL;
 }

◆ AtCommit_Memory()

static void AtCommit_Memory ( void )

static

Definition at line 1495 of file xact.c.

References Assert, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextSwitchTo(), TopMemoryContext, and TopTransactionContext.

Referenced by CommitTransaction(), and PrepareTransaction().

 {
     /*
      * Now that we're "out" of a transaction, have the system allocate things
      * in the top memory context instead of per-transaction contexts.
      */
     MemoryContextSwitchTo(TopMemoryContext);
 
     /*
      * Release all transaction-local memory.
      */
     Assert(TopTransactionContext != NULL);
     MemoryContextDelete(TopTransactionContext);
     TopTransactionContext = NULL;
     CurTransactionContext = NULL;
     CurrentTransactionState->curTransactionContext = NULL;
 }

◆ AtStart_Cache()

static void AtStart_Cache ( void )

static

Definition at line 1086 of file xact.c.

References AcceptInvalidationMessages().

Referenced by StartTransaction().

 {
     AcceptInvalidationMessages();
 }

◆ AtStart_Memory()

static void AtStart_Memory ( void )

static

Definition at line 1095 of file xact.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextSwitchTo(), TopMemoryContext, and TopTransactionContext.

Referenced by StartTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * If this is the first time through, create a private context for
      * AbortTransaction to work in.  By reserving some space now, we can
      * insulate AbortTransaction from out-of-memory scenarios.  Like
      * ErrorContext, we set it up with slow growth rate and a nonzero minimum
      * size, so that space will be reserved immediately.
      */
     if (TransactionAbortContext == NULL)
         TransactionAbortContext =
             AllocSetContextCreate(TopMemoryContext,
                                   "TransactionAbortContext",
                                   32 * 1024,
                                   32 * 1024,
                                   32 * 1024);
 
     /*
      * We shouldn't have a transaction context already.
      */
     Assert(TopTransactionContext == NULL);
 
     /*
      * Create a toplevel context for the transaction.
      */
     TopTransactionContext =
         AllocSetContextCreate(TopMemoryContext,
                               "TopTransactionContext",
                               ALLOCSET_DEFAULT_SIZES);
 
     /*
      * In a top-level transaction, CurTransactionContext is the same as
      * TopTransactionContext.
      */
     CurTransactionContext = TopTransactionContext;
     s->curTransactionContext = CurTransactionContext;
 
     /* Make the CurTransactionContext active. */
     MemoryContextSwitchTo(CurTransactionContext);
 }

◆ AtStart_ResourceOwner()

static void AtStart_ResourceOwner ( void )

static

Definition at line 1142 of file xact.c.

References Assert, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, ResourceOwnerCreate(), and TopTransactionResourceOwner.

Referenced by StartTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * We shouldn't have a transaction resource owner already.
      */
     Assert(TopTransactionResourceOwner == NULL);
 
     /*
      * Create a toplevel resource owner for the transaction.
      */
     s->curTransactionOwner = ResourceOwnerCreate(NULL, "TopTransaction");
 
     TopTransactionResourceOwner = s->curTransactionOwner;
     CurTransactionResourceOwner = s->curTransactionOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 }

◆ AtSubAbort_childXids()

static void AtSubAbort_childXids ( void )

static

Definition at line 1811 of file xact.c.

References TransactionStateData::childXids, CurrentTransactionState, TransactionStateData::maxChildXids, TransactionStateData::nChildXids, and pfree().

Referenced by AbortSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * We keep the child-XID arrays in TopTransactionContext (see
      * AtSubCommit_childXids).  This means we'd better free the array
      * explicitly at abort to avoid leakage.
      */
     if (s->childXids != NULL)
         pfree(s->childXids);
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 
     /*
      * We could prune the unreportedXids array here. But we don't bother. That
      * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
      * would likely introduce more CPU time into the more common paths, so we
      * choose not to do that.
      */
 }

◆ AtSubAbort_Memory()

static void AtSubAbort_Memory ( void )

static

Definition at line 1773 of file xact.c.

References Assert, and MemoryContextSwitchTo().

Referenced by AbortSubTransaction().

 {
     Assert(TransactionAbortContext != NULL);
 
     MemoryContextSwitchTo(TransactionAbortContext);
 }

◆ AtSubAbort_ResourceOwner()

static void AtSubAbort_ResourceOwner ( void )

static

Definition at line 1798 of file xact.c.

References CurrentResourceOwner, CurrentTransactionState, and TransactionStateData::curTransactionOwner.

Referenced by AbortSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /* Make sure we have a valid ResourceOwner */
     CurrentResourceOwner = s->curTransactionOwner;
 }

◆ AtSubCleanup_Memory()

static void AtSubCleanup_Memory ( void )

static

Definition at line 1879 of file xact.c.

References Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), and TransactionStateData::parent.

Referenced by CleanupSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /* Make sure we're not in an about-to-be-deleted context */
     MemoryContextSwitchTo(s->parent->curTransactionContext);
     CurTransactionContext = s->parent->curTransactionContext;
 
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextResetAndDeleteChildren(TransactionAbortContext);
 
     /*
      * Delete the subxact local memory contexts. Its CurTransactionContext can
      * go too (note this also kills CurTransactionContexts from any children
      * of the subxact).
      */
     if (s->curTransactionContext)
         MemoryContextDelete(s->curTransactionContext);
     s->curTransactionContext = NULL;
 }

◆ AtSubCommit_childXids()

static void AtSubCommit_childXids ( void )

static

Definition at line 1551 of file xact.c.

References Assert, TransactionStateData::childXids, CurrentTransactionState, ereport, errcode(), errmsg(), ERROR, TransactionStateData::fullTransactionId, MaxAllocSize, TransactionStateData::maxChildXids, MemoryContextAlloc(), Min, TransactionStateData::nChildXids, TransactionStateData::parent, pfree(), repalloc(), TopTransactionContext, and XidFromFullTransactionId.

Referenced by CommitSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
     int         new_nChildXids;
 
     Assert(s->parent != NULL);
 
     /*
      * The parent childXids array will need to hold my XID and all my
      * childXids, in addition to the XIDs already there.
      */
     new_nChildXids = s->parent->nChildXids + s->nChildXids + 1;
 
     /* Allocate or enlarge the parent array if necessary */
     if (s->parent->maxChildXids < new_nChildXids)
     {
         int         new_maxChildXids;
         TransactionId *new_childXids;
 
         /*
          * Make it 2x what's needed right now, to avoid having to enlarge it
          * repeatedly. But we can't go above MaxAllocSize.  (The latter limit
          * is what ensures that we don't need to worry about integer overflow
          * here or in the calculation of new_nChildXids.)
          */
         new_maxChildXids = Min(new_nChildXids * 2,
                                (int) (MaxAllocSize / sizeof(TransactionId)));
 
         if (new_maxChildXids < new_nChildXids)
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("maximum number of committed subtransactions (%d) exceeded",
                             (int) (MaxAllocSize / sizeof(TransactionId)))));
 
         /*
          * We keep the child-XID arrays in TopTransactionContext; this avoids
          * setting up child-transaction contexts for what might be just a few
          * bytes of grandchild XIDs.
          */
         if (s->parent->childXids == NULL)
             new_childXids =
                 MemoryContextAlloc(TopTransactionContext,
                                    new_maxChildXids * sizeof(TransactionId));
         else
             new_childXids = repalloc(s->parent->childXids,
                                      new_maxChildXids * sizeof(TransactionId));
 
         s->parent->childXids = new_childXids;
         s->parent->maxChildXids = new_maxChildXids;
     }
 
     /*
      * Copy all my XIDs to parent's array.
      *
      * Note: We rely on the fact that the XID of a child always follows that
      * of its parent.  By copying the XID of this subtransaction before the
      * XIDs of its children, we ensure that the array stays ordered. Likewise,
      * all XIDs already in the array belong to subtransactions started and
      * subcommitted before us, so their XIDs must precede ours.
      */
     s->parent->childXids[s->parent->nChildXids] = XidFromFullTransactionId(s->fullTransactionId);
 
     if (s->nChildXids > 0)
         memcpy(&s->parent->childXids[s->parent->nChildXids + 1],
                s->childXids,
                s->nChildXids * sizeof(TransactionId));
 
     s->parent->nChildXids = new_nChildXids;
 
     /* Release child's array to avoid leakage */
     if (s->childXids != NULL)
         pfree(s->childXids);
     /* We must reset these to avoid double-free if fail later in commit */
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 }

◆ AtSubCommit_Memory()

static void AtSubCommit_Memory ( void )

static

Definition at line 1522 of file xact.c.

References Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextIsEmpty(), MemoryContextSwitchTo(), and TransactionStateData::parent.

Referenced by CommitSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /* Return to parent transaction level's memory context. */
     CurTransactionContext = s->parent->curTransactionContext;
     MemoryContextSwitchTo(CurTransactionContext);
 
     /*
      * Ordinarily we cannot throw away the child's CurTransactionContext,
      * since the data it contains will be needed at upper commit.  However, if
      * there isn't actually anything in it, we can throw it away.  This avoids
      * a small memory leak in the common case of "trivial" subxacts.
      */
     if (MemoryContextIsEmpty(s->curTransactionContext))
     {
         MemoryContextDelete(s->curTransactionContext);
         s->curTransactionContext = NULL;
     }
 }

◆ AtSubStart_Memory()

static void AtSubStart_Memory ( void )

static

Definition at line 1170 of file xact.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, and MemoryContextSwitchTo().

Referenced by StartSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(CurTransactionContext != NULL);
 
     /*
      * Create a CurTransactionContext, which will be used to hold data that
      * survives subtransaction commit but disappears on subtransaction abort.
      * We make it a child of the immediate parent's CurTransactionContext.
      */
     CurTransactionContext = AllocSetContextCreate(CurTransactionContext,
                                                   "CurTransactionContext",
                                                   ALLOCSET_DEFAULT_SIZES);
     s->curTransactionContext = CurTransactionContext;
 
     /* Make the CurTransactionContext active. */
     MemoryContextSwitchTo(CurTransactionContext);
 }

◆ AtSubStart_ResourceOwner()

static void AtSubStart_ResourceOwner ( void )

static

Definition at line 1194 of file xact.c.

References Assert, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, TransactionStateData::parent, and ResourceOwnerCreate().

Referenced by StartSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /*
      * Create a resource owner for the subtransaction.  We make it a child of
      * the immediate parent's resource owner.
      */
     s->curTransactionOwner =
         ResourceOwnerCreate(s->parent->curTransactionOwner,
                             "SubTransaction");
 
     CurTransactionResourceOwner = s->curTransactionOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 }

◆ BeginImplicitTransactionBlock()

void BeginImplicitTransactionBlock ( void )

Definition at line 4040 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, TBLOCK_IMPLICIT_INPROGRESS, and TBLOCK_STARTED.

Referenced by exec_simple_query().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * If we are in STARTED state (that is, no transaction block is open),
      * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
      * block.
      *
      * For caller convenience, we consider all other transaction states as
      * legal here; otherwise the caller would need its own state check, which
      * seems rather pointless.
      */
     if (s->blockState == TBLOCK_STARTED)
         s->blockState = TBLOCK_IMPLICIT_INPROGRESS;
 }

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char * name )

Definition at line 4408 of file xact.c.

References TransactionStateData::blockState, BlockStateAsString(), CommitTransactionCommand(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), MemoryContextStrdup(), TransactionStateData::name, PushTransaction(), StartTransactionCommand(), TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, and TopTransactionContext.

Referenced by exec_stmt_block(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), pltcl_returnnext(), pltcl_subtrans_begin(), pltcl_subtransaction(), PLy_spi_subtransaction_begin(), PLy_subtransaction_enter(), ReorderBufferImmediateInvalidation(), and ReorderBufferProcessTXN().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for new subtransactions after that
      * point. We might be able to make an exception for the type of
      * subtransaction established by this function, which is typically used in
      * contexts where we're going to release or roll back the subtransaction
      * before proceeding further, so that no enduring change to the
      * transaction state occurs. For now, however, we prohibit this case along
      * with all the others.
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot start subtransactions during a parallel operation")));
 
     switch (s->blockState)
     {
         case TBLOCK_STARTED:
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_END:
         case TBLOCK_PREPARE:
         case TBLOCK_SUBINPROGRESS:
             /* Normal subtransaction start */
             PushTransaction();
             s = CurrentTransactionState;    /* changed by push */
 
             /*
              * Savepoint names, like the TransactionState block itself, live
              * in TopTransactionContext.
              */
             if (name)
                 s->name = MemoryContextStrdup(TopTransactionContext, name);
             break;
 
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_BEGIN:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
         case TBLOCK_ABORT_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
             elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
 
     CommitTransactionCommand();
     StartTransactionCommand();
 }

◆ BeginTransactionBlock()

void BeginTransactionBlock ( void )

Definition at line 3638 of file xact.c.

References TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), FATAL, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, and WARNING.

Referenced by standard_ProcessUtility().

 {
     TransactionState s = CurrentTransactionState;
 
     switch (s->blockState)
     {
             /*
              * We are not inside a transaction block, so allow one to begin.
              */
         case TBLOCK_STARTED:
             s->blockState = TBLOCK_BEGIN;
             break;
 
             /*
              * BEGIN converts an implicit transaction block to a regular one.
              * (Note that we allow this even if we've already done some
              * commands, which is a bit odd but matches historical practice.)
              */
         case TBLOCK_IMPLICIT_INPROGRESS:
             s->blockState = TBLOCK_BEGIN;
             break;
 
             /*
              * Already a transaction block in progress.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             ereport(WARNING,
                     (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                      errmsg("there is already a transaction in progress")));
             break;
 
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_BEGIN:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_END:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
         case TBLOCK_PREPARE:
             elog(FATAL, "BeginTransactionBlock: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
 }

◆ BlockStateAsString()

static const char * BlockStateAsString ( TBlockState blockState )

static

Definition at line 5394 of file xact.c.

References TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, and TBLOCK_SUBRESTART.

Referenced by BeginInternalSubTransaction(), BeginTransactionBlock(), CommitTransactionCommand(), DefineSavepoint(), EndTransactionBlock(), ReleaseCurrentSubTransaction(), ReleaseSavepoint(), RollbackAndReleaseCurrentSubTransaction(), RollbackToSavepoint(), ShowTransactionStateRec(), StartTransactionCommand(), TransactionBlockStatusCode(), and UserAbortTransactionBlock().

 {
     switch (blockState)
     {
         case TBLOCK_DEFAULT:
             return "DEFAULT";
         case TBLOCK_STARTED:
             return "STARTED";
         case TBLOCK_BEGIN:
             return "BEGIN";
         case TBLOCK_INPROGRESS:
             return "INPROGRESS";
         case TBLOCK_IMPLICIT_INPROGRESS:
             return "IMPLICIT_INPROGRESS";
         case TBLOCK_PARALLEL_INPROGRESS:
             return "PARALLEL_INPROGRESS";
         case TBLOCK_END:
             return "END";
         case TBLOCK_ABORT:
             return "ABORT";
         case TBLOCK_ABORT_END:
             return "ABORT_END";
         case TBLOCK_ABORT_PENDING:
             return "ABORT_PENDING";
         case TBLOCK_PREPARE:
             return "PREPARE";
         case TBLOCK_SUBBEGIN:
             return "SUBBEGIN";
         case TBLOCK_SUBINPROGRESS:
             return "SUBINPROGRESS";
         case TBLOCK_SUBRELEASE:
             return "SUBRELEASE";
         case TBLOCK_SUBCOMMIT:
             return "SUBCOMMIT";
         case TBLOCK_SUBABORT:
             return "SUBABORT";
         case TBLOCK_SUBABORT_END:
             return "SUBABORT_END";
         case TBLOCK_SUBABORT_PENDING:
             return "SUBABORT_PENDING";
         case TBLOCK_SUBRESTART:
             return "SUBRESTART";
         case TBLOCK_SUBABORT_RESTART:
             return "SUBABORT_RESTART";
     }
     return "UNRECOGNIZED";
 }

◆ CallSubXactCallbacks()

static void CallSubXactCallbacks	(	SubXactEvent	event,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

static

Definition at line 3617 of file xact.c.

References SubXactCallbackItem::arg, SubXactCallbackItem::callback, and SubXactCallbackItem::next.

Referenced by AbortSubTransaction(), CommitSubTransaction(), and StartSubTransaction().

 {
     SubXactCallbackItem *item;
 
     for (item = SubXact_callbacks; item; item = item->next)
         item->callback(event, mySubid, parentSubid, item->arg);
 }

◆ CallXactCallbacks()

static void CallXactCallbacks ( XactEvent event )

static

Definition at line 3562 of file xact.c.

References XactCallbackItem::arg, XactCallbackItem::callback, and XactCallbackItem::next.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

 {
     XactCallbackItem *item;
 
     for (item = Xact_callbacks; item; item = item->next)
         item->callback(event, item->arg);
 }

◆ CheckTransactionBlock()

static void CheckTransactionBlock	(	bool	isTopLevel,
		bool	throwError,
		const char *	stmtType
	)

static

Definition at line 3455 of file xact.c.

References ereport, errcode(), errmsg(), ERROR, IsSubTransaction(), IsTransactionBlock(), and WARNING.

Referenced by RequireTransactionBlock(), and WarnNoTransactionBlock().

 {
     /*
      * xact block already started?
      */
     if (IsTransactionBlock())
         return;
 
     /*
      * subtransaction?
      */
     if (IsSubTransaction())
         return;
 
     /*
      * inside a function call?
      */
     if (!isTopLevel)
         return;
 
     ereport(throwError ? ERROR : WARNING,
             (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
     /* translator: %s represents an SQL statement name */
              errmsg("%s can only be used in transaction blocks",
                     stmtType)));
 }

◆ CleanupSubTransaction()

static void CleanupSubTransaction ( void )

static

Definition at line 5081 of file xact.c.

References AtSubCleanup_Memory(), AtSubCleanup_Portals(), CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog, TransactionStateData::parent, PopTransaction(), ResourceOwnerDelete(), ShowTransactionState(), TransactionStateData::state, TransactionStateData::subTransactionId, TRANS_ABORT, TRANS_DEFAULT, TransStateAsString(), and WARNING.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), CommitTransactionCommand(), and RollbackAndReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     ShowTransactionState("CleanupSubTransaction");
 
     if (s->state != TRANS_ABORT)
         elog(WARNING, "CleanupSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     AtSubCleanup_Portals(s->subTransactionId);
 
     CurrentResourceOwner = s->parent->curTransactionOwner;
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     if (s->curTransactionOwner)
         ResourceOwnerDelete(s->curTransactionOwner);
     s->curTransactionOwner = NULL;
 
     AtSubCleanup_Memory();
 
     s->state = TRANS_DEFAULT;
 
     PopTransaction();
 }

◆ CleanupTransaction()

static void CleanupTransaction ( void )

static

Definition at line 2797 of file xact.c.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), and CommitTransactionCommand().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * State should still be TRANS_ABORT from AbortTransaction().
      */
     if (s->state != TRANS_ABORT)
         elog(FATAL, "CleanupTransaction: unexpected state %s",
              TransStateAsString(s->state));
 
     /*
      * do abort cleanup processing
      */
     AtCleanup_Portals();        /* now safe to release portal memory */
     AtEOXact_Snapshot(false, true); /* and release the transaction's snapshots */
 
     CurrentResourceOwner = NULL;    /* and resource owner */
     if (TopTransactionResourceOwner)
         ResourceOwnerDelete(TopTransactionResourceOwner);
     s->curTransactionOwner = NULL;
     CurTransactionResourceOwner = NULL;
     TopTransactionResourceOwner = NULL;
 
     AtCleanup_Memory();         /* and transaction memory */
 
     s->fullTransactionId = InvalidFullTransactionId;
     s->subTransactionId = InvalidSubTransactionId;
     s->nestingLevel = 0;
     s->gucNestLevel = 0;
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
     s->parallelModeLevel = 0;
 
     XactTopFullTransactionId = InvalidFullTransactionId;
     nParallelCurrentXids = 0;
 
     /*
      * done with abort processing, set current transaction state back to
      * default
      */
     s->state = TRANS_DEFAULT;
 }

◆ CommandCounterIncrement()

void CommandCounterIncrement ( void )

Definition at line 1021 of file xact.c.

References AtCCI_LocalCache(), currentCommandId, currentCommandIdUsed, elog, ereport, errcode(), errmsg(), ERROR, InvalidCommandId, IsInParallelMode(), IsParallelWorker, and SnapshotSetCommandId().

Referenced by _SPI_execute_plan(), acquire_inherited_sample_rows(), addFkRecurseReferenced(), addFkRecurseReferencing(), AddRoleMems(), AlterPublicationOptions(), AlterRole(), apply_handle_delete(), apply_handle_insert(), apply_handle_truncate(), apply_handle_update(), ATAddCheckConstraint(), ATExecAddColumn(), ATExecAlterColumnType(), ATExecCmd(), ATExecDetachPartition(), ATExecDropColumn(), ATExecDropConstraint(), ATExecDropExpression(), ATExecDropIdentity(), ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), ATParseTransformCmd(), ATRewriteTables(), AttachPartitionEnsureIndexes(), btadjustmembers(), CloneFkReferencing(), CommitSubTransaction(), CommitTransactionCommand(), copy_table_data(), create_ctas_internal(), create_toast_table(), CreateFKCheckTrigger(), createForeignKeyActionTriggers(), CreateForeignTable(), CreatePublication(), CreateRole(), CreateSchemaCommand(), CreateTrigger(), DefineCollation(), DefineDomain(), DefineQueryRewrite(), DefineRelation(), DefineVirtualRelation(), deleteOneObject(), DelRoleMems(), DropClonedTriggersFromPartition(), DropRole(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerInvoke(), EventTriggerSQLDrop(), EventTriggerTableRewrite(), exec_eval_simple_expr(), exec_execute_message(), exec_parse_message(), exec_simple_query(), ExecGrant_Database(), ExecGrant_Fdw(), ExecGrant_ForeignServer(), ExecGrant_Function(), ExecGrant_Language(), ExecGrant_Largeobject(), ExecGrant_Namespace(), ExecGrant_Relation(), ExecGrant_Tablespace(), ExecGrant_Type(), execute_sql_string(), ExplainOnePlan(), fmgr_sql(), hashadjustmembers(), ImportForeignSchema(), index_build(), index_create(), IndexSetParentIndex(), InitTempTableNamespace(), inv_create(), inv_drop(), inv_truncate(), inv_write(), LogicalRepSyncTableStart(), make_new_heap(), makeConfigurationDependencies(), moveArrayTypeName(), OperatorShellMake(), OperatorUpd(), pg_import_system_collations(), PortalRunMulti(), ProcedureCreate(), ProcessUtilitySlow(), recordExtensionInitPrivWorker(), reindex_relation(), ReindexRelationConcurrently(), RelationSetNewRelfilenode(), RenumberEnumType(), replorigin_create(), replorigin_drop(), ri_PerformCheck(), SetMatViewPopulatedState(), shdepReassignOwned(), SPI_cursor_open_internal(), standard_ProcessUtility(), StoreConstraints(), StorePartitionBound(), tryAttachPartitionForeignKey(), vacuum(), and validatePartitionedIndex().

 {
     /*
      * If the current value of the command counter hasn't been "used" to mark
      * tuples, we need not increment it, since there's no need to distinguish
      * a read-only command from others.  This helps postpone command counter
      * overflow, and keeps no-op CommandCounterIncrement operations cheap.
      */
     if (currentCommandIdUsed)
     {
         /*
          * Workers synchronize transaction state at the beginning of each
          * parallel operation, so we can't account for new commands after that
          * point.
          */
         if (IsInParallelMode() || IsParallelWorker())
             elog(ERROR, "cannot start commands during a parallel operation");
 
         currentCommandId += 1;
         if (currentCommandId == InvalidCommandId)
         {
             currentCommandId -= 1;
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("cannot have more than 2^32-2 commands in a transaction")));
         }
         currentCommandIdUsed = false;
 
         /* Propagate new command ID into static snapshots */
         SnapshotSetCommandId(currentCommandId);
 
         /*
          * Make any catalog changes done by the just-completed command visible
          * in the local syscache.  We obviously don't need to do this after a
          * read-only command.  (But see hacks in inval.c to make real sure we
          * don't think a command that queued inval messages was read-only.)
          */
         AtCCI_LocalCache();
     }
 }

◆ CommitSubTransaction()

static void CommitSubTransaction ( void )

static

Definition at line 4817 of file xact.c.

Referenced by CommitTransactionCommand(), and ReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     ShowTransactionState("CommitSubTransaction");
 
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "CommitSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     /* Pre-commit processing goes here */
 
     CallSubXactCallbacks(SUBXACT_EVENT_PRE_COMMIT_SUB, s->subTransactionId,
                          s->parent->subTransactionId);
 
     /* If in parallel mode, clean up workers and exit parallel mode. */
     if (IsInParallelMode())
     {
         AtEOSubXact_Parallel(true, s->subTransactionId);
         s->parallelModeLevel = 0;
     }
 
     /* Do the actual "commit", such as it is */
     s->state = TRANS_COMMIT;
 
     /* Must CCI to ensure commands of subtransaction are seen as done */
     CommandCounterIncrement();
 
     /*
      * Prior to 8.4 we marked subcommit in clog at this point.  We now only
      * perform that step, if required, as part of the atomic update of the
      * whole transaction tree at top level commit or abort.
      */
 
     /* Post-commit cleanup */
     if (FullTransactionIdIsValid(s->fullTransactionId))
         AtSubCommit_childXids();
     AfterTriggerEndSubXact(true);
     AtSubCommit_Portals(s->subTransactionId,
                         s->parent->subTransactionId,
                         s->parent->curTransactionOwner);
     AtEOSubXact_LargeObject(true, s->subTransactionId,
                             s->parent->subTransactionId);
     AtSubCommit_Notify();
 
     CallSubXactCallbacks(SUBXACT_EVENT_COMMIT_SUB, s->subTransactionId,
                          s->parent->subTransactionId);
 
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          true, false);
     AtEOSubXact_RelationCache(true, s->subTransactionId,
                               s->parent->subTransactionId);
     AtEOSubXact_Inval(true);
     AtSubCommit_smgr();
 
     /*
      * The only lock we actually release here is the subtransaction XID lock.
      */
     CurrentResourceOwner = s->curTransactionOwner;
     if (FullTransactionIdIsValid(s->fullTransactionId))
         XactLockTableDelete(XidFromFullTransactionId(s->fullTransactionId));
 
     /*
      * Other locks should get transferred to their parent resource owner.
      */
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_LOCKS,
                          true, false);
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          true, false);
 
     AtEOXact_GUC(true, s->gucNestLevel);
     AtEOSubXact_SPI(true, s->subTransactionId);
     AtEOSubXact_on_commit_actions(true, s->subTransactionId,
                                   s->parent->subTransactionId);
     AtEOSubXact_Namespace(true, s->subTransactionId,
                           s->parent->subTransactionId);
     AtEOSubXact_Files(true, s->subTransactionId,
                       s->parent->subTransactionId);
     AtEOSubXact_HashTables(true, s->nestingLevel);
     AtEOSubXact_PgStat(true, s->nestingLevel);
     AtSubCommit_Snapshot(s->nestingLevel);
     AtEOSubXact_ApplyLauncher(true, s->nestingLevel);
 
     /*
      * We need to restore the upper transaction's read-only state, in case the
      * upper is read-write while the child is read-only; GUC will incorrectly
      * think it should leave the child state in place.
      */
     XactReadOnly = s->prevXactReadOnly;
 
     CurrentResourceOwner = s->parent->curTransactionOwner;
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     ResourceOwnerDelete(s->curTransactionOwner);
     s->curTransactionOwner = NULL;
 
     AtSubCommit_Memory();
 
     s->state = TRANS_DEFAULT;
 
     PopTransaction();
 }

◆ CommitTransaction()

static void CommitTransaction ( void )

static

Definition at line 2073 of file xact.c.

Referenced by CommitTransactionCommand(), EndParallelWorkerTransaction(), EndRestoreBlobs(), restore_toc_entry(), and RestoreArchive().

 {
     TransactionState s = CurrentTransactionState;
     TransactionId latestXid;
     bool        is_parallel_worker;
 
     is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
 
     /* Enforce parallel mode restrictions during parallel worker commit. */
     if (is_parallel_worker)
         EnterParallelMode();
 
     ShowTransactionState("CommitTransaction");
 
     /*
      * check the current transaction state
      */
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "CommitTransaction while in %s state",
              TransStateAsString(s->state));
     Assert(s->parent == NULL);
 
     /*
      * Do pre-commit processing that involves calling user-defined code, such
      * as triggers.  Since closing cursors could queue trigger actions,
      * triggers could open cursors, etc, we have to keep looping until there's
      * nothing left to do.
      */
     for (;;)
     {
         /*
          * Fire all currently pending deferred triggers.
          */
         AfterTriggerFireDeferred();
 
         /*
          * Close open portals (converting holdable ones into static portals).
          * If there weren't any, we are done ... otherwise loop back to check
          * if they queued deferred triggers.  Lather, rinse, repeat.
          */
         if (!PreCommit_Portals(false))
             break;
     }
 
     CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
                       : XACT_EVENT_PRE_COMMIT);
 
     /*
      * The remaining actions cannot call any user-defined code, so it's safe
      * to start shutting down within-transaction services.  But note that most
      * of this stuff could still throw an error, which would switch us into
      * the transaction-abort path.
      */
 
     /* If we might have parallel workers, clean them up now. */
     if (IsInParallelMode())
         AtEOXact_Parallel(true);
 
     /* Shut down the deferred-trigger manager */
     AfterTriggerEndXact(true);
 
     /*
      * Let ON COMMIT management do its thing (must happen after closing
      * cursors, to avoid dangling-reference problems)
      */
     PreCommit_on_commit_actions();
 
     /*
      * Synchronize files that are created and not WAL-logged during this
      * transaction. This must happen before AtEOXact_RelationMap(), so that we
      * don't see committed-but-broken files after a crash.
      */
     smgrDoPendingSyncs(true, is_parallel_worker);
 
     /* close large objects before lower-level cleanup */
     AtEOXact_LargeObject(true);
 
     /*
      * Insert notifications sent by NOTIFY commands into the queue.  This
      * should be late in the pre-commit sequence to minimize time spent
      * holding the notify-insertion lock.  However, this could result in
      * creating a snapshot, so we must do it before serializable cleanup.
      */
     PreCommit_Notify();
 
     /*
      * Mark serializable transaction as complete for predicate locking
      * purposes.  This should be done as late as we can put it and still allow
      * errors to be raised for failure patterns found at commit.  This is not
      * appropriate in a parallel worker however, because we aren't committing
      * the leader's transaction and its serializable state will live on.
      */
     if (!is_parallel_worker)
         PreCommit_CheckForSerializationFailure();
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Commit updates to the relation map --- do this as late as possible */
     AtEOXact_RelationMap(true, is_parallel_worker);
 
     /*
      * set the current transaction state information appropriately during
      * commit processing
      */
     s->state = TRANS_COMMIT;
     s->parallelModeLevel = 0;
 
     if (!is_parallel_worker)
     {
         /*
          * We need to mark our XIDs as committed in pg_xact.  This is where we
          * durably commit.
          */
         latestXid = RecordTransactionCommit();
     }
     else
     {
         /*
          * We must not mark our XID committed; the parallel leader is
          * responsible for that.
          */
         latestXid = InvalidTransactionId;
 
         /*
          * Make sure the leader will know about any WAL we wrote before it
          * commits.
          */
         ParallelWorkerReportLastRecEnd(XactLastRecEnd);
     }
 
     TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid);
 
     /*
      * Let others know about no transaction in progress by me. Note that this
      * must be done _before_ releasing locks we hold and _after_
      * RecordTransactionCommit.
      */
     ProcArrayEndTransaction(MyProc, latestXid);
 
     /*
      * This is all post-commit cleanup.  Note that if an error is raised here,
      * it's too late to abort the transaction.  This should be just
      * noncritical resource releasing.
      *
      * The ordering of operations is not entirely random.  The idea is:
      * release resources visible to other backends (eg, files, buffer pins);
      * then release locks; then release backend-local resources. We want to
      * release locks at the point where any backend waiting for us will see
      * our transaction as being fully cleaned up.
      *
      * Resources that can be associated with individual queries are handled by
      * the ResourceOwner mechanism.  The other calls here are for backend-wide
      * state.
      */
 
     CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
                       : XACT_EVENT_COMMIT);
 
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          true, true);
 
     /* Check we've released all buffer pins */
     AtEOXact_Buffers(true);
 
     /* Clean up the relation cache */
     AtEOXact_RelationCache(true);
 
     /*
      * Make catalog changes visible to all backends.  This has to happen after
      * relcache references are dropped (see comments for
      * AtEOXact_RelationCache), but before locks are released (if anyone is
      * waiting for lock on a relation we've modified, we want them to know
      * about the catalog change before they start using the relation).
      */
     AtEOXact_Inval(true);
 
     AtEOXact_MultiXact();
 
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_LOCKS,
                          true, true);
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          true, true);
 
     /*
      * Likewise, dropping of files deleted during the transaction is best done
      * after releasing relcache and buffer pins.  (This is not strictly
      * necessary during commit, since such pins should have been released
      * already, but this ordering is definitely critical during abort.)  Since
      * this may take many seconds, also delay until after releasing locks.
      * Other backends will observe the attendant catalog changes and not
      * attempt to access affected files.
      */
     smgrDoPendingDeletes(true);
 
     AtCommit_Notify();
     AtEOXact_GUC(true, 1);
     AtEOXact_SPI(true);
     AtEOXact_Enum();
     AtEOXact_on_commit_actions(true);
     AtEOXact_Namespace(true, is_parallel_worker);
     AtEOXact_SMgr();
     AtEOXact_Files(true);
     AtEOXact_ComboCid();
     AtEOXact_HashTables(true);
     AtEOXact_PgStat(true, is_parallel_worker);
     AtEOXact_Snapshot(true, false);
     AtEOXact_ApplyLauncher(true);
     pgstat_report_xact_timestamp(0);
 
     CurrentResourceOwner = NULL;
     ResourceOwnerDelete(TopTransactionResourceOwner);
     s->curTransactionOwner = NULL;
     CurTransactionResourceOwner = NULL;
     TopTransactionResourceOwner = NULL;
 
     AtCommit_Memory();
 
     s->fullTransactionId = InvalidFullTransactionId;
     s->subTransactionId = InvalidSubTransactionId;
     s->nestingLevel = 0;
     s->gucNestLevel = 0;
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 
     XactTopFullTransactionId = InvalidFullTransactionId;
     nParallelCurrentXids = 0;
 
     /*
      * done with commit processing, set current transaction state back to
      * default
      */
     s->state = TRANS_DEFAULT;
 
     RESUME_INTERRUPTS();
 }

◆ CommitTransactionCommand()

void CommitTransactionCommand ( void )

Definition at line 2947 of file xact.c.

References AbortSubTransaction(), AbortTransaction(), Assert, AssertState, TransactionStateData::blockState, BlockStateAsString(), TransactionStateData::chain, CleanupSubTransaction(), CleanupTransaction(), CommandCounterIncrement(), CommitSubTransaction(), CommitTransaction(), CommitTransactionCommand(), CurrentTransactionState, DefineSavepoint(), elog, ERROR, FATAL, TransactionStateData::name, TransactionStateData::parent, PrepareTransaction(), RestoreTransactionCharacteristics(), TransactionStateData::savepointLevel, SaveTransactionCharacteristics(), StartSubTransaction(), StartTransaction(), TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, and TBLOCK_SUBRESTART.

Referenced by _SPI_commit(), apply_handle_commit(), apply_handle_stream_abort(), apply_handle_stream_commit(), apply_handle_stream_stop(), ApplyWorkerMain(), autoprewarm_database_main(), BeginInternalSubTransaction(), BootstrapModeMain(), cluster(), CommitTransactionCommand(), DefineIndex(), do_autovacuum(), exec_replication_command(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), ParallelWorkerMain(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), ProcessCatchupInterrupt(), ProcessCompletedNotifies(), ProcessIncomingNotify(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), vacuum(), and vacuum_rel().

 {
     TransactionState s = CurrentTransactionState;
 
     if (s->chain)
         SaveTransactionCharacteristics();
 
     switch (s->blockState)
     {
             /*
              * These shouldn't happen.  TBLOCK_DEFAULT means the previous
              * StartTransactionCommand didn't set the STARTED state
              * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
              * by EndParallelWorkerTransaction(), not this function.
              */
         case TBLOCK_DEFAULT:
         case TBLOCK_PARALLEL_INPROGRESS:
             elog(FATAL, "CommitTransactionCommand: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
 
             /*
              * If we aren't in a transaction block, just do our usual
              * transaction commit, and return to the idle state.
              */
         case TBLOCK_STARTED:
             CommitTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are completing a "BEGIN TRANSACTION" command, so we change
              * to the "transaction block in progress" state and return.  (We
              * assume the BEGIN did nothing to the database, so we need no
              * CommandCounterIncrement.)
              */
         case TBLOCK_BEGIN:
             s->blockState = TBLOCK_INPROGRESS;
             break;
 
             /*
              * This is the case when we have finished executing a command
              * someplace within a transaction block.  We increment the command
              * counter and return.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
             CommandCounterIncrement();
             break;
 
             /*
              * We are completing a "COMMIT" command.  Do it and return to the
              * idle state.
              */
         case TBLOCK_END:
             CommitTransaction();
             s->blockState = TBLOCK_DEFAULT;
             if (s->chain)
             {
                 StartTransaction();
                 s->blockState = TBLOCK_INPROGRESS;
                 s->chain = false;
                 RestoreTransactionCharacteristics();
             }
             break;
 
             /*
              * Here we are in the middle of a transaction block but one of the
              * commands caused an abort so we do nothing but remain in the
              * abort state.  Eventually we will get a ROLLBACK command.
              */
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             break;
 
             /*
              * Here we were in an aborted transaction block and we just got
              * the ROLLBACK command from the user, so clean up the
              * already-aborted transaction and return to the idle state.
              */
         case TBLOCK_ABORT_END:
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             if (s->chain)
             {
                 StartTransaction();
                 s->blockState = TBLOCK_INPROGRESS;
                 s->chain = false;
                 RestoreTransactionCharacteristics();
             }
             break;
 
             /*
              * Here we were in a perfectly good transaction block but the user
              * told us to ROLLBACK anyway.  We have to abort the transaction
              * and then clean up.
              */
         case TBLOCK_ABORT_PENDING:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             if (s->chain)
             {
                 StartTransaction();
                 s->blockState = TBLOCK_INPROGRESS;
                 s->chain = false;
                 RestoreTransactionCharacteristics();
             }
             break;
 
             /*
              * We are completing a "PREPARE TRANSACTION" command.  Do it and
              * return to the idle state.
              */
         case TBLOCK_PREPARE:
             PrepareTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We were just issued a SAVEPOINT inside a transaction block.
              * Start a subtransaction.  (DefineSavepoint already did
              * PushTransaction, so as to have someplace to put the SUBBEGIN
              * state.)
              */
         case TBLOCK_SUBBEGIN:
             StartSubTransaction();
             s->blockState = TBLOCK_SUBINPROGRESS;
             break;
 
             /*
              * We were issued a RELEASE command, so we end the current
              * subtransaction and return to the parent transaction. The parent
              * might be ended too, so repeat till we find an INPROGRESS
              * transaction or subtransaction.
              */
         case TBLOCK_SUBRELEASE:
             do
             {
                 CommitSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
             } while (s->blockState == TBLOCK_SUBRELEASE);
 
             Assert(s->blockState == TBLOCK_INPROGRESS ||
                    s->blockState == TBLOCK_SUBINPROGRESS);
             break;
 
             /*
              * We were issued a COMMIT, so we end the current subtransaction
              * hierarchy and perform final commit. We do this by rolling up
              * any subtransactions into their parent, which leads to O(N^2)
              * operations with respect to resource owners - this isn't that
              * bad until we approach a thousands of savepoints but is
              * necessary for correctness should after triggers create new
              * resource owners.
              */
         case TBLOCK_SUBCOMMIT:
             do
             {
                 CommitSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
             } while (s->blockState == TBLOCK_SUBCOMMIT);
             /* If we had a COMMIT command, finish off the main xact too */
             if (s->blockState == TBLOCK_END)
             {
                 Assert(s->parent == NULL);
                 CommitTransaction();
                 s->blockState = TBLOCK_DEFAULT;
             }
             else if (s->blockState == TBLOCK_PREPARE)
             {
                 Assert(s->parent == NULL);
                 PrepareTransaction();
                 s->blockState = TBLOCK_DEFAULT;
             }
             else
                 elog(ERROR, "CommitTransactionCommand: unexpected state %s",
                      BlockStateAsString(s->blockState));
             break;
 
             /*
              * The current already-failed subtransaction is ending due to a
              * ROLLBACK or ROLLBACK TO command, so pop it and recursively
              * examine the parent (which could be in any of several states).
              */
         case TBLOCK_SUBABORT_END:
             CleanupSubTransaction();
             CommitTransactionCommand();
             break;
 
             /*
              * As above, but it's not dead yet, so abort first.
              */
         case TBLOCK_SUBABORT_PENDING:
             AbortSubTransaction();
             CleanupSubTransaction();
             CommitTransactionCommand();
             break;
 
             /*
              * The current subtransaction is the target of a ROLLBACK TO
              * command.  Abort and pop it, then start a new subtransaction
              * with the same name.
              */
         case TBLOCK_SUBRESTART:
             {
                 char       *name;
                 int         savepointLevel;
 
                 /* save name and keep Cleanup from freeing it */
                 name = s->name;
                 s->name = NULL;
                 savepointLevel = s->savepointLevel;
 
                 AbortSubTransaction();
                 CleanupSubTransaction();
 
                 DefineSavepoint(NULL);
                 s = CurrentTransactionState;    /* changed by push */
                 s->name = name;
                 s->savepointLevel = savepointLevel;
 
                 /* This is the same as TBLOCK_SUBBEGIN case */
                 AssertState(s->blockState == TBLOCK_SUBBEGIN);
                 StartSubTransaction();
                 s->blockState = TBLOCK_SUBINPROGRESS;
             }
             break;
 
             /*
              * Same as above, but the subtransaction had already failed, so we
              * don't need AbortSubTransaction.
              */
         case TBLOCK_SUBABORT_RESTART:
             {
                 char       *name;
                 int         savepointLevel;
 
                 /* save name and keep Cleanup from freeing it */
                 name = s->name;
                 s->name = NULL;
                 savepointLevel = s->savepointLevel;
 
                 CleanupSubTransaction();
 
                 DefineSavepoint(NULL);
                 s = CurrentTransactionState;    /* changed by push */
                 s->name = name;
                 s->savepointLevel = savepointLevel;
 
                 /* This is the same as TBLOCK_SUBBEGIN case */
                 AssertState(s->blockState == TBLOCK_SUBBEGIN);
                 StartSubTransaction();
                 s->blockState = TBLOCK_SUBINPROGRESS;
             }
             break;
     }
 }

◆ DefineSavepoint()

void DefineSavepoint ( const char * name )

Definition at line 4087 of file xact.c.

References TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), MemoryContextStrdup(), TransactionStateData::name, PushTransaction(), TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, and TopTransactionContext.

Referenced by CommitTransactionCommand(), and standard_ProcessUtility().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for new subtransactions after that
      * point.  (Note that this check will certainly error out if s->blockState
      * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
      * below.)
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot define savepoints during a parallel operation")));
 
     switch (s->blockState)
     {
         case TBLOCK_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
             /* Normal subtransaction start */
             PushTransaction();
             s = CurrentTransactionState;    /* changed by push */
 
             /*
              * Savepoint names, like the TransactionState block itself, live
              * in TopTransactionContext.
              */
             if (name)
                 s->name = MemoryContextStrdup(TopTransactionContext, name);
             break;
 
             /*
              * We disallow savepoint commands in implicit transaction blocks.
              * There would be no great difficulty in allowing them so far as
              * this module is concerned, but a savepoint seems inconsistent
              * with exec_simple_query's behavior of abandoning the whole query
              * string upon error.  Also, the point of an implicit transaction
              * block (as opposed to a regular one) is to automatically close
              * after an error, so it's hard to see how a savepoint would fit
              * into that.
              *
              * The error messages for this are phrased as if there were no
              * active transaction block at all, which is historical but
              * perhaps could be improved.
              */
         case TBLOCK_IMPLICIT_INPROGRESS:
             ereport(ERROR,
                     (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
             /* translator: %s represents an SQL statement name */
                      errmsg("%s can only be used in transaction blocks",
                             "SAVEPOINT")));
             break;
 
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_STARTED:
         case TBLOCK_BEGIN:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_END:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
         case TBLOCK_ABORT_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
         case TBLOCK_PREPARE:
             elog(FATAL, "DefineSavepoint: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
 }

◆ EndImplicitTransactionBlock()

void EndImplicitTransactionBlock ( void )

Definition at line 4065 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, TBLOCK_IMPLICIT_INPROGRESS, and TBLOCK_STARTED.

Referenced by exec_simple_query().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
      * allowing CommitTransactionCommand to commit whatever happened during
      * the implicit transaction block as though it were a single statement.
      *
      * For caller convenience, we consider all other transaction states as
      * legal here; otherwise the caller would need its own state check, which
      * seems rather pointless.
      */
     if (s->blockState == TBLOCK_IMPLICIT_INPROGRESS)
         s->blockState = TBLOCK_STARTED;
 }

◆ EndParallelWorkerTransaction()

void EndParallelWorkerTransaction ( void )

Definition at line 5331 of file xact.c.

References Assert, TransactionStateData::blockState, CommitTransaction(), TBLOCK_DEFAULT, and TBLOCK_PARALLEL_INPROGRESS.

Referenced by ParallelWorkerMain().

 {
     Assert(CurrentTransactionState->blockState == TBLOCK_PARALLEL_INPROGRESS);
     CommitTransaction();
     CurrentTransactionState->blockState = TBLOCK_DEFAULT;
 }

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool chain )

Definition at line 3758 of file xact.c.

References Assert, TransactionStateData::blockState, BlockStateAsString(), TransactionStateData::chain, CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, TransactionStateData::parent, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBRESTART, and WARNING.

Referenced by PrepareTransactionBlock(), and standard_ProcessUtility().

 {
     TransactionState s = CurrentTransactionState;
     bool        result = false;
 
     switch (s->blockState)
     {
             /*
              * We are in a transaction block, so tell CommitTransactionCommand
              * to COMMIT.
              */
         case TBLOCK_INPROGRESS:
             s->blockState = TBLOCK_END;
             result = true;
             break;
 
             /*
              * We are in an implicit transaction block.  If AND CHAIN was
              * specified, error.  Otherwise commit, but issue a warning
              * because there was no explicit BEGIN before this.
              */
         case TBLOCK_IMPLICIT_INPROGRESS:
             if (chain)
                 ereport(ERROR,
                         (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                 /* translator: %s represents an SQL statement name */
                          errmsg("%s can only be used in transaction blocks",
                                 "COMMIT AND CHAIN")));
             else
                 ereport(WARNING,
                         (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                          errmsg("there is no transaction in progress")));
             s->blockState = TBLOCK_END;
             result = true;
             break;
 
             /*
              * We are in a failed transaction block.  Tell
              * CommitTransactionCommand it's time to exit the block.
              */
         case TBLOCK_ABORT:
             s->blockState = TBLOCK_ABORT_END;
             break;
 
             /*
              * We are in a live subtransaction block.  Set up to subcommit all
              * open subtransactions and then commit the main transaction.
              */
         case TBLOCK_SUBINPROGRESS:
             while (s->parent != NULL)
             {
                 if (s->blockState == TBLOCK_SUBINPROGRESS)
                     s->blockState = TBLOCK_SUBCOMMIT;
                 else
                     elog(FATAL, "EndTransactionBlock: unexpected state %s",
                          BlockStateAsString(s->blockState));
                 s = s->parent;
             }
             if (s->blockState == TBLOCK_INPROGRESS)
                 s->blockState = TBLOCK_END;
             else
                 elog(FATAL, "EndTransactionBlock: unexpected state %s",
                      BlockStateAsString(s->blockState));
             result = true;
             break;
 
             /*
              * Here we are inside an aborted subtransaction.  Treat the COMMIT
              * as ROLLBACK: set up to abort everything and exit the main
              * transaction.
              */
         case TBLOCK_SUBABORT:
             while (s->parent != NULL)
             {
                 if (s->blockState == TBLOCK_SUBINPROGRESS)
                     s->blockState = TBLOCK_SUBABORT_PENDING;
                 else if (s->blockState == TBLOCK_SUBABORT)
                     s->blockState = TBLOCK_SUBABORT_END;
                 else
                     elog(FATAL, "EndTransactionBlock: unexpected state %s",
                          BlockStateAsString(s->blockState));
                 s = s->parent;
             }
             if (s->blockState == TBLOCK_INPROGRESS)
                 s->blockState = TBLOCK_ABORT_PENDING;
             else if (s->blockState == TBLOCK_ABORT)
                 s->blockState = TBLOCK_ABORT_END;
             else
                 elog(FATAL, "EndTransactionBlock: unexpected state %s",
                      BlockStateAsString(s->blockState));
             break;
 
             /*
              * The user issued COMMIT when not inside a transaction.  For
              * COMMIT without CHAIN, issue a WARNING, staying in
              * TBLOCK_STARTED state.  The upcoming call to
              * CommitTransactionCommand() will then close the transaction and
              * put us back into the default state.  For COMMIT AND CHAIN,
              * error.
              */
         case TBLOCK_STARTED:
             if (chain)
                 ereport(ERROR,
                         (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                 /* translator: %s represents an SQL statement name */
                          errmsg("%s can only be used in transaction blocks",
                                 "COMMIT AND CHAIN")));
             else
                 ereport(WARNING,
                         (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                          errmsg("there is no transaction in progress")));
             result = true;
             break;
 
             /*
              * The user issued a COMMIT that somehow ran inside a parallel
              * worker.  We can't cope with that.
              */
         case TBLOCK_PARALLEL_INPROGRESS:
             ereport(FATAL,
                     (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                      errmsg("cannot commit during a parallel operation")));
             break;
 
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_BEGIN:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_END:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
         case TBLOCK_PREPARE:
             elog(FATAL, "EndTransactionBlock: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
 
     Assert(s->blockState == TBLOCK_STARTED ||
            s->blockState == TBLOCK_END ||
            s->blockState == TBLOCK_ABORT_END ||
            s->blockState == TBLOCK_ABORT_PENDING);
 
     s->chain = chain;
 
     return result;
 }

◆ EnterParallelMode()

void EnterParallelMode ( void )

Definition at line 979 of file xact.c.

References Assert, CurrentTransactionState, and TransactionStateData::parallelModeLevel.

Referenced by _bt_begin_parallel(), begin_parallel_vacuum(), CommitTransaction(), ExecutePlan(), and ParallelWorkerMain().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parallelModeLevel >= 0);
 
     ++s->parallelModeLevel;
 }

◆ EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace ( void )

Definition at line 5208 of file xact.c.

References add_size(), TransactionStateData::fullTransactionId, FullTransactionIdIsValid, mul_size(), TransactionStateData::nChildXids, TransactionStateData::parent, and SerializedTransactionStateHeaderSize.

Referenced by InitializeParallelDSM().

 {
     TransactionState s;
     Size        nxids = 0;
     Size        size = SerializedTransactionStateHeaderSize;
 
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         if (FullTransactionIdIsValid(s->fullTransactionId))
             nxids = add_size(nxids, 1);
         nxids = add_size(nxids, s->nChildXids);
     }
 
     return add_size(size, mul_size(sizeof(TransactionId), nxids));
 }

◆ ExitParallelMode()

void ExitParallelMode ( void )

Definition at line 992 of file xact.c.

References Assert, CurrentTransactionState, ParallelContextActive(), and TransactionStateData::parallelModeLevel.

Referenced by _bt_begin_parallel(), _bt_end_parallel(), end_parallel_vacuum(), ExecutePlan(), and ParallelWorkerMain().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parallelModeLevel > 0);
     Assert(s->parallelModeLevel > 1 || !ParallelContextActive());
 
     --s->parallelModeLevel;
 }

◆ ForceSyncCommit()

void ForceSyncCommit ( void )

Definition at line 1071 of file xact.c.

References forceSyncCommit.

Referenced by createdb(), CreateTableSpace(), dropdb(), DropTableSpace(), and movedb().

 {
     forceSyncCommit = true;
 }

◆ GetCurrentCommandId()

CommandId GetCurrentCommandId ( bool used )

Definition at line 761 of file xact.c.

References Assert, currentCommandId, currentCommandIdUsed, and IsParallelWorker.

Referenced by ATRewriteTable(), CatalogTuplesMultiInsertWithInfo(), CopyFrom(), create_estate_for_relation(), GetSnapshotData(), GetSnapshotDataReuse(), intorel_startup(), pgrowlocks(), RegisterRelcacheInvalidation(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), simple_heap_delete(), simple_heap_insert(), simple_heap_update(), simple_table_tuple_delete(), simple_table_tuple_insert(), simple_table_tuple_update(), standard_ExecutorStart(), toast_save_datum(), transientrel_startup(), and UpdateActiveSnapshotCommandId().

 {
     /* this is global to a transaction, not subtransaction-local */
     if (used)
     {
         /*
          * Forbid setting currentCommandIdUsed in a parallel worker, because
          * we have no provision for communicating this back to the leader.  We
          * could relax this restriction when currentCommandIdUsed was already
          * true at the start of the parallel operation.
          */
         Assert(!IsParallelWorker());
         currentCommandIdUsed = true;
     }
     return currentCommandId;
 }

◆ GetCurrentFullTransactionId()

FullTransactionId GetCurrentFullTransactionId ( void )

Definition at line 496 of file xact.c.

References AssignTransactionId(), CurrentTransactionState, TransactionStateData::fullTransactionId, and FullTransactionIdIsValid.

 {
     TransactionState s = CurrentTransactionState;
 
     if (!FullTransactionIdIsValid(s->fullTransactionId))
         AssignTransactionId(s);
     return s->fullTransactionId;
 }

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void )

Definition at line 514 of file xact.c.

References TransactionStateData::fullTransactionId.

 {
     return CurrentTransactionState->fullTransactionId;
 }

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void )

Definition at line 807 of file xact.c.

References stmtStartTimestamp.

Referenced by check_log_duration(), CreatePortal(), InitializeParallelDSM(), pgstat_report_activity(), statement_timestamp(), and StorePreparedStatement().

 {
     return stmtStartTimestamp;
 }

◆ GetCurrentSubTransactionId()

SubTransactionId GetCurrentSubTransactionId ( void )

Definition at line 723 of file xact.c.

References CurrentTransactionState, and TransactionStateData::subTransactionId.

Referenced by _SPI_begin_call(), AllocateDir(), AllocateFile(), CopyFrom(), CreateParallelContext(), CreatePortal(), ExecuteTruncateGuts(), init_sql_fcache(), InitTempTableNamespace(), inv_open(), MarkPortalActive(), OpenPipeStream(), OpenTransientFilePerm(), plpgsql_create_econtext(), plpgsql_inline_handler(), register_on_commit_action(), RelationAssumeNewRelfilenode(), RelationBuildLocalRelation(), RelationForgetRelation(), remove_on_commit_action(), sepgsql_set_client_label(), SPI_connect_ext(), and spi_dest_startup().

 {
     TransactionState s = CurrentTransactionState;
 
     return s->subTransactionId;
 }

◆ GetCurrentTransactionId()

TransactionId GetCurrentTransactionId ( void )

Definition at line 438 of file xact.c.

References AssignTransactionId(), CurrentTransactionState, TransactionStateData::fullTransactionId, FullTransactionIdIsValid, and XidFromFullTransactionId.

Referenced by asyncQueueNotificationToEntry(), check_exclusion_or_unique_constraint(), ExecInsert(), heap_abort_speculative(), heap_delete(), heap_insert(), heap_lock_tuple(), heap_multi_insert(), heap_update(), LogAccessExclusiveLock(), LogAccessExclusiveLockPrepare(), logical_rewrite_log_mapping(), LogLogicalMessage(), PreCommit_Notify(), PrepareTransaction(), RelationSetNewRelfilenode(), and ReorderBufferProcessTXN().

 {
     TransactionState s = CurrentTransactionState;
 
     if (!FullTransactionIdIsValid(s->fullTransactionId))
         AssignTransactionId(s);
     return XidFromFullTransactionId(s->fullTransactionId);
 }

◆ GetCurrentTransactionIdIfAny()

TransactionId GetCurrentTransactionIdIfAny ( void )

Definition at line 455 of file xact.c.

References TransactionStateData::fullTransactionId, and XidFromFullTransactionId.

Referenced by IsSubTransactionAssignmentPending(), RecordTransactionAbort(), ReorderBufferProcessTXN(), and XLogRecordAssemble().

 {
     return XidFromFullTransactionId(CurrentTransactionState->fullTransactionId);
 }

◆ GetCurrentTransactionNestLevel()

int GetCurrentTransactionNestLevel ( void )

Definition at line 857 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by AfterTriggerBeginSubXact(), AfterTriggerEndSubXact(), AfterTriggerSetState(), Async_Notify(), AtEOSubXact_Inval(), AtEOSubXact_Namespace(), AtSubAbort_Notify(), AtSubCommit_Notify(), AtSubCommit_smgr(), begin_remote_xact(), logicalrep_worker_stop_at_commit(), pgfdw_subxact_callback(), pgstat_count_heap_delete(), pgstat_count_heap_insert(), pgstat_count_heap_update(), pgstat_count_truncate(), PopOverrideSearchPath(), PrepareInvalidationState(), PushActiveSnapshot(), PushOverrideSearchPath(), queue_listen(), register_seq_scan(), RelationCreateStorage(), RelationDropStorage(), RelationMapUpdateMap(), RestoreReindexState(), SetReindexPending(), SetReindexProcessing(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), and smgrGetPendingDeletes().

 {
     TransactionState s = CurrentTransactionState;
 
     return s->nestingLevel;
 }

◆ GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp ( void )

Definition at line 798 of file xact.c.

References xactStartTimestamp.

Referenced by GetCurrentTimeUsec(), GetSQLCurrentTimestamp(), GetSQLLocalTimestamp(), InitializeParallelDSM(), now(), pg_timezone_abbrevs(), and pg_timezone_names().

 {
     return xactStartTimestamp;
 }

◆ GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp ( void )

Definition at line 819 of file xact.c.

References GetCurrentTimestamp(), and xactStopTimestamp.

Referenced by pgstat_report_stat().

 {
     if (xactStopTimestamp != 0)
         return xactStopTimestamp;
     return GetCurrentTimestamp();
 }

◆ GetStableLatestTransactionId()

TransactionId GetStableLatestTransactionId ( void )

Definition at line 541 of file xact.c.

References Assert, GetTopTransactionIdIfAny(), InvalidLocalTransactionId, InvalidTransactionId, PGPROC::lxid, MyProc, ReadNewTransactionId(), and TransactionIdIsValid.

Referenced by xid_age().

 {
     static LocalTransactionId lxid = InvalidLocalTransactionId;
     static TransactionId stablexid = InvalidTransactionId;
 
     if (lxid != MyProc->lxid)
     {
         lxid = MyProc->lxid;
         stablexid = GetTopTransactionIdIfAny();
         if (!TransactionIdIsValid(stablexid))
             stablexid = ReadNewTransactionId();
     }
 
     Assert(TransactionIdIsValid(stablexid));
 
     return stablexid;
 }

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void )

Definition at line 467 of file xact.c.

References AssignTransactionId(), FullTransactionIdIsValid, and XactTopFullTransactionId.

Referenced by pg_current_xact_id().

 {
     if (!FullTransactionIdIsValid(XactTopFullTransactionId))
         AssignTransactionId(&TopTransactionStateData);
     return XactTopFullTransactionId;
 }

◆ GetTopFullTransactionIdIfAny()

FullTransactionId GetTopFullTransactionIdIfAny ( void )

Definition at line 483 of file xact.c.

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

 {
     return XactTopFullTransactionId;
 }

◆ GetTopTransactionId()

TransactionId GetTopTransactionId ( void )

Definition at line 410 of file xact.c.

References AssignTransactionId(), FullTransactionIdIsValid, and XidFromFullTransactionId.

Referenced by AlterSequence(), AssignTransactionId(), do_setval(), fill_seq_with_data(), log_heap_new_cid(), and nextval_internal().

 {
     if (!FullTransactionIdIsValid(XactTopFullTransactionId))
         AssignTransactionId(&TopTransactionStateData);
     return XidFromFullTransactionId(XactTopFullTransactionId);
 }

◆ GetTopTransactionIdIfAny()

TransactionId GetTopTransactionIdIfAny ( void )

Definition at line 425 of file xact.c.

References XidFromFullTransactionId.

Referenced by CheckForSerializableConflictOut(), ConditionalXactLockTableWait(), CreateInitDecodingContext(), ExportSnapshot(), GetSerializableTransactionSnapshotInt(), GetStableLatestTransactionId(), HeapCheckForSerializableConflictOut(), ImportSnapshot(), index_drop(), initSpGistState(), log_line_prefix(), RecordTransactionCommit(), TransactionIdIsCurrentTransactionId(), write_csvlog(), XactLockTableWait(), XidIsConcurrent(), and XLogRecordAssemble().

 {
     return XidFromFullTransactionId(XactTopFullTransactionId);
 }

◆ IsAbortedTransactionBlockState()

bool IsAbortedTransactionBlockState ( void )

Definition at line 391 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, TBLOCK_ABORT, and TBLOCK_SUBABORT.

Referenced by BuildParamLogString(), exec_bind_message(), exec_describe_portal_message(), exec_describe_statement_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), HandleFunctionRequest(), PostgresMain(), and RecoveryConflictInterrupt().

 {
     TransactionState s = CurrentTransactionState;
 
     if (s->blockState == TBLOCK_ABORT ||
         s->blockState == TBLOCK_SUBABORT)
         return true;
 
     return false;
 }

◆ IsInParallelMode()

bool IsInParallelMode ( void )

Definition at line 1012 of file xact.c.

References TransactionStateData::parallelModeLevel.

Referenced by AbortSubTransaction(), AbortTransaction(), AssignTransactionId(), BeginInternalSubTransaction(), CheckTargetForConflictsIn(), CommandCounterIncrement(), CommitSubTransaction(), CommitTransaction(), CreateParallelContext(), CreatePredicateLock(), DefineSavepoint(), DeleteChildTargetLocks(), ExecSetVariableStmt(), GetLatestSnapshot(), GetNewTransactionId(), GetSerializableTransactionSnapshotInt(), GetTransactionSnapshot(), heap_delete(), heap_inplace_update(), heap_update(), PrepareTransaction(), PreventCommandIfParallelMode(), RelationCreateStorage(), RelationMapUpdateMap(), ReleaseCurrentSubTransaction(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), ReleaseSavepoint(), RemoveReindexPending(), RollbackToSavepoint(), set_config_option(), SetReindexPending(), standard_ExecutorStart(), standard_ProcessUtility(), update_index_statistics(), and UpdateActiveSnapshotCommandId().

 {
     return CurrentTransactionState->parallelModeLevel != 0;
 }

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool isTopLevel )

Definition at line 3493 of file xact.c.

References TransactionStateData::blockState, IsSubTransaction(), IsTransactionBlock(), TBLOCK_DEFAULT, and TBLOCK_STARTED.

Referenced by vacuum(), and vacuum_set_xid_limits().

 {
     /*
      * Return true on same conditions that would make
      * PreventInTransactionBlock error out
      */
     if (IsTransactionBlock())
         return true;
 
     if (IsSubTransaction())
         return true;
 
     if (!isTopLevel)
         return true;
 
     if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
         CurrentTransactionState->blockState != TBLOCK_STARTED)
         return true;
 
     return false;
 }

◆ IsSubTransaction()

bool IsSubTransaction ( void )

Definition at line 4757 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by _SPI_commit(), _SPI_rollback(), AfterTriggerSetState(), check_transaction_deferrable(), check_transaction_read_only(), check_XactIsoLevel(), CheckTargetForConflictsIn(), CheckTransactionBlock(), CreateReplicationSlot(), ExportSnapshot(), ImportSnapshot(), IsInTransactionBlock(), IsSubTransactionAssignmentPending(), PreventInTransactionBlock(), and RecoveryConflictInterrupt().

 {
     TransactionState s = CurrentTransactionState;
 
     if (s->nestingLevel >= 2)
         return true;
 
     return false;
 }

◆ IsSubTransactionAssignmentPending()

bool IsSubTransactionAssignmentPending ( void )

Definition at line 6079 of file xact.c.

References TransactionStateData::assigned, GetCurrentTransactionIdIfAny(), IsSubTransaction(), IsTransactionState(), TransactionIdIsValid, and XLogLogicalInfoActive.

Referenced by MarkSubTransactionAssigned(), and XLogRecordAssemble().

 {
     /* wal_level has to be logical */
     if (!XLogLogicalInfoActive())
         return false;
 
     /* we need to be in a transaction state */
     if (!IsTransactionState())
         return false;
 
     /* it has to be a subtransaction */
     if (!IsSubTransaction())
         return false;
 
     /* the subtransaction has to have a XID assigned */
     if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny()))
         return false;
 
     /* and it should not be already 'assigned' */
     return !CurrentTransactionState->assigned;
 }

◆ IsTransactionBlock()

bool IsTransactionBlock ( void )

Definition at line 4684 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, TBLOCK_DEFAULT, and TBLOCK_STARTED.

Referenced by CheckTransactionBlock(), CreateReplicationSlot(), IsInTransactionBlock(), PreventInTransactionBlock(), and standard_ProcessUtility().

 {
     TransactionState s = CurrentTransactionState;
 
     if (s->blockState == TBLOCK_DEFAULT || s->blockState == TBLOCK_STARTED)
         return false;
 
     return true;
 }

Enumerations
enum	TransState { TRANS_DEFAULT, TRANS_START, TRANS_INPROGRESS, TRANS_COMMIT, TRANS_ABORT, TRANS_PREPARE }

enum	TBlockState { TBLOCK_DEFAULT, TBLOCK_STARTED, TBLOCK_BEGIN, TBLOCK_INPROGRESS, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_END, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_PREPARE, TBLOCK_SUBBEGIN, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBCOMMIT, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBRESTART, TBLOCK_SUBABORT_RESTART }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ SerializedTransactionStateHeaderSize

Typedef Documentation

◆ SerializedTransactionState

◆ SubXactCallbackItem

◆ TBlockState

◆ TransactionState

◆ TransactionStateData

◆ TransState

◆ XactCallbackItem

Enumeration Type Documentation

◆ TBlockState

◆ TransState

Function Documentation

◆ AbortCurrentTransaction()

◆ AbortOutOfAnyTransaction()

◆ AbortSubTransaction()

◆ AbortTransaction()

◆ AssignTransactionId()

◆ AtAbort_Memory()

◆ AtAbort_ResourceOwner()

◆ AtCCI_LocalCache()

◆ AtCleanup_Memory()

◆ AtCommit_Memory()

◆ AtStart_Cache()

◆ AtStart_Memory()

◆ AtStart_ResourceOwner()

◆ AtSubAbort_childXids()

◆ AtSubAbort_Memory()

◆ AtSubAbort_ResourceOwner()

◆ AtSubCleanup_Memory()

◆ AtSubCommit_childXids()

◆ AtSubCommit_Memory()

◆ AtSubStart_Memory()

◆ AtSubStart_ResourceOwner()

◆ BeginImplicitTransactionBlock()

◆ BeginInternalSubTransaction()

◆ BeginTransactionBlock()

◆ BlockStateAsString()

◆ CallSubXactCallbacks()

◆ CallXactCallbacks()

◆ CheckTransactionBlock()

◆ CleanupSubTransaction()

◆ CleanupTransaction()

◆ CommandCounterIncrement()

◆ CommitSubTransaction()

◆ CommitTransaction()

◆ CommitTransactionCommand()

◆ DefineSavepoint()

◆ EndImplicitTransactionBlock()

◆ EndParallelWorkerTransaction()

◆ EndTransactionBlock()

◆ EnterParallelMode()

◆ EstimateTransactionStateSpace()

◆ ExitParallelMode()

◆ ForceSyncCommit()

◆ GetCurrentCommandId()

◆ GetCurrentFullTransactionId()

◆ GetCurrentFullTransactionIdIfAny()

◆ GetCurrentStatementStartTimestamp()

◆ GetCurrentSubTransactionId()

◆ GetCurrentTransactionId()

◆ GetCurrentTransactionIdIfAny()

◆ GetCurrentTransactionNestLevel()

◆ GetCurrentTransactionStartTimestamp()

◆ GetCurrentTransactionStopTimestamp()

◆ GetStableLatestTransactionId()

◆ GetTopFullTransactionId()

◆ GetTopFullTransactionIdIfAny()

◆ GetTopTransactionId()

◆ GetTopTransactionIdIfAny()

◆ IsAbortedTransactionBlockState()

◆ IsInParallelMode()

◆ IsInTransactionBlock()