#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/xlogrecovery.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 "common/pg_prng.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/logicalworker.h"
#include "replication/origin.h"
#include "replication/snapbuild.h"
#include "replication/syncrep.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/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

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 }

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 bool	CommitTransactionCommandInternal (void)

static bool	AbortCurrentTransactionInternal (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 s)

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)

bool	IsSubxactTopXidLogPending (void)

void	MarkSubxactTopXidLogged (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)

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 (SavedTransactionCharacteristics *s)

void	RestoreTransactionCharacteristics (const SavedTransactionCharacteristics *s)

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, RelFileLocator rels, int ndroppedstats, xl_xact_stats_item droppedstats, 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, RelFileLocator rels, int ndroppedstats, xl_xact_stats_item droppedstats, 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, XLogRecPtr lsn, RepOriginId origin_id)

void	xact_redo (XLogReaderState *record)

Variables
int	DefaultXactIsoLevel = XACT_READ_COMMITTED

int	XactIsoLevel = XACT_READ_COMMITTED

bool	DefaultXactReadOnly = false

bool	XactReadOnly

bool	DefaultXactDeferrable = false

bool	XactDeferrable

int	synchronous_commit = SYNCHRONOUS_COMMIT_ON

TransactionId	CheckXidAlive = InvalidTransactionId

bool	bsysscan = false

static FullTransactionId	XactTopFullTransactionId = {InvalidTransactionId}

static int	nParallelCurrentXids = 0

static 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

Macro Definition Documentation

◆ SerializedTransactionStateHeaderSize

#define SerializedTransactionStateHeaderSize offsetof(SerializedTransactionState, parallelCurrentXids)

Definition at line 237 of file xact.c.

Typedef Documentation

◆ SerializedTransactionState

typedef struct SerializedTransactionState SerializedTransactionState

◆ SubXactCallbackItem

typedef struct SubXactCallbackItem SubXactCallbackItem

◆ TBlockState

typedef enum TBlockState TBlockState

◆ TransactionState

typedef TransactionStateData* TransactionState

Definition at line 219 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 155 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 139 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 3425 of file xact.c.

 {
     /*
      * Repeatedly call AbortCurrentTransactionInternal() until all the work is
      * done.
      */
     while (!AbortCurrentTransactionInternal())
     {
     }
 }

References AbortCurrentTransactionInternal().

Referenced by _SPI_commit(), _SPI_rollback(), pa_stream_abort(), PostgresMain(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), and SnapBuildClearExportedSnapshot().

◆ AbortCurrentTransactionInternal()

static bool AbortCurrentTransactionInternal ( void )

static

Definition at line 3443 of file xact.c.

 {
     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.  As
              * we need to abort the parent, return false to request the caller
              * to do the next iteration.
              */
         case TBLOCK_SUBBEGIN:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
             AbortSubTransaction();
             CleanupSubTransaction();
             return false;
  
             /*
              * Same as above, except the Abort() was already done.
              */
         case TBLOCK_SUBABORT_END:
         case TBLOCK_SUBABORT_RESTART:
             CleanupSubTransaction();
             return false;
     }
  
     /* Done, no more iterations required */
     return true;
 }

References 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 AbortCurrentTransaction().

◆ AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction ( void )

Definition at line 4849 of file xact.c.

 {
     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);
  
     /*
      * Revert to TopMemoryContext, to ensure we exit in a well-defined state
      * whether there were any transactions to close or not.  (Callers that
      * don't intend to exit soon should switch to some other context to avoid
      * long-term memory leaks.)
      */
     MemoryContextSwitchTo(TopMemoryContext);
 }

References AbortSubTransaction(), AbortTransaction(), Assert, AtAbort_Memory(), AtAbort_Portals(), AtSubAbort_Portals(), TransactionStateData::blockState, CleanupSubTransaction(), CleanupTransaction(), CurrentTransactionState, TransactionStateData::curTransactionOwner, MemoryContextSwitchTo(), 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, TopMemoryContext, TRANS_DEFAULT, TRANS_INPROGRESS, and TRANS_START.

Referenced by DisableSubscriptionAndExit(), do_autovacuum(), perform_work_item(), RemoveTempRelationsCallback(), ShutdownPostgres(), start_apply(), and start_table_sync().

◆ AbortSubTransaction()

static void AbortSubTransaction ( void )

static

Definition at line 5205 of file xact.c.

 {
     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();
     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.
      */
     sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
  
     /*
      * 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();
  
     /*
      * No need for SnapBuildResetExportedSnapshotState() here, snapshot
      * exports are not supported in subtransactions.
      */
  
     /*
      * If this subxact has started any unfinished parallel operation, clean up
      * its workers and exit parallel mode.  Don't warn about leaked resources.
      */
     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);
     }
  
     /*
      * 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();
 }

Referenced by AbortCurrentTransactionInternal(), AbortOutOfAnyTransaction(), CommitTransactionCommandInternal(), and RollbackAndReleaseCurrentSubTransaction().

◆ AbortTransaction()

static void AbortTransaction ( void )

static

Definition at line 2787 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     TransactionId latestXid;
     bool        is_parallel_worker;
  
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
  
     /* Disable transaction timeout */
     if (TransactionTimeout > 0)
         disable_timeout(TRANSACTION_TIMEOUT, false);
  
     /* 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 context locks, too */
     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.
      */
     sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
  
     /*
      * 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();
  
     /* Reset snapshot export state. */
     SnapBuildResetExportedSnapshotState();
  
     /*
      * If this xact has started any unfinished parallel operation, clean up
      * its workers and exit parallel mode.  Don't warn about leaked resources.
      */
     AtEOXact_Parallel(false);
     s->parallelModeLevel = 0;
     s->parallelChildXact = false;   /* should be false already */
  
     /*
      * 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->vxid.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);
         AtEOXact_LogicalRepWorkers(false);
         pgstat_report_xact_timestamp(0);
     }
  
     /*
      * State remains TRANS_ABORT until CleanupTransaction().
      */
     RESUME_INTERRUPTS();
 }

Referenced by AbortCurrentTransactionInternal(), AbortOutOfAnyTransaction(), and CommitTransactionCommandInternal().

◆ AssignTransactionId()

static void AssignTransactionId ( TransactionState s )

static

Definition at line 633 of file xact.c.

 {
     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())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("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 PGPROC and
      * pg_subtrans.
      *
      * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
      * shared storage other than PGPROC; because if there's no room for it in
      * PGPROC, 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;
         }
     }
 }

References Assert, CurrentResourceOwner, TransactionStateData::curTransactionOwner, TransactionStateData::didLogXid, ereport, errcode(), errmsg(), 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(), TopTransactionStateData, TRANS_INPROGRESS, TransactionIdIsValid, unreportedXids, XactLockTableInsert(), XactTopFullTransactionId, XidFromFullTransactionId, XLOG_XACT_ASSIGNMENT, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogStandbyInfoActive, and xl_xact_assignment::xtop.

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

◆ AtAbort_Memory()

static void AtAbort_Memory ( void )

static

Definition at line 1872 of file xact.c.

 {
     /*
      * 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);
 }

References MemoryContextSwitchTo(), TopMemoryContext, and TransactionAbortContext.

Referenced by AbortOutOfAnyTransaction(), and AbortTransaction().

◆ AtAbort_ResourceOwner()

static void AtAbort_ResourceOwner ( void )

static

Definition at line 1904 of file xact.c.

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

References CurrentResourceOwner, and TopTransactionResourceOwner.

Referenced by AbortTransaction().

◆ AtCCI_LocalCache()

static void AtCCI_LocalCache ( void )

static

Definition at line 1567 of file xact.c.

 {
     /*
      * 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();
 }

References AtCCI_RelationMap(), and CommandEndInvalidationMessages().

Referenced by CommandCounterIncrement().

◆ AtCleanup_Memory()

static void AtCleanup_Memory ( void )

static

Definition at line 1962 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /* Should be at top level */
     Assert(s->parent == NULL);
  
     /*
      * Return to the memory context that was current before we started the
      * transaction.  (In principle, this could not be any of the contexts we
      * are about to delete.  If it somehow is, assertions in mcxt.c will
      * complain.)
      */
     MemoryContextSwitchTo(s->priorContext);
  
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextReset(TransactionAbortContext);
  
     /*
      * Release all transaction-local memory, the same as in AtCommit_Memory,
      * except we must cope with the possibility that we didn't get as far as
      * creating TopTransactionContext.
      */
     if (TopTransactionContext != NULL)
         MemoryContextReset(TopTransactionContext);
  
     /*
      * Clear these pointers as a pro-forma matter.  (Notionally, while
      * TopTransactionContext still exists, it's currently not associated with
      * this TransactionState struct.)
      */
     CurTransactionContext = NULL;
     s->curTransactionContext = NULL;
 }

References Assert, CurrentTransactionState, TransactionStateData::curTransactionContext, CurTransactionContext, MemoryContextReset(), MemoryContextSwitchTo(), TransactionStateData::parent, TransactionStateData::priorContext, TopTransactionContext, and TransactionAbortContext.

Referenced by CleanupTransaction().

◆ AtCommit_Memory()

static void AtCommit_Memory ( void )

static

Definition at line 1586 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /*
      * Return to the memory context that was current before we started the
      * transaction.  (In principle, this could not be any of the contexts we
      * are about to delete.  If it somehow is, assertions in mcxt.c will
      * complain.)
      */
     MemoryContextSwitchTo(s->priorContext);
  
     /*
      * Release all transaction-local memory.  TopTransactionContext survives
      * but becomes empty; any sub-contexts go away.
      */
     Assert(TopTransactionContext != NULL);
     MemoryContextReset(TopTransactionContext);
  
     /*
      * Clear these pointers as a pro-forma matter.  (Notionally, while
      * TopTransactionContext still exists, it's currently not associated with
      * this TransactionState struct.)
      */
     CurTransactionContext = NULL;
     s->curTransactionContext = NULL;
 }

References Assert, CurrentTransactionState, TransactionStateData::curTransactionContext, CurTransactionContext, MemoryContextReset(), MemoryContextSwitchTo(), TransactionStateData::priorContext, and TopTransactionContext.

Referenced by CommitTransaction(), and PrepareTransaction().

◆ AtStart_Cache()

static void AtStart_Cache ( void )

static

Definition at line 1165 of file xact.c.

 {
     AcceptInvalidationMessages();
 }

References AcceptInvalidationMessages().

Referenced by StartTransaction().

◆ AtStart_Memory()

static void AtStart_Memory ( void )

static

Definition at line 1174 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /*
      * Remember the memory context that was active prior to transaction start.
      */
     s->priorContext = CurrentMemoryContext;
  
     /*
      * 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);
  
     /*
      * Likewise, if this is the first time through, create a top-level context
      * for transaction-local data.  This context will be reset at transaction
      * end, and then re-used in later transactions.
      */
     if (TopTransactionContext == NULL)
         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);
 }

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

Referenced by StartTransaction().

◆ AtStart_ResourceOwner()

static void AtStart_ResourceOwner ( void )

static

Definition at line 1224 of file xact.c.

 {
     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;
 }

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

Referenced by StartTransaction().

◆ AtSubAbort_childXids()

static void AtSubAbort_childXids ( void )

static

Definition at line 1930 of file xact.c.

 {
     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.
      */
 }

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

Referenced by AbortSubTransaction().

◆ AtSubAbort_Memory()

static void AtSubAbort_Memory ( void )

static

Definition at line 1892 of file xact.c.

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

References Assert, MemoryContextSwitchTo(), and TransactionAbortContext.

Referenced by AbortSubTransaction().

◆ AtSubAbort_ResourceOwner()

static void AtSubAbort_ResourceOwner ( void )

static

Definition at line 1917 of file xact.c.

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

References CurrentResourceOwner, CurrentTransactionState, and TransactionStateData::curTransactionOwner.

Referenced by AbortSubTransaction().

◆ AtSubCleanup_Memory()

static void AtSubCleanup_Memory ( void )

static

Definition at line 2010 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     Assert(s->parent != NULL);
  
     /*
      * Return to the memory context that was current before we started the
      * subtransaction.  (In principle, this could not be any of the contexts
      * we are about to delete.  If it somehow is, assertions in mcxt.c will
      * complain.)
      */
     MemoryContextSwitchTo(s->priorContext);
  
     /* Update CurTransactionContext (might not be same as priorContext) */
     CurTransactionContext = s->parent->curTransactionContext;
  
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextReset(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;
 }

References Assert, CurrentTransactionState, TransactionStateData::curTransactionContext, CurTransactionContext, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), TransactionStateData::parent, TransactionStateData::priorContext, and TransactionAbortContext.

Referenced by CleanupSubTransaction().

◆ AtSubCommit_childXids()

static void AtSubCommit_childXids ( void )

static

Definition at line 1652 of file xact.c.

 {
     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;
 }

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().

◆ AtSubCommit_Memory()

static void AtSubCommit_Memory ( void )

static

Definition at line 1623 of file xact.c.

 {
     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;
     }
 }

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

Referenced by CommitSubTransaction().

◆ AtSubStart_Memory()

static void AtSubStart_Memory ( void )

static

Definition at line 1252 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     Assert(CurTransactionContext != NULL);
  
     /*
      * Remember the context that was active prior to subtransaction start.
      */
     s->priorContext = CurrentMemoryContext;
  
     /*
      * 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);
 }

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

Referenced by StartSubTransaction().

◆ AtSubStart_ResourceOwner()

static void AtSubStart_ResourceOwner ( void )

static

Definition at line 1281 of file xact.c.

 {
     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;
 }

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

Referenced by StartSubTransaction().

◆ BeginImplicitTransactionBlock()

void BeginImplicitTransactionBlock ( void )

Definition at line 4313 of file xact.c.

 {
     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;
 }

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

Referenced by exec_simple_query().

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char * name )

Definition at line 4681 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     bool        save_ExitOnAnyError = ExitOnAnyError;
  
     /*
      * Errors within this function are improbable, but if one does happen we
      * force a FATAL exit.  Callers generally aren't prepared to handle losing
      * control, and moreover our transaction state is probably corrupted if we
      * fail partway through; so an ordinary ERROR longjmp isn't okay.
      */
     ExitOnAnyError = true;
  
     /*
      * We do not check for parallel mode here.  It's permissible to start and
      * end "internal" subtransactions while in parallel mode, so long as no
      * new XIDs or command IDs are assigned.  Enforcement of that occurs in
      * AssignTransactionId() and CommandCounterIncrement().
      */
  
     switch (s->blockState)
     {
         case TBLOCK_STARTED:
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_PARALLEL_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_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();
  
     ExitOnAnyError = save_ExitOnAnyError;
 }

References TransactionStateData::blockState, BlockStateAsString(), CommitTransactionCommand(), CurrentTransactionState, elog, ExitOnAnyError, FATAL, MemoryContextStrdup(), TransactionStateData::name, 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().

◆ BeginTransactionBlock()

void BeginTransactionBlock ( void )

Definition at line 3911 of file xact.c.

 {
     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;
     }
 }

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 apply_handle_prepare_internal(), pa_start_subtrans(), and standard_ProcessUtility().

◆ BlockStateAsString()

static const char * BlockStateAsString ( TBlockState blockState )

static

Definition at line 5688 of file xact.c.

 {
     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";
 }

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(), CommitTransactionCommandInternal(), DefineSavepoint(), EndTransactionBlock(), ReleaseCurrentSubTransaction(), ReleaseSavepoint(), RollbackAndReleaseCurrentSubTransaction(), RollbackToSavepoint(), ShowTransactionStateRec(), StartTransactionCommand(), TransactionBlockStatusCode(), and UserAbortTransactionBlock().

◆ CallSubXactCallbacks()

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

static

Definition at line 3885 of file xact.c.

 {
     SubXactCallbackItem *item;
     SubXactCallbackItem *next;
  
     for (item = SubXact_callbacks; item; item = next)
     {
         /* allow callbacks to unregister themselves when called */
         next = item->next;
         item->callback(event, mySubid, parentSubid, item->arg);
     }
 }

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

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

◆ CallXactCallbacks()

static void CallXactCallbacks ( XactEvent event )

static

Definition at line 3825 of file xact.c.

 {
     XactCallbackItem *item;
     XactCallbackItem *next;
  
     for (item = Xact_callbacks; item; item = next)
     {
         /* allow callbacks to unregister themselves when called */
         next = item->next;
         item->callback(event, item->arg);
     }
 }

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

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

◆ CheckTransactionBlock()

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

static

Definition at line 3709 of file xact.c.

 {
     /*
      * 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)));
 }

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

Referenced by RequireTransactionBlock(), and WarnNoTransactionBlock().

◆ CleanupSubTransaction()

static void CleanupSubTransaction ( void )

static

Definition at line 5364 of file xact.c.

 {
     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();
 }

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 AbortCurrentTransactionInternal(), AbortOutOfAnyTransaction(), CommitTransactionCommandInternal(), and RollbackAndReleaseCurrentSubTransaction().

◆ CleanupTransaction()

static void CleanupTransaction ( void )

static

Definition at line 2983 of file xact.c.

 {
     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;
     s->parallelChildXact = false;
  
     XactTopFullTransactionId = InvalidFullTransactionId;
     nParallelCurrentXids = 0;
  
     /*
      * done with abort processing, set current transaction state back to
      * default
      */
     s->state = TRANS_DEFAULT;
 }

Referenced by AbortCurrentTransactionInternal(), AbortOutOfAnyTransaction(), and CommitTransactionCommandInternal().

◆ CommandCounterIncrement()

void CommandCounterIncrement ( void )

Definition at line 1098 of file xact.c.

 {
     /*
      * 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())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                      errmsg("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();
     }
 }

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

Referenced by _SPI_execute_plan(), acquire_inherited_sample_rows(), addFkRecurseReferenced(), addFkRecurseReferencing(), AddRoleMems(), AlterPublicationOptions(), AlterRole(), ATAddCheckConstraint(), ATExecAddColumn(), ATExecAlterColumnType(), ATExecCmd(), ATExecDropColumn(), ATExecDropConstraint(), ATExecDropExpression(), ATExecDropIdentity(), ATExecMergePartitions(), ATExecSetAccessMethodNoStorage(), ATExecSetCompression(), ATExecSetExpression(), ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), ATExecSplitPartition(), ATParseTransformCmd(), ATRewriteTables(), AttachPartitionEnsureIndexes(), btadjustmembers(), CloneFkReferencing(), CommitSubTransaction(), CommitTransactionCommandInternal(), copy_table_data(), create_ctas_internal(), create_toast_table(), CreateFKCheckTrigger(), createForeignKeyActionTriggers(), CreateForeignTable(), CreatePublication(), CreateRole(), CreateSchemaCommand(), CreateTriggerFiringOn(), DefineCollation(), DefineDomain(), DefineIndex(), DefineRelation(), DefineVirtualRelation(), deleteOneObject(), DetachPartitionFinalize(), do_analyze_rel(), DropClonedTriggersFromPartition(), DropRole(), end_replication_step(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerInvoke(), EventTriggerSQLDrop(), EventTriggerTableRewrite(), exec_eval_simple_expr(), exec_execute_message(), exec_parse_message(), exec_simple_query(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), execute_sql_string(), ExplainOnePlan(), finish_heap_swap(), fmgr_sql(), hashadjustmembers(), ImportForeignSchema(), index_build(), index_create(), IndexSetParentIndex(), InitTempTableNamespace(), inv_create(), inv_drop(), inv_truncate(), inv_write(), LogicalRepSyncTableStart(), make_new_heap(), makeConfigurationDependencies(), moveArrayTypeName(), objectNamesToOids(), OperatorShellMake(), OperatorUpd(), pg_import_system_collations(), PortalRunMulti(), ProcedureCreate(), process_syncing_tables_for_apply(), ProcessUtilitySlow(), recordExtensionInitPrivWorker(), reindex_index(), reindex_relation(), ReindexRelationConcurrently(), RelationSetNewRelfilenumber(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectPolicy(), RenumberEnumType(), ReplaceRoleInInitPriv(), replorigin_create(), replorigin_drop_by_name(), ri_PerformCheck(), SetDatabaseHasLoginEventTriggers(), SetDefaultACL(), SetMatViewPopulatedState(), shdepReassignOwned(), SPI_cursor_open_internal(), standard_ProcessUtility(), StoreConstraints(), StorePartitionBound(), tryAttachPartitionForeignKey(), vacuum(), and validatePartitionedIndex().

◆ CommitSubTransaction()

static void CommitSubTransaction ( void )

static

Definition at line 5091 of file xact.c.

 {
     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 this subxact has started any unfinished parallel operation, clean up
      * its workers and exit parallel mode.  Warn about leaked resources.
      */
     AtEOSubXact_Parallel(true, s->subTransactionId);
     if (s->parallelModeLevel != 0)
     {
         elog(WARNING, "parallelModeLevel is %d not 0 at end of subtransaction",
              s->parallelModeLevel);
         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->nestingLevel,
                         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);
  
     /*
      * 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();
 }

Referenced by CommitTransactionCommandInternal(), and ReleaseCurrentSubTransaction().

◆ CommitTransaction()

static void CommitTransaction ( void )

static

Definition at line 2216 of file xact.c.

 {
     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.  SECURITY_RESTRICTED_OPERATION contexts must not queue an
      * action that would run here, because that would bypass the sandbox.
      * 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;
     }
  
     /*
      * 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.
      */
  
     CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
                       : XACT_EVENT_PRE_COMMIT);
  
     /*
      * If this xact has started any unfinished parallel operation, clean up
      * its workers, warning about leaked resources.  (But we don't actually
      * reset parallelModeLevel till entering TRANS_COMMIT, a bit below.  This
      * keeps parallel mode restrictions active as long as possible in a
      * parallel worker.)
      */
     AtEOXact_Parallel(true);
     if (is_parallel_worker)
     {
         if (s->parallelModeLevel != 1)
             elog(WARNING, "parallelModeLevel is %d not 1 at end of parallel worker transaction",
                  s->parallelModeLevel);
     }
     else
     {
         if (s->parallelModeLevel != 0)
             elog(WARNING, "parallelModeLevel is %d not 0 at end of transaction",
                  s->parallelModeLevel);
     }
  
     /* 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;
     s->parallelChildXact = false;   /* should be false already */
  
     /* Disable transaction timeout */
     if (TransactionTimeout > 0)
         disable_timeout(TRANSACTION_TIMEOUT, false);
  
     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->vxid.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);
  
     CurrentResourceOwner = NULL;
     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);
  
     /*
      * Send out notification signals to other backends (and do other
      * post-commit NOTIFY cleanup).  This must not happen until after our
      * transaction is fully done from the viewpoint of other backends.
      */
     AtCommit_Notify();
  
     /*
      * Everything after this should be purely internal-to-this-backend
      * cleanup.
      */
     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);
     AtEOXact_LogicalRepWorkers(true);
     pgstat_report_xact_timestamp(0);
  
     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();
 }

Referenced by CommitTransactionCommandInternal(), EndParallelWorkerTransaction(), EndRestoreLOs(), restore_toc_entries_prefork(), restore_toc_entry(), and RestoreArchive().

◆ CommitTransactionCommand()

void CommitTransactionCommand ( void )

Definition at line 3131 of file xact.c.

 {
     /*
      * Repeatedly call CommitTransactionCommandInternal() until all the work
      * is done.
      */
     while (!CommitTransactionCommandInternal())
     {
     }
 }

References CommitTransactionCommandInternal().

Referenced by _SPI_commit(), AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_prepare_internal(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), BeginInternalSubTransaction(), BootstrapModeMain(), clear_subscription_skip_lsn(), cluster_multiple_rels(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), EventTriggerOnLogin(), exec_replication_command(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeLogRepWorker(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), pa_stream_abort(), ParallelApplyWorkerMain(), ParallelWorkerMain(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), run_apply_worker(), shell_check_detail(), stream_abort_internal(), stream_stop_internal(), synchronize_slots(), vacuum(), vacuum_rel(), validate_remote_info(), and worker_spi_main().

◆ CommitTransactionCommandInternal()

static bool CommitTransactionCommandInternal ( void )

static

Definition at line 3149 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     SavedTransactionCharacteristics savetc;
  
     /* Must save in case we need to restore below */
     SaveTransactionCharacteristics(&savetc);
  
     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(&savetc);
             }
             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(&savetc);
             }
             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(&savetc);
             }
             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;
  
             /*
              * The user 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;
  
             /*
              * The user 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;
  
             /*
              * The user 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;
                 if (s->chain)
                 {
                     StartTransaction();
                     s->blockState = TBLOCK_INPROGRESS;
                     s->chain = false;
                     RestoreTransactionCharacteristics(&savetc);
                 }
             }
             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).
              * As we need to examine the parent, return false to request the
              * caller to do the next iteration.
              */
         case TBLOCK_SUBABORT_END:
             CleanupSubTransaction();
             return false;
  
             /*
              * As above, but it's not dead yet, so abort first.
              */
         case TBLOCK_SUBABORT_PENDING:
             AbortSubTransaction();
             CleanupSubTransaction();
             return false;
  
             /*
              * 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 */
                 Assert(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 */
                 Assert(s->blockState == TBLOCK_SUBBEGIN);
                 StartSubTransaction();
                 s->blockState = TBLOCK_SUBINPROGRESS;
             }
             break;
     }
  
     /* Done, no more iterations required */
     return true;
 }

References AbortSubTransaction(), AbortTransaction(), Assert, TransactionStateData::blockState, BlockStateAsString(), TransactionStateData::chain, CleanupSubTransaction(), CleanupTransaction(), CommandCounterIncrement(), CommitSubTransaction(), CommitTransaction(), CurrentTransactionState, DefineSavepoint(), elog, ERROR, FATAL, TransactionStateData::name, 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 CommitTransactionCommand().

◆ DefineSavepoint()

void DefineSavepoint ( const char * name )

Definition at line 4360 of file xact.c.

 {
     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() || IsParallelWorker())
         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;
     }
 }

References TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), IsParallelWorker, MemoryContextStrdup(), TransactionStateData::name, 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 CommitTransactionCommandInternal(), pa_start_subtrans(), and standard_ProcessUtility().

◆ EndImplicitTransactionBlock()

void EndImplicitTransactionBlock ( void )

Definition at line 4338 of file xact.c.

 {
     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;
 }

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

Referenced by exec_simple_query().

◆ EndParallelWorkerTransaction()

void EndParallelWorkerTransaction ( void )

Definition at line 5617 of file xact.c.

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

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

Referenced by ParallelWorkerMain().

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool chain )

Definition at line 4031 of file xact.c.

 {
     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;
 }

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 apply_handle_commit_internal(), pa_stream_abort(), PrepareTransactionBlock(), and standard_ProcessUtility().

◆ EnterParallelMode()

void EnterParallelMode ( void )

Definition at line 1049 of file xact.c.

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

References Assert, CurrentTransactionState, and TransactionStateData::parallelModeLevel.

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), CommitTransaction(), ExecutePlan(), parallel_vacuum_init(), and ParallelWorkerMain().

◆ EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace ( void )

Definition at line 5493 of file xact.c.

 {
     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));
 }

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

Referenced by InitializeParallelDSM().

◆ ExitParallelMode()

void ExitParallelMode ( void )

Definition at line 1062 of file xact.c.

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

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

Referenced by _brin_begin_parallel(), _brin_end_parallel(), _bt_begin_parallel(), _bt_end_parallel(), ExecutePlan(), parallel_vacuum_end(), and ParallelWorkerMain().

◆ ForceSyncCommit()

void ForceSyncCommit ( void )

Definition at line 1150 of file xact.c.

 {
     forceSyncCommit = true;
 }

References forceSyncCommit.

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

◆ GetCurrentCommandId()

CommandId GetCurrentCommandId ( bool used )

Definition at line 827 of file xact.c.

 {
     /* 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.
          */
         if (IsParallelWorker())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                      errmsg("cannot modify data in a parallel worker")));
  
         currentCommandIdUsed = true;
     }
     return currentCommandId;
 }

References currentCommandId, currentCommandIdUsed, ereport, errcode(), errmsg(), ERROR, and IsParallelWorker.

Referenced by ATRewriteTable(), CatalogTuplesMultiInsertWithInfo(), CopyFrom(), create_edata_for_relation(), create_estate_for_relation(), GetSnapshotData(), GetSnapshotDataReuse(), intorel_startup(), moveMergedTablesRows(), moveSplitTableRows(), 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().

◆ GetCurrentFullTransactionId()

FullTransactionId GetCurrentFullTransactionId ( void )

Definition at line 510 of file xact.c.

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

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

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void )

Definition at line 528 of file xact.c.

 {
     return CurrentTransactionState->fullTransactionId;
 }

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void )

Definition at line 877 of file xact.c.

 {
     return stmtStartTimestamp;
 }

References stmtStartTimestamp.

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

◆ GetCurrentSubTransactionId()

SubTransactionId GetCurrentSubTransactionId ( void )

Definition at line 789 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::subTransactionId.

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

◆ GetCurrentTransactionId()

TransactionId GetCurrentTransactionId ( void )

Definition at line 452 of file xact.c.

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

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(), RelationSetNewRelfilenumber(), and ReorderBufferProcessTXN().

◆ GetCurrentTransactionIdIfAny()

TransactionId GetCurrentTransactionIdIfAny ( void )

Definition at line 469 of file xact.c.

 {
     return XidFromFullTransactionId(CurrentTransactionState->fullTransactionId);
 }

References CurrentTransactionState, TransactionStateData::fullTransactionId, and XidFromFullTransactionId.

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

◆ GetCurrentTransactionNestLevel()

int GetCurrentTransactionNestLevel ( void )

Definition at line 927 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by AddEnumLabel(), AfterTriggerBeginSubXact(), AfterTriggerEndSubXact(), AfterTriggerSetState(), Async_Notify(), AtEOSubXact_Inval(), AtSubAbort_Notify(), AtSubCommit_Notify(), AtSubCommit_smgr(), begin_remote_xact(), create_drop_transactional_internal(), CreatePortal(), ensure_tabstat_xact_level(), EnumValuesCreate(), pgfdw_subxact_callback(), pgstat_drop_relation(), PrepareInvalidationState(), PushActiveSnapshot(), queue_listen(), register_seq_scan(), RelationCreateStorage(), RelationDropStorage(), RelationMapUpdateMap(), RestoreReindexState(), SetReindexPending(), SetReindexProcessing(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), and smgrGetPendingDeletes().

◆ GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp ( void )

Definition at line 868 of file xact.c.

 {
     return xactStartTimestamp;
 }

References xactStartTimestamp.

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

◆ GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp ( void )

Definition at line 889 of file xact.c.

 {
     TransactionState s PG_USED_FOR_ASSERTS_ONLY = CurrentTransactionState;
  
     /* should only be called after commit / abort processing */
     Assert(s->state == TRANS_DEFAULT ||
            s->state == TRANS_COMMIT ||
            s->state == TRANS_ABORT ||
            s->state == TRANS_PREPARE);
  
     if (xactStopTimestamp == 0)
         xactStopTimestamp = GetCurrentTimestamp();
  
     return xactStopTimestamp;
 }

References Assert, CurrentTransactionState, GetCurrentTimestamp(), PG_USED_FOR_ASSERTS_ONLY, TRANS_ABORT, TRANS_COMMIT, TRANS_DEFAULT, TRANS_PREPARE, and xactStopTimestamp.

Referenced by pgstat_relation_flush_cb(), pgstat_report_stat(), RecordTransactionAbort(), and RecordTransactionCommit().

◆ GetStableLatestTransactionId()

TransactionId GetStableLatestTransactionId ( void )

Definition at line 605 of file xact.c.

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

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

Referenced by xid_age().

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void )

Definition at line 481 of file xact.c.

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

References AssignTransactionId(), FullTransactionIdIsValid, TopTransactionStateData, and XactTopFullTransactionId.

Referenced by pg_current_xact_id().

◆ GetTopFullTransactionIdIfAny()

FullTransactionId GetTopFullTransactionIdIfAny ( void )

Definition at line 497 of file xact.c.

 {
     return XactTopFullTransactionId;
 }

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

◆ GetTopTransactionId()

TransactionId GetTopTransactionId ( void )

Definition at line 424 of file xact.c.

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

References AssignTransactionId(), FullTransactionIdIsValid, TopTransactionStateData, XactTopFullTransactionId, and XidFromFullTransactionId.

Referenced by AlterSequence(), AssignTransactionId(), consume_xids_common(), do_setval(), fill_seq_fork_with_data(), log_heap_new_cid(), nextval_internal(), and SequenceChangePersistence().

◆ GetTopTransactionIdIfAny()

TransactionId GetTopTransactionIdIfAny ( void )

Definition at line 439 of file xact.c.

 {
     return XidFromFullTransactionId(XactTopFullTransactionId);
 }

References XactTopFullTransactionId, and XidFromFullTransactionId.

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

◆ IsAbortedTransactionBlockState()

bool IsAbortedTransactionBlockState ( void )

Definition at line 405 of file xact.c.

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

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 ProcessRecoveryConflictInterrupt().

◆ IsInParallelMode()

bool IsInParallelMode ( void )

Definition at line 1087 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     return s->parallelModeLevel != 0 || s->parallelChildXact;
 }

References CurrentTransactionState, TransactionStateData::parallelChildXact, and TransactionStateData::parallelModeLevel.

Referenced by AssignTransactionId(), CheckTargetForConflictsIn(), CommandCounterIncrement(), CreateParallelContext(), CreatePredicateLock(), DefineSavepoint(), DeleteChildTargetLocks(), ExecSetVariableStmt(), GetLatestSnapshot(), GetNewTransactionId(), GetSerializableTransactionSnapshotInt(), GetTransactionSnapshot(), heap_delete(), heap_inplace_update(), heap_update(), heap_vacuum_rel(), PrepareTransaction(), PreventCommandIfParallelMode(), RelationCreateStorage(), RelationMapUpdateMap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), ReleaseSavepoint(), RemoveReindexPending(), RollbackToSavepoint(), set_config_with_handle(), SetReindexPending(), standard_ExecutorStart(), standard_ProcessUtility(), and UpdateActiveSnapshotCommandId().

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool isTopLevel )

Definition at line 3753 of file xact.c.

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

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

Referenced by vacuum().

◆ IsSubTransaction()

bool IsSubTransaction ( void )

Definition at line 5031 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by _SPI_commit(), _SPI_rollback(), AfterTriggerSetState(), check_transaction_deferrable(), check_transaction_isolation(), check_transaction_read_only(), CheckTargetForConflictsIn(), CheckTransactionBlock(), CreateReplicationSlot(), ExportSnapshot(), ImportSnapshot(), IsInTransactionBlock(), IsSubxactTopXidLogPending(), PreventInTransactionBlock(), and ProcessRecoveryConflictInterrupt().

◆ IsSubxactTopXidLogPending()

bool IsSubxactTopXidLogPending ( void )

Definition at line 557 of file xact.c.

 {
     /* check whether it is already logged */
     if (CurrentTransactionState->topXidLogged)
         return false;
  
     /* 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;
  
     return true;
 }

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

Referenced by MarkSubxactTopXidLogged(), and XLogRecordAssemble().

◆ IsTransactionBlock()

bool IsTransactionBlock ( void )

Definition at line 4958 of file xact.c.

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

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

Referenced by apply_handle_commit_internal(), apply_handle_prepare_internal(), CheckTransactionBlock(), CreateReplicationSlot(), IsInTransactionBlock(), pa_start_subtrans(), pa_stream_abort(), PreventInTransactionBlock(), and standard_ProcessUtility().

◆ IsTransactionOrTransactionBlock()

bool IsTransactionOrTransactionBlock ( void )

Definition at line 4976 of file xact.c.

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

References TransactionStateData::blockState, CurrentTransactionState, and TBLOCK_DEFAULT.

Referenced by apply_handle_stream_stop(), pgstat_report_stat(), PostgresMain(), ProcessCatchupInterrupt(), ProcessInterrupts(), ProcessNotifyInterrupt(), ProcessRecoveryConflictInterrupt(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), SnapBuildExportSnapshot(), StartupDecodingContext(), and WalSndErrorCleanup().

◆ IsTransactionState()

bool IsTransactionState ( void )

Definition at line 385 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /*
      * TRANS_DEFAULT and TRANS_ABORT are obviously unsafe states.  However, we
      * also reject the startup/shutdown states TRANS_START, TRANS_COMMIT,
      * TRANS_PREPARE since it might be too soon or too late within those
      * transition states to do anything interesting.  Hence, the only "valid"
      * state is TRANS_INPROGRESS.
      */
     return (s->state == TRANS_INPROGRESS);
 }

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

Referenced by apply_handle_commit_internal(), apply_handle_origin(), assign_transaction_timeout(), begin_replication_step(), check_client_encoding(), check_default_table_access_method(), check_default_tablespace(), check_default_text_search_config(), check_role(), check_session_authorization(), check_temp_tablespaces(), check_transaction_isolation(), check_transaction_read_only(), clear_subscription_skip_lsn(), CreateInitDecodingContext(), ensure_last_message(), FetchTableStates(), InitializeClientEncoding(), IsSubxactTopXidLogPending(), LogicalRepApplyLoop(), LogLogicalMessage(), maybe_reread_subscription(), pa_send_data(), pa_start_subtrans(), pg_attribute_noreturn(), pg_do_encoding_conversion(), PrepareClientEncoding(), PrepareTempTablespaces(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), RelationClearRelation(), RelationFlushRelation(), RelationIdGetRelation(), RelationInitPhysicalAddr(), RelationReloadNailed(), replorigin_create(), replorigin_drop_by_name(), SearchCatCacheInternal(), SetMultiXactIdLimit(), SetTransactionIdLimit(), SnapBuildClearExportedSnapshot(), SocketBackend(), stream_stop_internal(), synchronize_slots(), and validate_remote_info().

◆ MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny ( void )

Definition at line 539 of file xact.c.

 {
     if (FullTransactionIdIsValid(CurrentTransactionState->fullTransactionId))
         CurrentTransactionState->didLogXid = true;
 }

References CurrentTransactionState, TransactionStateData::didLogXid, TransactionStateData::fullTransactionId, and FullTransactionIdIsValid.

Referenced by XLogInsertRecord().

◆ MarkSubxactTopXidLogged()

void MarkSubxactTopXidLogged ( void )

Definition at line 589 of file xact.c.

 {
     Assert(IsSubxactTopXidLogPending());
  
     CurrentTransactionState->topXidLogged = true;
 }

References Assert, CurrentTransactionState, IsSubxactTopXidLogPending(), and TransactionStateData::topXidLogged.

Referenced by XLogInsertRecord().

◆ PopTransaction()

static void PopTransaction ( void )

static

Definition at line 5459 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     if (s->state != TRANS_DEFAULT)
         elog(WARNING, "PopTransaction while in %s state",
              TransStateAsString(s->state));
  
     if (s->parent == NULL)
         elog(FATAL, "PopTransaction with no parent");
  
     CurrentTransactionState = s->parent;
  
     /* Let's just make sure CurTransactionContext is good */
     CurTransactionContext = s->parent->curTransactionContext;
     MemoryContextSwitchTo(CurTransactionContext);
  
     /* Ditto for ResourceOwner links */
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     CurrentResourceOwner = s->parent->curTransactionOwner;
  
     /* Free the old child structure */
     if (s->name)
         pfree(s->name);
     pfree(s);
 }

References CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionContext, CurTransactionContext, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog, FATAL, MemoryContextSwitchTo(), TransactionStateData::name, TransactionStateData::parent, pfree(), TransactionStateData::state, TRANS_DEFAULT, TransStateAsString(), and WARNING.

Referenced by CleanupSubTransaction(), and CommitSubTransaction().

◆ PrepareTransaction()

static void PrepareTransaction ( void )

static

Definition at line 2498 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     TransactionId xid = GetCurrentTransactionId();
     GlobalTransaction gxact;
     TimestampTz prepared_at;
  
     Assert(!IsInParallelMode());
  
     ShowTransactionState("PrepareTransaction");
  
     /*
      * check the current transaction state
      */
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "PrepareTransaction 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(true))
             break;
     }
  
     CallXactCallbacks(XACT_EVENT_PRE_PREPARE);
  
     /*
      * 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.
      */
  
     /* 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 EndPrepare(), so that we don't see
      * committed-but-broken files after a crash and COMMIT PREPARED.
      */
     smgrDoPendingSyncs(true, false);
  
     /* close large objects before lower-level cleanup */
     AtEOXact_LargeObject(true);
  
     /* NOTIFY requires no work at this point */
  
     /*
      * 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.
      */
     PreCommit_CheckForSerializationFailure();
  
     /*
      * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
      * this transaction.  Having the prepared xact hold locks on another
      * backend's temp table seems a bad idea --- for instance it would prevent
      * the backend from exiting.  There are other problems too, such as how to
      * clean up the source backend's local buffers and ON COMMIT state if the
      * prepared xact includes a DROP of a temp table.
      *
      * Other objects types, like functions, operators or extensions, share the
      * same restriction as they should not be created, locked or dropped as
      * this can mess up with this session or even a follow-up session trying
      * to use the same temporary namespace.
      *
      * We must check this after executing any ON COMMIT actions, because they
      * might still access a temp relation.
      *
      * XXX In principle this could be relaxed to allow some useful special
      * cases, such as a temp table created and dropped all within the
      * transaction.  That seems to require much more bookkeeping though.
      */
     if ((MyXactFlags & XACT_FLAGS_ACCESSEDTEMPNAMESPACE))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot PREPARE a transaction that has operated on temporary objects")));
  
     /*
      * Likewise, don't allow PREPARE after pg_export_snapshot.  This could be
      * supported if we added cleanup logic to twophase.c, but for now it
      * doesn't seem worth the trouble.
      */
     if (XactHasExportedSnapshots())
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot PREPARE a transaction that has exported snapshots")));
  
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
  
     /*
      * set the current transaction state information appropriately during
      * prepare processing
      */
     s->state = TRANS_PREPARE;
  
     /* Disable transaction timeout */
     if (TransactionTimeout > 0)
         disable_timeout(TRANSACTION_TIMEOUT, false);
  
     prepared_at = GetCurrentTimestamp();
  
     /*
      * Reserve the GID for this transaction. This could fail if the requested
      * GID is invalid or already in use.
      */
     gxact = MarkAsPreparing(xid, prepareGID, prepared_at,
                             GetUserId(), MyDatabaseId);
     prepareGID = NULL;
  
     /*
      * Collect data for the 2PC state file.  Note that in general, no actual
      * state change should happen in the called modules during this step,
      * since it's still possible to fail before commit, and in that case we
      * want transaction abort to be able to clean up.  (In particular, the
      * AtPrepare routines may error out if they find cases they cannot
      * handle.)  State cleanup should happen in the PostPrepare routines
      * below.  However, some modules can go ahead and clear state here because
      * they wouldn't do anything with it during abort anyway.
      *
      * Note: because the 2PC state file records will be replayed in the same
      * order they are made, the order of these calls has to match the order in
      * which we want things to happen during COMMIT PREPARED or ROLLBACK
      * PREPARED; in particular, pay attention to whether things should happen
      * before or after releasing the transaction's locks.
      */
     StartPrepare(gxact);
  
     AtPrepare_Notify();
     AtPrepare_Locks();
     AtPrepare_PredicateLocks();
     AtPrepare_PgStat();
     AtPrepare_MultiXact();
     AtPrepare_RelationMap();
  
     /*
      * Here is where we really truly prepare.
      *
      * We have to record transaction prepares even if we didn't make any
      * updates, because the transaction manager might get confused if we lose
      * a global transaction.
      */
     EndPrepare(gxact);
  
     /*
      * Now we clean up backend-internal state and release internal resources.
      */
  
     /* Reset XactLastRecEnd until the next transaction writes something */
     XactLastRecEnd = 0;
  
     /*
      * Transfer our locks to a dummy PGPROC.  This has to be done before
      * ProcArrayClearTransaction().  Otherwise, a GetLockConflicts() would
      * conclude "xact already committed or aborted" for our locks.
      */
     PostPrepare_Locks(xid);
  
     /*
      * Let others know about no transaction in progress by me.  This has to be
      * done *after* the prepared transaction has been marked valid, else
      * someone may think it is unlocked and recyclable.
      */
     ProcArrayClearTransaction(MyProc);
  
     /*
      * In normal commit-processing, this is all non-critical post-transaction
      * cleanup.  When the transaction is prepared, however, it's important
      * that the locks and other per-backend resources are transferred to the
      * prepared transaction's PGPROC entry.  Note that if an error is raised
      * here, it's too late to abort the transaction. XXX: This probably should
      * be in a critical section, to force a PANIC if any of this fails, but
      * that cure could be worse than the disease.
      */
  
     CallXactCallbacks(XACT_EVENT_PREPARE);
  
     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);
  
     /* notify doesn't need a postprepare call */
  
     PostPrepare_PgStat();
  
     PostPrepare_Inval();
  
     PostPrepare_smgr();
  
     PostPrepare_MultiXact(xid);
  
     PostPrepare_PredicateLocks(xid);
  
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_LOCKS,
                          true, true);
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          true, true);
  
     /*
      * Allow another backend to finish the transaction.  After
      * PostPrepare_Twophase(), the transaction is completely detached from our
      * backend.  The rest is just non-critical cleanup of backend-local state.
      */
     PostPrepare_Twophase();
  
     /* PREPARE acts the same as COMMIT as far as GUC is concerned */
     AtEOXact_GUC(true, 1);
     AtEOXact_SPI(true);
     AtEOXact_Enum();
     AtEOXact_on_commit_actions(true);
     AtEOXact_Namespace(true, false);
     AtEOXact_SMgr();
     AtEOXact_Files(true);
     AtEOXact_ComboCid();
     AtEOXact_HashTables(true);
     /* don't call AtEOXact_PgStat here; we fixed pgstat state above */
     AtEOXact_Snapshot(true, true);
     /* we treat PREPARE as ROLLBACK so far as waking workers goes */
     AtEOXact_ApplyLauncher(false);
     AtEOXact_LogicalRepWorkers(false);
     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 1st phase commit processing, set current transaction state
      * back to default
      */
     s->state = TRANS_DEFAULT;
  
     RESUME_INTERRUPTS();
 }

Referenced by CommitTransactionCommandInternal().

◆ PrepareTransactionBlock()

bool PrepareTransactionBlock ( const char * gid )

Definition at line 3979 of file xact.c.

 {
     TransactionState s;
     bool        result;
  
     /* Set up to commit the current transaction */
     result = EndTransactionBlock(false);
  
     /* If successful, change outer tblock state to PREPARE */
     if (result)
     {
         s = CurrentTransactionState;
  
         while (s->parent != NULL)
             s = s->parent;
  
         if (s->blockState == TBLOCK_END)
         {
             /* Save GID where PrepareTransaction can find it again */
             prepareGID = MemoryContextStrdup(TopTransactionContext, gid);
  
             s->blockState = TBLOCK_PREPARE;
         }
         else
         {
             /*
              * ignore case where we are not in a transaction;
              * EndTransactionBlock already issued a warning.
              */
             Assert(s->blockState == TBLOCK_STARTED ||
                    s->blockState == TBLOCK_IMPLICIT_INPROGRESS);
             /* Don't send back a PREPARE result tag... */
             result = false;
         }
     }
  
     return result;
 }

References Assert, TransactionStateData::blockState, CurrentTransactionState, EndTransactionBlock(), MemoryContextStrdup(), TransactionStateData::parent, prepareGID, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, and TopTransactionContext.

Referenced by apply_handle_prepare_internal(), and standard_ProcessUtility().

◆ PreventInTransactionBlock()

void PreventInTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3622 of file xact.c.

 {
     /*
      * xact block already started?
      */
     if (IsTransactionBlock())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
         /* translator: %s represents an SQL statement name */
                  errmsg("%s cannot run inside a transaction block",
                         stmtType)));
  
     /*
      * subtransaction?
      */
     if (IsSubTransaction())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
         /* translator: %s represents an SQL statement name */
                  errmsg("%s cannot run inside a subtransaction",
                         stmtType)));
  
     /*
      * inside a pipeline that has started an implicit transaction?
      */
     if (MyXactFlags & XACT_FLAGS_PIPELINING)
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
         /* translator: %s represents an SQL statement name */
                  errmsg("%s cannot be executed within a pipeline",
                         stmtType)));
  
     /*
      * inside a function call?
      */
     if (!isTopLevel)
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
         /* translator: %s represents an SQL statement name */
                  errmsg("%s cannot be executed from a function", stmtType)));
  
     /* If we got past IsTransactionBlock test, should be in default state */
     if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
         CurrentTransactionState->blockState != TBLOCK_STARTED)
         elog(FATAL, "cannot prevent transaction chain");
  
     /* All okay.  Set the flag to make sure the right thing happens later. */
     MyXactFlags |= XACT_FLAGS_NEEDIMMEDIATECOMMIT;
 }

References TransactionStateData::blockState, CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsSubTransaction(), IsTransactionBlock(), MyXactFlags, TBLOCK_DEFAULT, TBLOCK_STARTED, XACT_FLAGS_NEEDIMMEDIATECOMMIT, and XACT_FLAGS_PIPELINING.

Referenced by AlterDatabase(), AlterSubscription(), CheckAlterSubOption(), cluster(), CreateSubscription(), DiscardAll(), DropSubscription(), exec_replication_command(), ExecDropStmt(), ExecReindex(), ProcessUtilitySlow(), ReindexPartitions(), standard_ProcessUtility(), and vacuum().

◆ PushTransaction()

static void PushTransaction ( void )

static

Definition at line 5397 of file xact.c.

 {
     TransactionState p = CurrentTransactionState;
     TransactionState s;
  
     /*
      * We keep subtransaction state nodes in TopTransactionContext.
      */
     s = (TransactionState)
         MemoryContextAllocZero(TopTransactionContext,
                                sizeof(TransactionStateData));
  
     /*
      * Assign a subtransaction ID, watching out for counter wraparound.
      */
     currentSubTransactionId += 1;
     if (currentSubTransactionId == InvalidSubTransactionId)
     {
         currentSubTransactionId -= 1;
         pfree(s);
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("cannot have more than 2^32-1 subtransactions in a transaction")));
     }
  
     /*
      * We can now stack a minimally valid subtransaction without fear of
      * failure.
      */
     s->fullTransactionId = InvalidFullTransactionId;    /* until assigned */
     s->subTransactionId = currentSubTransactionId;
     s->parent = p;
     s->nestingLevel = p->nestingLevel + 1;
     s->gucNestLevel = NewGUCNestLevel();
     s->savepointLevel = p->savepointLevel;
     s->state = TRANS_DEFAULT;
     s->blockState = TBLOCK_SUBBEGIN;
     GetUserIdAndSecContext(&s->prevUser, &s->prevSecContext);
     s->prevXactReadOnly = XactReadOnly;
     s->startedInRecovery = p->startedInRecovery;
     s->parallelModeLevel = 0;
     s->parallelChildXact = (p->parallelModeLevel != 0 || p->parallelChildXact);
     s->topXidLogged = false;
  
     CurrentTransactionState = s;
  
     /*
      * AbortSubTransaction and CleanupSubTransaction have to be able to cope
      * with the subtransaction from here on out; in particular they should not
      * assume that it necessarily has a transaction context, resource owner,
      * or XID.
      */
 }

Referenced by BeginInternalSubTransaction(), and DefineSavepoint().

◆ RecordTransactionAbort()

static TransactionId RecordTransactionAbort ( bool isSubXact )

static

Definition at line 1742 of file xact.c.

 {
     TransactionId xid = GetCurrentTransactionIdIfAny();
     TransactionId latestXid;
     int         nrels;
     RelFileLocator *rels;
     int         ndroppedstats = 0;
     xl_xact_stats_item *droppedstats = NULL;
     int         nchildren;
     TransactionId *children;
     TimestampTz xact_time;
     bool        replorigin;
  
     /*
      * If we haven't been assigned an XID, nobody will care whether we aborted
      * or not.  Hence, we're done in that case.  It does not matter if we have
      * rels to delete (note that this routine is not responsible for actually
      * deleting 'em).  We cannot have any child XIDs, either.
      */
     if (!TransactionIdIsValid(xid))
     {
         /* Reset XactLastRecEnd until the next transaction writes something */
         if (!isSubXact)
             XactLastRecEnd = 0;
         return InvalidTransactionId;
     }
  
     /*
      * We have a valid XID, so we should write an ABORT record for it.
      *
      * We do not flush XLOG to disk here, since the default assumption after a
      * crash would be that we aborted, anyway.  For the same reason, we don't
      * need to worry about interlocking against checkpoint start.
      */
  
     /*
      * Check that we haven't aborted halfway through RecordTransactionCommit.
      */
     if (TransactionIdDidCommit(xid))
         elog(PANIC, "cannot abort transaction %u, it was already committed",
              xid);
  
     /*
      * Are we using the replication origins feature?  Or, in other words, are
      * we replaying remote actions?
      */
     replorigin = (replorigin_session_origin != InvalidRepOriginId &&
                   replorigin_session_origin != DoNotReplicateId);
  
     /* Fetch the data we need for the abort record */
     nrels = smgrGetPendingDeletes(false, &rels);
     nchildren = xactGetCommittedChildren(&children);
     ndroppedstats = pgstat_get_transactional_drops(false, &droppedstats);
  
     /* XXX do we really need a critical section here? */
     START_CRIT_SECTION();
  
     /* Write the ABORT record */
     if (isSubXact)
         xact_time = GetCurrentTimestamp();
     else
     {
         xact_time = GetCurrentTransactionStopTimestamp();
     }
  
     XactLogAbortRecord(xact_time,
                        nchildren, children,
                        nrels, rels,
                        ndroppedstats, droppedstats,
                        MyXactFlags, InvalidTransactionId,
                        NULL);
  
     if (replorigin)
         /* Move LSNs forward for this replication origin */
         replorigin_session_advance(replorigin_session_origin_lsn,
                                    XactLastRecEnd);
  
     /*
      * Report the latest async abort LSN, so that the WAL writer knows to
      * flush this abort. There's nothing to be gained by delaying this, since
      * WALWriter may as well do this when it can. This is important with
      * streaming replication because if we don't flush WAL regularly we will
      * find that large aborts leave us with a long backlog for when commits
      * occur after the abort, increasing our window of data loss should
      * problems occur at that point.
      */
     if (!isSubXact)
         XLogSetAsyncXactLSN(XactLastRecEnd);
  
     /*
      * Mark the transaction aborted in clog.  This is not absolutely necessary
      * but we may as well do it while we are here; also, in the subxact case
      * it is helpful because XactLockTableWait makes use of it to avoid
      * waiting for already-aborted subtransactions.  It is OK to do it without
      * having flushed the ABORT record to disk, because in event of a crash
      * we'd be assumed to have aborted anyway.
      */
     TransactionIdAbortTree(xid, nchildren, children);
  
     END_CRIT_SECTION();
  
     /* Compute latestXid while we have the child XIDs handy */
     latestXid = TransactionIdLatest(xid, nchildren, children);
  
     /*
      * If we're aborting a subtransaction, we can immediately remove failed
      * XIDs from PGPROC's cache of running child XIDs.  We do that here for
      * subxacts, because we already have the child XID array at hand.  For
      * main xacts, the equivalent happens just after this function returns.
      */
     if (isSubXact)
         XidCacheRemoveRunningXids(xid, nchildren, children, latestXid);
  
     /* Reset XactLastRecEnd until the next transaction writes something */
     if (!isSubXact)
         XactLastRecEnd = 0;
  
     /* And clean up local data */
     if (rels)
         pfree(rels);
     if (ndroppedstats)
         pfree(droppedstats);
  
     return latestXid;
 }

References DoNotReplicateId, elog, END_CRIT_SECTION, GetCurrentTimestamp(), GetCurrentTransactionIdIfAny(), GetCurrentTransactionStopTimestamp(), InvalidRepOriginId, InvalidTransactionId, MyXactFlags, PANIC, pfree(), pgstat_get_transactional_drops(), replorigin_session_advance(), replorigin_session_origin, replorigin_session_origin_lsn, smgrGetPendingDeletes(), START_CRIT_SECTION, TransactionIdAbortTree(), TransactionIdDidCommit(), TransactionIdIsValid, TransactionIdLatest(), xactGetCommittedChildren(), XactLastRecEnd, XactLogAbortRecord(), XidCacheRemoveRunningXids(), and XLogSetAsyncXactLSN().

Referenced by AbortSubTransaction(), and AbortTransaction().

◆ RecordTransactionCommit()

static TransactionId RecordTransactionCommit ( void )

static

Definition at line 1313 of file xact.c.

 {
     TransactionId xid = GetTopTransactionIdIfAny();
     bool        markXidCommitted = TransactionIdIsValid(xid);
     TransactionId latestXid = InvalidTransactionId;
     int         nrels;
     RelFileLocator *rels;
     int         nchildren;
     TransactionId *children;
     int         ndroppedstats = 0;
     xl_xact_stats_item *droppedstats = NULL;
     int         nmsgs = 0;
     SharedInvalidationMessage *invalMessages = NULL;
     bool        RelcacheInitFileInval = false;
     bool        wrote_xlog;
  
     /*
      * Log pending invalidations for logical decoding of in-progress
      * transactions.  Normally for DDLs, we log this at each command end,
      * however, for certain cases where we directly update the system table
      * without a transaction block, the invalidations are not logged till this
      * time.
      */
     if (XLogLogicalInfoActive())
         LogLogicalInvalidations();
  
     /* Get data needed for commit record */
     nrels = smgrGetPendingDeletes(true, &rels);
     nchildren = xactGetCommittedChildren(&children);
     ndroppedstats = pgstat_get_transactional_drops(true, &droppedstats);
     if (XLogStandbyInfoActive())
         nmsgs = xactGetCommittedInvalidationMessages(&invalMessages,
                                                      &RelcacheInitFileInval);
     wrote_xlog = (XactLastRecEnd != 0);
  
     /*
      * If we haven't been assigned an XID yet, we neither can, nor do we want
      * to write a COMMIT record.
      */
     if (!markXidCommitted)
     {
         /*
          * We expect that every RelationDropStorage is followed by a catalog
          * update, and hence XID assignment, so we shouldn't get here with any
          * pending deletes. Same is true for dropping stats.
          *
          * Use a real test not just an Assert to check this, since it's a bit
          * fragile.
          */
         if (nrels != 0 || ndroppedstats != 0)
             elog(ERROR, "cannot commit a transaction that deleted files but has no xid");
  
         /* Can't have child XIDs either; AssignTransactionId enforces this */
         Assert(nchildren == 0);
  
         /*
          * Transactions without an assigned xid can contain invalidation
          * messages (e.g. explicit relcache invalidations or catcache
          * invalidations for inplace updates); standbys need to process those.
          * We can't emit a commit record without an xid, and we don't want to
          * force assigning an xid, because that'd be problematic for e.g.
          * vacuum.  Hence we emit a bespoke record for the invalidations. We
          * don't want to use that in case a commit record is emitted, so they
          * happen synchronously with commits (besides not wanting to emit more
          * WAL records).
          */
         if (nmsgs != 0)
         {
             LogStandbyInvalidations(nmsgs, invalMessages,
                                     RelcacheInitFileInval);
             wrote_xlog = true;  /* not strictly necessary */
         }
  
         /*
          * If we didn't create XLOG entries, we're done here; otherwise we
          * should trigger flushing those entries the same as a commit record
          * would.  This will primarily happen for HOT pruning and the like; we
          * want these to be flushed to disk in due time.
          */
         if (!wrote_xlog)
             goto cleanup;
     }
     else
     {
         bool        replorigin;
  
         /*
          * Are we using the replication origins feature?  Or, in other words,
          * are we replaying remote actions?
          */
         replorigin = (replorigin_session_origin != InvalidRepOriginId &&
                       replorigin_session_origin != DoNotReplicateId);
  
         /*
          * Mark ourselves as within our "commit critical section".  This
          * forces any concurrent checkpoint to wait until we've updated
          * pg_xact.  Without this, it is possible for the checkpoint to set
          * REDO after the XLOG record but fail to flush the pg_xact update to
          * disk, leading to loss of the transaction commit if the system
          * crashes a little later.
          *
          * Note: we could, but don't bother to, set this flag in
          * RecordTransactionAbort.  That's because loss of a transaction abort
          * is noncritical; the presumption would be that it aborted, anyway.
          *
          * It's safe to change the delayChkptFlags flag of our own backend
          * without holding the ProcArrayLock, since we're the only one
          * modifying it.  This makes checkpoint's determination of which xacts
          * are delaying the checkpoint a bit fuzzy, but it doesn't matter.
          */
         Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);
         START_CRIT_SECTION();
         MyProc->delayChkptFlags |= DELAY_CHKPT_START;
  
         /*
          * Insert the commit XLOG record.
          */
         XactLogCommitRecord(GetCurrentTransactionStopTimestamp(),
                             nchildren, children, nrels, rels,
                             ndroppedstats, droppedstats,
                             nmsgs, invalMessages,
                             RelcacheInitFileInval,
                             MyXactFlags,
                             InvalidTransactionId, NULL /* plain commit */ );
  
         if (replorigin)
             /* Move LSNs forward for this replication origin */
             replorigin_session_advance(replorigin_session_origin_lsn,
                                        XactLastRecEnd);
  
         /*
          * Record commit timestamp.  The value comes from plain commit
          * timestamp if there's no replication origin; otherwise, the
          * timestamp was already set in replorigin_session_origin_timestamp by
          * replication.
          *
          * We don't need to WAL-log anything here, as the commit record
          * written above already contains the data.
          */
  
         if (!replorigin || replorigin_session_origin_timestamp == 0)
             replorigin_session_origin_timestamp = GetCurrentTransactionStopTimestamp();
  
         TransactionTreeSetCommitTsData(xid, nchildren, children,
                                        replorigin_session_origin_timestamp,
                                        replorigin_session_origin);
     }
  
     /*
      * Check if we want to commit asynchronously.  We can allow the XLOG flush
      * to happen asynchronously if synchronous_commit=off, or if the current
      * transaction has not performed any WAL-logged operation or didn't assign
      * an xid.  The transaction can end up not writing any WAL, even if it has
      * an xid, if it only wrote to temporary and/or unlogged tables.  It can
      * end up having written WAL without an xid if it did HOT pruning.  In
      * case of a crash, the loss of such a transaction will be irrelevant;
      * temp tables will be lost anyway, unlogged tables will be truncated and
      * HOT pruning will be done again later. (Given the foregoing, you might
      * think that it would be unnecessary to emit the XLOG record at all in
      * this case, but we don't currently try to do that.  It would certainly
      * cause problems at least in Hot Standby mode, where the
      * KnownAssignedXids machinery requires tracking every XID assignment.  It
      * might be OK to skip it only when wal_level < replica, but for now we
      * don't.)
      *
      * However, if we're doing cleanup of any non-temp rels or committing any
      * command that wanted to force sync commit, then we must flush XLOG
      * immediately.  (We must not allow asynchronous commit if there are any
      * non-temp tables to be deleted, because we might delete the files before
      * the COMMIT record is flushed to disk.  We do allow asynchronous commit
      * if all to-be-deleted tables are temporary though, since they are lost
      * anyway if we crash.)
      */
     if ((wrote_xlog && markXidCommitted &&
          synchronous_commit > SYNCHRONOUS_COMMIT_OFF) ||
         forceSyncCommit || nrels > 0)
     {
         XLogFlush(XactLastRecEnd);
  
         /*
          * Now we may update the CLOG, if we wrote a COMMIT record above
          */
         if (markXidCommitted)
             TransactionIdCommitTree(xid, nchildren, children);
     }
     else
     {
         /*
          * Asynchronous commit case:
          *
          * This enables possible committed transaction loss in the case of a
          * postmaster crash because WAL buffers are left unwritten. Ideally we
          * could issue the WAL write without the fsync, but some
          * wal_sync_methods do not allow separate write/fsync.
          *
          * Report the latest async commit LSN, so that the WAL writer knows to
          * flush this commit.
          */
         XLogSetAsyncXactLSN(XactLastRecEnd);
  
         /*
          * We must not immediately update the CLOG, since we didn't flush the
          * XLOG. Instead, we store the LSN up to which the XLOG must be
          * flushed before the CLOG may be updated.
          */
         if (markXidCommitted)
             TransactionIdAsyncCommitTree(xid, nchildren, children, XactLastRecEnd);
     }
  
     /*
      * If we entered a commit critical section, leave it now, and let
      * checkpoints proceed.
      */
     if (markXidCommitted)
     {
         MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
         END_CRIT_SECTION();
     }
  
     /* Compute latestXid while we have the child XIDs handy */
     latestXid = TransactionIdLatest(xid, nchildren, children);
  
     /*
      * Wait for synchronous replication, if required. Similar to the decision
      * above about using committing asynchronously we only want to wait if
      * this backend assigned an xid and wrote WAL.  No need to wait if an xid
      * was assigned due to temporary/unlogged tables or due to HOT pruning.
      *
      * Note that at this stage we have marked clog, but still show as running
      * in the procarray and continue to hold locks.
      */
     if (wrote_xlog && markXidCommitted)
         SyncRepWaitForLSN(XactLastRecEnd, true);
  
     /* remember end of last commit record */
     XactLastCommitEnd = XactLastRecEnd;
  
     /* Reset XactLastRecEnd until the next transaction writes something */
     XactLastRecEnd = 0;
 cleanup:
     /* Clean up local data */
     if (rels)
         pfree(rels);
     if (ndroppedstats)
         pfree(droppedstats);
  
     return latestXid;
 }

References Assert, cleanup(), DELAY_CHKPT_START, PGPROC::delayChkptFlags, DoNotReplicateId, elog, END_CRIT_SECTION, ERROR, forceSyncCommit, GetCurrentTransactionStopTimestamp(), GetTopTransactionIdIfAny(), InvalidRepOriginId, InvalidTransactionId, LogLogicalInvalidations(), LogStandbyInvalidations(), MyProc, MyXactFlags, pfree(), pgstat_get_transactional_drops(), replorigin_session_advance(), replorigin_session_origin, replorigin_session_origin_lsn, replorigin_session_origin_timestamp, smgrGetPendingDeletes(), START_CRIT_SECTION, synchronous_commit, SYNCHRONOUS_COMMIT_OFF, SyncRepWaitForLSN(), TransactionIdAsyncCommitTree(), TransactionIdCommitTree(), TransactionIdIsValid, TransactionIdLatest(), TransactionTreeSetCommitTsData(), xactGetCommittedChildren(), xactGetCommittedInvalidationMessages(), XactLastCommitEnd, XactLastRecEnd, XactLogCommitRecord(), XLogFlush(), XLogLogicalInfoActive, XLogSetAsyncXactLSN(), and XLogStandbyInfoActive.

Referenced by CommitTransaction().

◆ RegisterSubXactCallback()

void RegisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

Definition at line 3851 of file xact.c.

 {
     SubXactCallbackItem *item;
  
     item = (SubXactCallbackItem *)
         MemoryContextAlloc(TopMemoryContext, sizeof(SubXactCallbackItem));
     item->callback = callback;
     item->arg = arg;
     item->next = SubXact_callbacks;
     SubXact_callbacks = item;
 }

References SubXactCallbackItem::arg, arg, SubXactCallbackItem::callback, callback(), MemoryContextAlloc(), SubXactCallbackItem::next, SubXact_callbacks, and TopMemoryContext.

Referenced by _PG_init(), GetConnection(), and sepgsql_init_client_label().

◆ RegisterXactCallback()

void RegisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

Definition at line 3791 of file xact.c.

 {
     XactCallbackItem *item;
  
     item = (XactCallbackItem *)
         MemoryContextAlloc(TopMemoryContext, sizeof(XactCallbackItem));
     item->callback = callback;
     item->arg = arg;
     item->next = Xact_callbacks;
     Xact_callbacks = item;
 }

References XactCallbackItem::arg, arg, XactCallbackItem::callback, callback(), MemoryContextAlloc(), XactCallbackItem::next, TopMemoryContext, and Xact_callbacks.

Referenced by _PG_init(), GetConnection(), and sepgsql_init_client_label().

◆ ReleaseCurrentSubTransaction()

void ReleaseCurrentSubTransaction ( void )

Definition at line 4755 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /*
      * We do not check for parallel mode here.  It's permissible to start and
      * end "internal" subtransactions while in parallel mode, so long as no
      * new XIDs or command IDs are assigned.
      */
  
     if (s->blockState != TBLOCK_SUBINPROGRESS)
         elog(ERROR, "ReleaseCurrentSubTransaction: unexpected state %s",
              BlockStateAsString(s->blockState));
     Assert(s->state == TRANS_INPROGRESS);
     MemoryContextSwitchTo(CurTransactionContext);
     CommitSubTransaction();
     s = CurrentTransactionState;    /* changed by pop */
     Assert(s->state == TRANS_INPROGRESS);
 }

References Assert, TransactionStateData::blockState, BlockStateAsString(), CommitSubTransaction(), CurrentTransactionState, CurTransactionContext, elog, ERROR, MemoryContextSwitchTo(), TransactionStateData::state, TBLOCK_SUBINPROGRESS, and TRANS_INPROGRESS.

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_subtrans_commit(), pltcl_subtransaction(), PLy_spi_subtransaction_commit(), and PLy_subtransaction_exit().

◆ ReleaseSavepoint()

void ReleaseSavepoint ( const char * name )

Definition at line 4445 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     TransactionState target,
                 xact;
  
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for transaction state change 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() || IsParallelWorker())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot release savepoints during a parallel operation")));
  
     switch (s->blockState)
     {
             /*
              * We can't release a savepoint if there is no savepoint defined.
              */
         case TBLOCK_INPROGRESS:
             ereport(ERROR,
                     (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                      errmsg("savepoint \"%s\" does not exist", name)));
             break;
  
         case TBLOCK_IMPLICIT_INPROGRESS:
             /* See comment about implicit transactions in DefineSavepoint */
             ereport(ERROR,
                     (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
             /* translator: %s represents an SQL statement name */
                      errmsg("%s can only be used in transaction blocks",
                             "RELEASE SAVEPOINT")));
             break;
  
             /*
              * We are in a non-aborted subtransaction.  This is the only valid
              * case.
              */
         case TBLOCK_SUBINPROGRESS:
             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, "ReleaseSavepoint: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
  
     for (target = s; PointerIsValid(target); target = target->parent)
     {
         if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
             break;
     }
  
     if (!PointerIsValid(target))
         ereport(ERROR,
                 (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                  errmsg("savepoint \"%s\" does not exist", name)));
  
     /* disallow crossing savepoint level boundaries */
     if (target->savepointLevel != s->savepointLevel)
         ereport(ERROR,
                 (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
  
     /*
      * Mark "commit pending" all subtransactions up to the target
      * subtransaction.  The actual commits will happen when control gets to
      * CommitTransactionCommand.
      */
     xact = CurrentTransactionState;
     for (;;)
     {
         Assert(xact->blockState == TBLOCK_SUBINPROGRESS);
         xact->blockState = TBLOCK_SUBRELEASE;
         if (xact == target)
             break;
         xact = xact->parent;
         Assert(PointerIsValid(xact));
     }
 }

References Assert, TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), IsParallelWorker, TransactionStateData::name, name, TransactionStateData::parent, PointerIsValid, TransactionStateData::savepointLevel, 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 standard_ProcessUtility().

◆ RequireTransactionBlock()

void RequireTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3700 of file xact.c.

 {
     CheckTransactionBlock(isTopLevel, true, stmtType);
 }

References CheckTransactionBlock().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

◆ RestoreTransactionCharacteristics()

void RestoreTransactionCharacteristics ( const SavedTransactionCharacteristics * s )

Definition at line 3118 of file xact.c.

 {
     XactIsoLevel = s->save_XactIsoLevel;
     XactReadOnly = s->save_XactReadOnly;
     XactDeferrable = s->save_XactDeferrable;
 }

References SavedTransactionCharacteristics::save_XactDeferrable, SavedTransactionCharacteristics::save_XactIsoLevel, SavedTransactionCharacteristics::save_XactReadOnly, XactDeferrable, XactIsoLevel, and XactReadOnly.

Referenced by _SPI_commit(), _SPI_rollback(), and CommitTransactionCommandInternal().

◆ RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction ( void )

Definition at line 4783 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     /*
      * We do not check for parallel mode here.  It's permissible to start and
      * end "internal" subtransactions while in parallel mode, so long as no
      * new XIDs or command IDs are assigned.
      */
  
     switch (s->blockState)
     {
             /* Must be in a subtransaction */
         case TBLOCK_SUBINPROGRESS:
         case TBLOCK_SUBABORT:
             break;
  
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_STARTED:
         case TBLOCK_BEGIN:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_INPROGRESS:
         case TBLOCK_END:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT:
         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, "RollbackAndReleaseCurrentSubTransaction: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
  
     /*
      * Abort the current subtransaction, if needed.
      */
     if (s->blockState == TBLOCK_SUBINPROGRESS)
         AbortSubTransaction();
  
     /* And clean it up, too */
     CleanupSubTransaction();
  
     s = CurrentTransactionState;    /* changed by pop */
     Assert(s->blockState == TBLOCK_SUBINPROGRESS ||
            s->blockState == TBLOCK_INPROGRESS ||
            s->blockState == TBLOCK_IMPLICIT_INPROGRESS ||
            s->blockState == TBLOCK_PARALLEL_INPROGRESS ||
            s->blockState == TBLOCK_STARTED);
 }

References AbortSubTransaction(), Assert, TransactionStateData::blockState, BlockStateAsString(), CleanupSubTransaction(), CurrentTransactionState, elog, 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, and TBLOCK_SUBRESTART.

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_subtrans_abort(), pltcl_subtransaction(), PLy_abort_open_subtransactions(), PLy_spi_subtransaction_abort(), PLy_subtransaction_exit(), ReorderBufferImmediateInvalidation(), and ReorderBufferProcessTXN().

◆ RollbackToSavepoint()

void RollbackToSavepoint ( const char * name )

Definition at line 4554 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
     TransactionState target,
                 xact;
  
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for transaction state change 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() || IsParallelWorker())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot rollback to savepoints during a parallel operation")));
  
     switch (s->blockState)
     {
             /*
              * We can't rollback to a savepoint if there is no savepoint
              * defined.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_ABORT:
             ereport(ERROR,
                     (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                      errmsg("savepoint \"%s\" does not exist", name)));
             break;
  
         case TBLOCK_IMPLICIT_INPROGRESS:
             /* See comment about implicit transactions in DefineSavepoint */
             ereport(ERROR,
                     (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
             /* translator: %s represents an SQL statement name */
                      errmsg("%s can only be used in transaction blocks",
                             "ROLLBACK TO SAVEPOINT")));
             break;
  
             /*
              * There is at least one savepoint, so proceed.
              */
         case TBLOCK_SUBINPROGRESS:
         case TBLOCK_SUBABORT:
             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_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, "RollbackToSavepoint: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
  
     for (target = s; PointerIsValid(target); target = target->parent)
     {
         if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
             break;
     }
  
     if (!PointerIsValid(target))
         ereport(ERROR,
                 (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                  errmsg("savepoint \"%s\" does not exist", name)));
  
     /* disallow crossing savepoint level boundaries */
     if (target->savepointLevel != s->savepointLevel)
         ereport(ERROR,
                 (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
  
     /*
      * Mark "abort pending" all subtransactions up to the target
      * subtransaction.  The actual aborts will happen when control gets to
      * CommitTransactionCommand.
      */
     xact = CurrentTransactionState;
     for (;;)
     {
         if (xact == target)
             break;
         if (xact->blockState == TBLOCK_SUBINPROGRESS)
             xact->blockState = TBLOCK_SUBABORT_PENDING;
         else if (xact->blockState == TBLOCK_SUBABORT)
             xact->blockState = TBLOCK_SUBABORT_END;
         else
             elog(FATAL, "RollbackToSavepoint: unexpected state %s",
                  BlockStateAsString(xact->blockState));
         xact = xact->parent;
         Assert(PointerIsValid(xact));
     }
  
     /* And mark the target as "restart pending" */
     if (xact->blockState == TBLOCK_SUBINPROGRESS)
         xact->blockState = TBLOCK_SUBRESTART;
     else if (xact->blockState == TBLOCK_SUBABORT)
         xact->blockState = TBLOCK_SUBABORT_RESTART;
     else
         elog(FATAL, "RollbackToSavepoint: unexpected state %s",
              BlockStateAsString(xact->blockState));
 }

References Assert, TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), IsParallelWorker, TransactionStateData::name, name, TransactionStateData::parent, PointerIsValid, TransactionStateData::savepointLevel, 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 pa_stream_abort(), and standard_ProcessUtility().

◆ SaveTransactionCharacteristics()

void SaveTransactionCharacteristics ( SavedTransactionCharacteristics * s )

Definition at line 3110 of file xact.c.

 {
     s->save_XactIsoLevel = XactIsoLevel;
     s->save_XactReadOnly = XactReadOnly;
     s->save_XactDeferrable = XactDeferrable;
 }

References SavedTransactionCharacteristics::save_XactDeferrable, SavedTransactionCharacteristics::save_XactIsoLevel, SavedTransactionCharacteristics::save_XactReadOnly, XactDeferrable, XactIsoLevel, and XactReadOnly.

Referenced by _SPI_commit(), _SPI_rollback(), and CommitTransactionCommandInternal().

◆ SerializeTransactionState()

void SerializeTransactionState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 5521 of file xact.c.

 {
     TransactionState s;
     Size        nxids = 0;
     Size        i = 0;
     TransactionId *workspace;
     SerializedTransactionState *result;
  
     result = (SerializedTransactionState *) start_address;
  
     result->xactIsoLevel = XactIsoLevel;
     result->xactDeferrable = XactDeferrable;
     result->topFullTransactionId = XactTopFullTransactionId;
     result->currentFullTransactionId =
         CurrentTransactionState->fullTransactionId;
     result->currentCommandId = currentCommandId;
  
     /*
      * If we're running in a parallel worker and launching a parallel worker
      * of our own, we can just pass along the information that was passed to
      * us.
      */
     if (nParallelCurrentXids > 0)
     {
         result->nParallelCurrentXids = nParallelCurrentXids;
         memcpy(&result->parallelCurrentXids[0], ParallelCurrentXids,
                nParallelCurrentXids * sizeof(TransactionId));
         return;
     }
  
     /*
      * OK, we need to generate a sorted list of XIDs that our workers should
      * view as current.  First, figure out how many there are.
      */
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         if (FullTransactionIdIsValid(s->fullTransactionId))
             nxids = add_size(nxids, 1);
         nxids = add_size(nxids, s->nChildXids);
     }
     Assert(SerializedTransactionStateHeaderSize + nxids * sizeof(TransactionId)
            <= maxsize);
  
     /* Copy them to our scratch space. */
     workspace = palloc(nxids * sizeof(TransactionId));
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         if (FullTransactionIdIsValid(s->fullTransactionId))
             workspace[i++] = XidFromFullTransactionId(s->fullTransactionId);
         if (s->nChildXids > 0)
             memcpy(&workspace[i], s->childXids,
                    s->nChildXids * sizeof(TransactionId));
         i += s->nChildXids;
     }
     Assert(i == nxids);
  
     /* Sort them. */
     qsort(workspace, nxids, sizeof(TransactionId), xidComparator);
  
     /* Copy data into output area. */
     result->nParallelCurrentXids = nxids;
     memcpy(&result->parallelCurrentXids[0], workspace,
            nxids * sizeof(TransactionId));
 }

Referenced by InitializeParallelDSM().

◆ SetCurrentStatementStartTimestamp()

void SetCurrentStatementStartTimestamp ( void )

Definition at line 912 of file xact.c.

 {
     if (!IsParallelWorker())
         stmtStartTimestamp = GetCurrentTimestamp();
     else
         Assert(stmtStartTimestamp != 0);
 }

References Assert, GetCurrentTimestamp(), IsParallelWorker, and stmtStartTimestamp.

Referenced by autovac_report_activity(), autovac_report_workitem(), begin_replication_step(), initialize_worker_spi(), InitPostgres(), PostgresMain(), and worker_spi_main().

◆ SetParallelStartTimestamps()

void SetParallelStartTimestamps	(	TimestampTz	xact_ts,
		TimestampTz	stmt_ts
	)

Definition at line 857 of file xact.c.

 {
     Assert(IsParallelWorker());
     xactStartTimestamp = xact_ts;
     stmtStartTimestamp = stmt_ts;
 }

References Assert, IsParallelWorker, stmtStartTimestamp, and xactStartTimestamp.

Referenced by ParallelWorkerMain().

◆ ShowTransactionState()

static void ShowTransactionState ( const char * str )

static

Definition at line 5629 of file xact.c.

 {
     /* skip work if message will definitely not be printed */
     if (message_level_is_interesting(DEBUG5))
         ShowTransactionStateRec(str, CurrentTransactionState);
 }

References CurrentTransactionState, DEBUG5, message_level_is_interesting(), ShowTransactionStateRec(), and str.

Referenced by AbortSubTransaction(), CleanupSubTransaction(), CommitSubTransaction(), CommitTransaction(), PrepareTransaction(), StartSubTransaction(), and StartTransaction().

◆ ShowTransactionStateRec()

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

static

Definition at line 5641 of file xact.c.

 {
     StringInfoData buf;
  
     if (s->parent)
     {
         /*
          * Since this function recurses, it could be driven to stack overflow.
          * This is just a debugging aid, so we can leave out some details
          * instead of erroring out with check_stack_depth().
          */
         if (stack_is_too_deep())
             ereport(DEBUG5,
                     (errmsg_internal("%s(%d): parent omitted to avoid stack overflow",
                                      str, s->nestingLevel)));
         else
             ShowTransactionStateRec(str, s->parent);
     }
  
     initStringInfo(&buf);
     if (s->nChildXids > 0)
     {
         int         i;
  
         appendStringInfo(&buf, ", children: %u", s->childXids[0]);
         for (i = 1; i < s->nChildXids; i++)
             appendStringInfo(&buf, " %u", s->childXids[i]);
     }
     ereport(DEBUG5,
             (errmsg_internal("%s(%d) name: %s; blockState: %s; state: %s, xid/subid/cid: %u/%u/%u%s%s",
                              str, s->nestingLevel,
                              PointerIsValid(s->name) ? s->name : "unnamed",
                              BlockStateAsString(s->blockState),
                              TransStateAsString(s->state),
                              (unsigned int) XidFromFullTransactionId(s->fullTransactionId),
                              (unsigned int) s->subTransactionId,
                              (unsigned int) currentCommandId,
                              currentCommandIdUsed ? " (used)" : "",
                              buf.data)));
     pfree(buf.data);
 }

Referenced by ShowTransactionState().

◆ StartParallelWorkerTransaction()

void StartParallelWorkerTransaction ( char * tstatespace )

Definition at line 5592 of file xact.c.

 {
     SerializedTransactionState *tstate;
  
     Assert(CurrentTransactionState->blockState == TBLOCK_DEFAULT);
     StartTransaction();
  
     tstate = (SerializedTransactionState *) tstatespace;
     XactIsoLevel = tstate->xactIsoLevel;
     XactDeferrable = tstate->xactDeferrable;
     XactTopFullTransactionId = tstate->topFullTransactionId;
     CurrentTransactionState->fullTransactionId =
         tstate->currentFullTransactionId;
     currentCommandId = tstate->currentCommandId;
     nParallelCurrentXids = tstate->nParallelCurrentXids;
     ParallelCurrentXids = &tstate->parallelCurrentXids[0];
  
     CurrentTransactionState->blockState = TBLOCK_PARALLEL_INPROGRESS;
 }

References Assert, TransactionStateData::blockState, SerializedTransactionState::currentCommandId, currentCommandId, SerializedTransactionState::currentFullTransactionId, CurrentTransactionState, TransactionStateData::fullTransactionId, nParallelCurrentXids, SerializedTransactionState::nParallelCurrentXids, ParallelCurrentXids, SerializedTransactionState::parallelCurrentXids, StartTransaction(), TBLOCK_DEFAULT, TBLOCK_PARALLEL_INPROGRESS, SerializedTransactionState::topFullTransactionId, XactDeferrable, SerializedTransactionState::xactDeferrable, XactIsoLevel, SerializedTransactionState::xactIsoLevel, and XactTopFullTransactionId.

Referenced by ParallelWorkerMain().

◆ StartSubTransaction()

static void StartSubTransaction ( void )

static

Definition at line 5054 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     if (s->state != TRANS_DEFAULT)
         elog(WARNING, "StartSubTransaction while in %s state",
              TransStateAsString(s->state));
  
     s->state = TRANS_START;
  
     /*
      * Initialize subsystems for new subtransaction
      *
      * must initialize resource-management stuff first
      */
     AtSubStart_Memory();
     AtSubStart_ResourceOwner();
     AfterTriggerBeginSubXact();
  
     s->state = TRANS_INPROGRESS;
  
     /*
      * Call start-of-subxact callbacks
      */
     CallSubXactCallbacks(SUBXACT_EVENT_START_SUB, s->subTransactionId,
                          s->parent->subTransactionId);
  
     ShowTransactionState("StartSubTransaction");
 }

References AfterTriggerBeginSubXact(), AtSubStart_Memory(), AtSubStart_ResourceOwner(), CallSubXactCallbacks(), CurrentTransactionState, elog, TransactionStateData::parent, ShowTransactionState(), TransactionStateData::state, TransactionStateData::subTransactionId, SUBXACT_EVENT_START_SUB, TRANS_DEFAULT, TRANS_INPROGRESS, TRANS_START, TransStateAsString(), and WARNING.

Referenced by CommitTransactionCommandInternal().

◆ StartTransaction()

static void StartTransaction ( void )

static

Definition at line 2052 of file xact.c.

 {
     TransactionState s;
     VirtualTransactionId vxid;
  
     /*
      * Let's just make sure the state stack is empty
      */
     s = &TopTransactionStateData;
     CurrentTransactionState = s;
  
     Assert(!FullTransactionIdIsValid(XactTopFullTransactionId));
  
     /* check the current transaction state */
     Assert(s->state == TRANS_DEFAULT);
  
     /*
      * Set the current transaction state information appropriately during
      * start processing.  Note that once the transaction status is switched
      * this process cannot fail until the user ID and the security context
      * flags are fetched below.
      */
     s->state = TRANS_START;
     s->fullTransactionId = InvalidFullTransactionId;    /* until assigned */
  
     /* Determine if statements are logged in this transaction */
     xact_is_sampled = log_xact_sample_rate != 0 &&
         (log_xact_sample_rate == 1 ||
          pg_prng_double(&pg_global_prng_state) <= log_xact_sample_rate);
  
     /*
      * initialize current transaction state fields
      *
      * note: prevXactReadOnly is not used at the outermost level
      */
     s->nestingLevel = 1;
     s->gucNestLevel = 1;
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
  
     /*
      * Once the current user ID and the security context flags are fetched,
      * both will be properly reset even if transaction startup fails.
      */
     GetUserIdAndSecContext(&s->prevUser, &s->prevSecContext);
  
     /* SecurityRestrictionContext should never be set outside a transaction */
     Assert(s->prevSecContext == 0);
  
     /*
      * Make sure we've reset xact state variables
      *
      * If recovery is still in progress, mark this transaction as read-only.
      * We have lower level defences in XLogInsert and elsewhere to stop us
      * from modifying data during recovery, but this gives the normal
      * indication to the user that the transaction is read-only.
      */
     if (RecoveryInProgress())
     {
         s->startedInRecovery = true;
         XactReadOnly = true;
     }
     else
     {
         s->startedInRecovery = false;
         XactReadOnly = DefaultXactReadOnly;
     }
     XactDeferrable = DefaultXactDeferrable;
     XactIsoLevel = DefaultXactIsoLevel;
     forceSyncCommit = false;
     MyXactFlags = 0;
  
     /*
      * reinitialize within-transaction counters
      */
     s->subTransactionId = TopSubTransactionId;
     currentSubTransactionId = TopSubTransactionId;
     currentCommandId = FirstCommandId;
     currentCommandIdUsed = false;
  
     /*
      * initialize reported xid accounting
      */
     nUnreportedXids = 0;
     s->didLogXid = false;
  
     /*
      * must initialize resource-management stuff first
      */
     AtStart_Memory();
     AtStart_ResourceOwner();
  
     /*
      * Assign a new LocalTransactionId, and combine it with the proc number to
      * form a virtual transaction id.
      */
     vxid.procNumber = MyProcNumber;
     vxid.localTransactionId = GetNextLocalTransactionId();
  
     /*
      * Lock the virtual transaction id before we announce it in the proc array
      */
     VirtualXactLockTableInsert(vxid);
  
     /*
      * Advertise it in the proc array.  We assume assignment of
      * localTransactionId is atomic, and the proc number should be set
      * already.
      */
     Assert(MyProc->vxid.procNumber == vxid.procNumber);
     MyProc->vxid.lxid = vxid.localTransactionId;
  
     TRACE_POSTGRESQL_TRANSACTION_START(vxid.localTransactionId);
  
     /*
      * set transaction_timestamp() (a/k/a now()).  Normally, we want this to
      * be the same as the first command's statement_timestamp(), so don't do a
      * fresh GetCurrentTimestamp() call (which'd be expensive anyway).  But
      * for transactions started inside procedures (i.e., nonatomic SPI
      * contexts), we do need to advance the timestamp.  Also, in a parallel
      * worker, the timestamp should already have been provided by a call to
      * SetParallelStartTimestamps().
      */
     if (!IsParallelWorker())
     {
         if (!SPI_inside_nonatomic_context())
             xactStartTimestamp = stmtStartTimestamp;
         else
             xactStartTimestamp = GetCurrentTimestamp();
     }
     else
         Assert(xactStartTimestamp != 0);
     pgstat_report_xact_timestamp(xactStartTimestamp);
     /* Mark xactStopTimestamp as unset. */
     xactStopTimestamp = 0;
  
     /*
      * initialize other subsystems for new transaction
      */
     AtStart_GUC();
     AtStart_Cache();
     AfterTriggerBeginXact();
  
     /*
      * done with start processing, set current transaction state to "in
      * progress"
      */
     s->state = TRANS_INPROGRESS;
  
     /* Schedule transaction timeout */
     if (TransactionTimeout > 0)
         enable_timeout_after(TRANSACTION_TIMEOUT, TransactionTimeout);
  
     ShowTransactionState("StartTransaction");
 }

Referenced by _doSetFixedOutputState(), CommitTransactionCommandInternal(), restore_toc_entry(), RestoreArchive(), StartParallelWorkerTransaction(), StartRestoreLOs(), and StartTransactionCommand().

◆ StartTransactionCommand()

void StartTransactionCommand ( void )

Definition at line 3033 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     switch (s->blockState)
     {
             /*
              * if we aren't in a transaction block, we just do our usual start
              * transaction.
              */
         case TBLOCK_DEFAULT:
             StartTransaction();
             s->blockState = TBLOCK_STARTED;
             break;
  
             /*
              * We are somewhere in a transaction block or subtransaction and
              * about to start a new command.  For now we do nothing, but
              * someday we may do command-local resource initialization. (Note
              * that any needed CommandCounterIncrement was done by the
              * previous CommitTransactionCommand.)
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
             break;
  
             /*
              * Here we are in a failed transaction block (one of the commands
              * caused an abort) so we do nothing but remain in the abort
              * state.  Eventually we will get a ROLLBACK command which will
              * get us out of this state.  (It is up to other code to ensure
              * that no commands other than ROLLBACK will be processed in these
              * states.)
              */
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             break;
  
             /* These cases are invalid. */
         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_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
         case TBLOCK_PREPARE:
             elog(ERROR, "StartTransactionCommand: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
  
     /*
      * We must switch to CurTransactionContext before returning. This is
      * already done if we called StartTransaction, otherwise not.
      */
     Assert(CurTransactionContext != NULL);
     MemoryContextSwitchTo(CurTransactionContext);
 }

References Assert, TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, CurTransactionContext, elog, ERROR, MemoryContextSwitchTo(), 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(), _SPI_rollback(), apply_handle_commit_internal(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), begin_replication_step(), BeginInternalSubTransaction(), BootstrapModeMain(), clear_subscription_skip_lsn(), cluster(), cluster_multiple_rels(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), EventTriggerOnLogin(), exec_replication_command(), FetchTableStates(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeLogRepWorker(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), ParallelApplyWorkerMain(), ParallelWorkerMain(), perform_work_item(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), ReorderBufferProcessTXN(), run_apply_worker(), shell_check_detail(), SnapBuildExportSnapshot(), start_xact_command(), synchronize_slots(), vacuum(), vacuum_rel(), validate_remote_info(), and worker_spi_main().

◆ SubTransactionIsActive()

bool SubTransactionIsActive ( SubTransactionId subxid )

Definition at line 803 of file xact.c.

 {
     TransactionState s;
  
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         if (s->state == TRANS_ABORT)
             continue;
         if (s->subTransactionId == subxid)
             return true;
     }
     return false;
 }

References CurrentTransactionState, TransactionStateData::parent, TransactionStateData::state, TransactionStateData::subTransactionId, and TRANS_ABORT.

Referenced by fmgr_sql().

◆ TransactionBlockStatusCode()

char TransactionBlockStatusCode ( void )

Definition at line 4990 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     switch (s->blockState)
     {
         case TBLOCK_DEFAULT:
         case TBLOCK_STARTED:
             return 'I';         /* idle --- not in transaction */
         case TBLOCK_BEGIN:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
         case TBLOCK_END:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_PREPARE:
             return 'T';         /* in transaction */
         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:
             return 'E';         /* in failed transaction */
     }
  
     /* should never get here */
     elog(FATAL, "invalid transaction block state: %s",
          BlockStateAsString(s->blockState));
     return 0;                   /* keep compiler quiet */
 }

References TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, elog, 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, and TBLOCK_SUBRESTART.

Referenced by ReadyForQuery().

◆ TransactionIdIsCurrentTransactionId()

bool TransactionIdIsCurrentTransactionId ( TransactionId xid )

Definition at line 939 of file xact.c.

 {
     TransactionState s;
  
     /*
      * We always say that BootstrapTransactionId is "not my transaction ID"
      * even when it is (ie, during bootstrap).  Along with the fact that
      * transam.c always treats BootstrapTransactionId as already committed,
      * this causes the heapam_visibility.c routines to see all tuples as
      * committed, which is what we need during bootstrap.  (Bootstrap mode
      * only inserts tuples, it never updates or deletes them, so all tuples
      * can be presumed good immediately.)
      *
      * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
      * not my transaction ID, so we can just return "false" immediately for
      * any non-normal XID.
      */
     if (!TransactionIdIsNormal(xid))
         return false;
  
     if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
         return true;
  
     /*
      * In parallel workers, the XIDs we must consider as current are stored in
      * ParallelCurrentXids rather than the transaction-state stack.  Note that
      * the XIDs in this array are sorted numerically rather than according to
      * transactionIdPrecedes order.
      */
     if (nParallelCurrentXids > 0)
     {
         int         low,
                     high;
  
         low = 0;
         high = nParallelCurrentXids - 1;
         while (low <= high)
         {
             int         middle;
             TransactionId probe;
  
             middle = low + (high - low) / 2;
             probe = ParallelCurrentXids[middle];
             if (probe == xid)
                 return true;
             else if (probe < xid)
                 low = middle + 1;
             else
                 high = middle - 1;
         }
         return false;
     }
  
     /*
      * We will return true for the Xid of the current subtransaction, any of
      * its subcommitted children, any of its parents, or any of their
      * previously subcommitted children.  However, a transaction being aborted
      * is no longer "current", even though it may still have an entry on the
      * state stack.
      */
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         int         low,
                     high;
  
         if (s->state == TRANS_ABORT)
             continue;
         if (!FullTransactionIdIsValid(s->fullTransactionId))
             continue;           /* it can't have any child XIDs either */
         if (TransactionIdEquals(xid, XidFromFullTransactionId(s->fullTransactionId)))
             return true;
         /* As the childXids array is ordered, we can use binary search */
         low = 0;
         high = s->nChildXids - 1;
         while (low <= high)
         {
             int         middle;
             TransactionId probe;
  
             middle = low + (high - low) / 2;
             probe = s->childXids[middle];
             if (TransactionIdEquals(probe, xid))
                 return true;
             else if (TransactionIdPrecedes(probe, xid))
                 low = middle + 1;
             else
                 high = middle - 1;
         }
     }
  
     return false;
 }

References TransactionStateData::childXids, CurrentTransactionState, TransactionStateData::fullTransactionId, FullTransactionIdIsValid, GetTopTransactionIdIfAny(), TransactionStateData::nChildXids, nParallelCurrentXids, ParallelCurrentXids, TransactionStateData::parent, TransactionStateData::state, TRANS_ABORT, TransactionIdEquals, TransactionIdIsNormal, TransactionIdPrecedes(), and XidFromFullTransactionId.

Referenced by compute_new_xmax_infomask(), Do_MultiXactIdWait(), DoesMultiXactIdConflict(), ExecCheckTupleVisible(), ExecMergeMatched(), ExecOnConflictUpdate(), FreezeMultiXactId(), heap_delete(), heap_lock_tuple(), heap_update(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), heapam_scan_analyze_next_tuple(), heapam_tuple_lock(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), MultiXactIdIsRunning(), PredicateLockTID(), SnapBuildWaitSnapshot(), test_lockmode_for_conflict(), TransactionIdIsInProgress(), tts_buffer_is_current_xact_tuple(), and tts_heap_is_current_xact_tuple().

◆ TransactionStartedDuringRecovery()

bool TransactionStartedDuringRecovery ( void )

Definition at line 1040 of file xact.c.

 {
     return CurrentTransactionState->startedInRecovery;
 }

References CurrentTransactionState, and TransactionStateData::startedInRecovery.

Referenced by RelationGetIndexScan().

◆ TransStateAsString()

static const char * TransStateAsString ( TransState state )

static

Definition at line 5741 of file xact.c.

 {
     switch (state)
     {
         case TRANS_DEFAULT:
             return "DEFAULT";
         case TRANS_START:
             return "START";
         case TRANS_INPROGRESS:
             return "INPROGRESS";
         case TRANS_COMMIT:
             return "COMMIT";
         case TRANS_ABORT:
             return "ABORT";
         case TRANS_PREPARE:
             return "PREPARE";
     }
     return "UNRECOGNIZED";
 }

References TRANS_ABORT, TRANS_COMMIT, TRANS_DEFAULT, TRANS_INPROGRESS, TRANS_PREPARE, and TRANS_START.

Referenced by AbortSubTransaction(), AbortTransaction(), CleanupSubTransaction(), CleanupTransaction(), CommitSubTransaction(), CommitTransaction(), PopTransaction(), PrepareTransaction(), ShowTransactionStateRec(), and StartSubTransaction().

◆ UnregisterSubXactCallback()

void UnregisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

Definition at line 3864 of file xact.c.

 {
     SubXactCallbackItem *item;
     SubXactCallbackItem *prev;
  
     prev = NULL;
     for (item = SubXact_callbacks; item; prev = item, item = item->next)
     {
         if (item->callback == callback && item->arg == arg)
         {
             if (prev)
                 prev->next = item->next;
             else
                 SubXact_callbacks = item->next;
             pfree(item);
             break;
         }
     }
 }

References SubXactCallbackItem::arg, arg, SubXactCallbackItem::callback, callback(), SubXactCallbackItem::next, pfree(), and SubXact_callbacks.

◆ UnregisterXactCallback()

void UnregisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

Definition at line 3804 of file xact.c.

 {
     XactCallbackItem *item;
     XactCallbackItem *prev;
  
     prev = NULL;
     for (item = Xact_callbacks; item; prev = item, item = item->next)
     {
         if (item->callback == callback && item->arg == arg)
         {
             if (prev)
                 prev->next = item->next;
             else
                 Xact_callbacks = item->next;
             pfree(item);
             break;
         }
     }
 }

References XactCallbackItem::arg, arg, XactCallbackItem::callback, callback(), XactCallbackItem::next, pfree(), and Xact_callbacks.

◆ UserAbortTransactionBlock()

void UserAbortTransactionBlock ( bool chain )

Definition at line 4191 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     switch (s->blockState)
     {
             /*
              * We are inside a transaction block and we got a ROLLBACK command
              * from the user, so tell CommitTransactionCommand to abort and
              * exit the transaction block.
              */
         case TBLOCK_INPROGRESS:
             s->blockState = TBLOCK_ABORT_PENDING;
             break;
  
             /*
              * We are inside a failed transaction block and we got a ROLLBACK
              * command from the user.  Abort processing is already done, so
              * CommitTransactionCommand just has to cleanup and go back to
              * idle state.
              */
         case TBLOCK_ABORT:
             s->blockState = TBLOCK_ABORT_END;
             break;
  
             /*
              * We are inside a subtransaction.  Mark everything up to top
              * level as exitable.
              */
         case TBLOCK_SUBINPROGRESS:
         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, "UserAbortTransactionBlock: 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, "UserAbortTransactionBlock: unexpected state %s",
                      BlockStateAsString(s->blockState));
             break;
  
             /*
              * The user issued ABORT when not inside a transaction.  For
              * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
              * The upcoming call to CommitTransactionCommand() will then put
              * us back into the default state.  For ROLLBACK AND CHAIN, error.
              *
              * We do the same thing with ABORT inside an implicit transaction,
              * although in this case we might be rolling back actual database
              * state changes.  (It's debatable whether we should issue a
              * WARNING in this case, but we have done so historically.)
              */
         case TBLOCK_STARTED:
         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",
                                 "ROLLBACK AND CHAIN")));
             else
                 ereport(WARNING,
                         (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                          errmsg("there is no transaction in progress")));
             s->blockState = TBLOCK_ABORT_PENDING;
             break;
  
             /*
              * The user issued an ABORT 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 abort 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, "UserAbortTransactionBlock: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
  
     Assert(s->blockState == TBLOCK_ABORT_END ||
            s->blockState == TBLOCK_ABORT_PENDING);
  
     s->chain = chain;
 }

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 standard_ProcessUtility().

◆ WarnNoTransactionBlock()

void WarnNoTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3694 of file xact.c.

 {
     CheckTransactionBlock(isTopLevel, false, stmtType);
 }

References CheckTransactionBlock().

Referenced by ExecSetVariableStmt(), and standard_ProcessUtility().

◆ xact_redo()

void xact_redo ( XLogReaderState * record )

Definition at line 6344 of file xact.c.

 {
     uint8       info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
  
     /* Backup blocks are not used in xact records */
     Assert(!XLogRecHasAnyBlockRefs(record));
  
     if (info == XLOG_XACT_COMMIT)
     {
         xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
         xl_xact_parsed_commit parsed;
  
         ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
         xact_redo_commit(&parsed, XLogRecGetXid(record),
                          record->EndRecPtr, XLogRecGetOrigin(record));
     }
     else if (info == XLOG_XACT_COMMIT_PREPARED)
     {
         xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
         xl_xact_parsed_commit parsed;
  
         ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
         xact_redo_commit(&parsed, parsed.twophase_xid,
                          record->EndRecPtr, XLogRecGetOrigin(record));
  
         /* Delete TwoPhaseState gxact entry and/or 2PC file. */
         LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
         PrepareRedoRemove(parsed.twophase_xid, false);
         LWLockRelease(TwoPhaseStateLock);
     }
     else if (info == XLOG_XACT_ABORT)
     {
         xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
         xl_xact_parsed_abort parsed;
  
         ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
         xact_redo_abort(&parsed, XLogRecGetXid(record),
                         record->EndRecPtr, XLogRecGetOrigin(record));
     }
     else if (info == XLOG_XACT_ABORT_PREPARED)
     {
         xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
         xl_xact_parsed_abort parsed;
  
         ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
         xact_redo_abort(&parsed, parsed.twophase_xid,
                         record->EndRecPtr, XLogRecGetOrigin(record));
  
         /* Delete TwoPhaseState gxact entry and/or 2PC file. */
         LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
         PrepareRedoRemove(parsed.twophase_xid, false);
         LWLockRelease(TwoPhaseStateLock);
     }
     else if (info == XLOG_XACT_PREPARE)
     {
         /*
          * Store xid and start/end pointers of the WAL record in TwoPhaseState
          * gxact entry.
          */
         LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
         PrepareRedoAdd(XLogRecGetData(record),
                        record->ReadRecPtr,
                        record->EndRecPtr,
                        XLogRecGetOrigin(record));
         LWLockRelease(TwoPhaseStateLock);
     }
     else if (info == XLOG_XACT_ASSIGNMENT)
     {
         xl_xact_assignment *xlrec = (xl_xact_assignment *) XLogRecGetData(record);
  
         if (standbyState >= STANDBY_INITIALIZED)
             ProcArrayApplyXidAssignment(xlrec->xtop,
                                         xlrec->nsubxacts, xlrec->xsub);
     }
     else if (info == XLOG_XACT_INVALIDATIONS)
     {
         /*
          * XXX we do ignore this for now, what matters are invalidations
          * written into the commit record.
          */
     }
     else
         elog(PANIC, "xact_redo: unknown op code %u", info);
 }

References Assert, elog, XLogReaderState::EndRecPtr, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_xact_assignment::nsubxacts, PANIC, ParseAbortRecord(), ParseCommitRecord(), PrepareRedoAdd(), PrepareRedoRemove(), ProcArrayApplyXidAssignment(), XLogReaderState::ReadRecPtr, STANDBY_INITIALIZED, standbyState, xl_xact_parsed_commit::twophase_xid, xl_xact_parsed_abort::twophase_xid, xact_redo_abort(), xact_redo_commit(), XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_ASSIGNMENT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_INVALIDATIONS, XLOG_XACT_OPMASK, XLOG_XACT_PREPARE, XLogRecGetData, XLogRecGetInfo, XLogRecGetOrigin, XLogRecGetXid, XLogRecHasAnyBlockRefs, xl_xact_assignment::xsub, and xl_xact_assignment::xtop.

◆ xact_redo_abort()

static void xact_redo_abort	(	xl_xact_parsed_abort *	parsed,
		TransactionId	xid,
		XLogRecPtr	lsn,
		RepOriginId	origin_id
	)

static

Definition at line 6265 of file xact.c.

 {
     TransactionId max_xid;
  
     Assert(TransactionIdIsValid(xid));
  
     /* Make sure nextXid is beyond any XID mentioned in the record. */
     max_xid = TransactionIdLatest(xid,
                                   parsed->nsubxacts,
                                   parsed->subxacts);
     AdvanceNextFullTransactionIdPastXid(max_xid);
  
     if (standbyState == STANDBY_DISABLED)
     {
         /* Mark the transaction aborted in pg_xact, no need for async stuff */
         TransactionIdAbortTree(xid, parsed->nsubxacts, parsed->subxacts);
     }
     else
     {
         /*
          * If a transaction completion record arrives that has as-yet
          * unobserved subtransactions then this will not have been fully
          * handled by the call to RecordKnownAssignedTransactionIds() in the
          * main recovery loop in xlog.c. So we need to do bookkeeping again to
          * cover that case. This is confusing and it is easy to think this
          * call is irrelevant, which has happened three times in development
          * already. Leave it in.
          */
         RecordKnownAssignedTransactionIds(max_xid);
  
         /* Mark the transaction aborted in pg_xact, no need for async stuff */
         TransactionIdAbortTree(xid, parsed->nsubxacts, parsed->subxacts);
  
         /*
          * We must update the ProcArray after we have marked clog.
          */
         ExpireTreeKnownAssignedTransactionIds(xid, parsed->nsubxacts, parsed->subxacts, max_xid);
  
         /*
          * There are no invalidation messages to send or undo.
          */
  
         /*
          * Release locks, if any. There are no invalidations to send.
          */
         if (parsed->xinfo & XACT_XINFO_HAS_AE_LOCKS)
             StandbyReleaseLockTree(xid, parsed->nsubxacts, parsed->subxacts);
     }
  
     if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
     {
         /* recover apply progress */
         replorigin_advance(origin_id, parsed->origin_lsn, lsn,
                            false /* backward */ , false /* WAL */ );
     }
  
     /* Make sure files supposed to be dropped are dropped */
     if (parsed->nrels > 0)
     {
         /*
          * See comments about update of minimum recovery point on truncation,
          * in xact_redo_commit().
          */
         XLogFlush(lsn);
  
         DropRelationFiles(parsed->xlocators, parsed->nrels, true);
     }
  
     if (parsed->nstats > 0)
     {
         /* see equivalent call for relations above */
         XLogFlush(lsn);
  
         pgstat_execute_transactional_drops(parsed->nstats, parsed->stats, true);
     }
 }

Referenced by xact_redo().

◆ xact_redo_commit()

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

static

Definition at line 6111 of file xact.c.

 {
     TransactionId max_xid;
     TimestampTz commit_time;
  
     Assert(TransactionIdIsValid(xid));
  
     max_xid = TransactionIdLatest(xid, parsed->nsubxacts, parsed->subxacts);
  
     /* Make sure nextXid is beyond any XID mentioned in the record. */
     AdvanceNextFullTransactionIdPastXid(max_xid);
  
     Assert(((parsed->xinfo & XACT_XINFO_HAS_ORIGIN) == 0) ==
            (origin_id == InvalidRepOriginId));
  
     if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
         commit_time = parsed->origin_timestamp;
     else
         commit_time = parsed->xact_time;
  
     /* Set the transaction commit timestamp and metadata */
     TransactionTreeSetCommitTsData(xid, parsed->nsubxacts, parsed->subxacts,
                                    commit_time, origin_id);
  
     if (standbyState == STANDBY_DISABLED)
     {
         /*
          * Mark the transaction committed in pg_xact.
          */
         TransactionIdCommitTree(xid, parsed->nsubxacts, parsed->subxacts);
     }
     else
     {
         /*
          * If a transaction completion record arrives that has as-yet
          * unobserved subtransactions then this will not have been fully
          * handled by the call to RecordKnownAssignedTransactionIds() in the
          * main recovery loop in xlog.c. So we need to do bookkeeping again to
          * cover that case. This is confusing and it is easy to think this
          * call is irrelevant, which has happened three times in development
          * already. Leave it in.
          */
         RecordKnownAssignedTransactionIds(max_xid);
  
         /*
          * Mark the transaction committed in pg_xact. We use async commit
          * protocol during recovery to provide information on database
          * consistency for when users try to set hint bits. It is important
          * that we do not set hint bits until the minRecoveryPoint is past
          * this commit record. This ensures that if we crash we don't see hint
          * bits set on changes made by transactions that haven't yet
          * recovered. It's unlikely but it's good to be safe.
          */
         TransactionIdAsyncCommitTree(xid, parsed->nsubxacts, parsed->subxacts, lsn);
  
         /*
          * We must mark clog before we update the ProcArray.
          */
         ExpireTreeKnownAssignedTransactionIds(xid, parsed->nsubxacts, parsed->subxacts, max_xid);
  
         /*
          * Send any cache invalidations attached to the commit. We must
          * maintain the same order of invalidation then release locks as
          * occurs in CommitTransaction().
          */
         ProcessCommittedInvalidationMessages(parsed->msgs, parsed->nmsgs,
                                              XactCompletionRelcacheInitFileInval(parsed->xinfo),
                                              parsed->dbId, parsed->tsId);
  
         /*
          * Release locks, if any. We do this for both two phase and normal one
          * phase transactions. In effect we are ignoring the prepare phase and
          * just going straight to lock release.
          */
         if (parsed->xinfo & XACT_XINFO_HAS_AE_LOCKS)
             StandbyReleaseLockTree(xid, parsed->nsubxacts, parsed->subxacts);
     }
  
     if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
     {
         /* recover apply progress */
         replorigin_advance(origin_id, parsed->origin_lsn, lsn,
                            false /* backward */ , false /* WAL */ );
     }
  
     /* Make sure files supposed to be dropped are dropped */
     if (parsed->nrels > 0)
     {
         /*
          * First update minimum recovery point to cover this WAL record. Once
          * a relation is deleted, there's no going back. The buffer manager
          * enforces the WAL-first rule for normal updates to relation files,
          * so that the minimum recovery point is always updated before the
          * corresponding change in the data file is flushed to disk, but we
          * have to do the same here since we're bypassing the buffer manager.
          *
          * Doing this before deleting the files means that if a deletion fails
          * for some reason, you cannot start up the system even after restart,
          * until you fix the underlying situation so that the deletion will
          * succeed. Alternatively, we could update the minimum recovery point
          * after deletion, but that would leave a small window where the
          * WAL-first rule would be violated.
          */
         XLogFlush(lsn);
  
         /* Make sure files supposed to be dropped are dropped */
         DropRelationFiles(parsed->xlocators, parsed->nrels, true);
     }
  
     if (parsed->nstats > 0)
     {
         /* see equivalent call for relations above */
         XLogFlush(lsn);
  
         pgstat_execute_transactional_drops(parsed->nstats, parsed->stats, true);
     }
  
     /*
      * We issue an XLogFlush() for the same reason we emit ForceSyncCommit()
      * in normal operation. For example, in CREATE DATABASE, we copy all files
      * from the template database, and then commit the transaction. If we
      * crash after all the files have been copied but before the commit, you
      * have files in the data directory without an entry in pg_database. To
      * minimize the window for that, we use ForceSyncCommit() to rush the
      * commit record to disk as quick as possible. We have the same window
      * during recovery, and forcing an XLogFlush() (which updates
      * minRecoveryPoint during recovery) helps to reduce that problem window,
      * for any user that requested ForceSyncCommit().
      */
     if (XactCompletionForceSyncCommit(parsed->xinfo))
         XLogFlush(lsn);
  
     /*
      * If asked by the primary (because someone is waiting for a synchronous
      * commit = remote_apply), we will need to ask walreceiver to send a reply
      * immediately.
      */
     if (XactCompletionApplyFeedback(parsed->xinfo))
         XLogRequestWalReceiverReply();
 }

Referenced by xact_redo().

◆ xactGetCommittedChildren()

int xactGetCommittedChildren ( TransactionId ** ptr )

Definition at line 5771 of file xact.c.

 {
     TransactionState s = CurrentTransactionState;
  
     if (s->nChildXids == 0)
         *ptr = NULL;
     else
         *ptr = s->childXids;
  
     return s->nChildXids;
 }

References TransactionStateData::childXids, CurrentTransactionState, and TransactionStateData::nChildXids.

Referenced by ExportSnapshot(), RecordTransactionAbort(), RecordTransactionCommit(), and StartPrepare().

◆ XactLogAbortRecord()

XLogRecPtr XactLogAbortRecord	(	TimestampTz	abort_time,
		int	nsubxacts,
		TransactionId *	subxacts,
		int	nrels,
		RelFileLocator *	rels,
		int	ndroppedstats,
		xl_xact_stats_item *	droppedstats,
		int	xactflags,
		TransactionId	twophase_xid,
		const char *	twophase_gid
	)

Definition at line 5967 of file xact.c.

 {
     xl_xact_abort xlrec;
     xl_xact_xinfo xl_xinfo;
     xl_xact_subxacts xl_subxacts;
     xl_xact_relfilelocators xl_relfilelocators;
     xl_xact_stats_items xl_dropped_stats;
     xl_xact_twophase xl_twophase;
     xl_xact_dbinfo xl_dbinfo;
     xl_xact_origin xl_origin;
  
     uint8       info;
  
     Assert(CritSectionCount > 0);
  
     xl_xinfo.xinfo = 0;
  
     /* decide between a plain and 2pc abort */
     if (!TransactionIdIsValid(twophase_xid))
         info = XLOG_XACT_ABORT;
     else
         info = XLOG_XACT_ABORT_PREPARED;
  
  
     /* First figure out and collect all the information needed */
  
     xlrec.xact_time = abort_time;
  
     if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
         xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
  
     if (nsubxacts > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
         xl_subxacts.nsubxacts = nsubxacts;
     }
  
     if (nrels > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
         xl_relfilelocators.nrels = nrels;
         info |= XLR_SPECIAL_REL_UPDATE;
     }
  
     if (ndroppedstats > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
         xl_dropped_stats.nitems = ndroppedstats;
     }
  
     if (TransactionIdIsValid(twophase_xid))
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
         xl_twophase.xid = twophase_xid;
         Assert(twophase_gid != NULL);
  
         if (XLogLogicalInfoActive())
             xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
     }
  
     if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
         xl_dbinfo.dbId = MyDatabaseId;
         xl_dbinfo.tsId = MyDatabaseTableSpace;
     }
  
     /*
      * Dump transaction origin information. We need this during recovery to
      * update the replication origin progress.
      */
     if (replorigin_session_origin != InvalidRepOriginId)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
  
         xl_origin.origin_lsn = replorigin_session_origin_lsn;
         xl_origin.origin_timestamp = replorigin_session_origin_timestamp;
     }
  
     if (xl_xinfo.xinfo != 0)
         info |= XLOG_XACT_HAS_INFO;
  
     /* Then include all the collected data into the abort record. */
  
     XLogBeginInsert();
  
     XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);
  
     if (xl_xinfo.xinfo != 0)
         XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
         XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
     {
         XLogRegisterData((char *) (&xl_subxacts),
                          MinSizeOfXactSubxacts);
         XLogRegisterData((char *) subxacts,
                          nsubxacts * sizeof(TransactionId));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
     {
         XLogRegisterData((char *) (&xl_relfilelocators),
                          MinSizeOfXactRelfileLocators);
         XLogRegisterData((char *) rels,
                          nrels * sizeof(RelFileLocator));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
     {
         XLogRegisterData((char *) (&xl_dropped_stats),
                          MinSizeOfXactStatsItems);
         XLogRegisterData((char *) droppedstats,
                          ndroppedstats * sizeof(xl_xact_stats_item));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
     {
         XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
         if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
             XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
         XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
  
     /* Include the replication origin */
     XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
  
     return XLogInsert(RM_XACT_ID, info);
 }

References Assert, CritSectionCount, xl_xact_dbinfo::dbId, InvalidRepOriginId, MinSizeOfXactAbort, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, MyDatabaseId, MyDatabaseTableSpace, xl_xact_stats_items::nitems, xl_xact_relfilelocators::nrels, xl_xact_subxacts::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_origin::origin_timestamp, replorigin_session_origin, replorigin_session_origin_lsn, replorigin_session_origin_timestamp, TransactionIdIsValid, xl_xact_dbinfo::tsId, unconstify, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, xl_xact_abort::xact_time, XACT_XINFO_HAS_AE_LOCKS, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, XLOG_INCLUDE_ORIGIN, XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_HAS_INFO, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogSetRecordFlags(), and XLR_SPECIAL_REL_UPDATE.

Referenced by RecordTransactionAbort(), and RecordTransactionAbortPrepared().

◆ XactLogCommitRecord()

XLogRecPtr XactLogCommitRecord	(	TimestampTz	commit_time,
		int	nsubxacts,
		TransactionId *	subxacts,
		int	nrels,
		RelFileLocator *	rels,
		int	ndroppedstats,
		xl_xact_stats_item *	droppedstats,
		int	nmsgs,
		SharedInvalidationMessage *	msgs,
		bool	relcacheInval,
		int	xactflags,
		TransactionId	twophase_xid,
		const char *	twophase_gid
	)

Definition at line 5795 of file xact.c.

 {
     xl_xact_commit xlrec;
     xl_xact_xinfo xl_xinfo;
     xl_xact_dbinfo xl_dbinfo;
     xl_xact_subxacts xl_subxacts;
     xl_xact_relfilelocators xl_relfilelocators;
     xl_xact_stats_items xl_dropped_stats;
     xl_xact_invals xl_invals;
     xl_xact_twophase xl_twophase;
     xl_xact_origin xl_origin;
     uint8       info;
  
     Assert(CritSectionCount > 0);
  
     xl_xinfo.xinfo = 0;
  
     /* decide between a plain and 2pc commit */
     if (!TransactionIdIsValid(twophase_xid))
         info = XLOG_XACT_COMMIT;
     else
         info = XLOG_XACT_COMMIT_PREPARED;
  
     /* First figure out and collect all the information needed */
  
     xlrec.xact_time = commit_time;
  
     if (relcacheInval)
         xl_xinfo.xinfo |= XACT_COMPLETION_UPDATE_RELCACHE_FILE;
     if (forceSyncCommit)
         xl_xinfo.xinfo |= XACT_COMPLETION_FORCE_SYNC_COMMIT;
     if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
         xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
  
     /*
      * Check if the caller would like to ask standbys for immediate feedback
      * once this commit is applied.
      */
     if (synchronous_commit >= SYNCHRONOUS_COMMIT_REMOTE_APPLY)
         xl_xinfo.xinfo |= XACT_COMPLETION_APPLY_FEEDBACK;
  
     /*
      * Relcache invalidations requires information about the current database
      * and so does logical decoding.
      */
     if (nmsgs > 0 || XLogLogicalInfoActive())
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
         xl_dbinfo.dbId = MyDatabaseId;
         xl_dbinfo.tsId = MyDatabaseTableSpace;
     }
  
     if (nsubxacts > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
         xl_subxacts.nsubxacts = nsubxacts;
     }
  
     if (nrels > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
         xl_relfilelocators.nrels = nrels;
         info |= XLR_SPECIAL_REL_UPDATE;
     }
  
     if (ndroppedstats > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
         xl_dropped_stats.nitems = ndroppedstats;
     }
  
     if (nmsgs > 0)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_INVALS;
         xl_invals.nmsgs = nmsgs;
     }
  
     if (TransactionIdIsValid(twophase_xid))
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
         xl_twophase.xid = twophase_xid;
         Assert(twophase_gid != NULL);
  
         if (XLogLogicalInfoActive())
             xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
     }
  
     /* dump transaction origin information */
     if (replorigin_session_origin != InvalidRepOriginId)
     {
         xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
  
         xl_origin.origin_lsn = replorigin_session_origin_lsn;
         xl_origin.origin_timestamp = replorigin_session_origin_timestamp;
     }
  
     if (xl_xinfo.xinfo != 0)
         info |= XLOG_XACT_HAS_INFO;
  
     /* Then include all the collected data into the commit record. */
  
     XLogBeginInsert();
  
     XLogRegisterData((char *) (&xlrec), sizeof(xl_xact_commit));
  
     if (xl_xinfo.xinfo != 0)
         XLogRegisterData((char *) (&xl_xinfo.xinfo), sizeof(xl_xinfo.xinfo));
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
         XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
     {
         XLogRegisterData((char *) (&xl_subxacts),
                          MinSizeOfXactSubxacts);
         XLogRegisterData((char *) subxacts,
                          nsubxacts * sizeof(TransactionId));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
     {
         XLogRegisterData((char *) (&xl_relfilelocators),
                          MinSizeOfXactRelfileLocators);
         XLogRegisterData((char *) rels,
                          nrels * sizeof(RelFileLocator));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
     {
         XLogRegisterData((char *) (&xl_dropped_stats),
                          MinSizeOfXactStatsItems);
         XLogRegisterData((char *) droppedstats,
                          ndroppedstats * sizeof(xl_xact_stats_item));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
     {
         XLogRegisterData((char *) (&xl_invals), MinSizeOfXactInvals);
         XLogRegisterData((char *) msgs,
                          nmsgs * sizeof(SharedInvalidationMessage));
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
     {
         XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
         if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
             XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
     }
  
     if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
         XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
  
     /* we allow filtering by xacts */
     XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
  
     return XLogInsert(RM_XACT_ID, info);
 }

References Assert, CritSectionCount, xl_xact_dbinfo::dbId, forceSyncCommit, InvalidRepOriginId, MinSizeOfXactInvals, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, MyDatabaseId, MyDatabaseTableSpace, xl_xact_stats_items::nitems, xl_xact_invals::nmsgs, xl_xact_relfilelocators::nrels, xl_xact_subxacts::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_origin::origin_timestamp, replorigin_session_origin, replorigin_session_origin_lsn, replorigin_session_origin_timestamp, synchronous_commit, SYNCHRONOUS_COMMIT_REMOTE_APPLY, TransactionIdIsValid, xl_xact_dbinfo::tsId, unconstify, XACT_COMPLETION_APPLY_FEEDBACK, XACT_COMPLETION_FORCE_SYNC_COMMIT, XACT_COMPLETION_UPDATE_RELCACHE_FILE, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, xl_xact_commit::xact_time, XACT_XINFO_HAS_AE_LOCKS, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_INVALS, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, XLOG_INCLUDE_ORIGIN, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_HAS_INFO, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogSetRecordFlags(), and XLR_SPECIAL_REL_UPDATE.

Referenced by RecordTransactionCommit(), and RecordTransactionCommitPrepared().

Variable Documentation

◆ bsysscan

bool bsysscan = false

Definition at line 98 of file xact.c.

Referenced by heap_getnext(), ResetLogicalStreamingState(), systable_beginscan(), systable_endscan(), table_index_fetch_tuple(), table_scan_bitmap_next_block(), table_scan_bitmap_next_tuple(), table_scan_getnextslot(), table_scan_sample_next_block(), table_scan_sample_next_tuple(), table_tuple_fetch_row_version(), and table_tuple_get_latest_tid().

◆ CheckXidAlive

◆ currentCommandId

CommandId currentCommandId

static

Definition at line 265 of file xact.c.

Referenced by CommandCounterIncrement(), GetCurrentCommandId(), SerializeTransactionState(), ShowTransactionStateRec(), StartParallelWorkerTransaction(), and StartTransaction().

◆ currentCommandIdUsed

bool currentCommandIdUsed

static

Definition at line 266 of file xact.c.

Referenced by CommandCounterIncrement(), GetCurrentCommandId(), ShowTransactionStateRec(), and StartTransaction().

◆ currentSubTransactionId

SubTransactionId currentSubTransactionId

static

Definition at line 264 of file xact.c.

Referenced by PushTransaction(), and StartTransaction().

◆ CurrentTransactionState

TransactionState CurrentTransactionState = &TopTransactionStateData

static

Definition at line 258 of file xact.c.

◆ DefaultXactDeferrable

bool DefaultXactDeferrable = false

Definition at line 82 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactIsoLevel

int DefaultXactIsoLevel = XACT_READ_COMMITTED

Definition at line 76 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactReadOnly

bool DefaultXactReadOnly = false

Definition at line 79 of file xact.c.

Referenced by StartTransaction().

◆ forceSyncCommit

bool forceSyncCommit = false

static

Definition at line 291 of file xact.c.

Referenced by ForceSyncCommit(), RecordTransactionCommit(), StartTransaction(), and XactLogCommitRecord().

◆ MyXactFlags

◆ nParallelCurrentXids

int nParallelCurrentXids = 0

static

Definition at line 124 of file xact.c.

Referenced by CleanupTransaction(), CommitTransaction(), PrepareTransaction(), SerializeTransactionState(), StartParallelWorkerTransaction(), and TransactionIdIsCurrentTransactionId().

◆ nUnreportedXids

int nUnreportedXids

static

Definition at line 255 of file xact.c.

Referenced by AssignTransactionId(), and StartTransaction().

◆ ParallelCurrentXids

TransactionId* ParallelCurrentXids

static

Definition at line 125 of file xact.c.

Referenced by SerializeTransactionState(), StartParallelWorkerTransaction(), and TransactionIdIsCurrentTransactionId().

◆ prepareGID

char* prepareGID

static

Definition at line 286 of file xact.c.

Referenced by PrepareTransaction(), and PrepareTransactionBlock().

◆ stmtStartTimestamp

TimestampTz stmtStartTimestamp

static

Definition at line 279 of file xact.c.

Referenced by GetCurrentStatementStartTimestamp(), SetCurrentStatementStartTimestamp(), SetParallelStartTimestamps(), and StartTransaction().

◆ SubXact_callbacks

SubXactCallbackItem* SubXact_callbacks = NULL

static

Definition at line 325 of file xact.c.

Referenced by CallSubXactCallbacks(), RegisterSubXactCallback(), and UnregisterSubXactCallback().

◆ synchronous_commit

int synchronous_commit = SYNCHRONOUS_COMMIT_ON

Definition at line 85 of file xact.c.

Referenced by AutoVacWorkerMain(), RecordTransactionCommit(), and XactLogCommitRecord().

◆ TopTransactionStateData

TransactionStateData TopTransactionStateData

static

Initial value:

= {
    .state = TRANS_DEFAULT,
    .blockState = TBLOCK_DEFAULT,
    .topXidLogged = false,
}

Definition at line 245 of file xact.c.

Referenced by AssignTransactionId(), GetTopFullTransactionId(), GetTopTransactionId(), and StartTransaction().

◆ TransactionAbortContext

MemoryContext TransactionAbortContext = NULL

static

Definition at line 301 of file xact.c.

Referenced by AtAbort_Memory(), AtCleanup_Memory(), AtStart_Memory(), AtSubAbort_Memory(), and AtSubCleanup_Memory().

◆ unreportedXids

TransactionId unreportedXids[PGPROC_MAX_CACHED_SUBXIDS]

static

Definition at line 256 of file xact.c.

Referenced by AssignTransactionId().

◆ Xact_callbacks

XactCallbackItem* Xact_callbacks = NULL

static

Definition at line 313 of file xact.c.

Referenced by CallXactCallbacks(), RegisterXactCallback(), and UnregisterXactCallback().

◆ xact_is_sampled

bool xact_is_sampled = false

Definition at line 294 of file xact.c.

Referenced by check_log_duration(), and StartTransaction().

◆ XactDeferrable

bool XactDeferrable

Definition at line 83 of file xact.c.

Referenced by GetSafeSnapshot(), GetSerializableTransactionSnapshot(), RestoreTransactionCharacteristics(), SaveTransactionCharacteristics(), SerializeTransactionState(), SetSerializableTransactionSnapshot(), StartParallelWorkerTransaction(), and StartTransaction().

◆ XactIsoLevel

int XactIsoLevel = XACT_READ_COMMITTED

Definition at line 77 of file xact.c.

Referenced by check_transaction_isolation(), CreateReplicationSlot(), ExportSnapshot(), InitPostgres(), RestoreTransactionCharacteristics(), SaveTransactionCharacteristics(), SerializeTransactionState(), SnapBuildExportSnapshot(), SnapBuildInitialSnapshot(), StartParallelWorkerTransaction(), and StartTransaction().

◆ XactReadOnly

◆ xactStartTimestamp

TimestampTz xactStartTimestamp

static

Definition at line 278 of file xact.c.

Referenced by GetCurrentTransactionStartTimestamp(), SetParallelStartTimestamps(), and StartTransaction().

◆ xactStopTimestamp

TimestampTz xactStopTimestamp

static

Definition at line 280 of file xact.c.

Referenced by GetCurrentTransactionStopTimestamp(), and StartTransaction().

◆ XactTopFullTransactionId

FullTransactionId XactTopFullTransactionId = {InvalidTransactionId}

static

Definition at line 123 of file xact.c.

Referenced by AssignTransactionId(), CleanupTransaction(), CommitTransaction(), GetTopFullTransactionId(), GetTopFullTransactionIdIfAny(), GetTopTransactionId(), GetTopTransactionIdIfAny(), PrepareTransaction(), SerializeTransactionState(), StartParallelWorkerTransaction(), and StartTransaction().

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()

◆ AbortCurrentTransactionInternal()

◆ 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()

◆ CommitTransactionCommandInternal()

◆ DefineSavepoint()

◆ EndImplicitTransactionBlock()

◆ EndParallelWorkerTransaction()

◆ EndTransactionBlock()

◆ EnterParallelMode()

◆ EstimateTransactionStateSpace()

◆ ExitParallelMode()

◆ ForceSyncCommit()

◆ GetCurrentCommandId()

◆ GetCurrentFullTransactionId()

◆ GetCurrentFullTransactionIdIfAny()

◆ GetCurrentStatementStartTimestamp()

◆ GetCurrentSubTransactionId()

◆ GetCurrentTransactionId()

◆ GetCurrentTransactionIdIfAny()

◆ GetCurrentTransactionNestLevel()

◆ GetCurrentTransactionStartTimestamp()

◆ GetCurrentTransactionStopTimestamp()

◆ GetStableLatestTransactionId()

◆ GetTopFullTransactionId()

◆ GetTopFullTransactionIdIfAny()

◆ GetTopTransactionId()

◆ GetTopTransactionIdIfAny()

◆ IsAbortedTransactionBlockState()