xact.c File Reference

#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 "replication/walsender.h"
#include "storage/condition_variable.h"
#include "storage/fd.h"
#include "storage/lmgr.h"
#include "storage/md.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/combocid.h"
#include "utils/guc.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/relmapper.h"
#include "utils/snapmgr.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"

Include dependency graph for xact.c:

Go to the source code of this file.

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 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 233 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 215 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 157 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 141 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 3306 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.
             */
        case TBLOCK_SUBBEGIN:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
            AbortSubTransaction();
            CleanupSubTransaction();
            AbortCurrentTransaction();
            break;
 
            /*
             * Same as above, except the Abort() was already done.
             */
        case TBLOCK_SUBABORT_END:
        case TBLOCK_SUBABORT_RESTART:
            CleanupSubTransaction();
            AbortCurrentTransaction();
            break;
    }
}

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 _SPI_commit(), _SPI_rollback(), AutoVacLauncherMain(), pa_stream_abort(), PostgresMain(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), and SnapBuildClearExportedSnapshot().

AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction

(

void

)

Definition at line 4713 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);
 
    /* If we didn't actually have anything to do, revert to TopMemoryContext */
    AtCleanup_Memory();
}

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

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

AbortSubTransaction()

static void AbortSubTransaction ( void  )

static

Definition at line 5059 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();
    AbortBufferIO();
    UnlockBuffers();
 
    /* Reset WAL record construction state */
    XLogResetInsertion();
 
    /* Cancel condition variable sleep */
    ConditionVariableCancelSleep();
 
    /*
     * Also clean up any open wait for lock, since the lock manager will choke
     * if we try to wait for another lock before doing this.
     */
    LockErrorCleanup();
 
    /*
     * If any timeout events are still active, make sure the timeout interrupt
     * is scheduled.  This covers possible loss of a timeout interrupt due to
     * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
     * We delay this till after LockErrorCleanup so that we don't uselessly
     * reschedule lock or deadlock check timeouts.
     */
    reschedule_timeouts();
 
    /*
     * Re-enable signals, in case we got here by longjmp'ing out of a signal
     * handler.  We do this fairly early in the sequence so that the timeout
     * infrastructure will be functional if needed while aborting.
     */
    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.
     */
 
    /* Exit from parallel mode, if necessary. */
    if (IsInParallelMode())
    {
        AtEOSubXact_Parallel(false, s->subTransactionId);
        s->parallelModeLevel = 0;
    }
 
    /*
     * We can skip all this stuff if the subxact failed before creating a
     * ResourceOwner...
     */
    if (s->curTransactionOwner)
    {
        AfterTriggerEndSubXact(false);
        AtSubAbort_Portals(s->subTransactionId,
                           s->parent->subTransactionId,
                           s->curTransactionOwner,
                           s->parent->curTransactionOwner);
        AtEOSubXact_LargeObject(false, s->subTransactionId,
                                s->parent->subTransactionId);
        AtSubAbort_Notify();
 
        /* Advertise the fact that we aborted in pg_xact. */
        (void) RecordTransactionAbort(true);
 
        /* Post-abort cleanup */
        if (FullTransactionIdIsValid(s->fullTransactionId))
            AtSubAbort_childXids();
 
        CallSubXactCallbacks(SUBXACT_EVENT_ABORT_SUB, s->subTransactionId,
                             s->parent->subTransactionId);
 
        ResourceOwnerRelease(s->curTransactionOwner,
                             RESOURCE_RELEASE_BEFORE_LOCKS,
                             false, false);
        AtEOSubXact_RelationCache(false, s->subTransactionId,
                                  s->parent->subTransactionId);
        AtEOSubXact_Inval(false);
        ResourceOwnerRelease(s->curTransactionOwner,
                             RESOURCE_RELEASE_LOCKS,
                             false, false);
        ResourceOwnerRelease(s->curTransactionOwner,
                             RESOURCE_RELEASE_AFTER_LOCKS,
                             false, false);
        AtSubAbort_smgr();
 
        AtEOXact_GUC(false, s->gucNestLevel);
        AtEOSubXact_SPI(false, s->subTransactionId);
        AtEOSubXact_on_commit_actions(false, s->subTransactionId,
                                      s->parent->subTransactionId);
        AtEOSubXact_Namespace(false, s->subTransactionId,
                              s->parent->subTransactionId);
        AtEOSubXact_Files(false, s->subTransactionId,
                          s->parent->subTransactionId);
        AtEOSubXact_HashTables(false, s->nestingLevel);
        AtEOSubXact_PgStat(false, s->nestingLevel);
        AtSubAbort_Snapshot(s->nestingLevel);
    }
 
    /*
     * 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();
}

References AbortBufferIO(), AfterTriggerEndSubXact(), AtEOSubXact_Files(), AtEOSubXact_HashTables(), AtEOSubXact_Inval(), AtEOSubXact_LargeObject(), AtEOSubXact_Namespace(), AtEOSubXact_on_commit_actions(), AtEOSubXact_Parallel(), AtEOSubXact_PgStat(), AtEOSubXact_RelationCache(), AtEOSubXact_SPI(), AtEOXact_GUC(), AtSubAbort_childXids(), AtSubAbort_Memory(), AtSubAbort_Notify(), AtSubAbort_Portals(), AtSubAbort_ResourceOwner(), AtSubAbort_smgr(), AtSubAbort_Snapshot(), CallSubXactCallbacks(), ConditionVariableCancelSleep(), CurrentTransactionState, TransactionStateData::curTransactionOwner, elog(), TransactionStateData::fullTransactionId, FullTransactionIdIsValid, TransactionStateData::gucNestLevel, HOLD_INTERRUPTS, IsInParallelMode(), LockErrorCleanup(), LWLockReleaseAll(), TransactionStateData::nestingLevel, TransactionStateData::parallelModeLevel, TransactionStateData::parent, pgstat_progress_end_command(), pgstat_report_wait_end(), TransactionStateData::prevSecContext, TransactionStateData::prevUser, TransactionStateData::prevXactReadOnly, RecordTransactionAbort(), reschedule_timeouts(), ResetLogicalStreamingState(), ResetReindexState(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerRelease(), RESUME_INTERRUPTS, SetUserIdAndSecContext(), ShowTransactionState(), TransactionStateData::state, TransactionStateData::subTransactionId, SUBXACT_EVENT_ABORT_SUB, TRANS_ABORT, TRANS_INPROGRESS, TransStateAsString(), UnBlockSig, UnlockBuffers(), WARNING, XactReadOnly, and XLogResetInsertion().

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

AbortTransaction()

static void AbortTransaction ( void  )

static

Definition at line 2697 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
    TransactionId latestXid;
    bool        is_parallel_worker;
 
    /* Prevent cancel/die interrupt while cleaning up */
    HOLD_INTERRUPTS();
 
    /* Make sure we have a valid memory context and resource owner */
    AtAbort_Memory();
    AtAbort_ResourceOwner();
 
    /*
     * Release any LW locks we might be holding as quickly as possible.
     * (Regular locks, however, must be held till we finish aborting.)
     * Releasing LW locks is critical since we might try to grab them again
     * while cleaning up!
     */
    LWLockReleaseAll();
 
    /* Clear wait information and command progress indicator */
    pgstat_report_wait_end();
    pgstat_progress_end_command();
 
    /* Clean up buffer I/O and buffer context locks, too */
    AbortBufferIO();
    UnlockBuffers();
 
    /* Reset WAL record construction state */
    XLogResetInsertion();
 
    /* Cancel condition variable sleep */
    ConditionVariableCancelSleep();
 
    /*
     * Also clean up any open wait for lock, since the lock manager will choke
     * if we try to wait for another lock before doing this.
     */
    LockErrorCleanup();
 
    /*
     * If any timeout events are still active, make sure the timeout interrupt
     * is scheduled.  This covers possible loss of a timeout interrupt due to
     * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
     * We delay this till after LockErrorCleanup so that we don't uselessly
     * reschedule lock or deadlock check timeouts.
     */
    reschedule_timeouts();
 
    /*
     * Re-enable signals, in case we got here by longjmp'ing out of a signal
     * handler.  We do this fairly early in the sequence so that the timeout
     * infrastructure will be functional if needed while aborting.
     */
    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 in parallel mode, clean up workers and exit parallel mode. */
    if (IsInParallelMode())
    {
        AtEOXact_Parallel(false);
        s->parallelModeLevel = 0;
    }
 
    /*
     * do abort processing
     */
    AfterTriggerEndXact(false); /* 'false' means it's abort */
    AtAbort_Portals();
    smgrDoPendingSyncs(false, is_parallel_worker);
    AtEOXact_LargeObject(false);
    AtAbort_Notify();
    AtEOXact_RelationMap(false, is_parallel_worker);
    AtAbort_Twophase();
 
    /*
     * Advertise the fact that we aborted in pg_xact (assuming that we got as
     * far as assigning an XID to advertise).  But if we're inside a parallel
     * worker, skip this; the user backend must be the one to write the abort
     * record.
     */
    if (!is_parallel_worker)
        latestXid = RecordTransactionAbort(false);
    else
    {
        latestXid = InvalidTransactionId;
 
        /*
         * Since the parallel leader won't get our value of XactLastRecEnd in
         * this case, we nudge WAL-writer ourselves in this case.  See related
         * comments in RecordTransactionAbort for why this matters.
         */
        XLogSetAsyncXactLSN(XactLastRecEnd);
    }
 
    TRACE_POSTGRESQL_TRANSACTION_ABORT(MyProc->lxid);
 
    /*
     * Let others know about no transaction in progress by me. Note that this
     * must be done _before_ releasing locks we hold and _after_
     * RecordTransactionAbort.
     */
    ProcArrayEndTransaction(MyProc, latestXid);
 
    /*
     * Post-abort cleanup.  See notes in CommitTransaction() concerning
     * ordering.  We can skip all of it if the transaction failed before
     * creating a resource owner.
     */
    if (TopTransactionResourceOwner != NULL)
    {
        if (is_parallel_worker)
            CallXactCallbacks(XACT_EVENT_PARALLEL_ABORT);
        else
            CallXactCallbacks(XACT_EVENT_ABORT);
 
        ResourceOwnerRelease(TopTransactionResourceOwner,
                             RESOURCE_RELEASE_BEFORE_LOCKS,
                             false, true);
        AtEOXact_Buffers(false);
        AtEOXact_RelationCache(false);
        AtEOXact_Inval(false);
        AtEOXact_MultiXact();
        ResourceOwnerRelease(TopTransactionResourceOwner,
                             RESOURCE_RELEASE_LOCKS,
                             false, true);
        ResourceOwnerRelease(TopTransactionResourceOwner,
                             RESOURCE_RELEASE_AFTER_LOCKS,
                             false, true);
        smgrDoPendingDeletes(false);
 
        AtEOXact_GUC(false, 1);
        AtEOXact_SPI(false);
        AtEOXact_Enum();
        AtEOXact_on_commit_actions(false);
        AtEOXact_Namespace(false, is_parallel_worker);
        AtEOXact_SMgr();
        AtEOXact_Files(false);
        AtEOXact_ComboCid();
        AtEOXact_HashTables(false);
        AtEOXact_PgStat(false, is_parallel_worker);
        AtEOXact_ApplyLauncher(false);
        AtEOXact_LogicalRepWorkers(false);
        pgstat_report_xact_timestamp(0);
    }
 
    /*
     * State remains TRANS_ABORT until CleanupTransaction().
     */
    RESUME_INTERRUPTS();
}

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

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

AssignTransactionId()

static void AssignTransactionId ( TransactionState  s )

static

Definition at line 626 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())
        elog(ERROR, "cannot assign XIDs during a parallel operation");
 
    /*
     * Ensure parent(s) have XIDs, so that a child always has an XID later
     * than its parent.  Mustn't recurse here, or we might get a stack
     * overflow if we're at the bottom of a huge stack of subtransactions none
     * of which have XIDs yet.
     */
    if (isSubXact && !FullTransactionIdIsValid(s->parent->fullTransactionId))
    {
        TransactionState p = s->parent;
        TransactionState *parents;
        size_t      parentOffset = 0;
 
        parents = palloc(sizeof(TransactionState) * s->nestingLevel);
        while (p != NULL && !FullTransactionIdIsValid(p->fullTransactionId))
        {
            parents[parentOffset++] = p;
            p = p->parent;
        }
 
        /*
         * This is technically a recursive call, but the recursion will never
         * be more than one layer deep.
         */
        while (parentOffset != 0)
            AssignTransactionId(parents[--parentOffset]);
 
        pfree(parents);
    }
 
    /*
     * When wal_level=logical, guarantee that a subtransaction's xid can only
     * be seen in the WAL stream if its toplevel xid has been logged before.
     * If necessary we log an xact_assignment record with fewer than
     * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
     * for a transaction even though it appears in a WAL record, we just might
     * superfluously log something. That can happen when an xid is included
     * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
     * xl_standby_locks.
     */
    if (isSubXact && XLogLogicalInfoActive() &&
        !TopTransactionStateData.didLogXid)
        log_unknown_top = true;
 
    /*
     * Generate a new FullTransactionId and record its xid in 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, elog(), ERROR, TransactionStateData::fullTransactionId, FullTransactionIdIsValid, GetNewTransactionId(), GetTopTransactionId(), IsInParallelMode(), IsParallelWorker, MinSizeOfXactAssignment, TransactionStateData::nestingLevel, xl_xact_assignment::nsubxacts, nUnreportedXids, palloc(), TransactionStateData::parent, pfree(), PGPROC_MAX_CACHED_SUBXIDS, RegisterPredicateLockingXid(), TransactionStateData::state, SubTransSetParent(), 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 1832 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 1864 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 1537 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 1922 of file xact.c.

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

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

Referenced by AbortOutOfAnyTransaction(), and CleanupTransaction().

AtCommit_Memory()

static void AtCommit_Memory ( void  )

static

Definition at line 1556 of file xact.c.

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

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

Referenced by CommitTransaction(), and PrepareTransaction().

AtStart_Cache()

static void AtStart_Cache ( void  )

static

Definition at line 1143 of file xact.c.

{
    AcceptInvalidationMessages();
}

References AcceptInvalidationMessages().

Referenced by StartTransaction().

AtStart_Memory()

static void AtStart_Memory ( void  )

static

Definition at line 1152 of file xact.c.

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

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

Referenced by StartTransaction().

AtStart_ResourceOwner()

static void AtStart_ResourceOwner ( void  )

static

Definition at line 1199 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 1890 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 1852 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 1877 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 1958 of file xact.c.

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

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

Referenced by CleanupSubTransaction().

AtSubCommit_childXids()

static void AtSubCommit_childXids ( void  )

static

Definition at line 1612 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 1583 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 1227 of file xact.c.

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

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

Referenced by StartSubTransaction().

AtSubStart_ResourceOwner()

static void AtSubStart_ResourceOwner ( void  )

static

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

References TransactionStateData::blockState, BlockStateAsString(), CommitTransactionCommand(), CurrentTransactionState, elog(), ereport, errcode(), errmsg(), ERROR, FATAL, IsInParallelMode(), 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 3771 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 5531 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(), CommitTransactionCommand(), 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 3745 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 3685 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 3569 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 5218 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 AbortCurrentTransaction(), AbortOutOfAnyTransaction(), CommitTransactionCommand(), and RollbackAndReleaseCurrentSubTransaction().

CleanupTransaction()

static void CleanupTransaction ( void  )

static

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

References AtCleanup_Memory(), AtCleanup_Portals(), AtEOXact_Snapshot(), TransactionStateData::childXids, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog(), FATAL, TransactionStateData::fullTransactionId, TransactionStateData::gucNestLevel, InvalidFullTransactionId, InvalidSubTransactionId, TransactionStateData::maxChildXids, TransactionStateData::nChildXids, TransactionStateData::nestingLevel, nParallelCurrentXids, TransactionStateData::parallelModeLevel, ResourceOwnerDelete(), TransactionStateData::state, TransactionStateData::subTransactionId, TopTransactionResourceOwner, TRANS_ABORT, TRANS_DEFAULT, TransStateAsString(), and XactTopFullTransactionId.

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

CommandCounterIncrement()

void CommandCounterIncrement

(

void

)

Definition at line 1078 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())
            elog(ERROR, "cannot start commands during a parallel operation");
 
        currentCommandId += 1;
        if (currentCommandId == InvalidCommandId)
        {
            currentCommandId -= 1;
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("cannot have more than 2^32-2 commands in a transaction")));
        }
        currentCommandIdUsed = false;
 
        /* Propagate new command ID into static snapshots */
        SnapshotSetCommandId(currentCommandId);
 
        /*
         * Make any catalog changes done by the just-completed command visible
         * in the local syscache.  We obviously don't need to do this after a
         * read-only command.  (But see hacks in inval.c to make real sure we
         * don't think a command that queued inval messages was read-only.)
         */
        AtCCI_LocalCache();
    }
}

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

Referenced by _SPI_execute_plan(), acquire_inherited_sample_rows(), addFkRecurseReferenced(), addFkRecurseReferencing(), AddRoleMems(), AlterPublicationOptions(), AlterRole(), ATAddCheckConstraint(), ATExecAddColumn(), ATExecAlterColumnType(), ATExecCmd(), ATExecDropColumn(), ATExecDropConstraint(), ATExecDropExpression(), ATExecDropIdentity(), ATExecSetCompression(), ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), ATParseTransformCmd(), ATRewriteTables(), AttachPartitionEnsureIndexes(), btadjustmembers(), CloneFkReferencing(), CommitSubTransaction(), CommitTransactionCommand(), copy_table_data(), create_ctas_internal(), create_toast_table(), CreateFKCheckTrigger(), createForeignKeyActionTriggers(), CreateForeignTable(), CreatePublication(), CreateRole(), CreateSchemaCommand(), CreateTriggerFiringOn(), DefineCollation(), DefineDomain(), DefineRelation(), DefineVirtualRelation(), deleteOneObject(), DetachPartitionFinalize(), 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(), RemoveRoleFromObjectPolicy(), RenumberEnumType(), replorigin_create(), replorigin_drop_by_name(), ri_PerformCheck(), SetDefaultACL(), SetMatViewPopulatedState(), shdepReassignOwned(), SPI_cursor_open_internal(), standard_ProcessUtility(), StoreConstraints(), StorePartitionBound(), tryAttachPartitionForeignKey(), vacuum(), and validatePartitionedIndex().

CommitSubTransaction()

static void CommitSubTransaction ( void  )

static

Definition at line 4950 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 in parallel mode, clean up workers and exit parallel mode. */
    if (IsInParallelMode())
    {
        AtEOSubXact_Parallel(true, s->subTransactionId);
        s->parallelModeLevel = 0;
    }
 
    /* Do the actual "commit", such as it is */
    s->state = TRANS_COMMIT;
 
    /* Must CCI to ensure commands of subtransaction are seen as done */
    CommandCounterIncrement();
 
    /*
     * Prior to 8.4 we marked subcommit in clog at this point.  We now only
     * perform that step, if required, as part of the atomic update of the
     * whole transaction tree at top level commit or abort.
     */
 
    /* Post-commit cleanup */
    if (FullTransactionIdIsValid(s->fullTransactionId))
        AtSubCommit_childXids();
    AfterTriggerEndSubXact(true);
    AtSubCommit_Portals(s->subTransactionId,
                        s->parent->subTransactionId,
                        s->parent->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();
}

References AfterTriggerEndSubXact(), AtEOSubXact_Files(), AtEOSubXact_HashTables(), AtEOSubXact_Inval(), AtEOSubXact_LargeObject(), AtEOSubXact_Namespace(), AtEOSubXact_on_commit_actions(), AtEOSubXact_Parallel(), AtEOSubXact_PgStat(), AtEOSubXact_RelationCache(), AtEOSubXact_SPI(), AtEOXact_GUC(), AtSubCommit_childXids(), AtSubCommit_Memory(), AtSubCommit_Notify(), AtSubCommit_Portals(), AtSubCommit_smgr(), AtSubCommit_Snapshot(), CallSubXactCallbacks(), CommandCounterIncrement(), CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog(), TransactionStateData::fullTransactionId, FullTransactionIdIsValid, TransactionStateData::gucNestLevel, IsInParallelMode(), TransactionStateData::nestingLevel, TransactionStateData::parallelModeLevel, TransactionStateData::parent, PopTransaction(), TransactionStateData::prevXactReadOnly, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerDelete(), ResourceOwnerRelease(), ShowTransactionState(), TransactionStateData::state, TransactionStateData::subTransactionId, SUBXACT_EVENT_COMMIT_SUB, SUBXACT_EVENT_PRE_COMMIT_SUB, TRANS_COMMIT, TRANS_DEFAULT, TRANS_INPROGRESS, TransStateAsString(), WARNING, XactLockTableDelete(), XactReadOnly, and XidFromFullTransactionId.

Referenced by CommitTransactionCommand(), and ReleaseCurrentSubTransaction().

CommitTransaction()

static void CommitTransaction ( void  )

static

Definition at line 2152 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 we might have parallel workers, clean them up now. */
    if (IsInParallelMode())
        AtEOXact_Parallel(true);
 
    /* Shut down the deferred-trigger manager */
    AfterTriggerEndXact(true);
 
    /*
     * Let ON COMMIT management do its thing (must happen after closing
     * cursors, to avoid dangling-reference problems)
     */
    PreCommit_on_commit_actions();
 
    /*
     * Synchronize files that are created and not WAL-logged during this
     * transaction. This must happen before AtEOXact_RelationMap(), so that we
     * don't see committed-but-broken files after a crash.
     */
    smgrDoPendingSyncs(true, is_parallel_worker);
 
    /* close large objects before lower-level cleanup */
    AtEOXact_LargeObject(true);
 
    /*
     * Insert notifications sent by NOTIFY commands into the queue.  This
     * should be late in the pre-commit sequence to minimize time spent
     * holding the notify-insertion lock.  However, this could result in
     * creating a snapshot, so we must do it before serializable cleanup.
     */
    PreCommit_Notify();
 
    /*
     * Mark serializable transaction as complete for predicate locking
     * purposes.  This should be done as late as we can put it and still allow
     * errors to be raised for failure patterns found at commit.  This is not
     * appropriate in a parallel worker however, because we aren't committing
     * the leader's transaction and its serializable state will live on.
     */
    if (!is_parallel_worker)
        PreCommit_CheckForSerializationFailure();
 
    /* Prevent cancel/die interrupt while cleaning up */
    HOLD_INTERRUPTS();
 
    /* Commit updates to the relation map --- do this as late as possible */
    AtEOXact_RelationMap(true, is_parallel_worker);
 
    /*
     * set the current transaction state information appropriately during
     * commit processing
     */
    s->state = TRANS_COMMIT;
    s->parallelModeLevel = 0;
 
    if (!is_parallel_worker)
    {
        /*
         * We need to mark our XIDs as committed in pg_xact.  This is where we
         * durably commit.
         */
        latestXid = RecordTransactionCommit();
    }
    else
    {
        /*
         * We must not mark our XID committed; the parallel leader is
         * responsible for that.
         */
        latestXid = InvalidTransactionId;
 
        /*
         * Make sure the leader will know about any WAL we wrote before it
         * commits.
         */
        ParallelWorkerReportLastRecEnd(XactLastRecEnd);
    }
 
    TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid);
 
    /*
     * Let others know about no transaction in progress by me. Note that this
     * must be done _before_ releasing locks we hold and _after_
     * RecordTransactionCommit.
     */
    ProcArrayEndTransaction(MyProc, latestXid);
 
    /*
     * This is all post-commit cleanup.  Note that if an error is raised here,
     * it's too late to abort the transaction.  This should be just
     * noncritical resource releasing.
     *
     * The ordering of operations is not entirely random.  The idea is:
     * release resources visible to other backends (eg, files, buffer pins);
     * then release locks; then release backend-local resources. We want to
     * release locks at the point where any backend waiting for us will see
     * our transaction as being fully cleaned up.
     *
     * Resources that can be associated with individual queries are handled by
     * the ResourceOwner mechanism.  The other calls here are for backend-wide
     * state.
     */
 
    CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
                      : XACT_EVENT_COMMIT);
 
    ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_BEFORE_LOCKS,
                         true, true);
 
    /* Check we've released all buffer pins */
    AtEOXact_Buffers(true);
 
    /* Clean up the relation cache */
    AtEOXact_RelationCache(true);
 
    /*
     * Make catalog changes visible to all backends.  This has to happen after
     * relcache references are dropped (see comments for
     * AtEOXact_RelationCache), but before locks are released (if anyone is
     * waiting for lock on a relation we've modified, we want them to know
     * about the catalog change before they start using the relation).
     */
    AtEOXact_Inval(true);
 
    AtEOXact_MultiXact();
 
    ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_LOCKS,
                         true, true);
    ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_AFTER_LOCKS,
                         true, true);
 
    /*
     * Likewise, dropping of files deleted during the transaction is best done
     * after releasing relcache and buffer pins.  (This is not strictly
     * necessary during commit, since such pins should have been released
     * already, but this ordering is definitely critical during abort.)  Since
     * this may take many seconds, also delay until after releasing locks.
     * Other backends will observe the attendant catalog changes and not
     * attempt to access affected files.
     */
    smgrDoPendingDeletes(true);
 
    /*
     * 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);
 
    CurrentResourceOwner = NULL;
    ResourceOwnerDelete(TopTransactionResourceOwner);
    s->curTransactionOwner = NULL;
    CurTransactionResourceOwner = NULL;
    TopTransactionResourceOwner = NULL;
 
    AtCommit_Memory();
 
    s->fullTransactionId = InvalidFullTransactionId;
    s->subTransactionId = InvalidSubTransactionId;
    s->nestingLevel = 0;
    s->gucNestLevel = 0;
    s->childXids = NULL;
    s->nChildXids = 0;
    s->maxChildXids = 0;
 
    XactTopFullTransactionId = InvalidFullTransactionId;
    nParallelCurrentXids = 0;
 
    /*
     * done with commit processing, set current transaction state back to
     * default
     */
    s->state = TRANS_DEFAULT;
 
    RESUME_INTERRUPTS();
}

References AfterTriggerEndXact(), AfterTriggerFireDeferred(), Assert(), AtCommit_Memory(), AtCommit_Notify(), AtEOXact_ApplyLauncher(), AtEOXact_Buffers(), AtEOXact_ComboCid(), AtEOXact_Enum(), AtEOXact_Files(), AtEOXact_GUC(), AtEOXact_HashTables(), AtEOXact_Inval(), AtEOXact_LargeObject(), AtEOXact_LogicalRepWorkers(), AtEOXact_MultiXact(), AtEOXact_Namespace(), AtEOXact_on_commit_actions(), AtEOXact_Parallel(), AtEOXact_PgStat(), AtEOXact_RelationCache(), AtEOXact_RelationMap(), AtEOXact_SMgr(), AtEOXact_Snapshot(), AtEOXact_SPI(), TransactionStateData::blockState, CallXactCallbacks(), TransactionStateData::childXids, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog(), EnterParallelMode(), TransactionStateData::fullTransactionId, TransactionStateData::gucNestLevel, HOLD_INTERRUPTS, InvalidFullTransactionId, InvalidSubTransactionId, InvalidTransactionId, IsInParallelMode(), PGPROC::lxid, TransactionStateData::maxChildXids, MyProc, TransactionStateData::nChildXids, TransactionStateData::nestingLevel, nParallelCurrentXids, TransactionStateData::parallelModeLevel, ParallelWorkerReportLastRecEnd(), TransactionStateData::parent, pgstat_report_xact_timestamp(), PreCommit_CheckForSerializationFailure(), PreCommit_Notify(), PreCommit_on_commit_actions(), PreCommit_Portals(), ProcArrayEndTransaction(), RecordTransactionCommit(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerDelete(), ResourceOwnerRelease(), RESUME_INTERRUPTS, ShowTransactionState(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), TransactionStateData::state, TransactionStateData::subTransactionId, TBLOCK_PARALLEL_INPROGRESS, TopTransactionResourceOwner, TRANS_COMMIT, TRANS_DEFAULT, TRANS_INPROGRESS, TransStateAsString(), WARNING, XACT_EVENT_COMMIT, XACT_EVENT_PARALLEL_COMMIT, XACT_EVENT_PARALLEL_PRE_COMMIT, XACT_EVENT_PRE_COMMIT, XactLastRecEnd, and XactTopFullTransactionId.

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

CommitTransactionCommand()

void CommitTransactionCommand

(

void

)

Definition at line 3035 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
    SavedTransactionCharacteristics savetc;
 
    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).
             */
        case TBLOCK_SUBABORT_END:
            CleanupSubTransaction();
            CommitTransactionCommand();
            break;
 
            /*
             * As above, but it's not dead yet, so abort first.
             */
        case TBLOCK_SUBABORT_PENDING:
            AbortSubTransaction();
            CleanupSubTransaction();
            CommitTransactionCommand();
            break;
 
            /*
             * The current subtransaction is the target of a ROLLBACK TO
             * command.  Abort and pop it, then start a new subtransaction
             * with the same name.
             */
        case TBLOCK_SUBRESTART:
            {
                char       *name;
                int         savepointLevel;
 
                /* save name and keep Cleanup from freeing it */
                name = s->name;
                s->name = NULL;
                savepointLevel = s->savepointLevel;
 
                AbortSubTransaction();
                CleanupSubTransaction();
 
                DefineSavepoint(NULL);
                s = CurrentTransactionState;    /* changed by push */
                s->name = name;
                s->savepointLevel = savepointLevel;
 
                /* This is the same as TBLOCK_SUBBEGIN case */
                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;
    }
}

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 _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(), ApplyWorkerMain(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), BeginInternalSubTransaction(), BootstrapModeMain(), clear_subscription_skip_lsn(), cluster_multiple_rels(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), exec_replication_command(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeApplyWorker(), 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(), shell_check_detail(), stream_abort_internal(), stream_stop_internal(), vacuum(), and vacuum_rel().

DefineSavepoint()

void DefineSavepoint

(

const char *

name

)

Definition at line 4220 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())
        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(), 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 CommitTransactionCommand(), pa_start_subtrans(), and standard_ProcessUtility().

EndImplicitTransactionBlock()

void EndImplicitTransactionBlock

(

void

)

Definition at line 4198 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 5469 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 3891 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 1036 of file xact.c.

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

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

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

EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace

(

void

)

Definition at line 5345 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, and SerializedTransactionStateHeaderSize.

Referenced by InitializeParallelDSM().

ExitParallelMode()

void ExitParallelMode

(

void

)

Definition at line 1049 of file xact.c.

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

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

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

ForceSyncCommit()

void ForceSyncCommit

(

void

)

Definition at line 1128 of file xact.c.

{
    forceSyncCommit = true;
}

References forceSyncCommit.

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

GetCurrentCommandId()

CommandId GetCurrentCommandId

(

bool

used

)

Definition at line 818 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.
         */
        Assert(!IsParallelWorker());
        currentCommandIdUsed = true;
    }
    return currentCommandId;
}

References Assert(), currentCommandId, currentCommandIdUsed, and IsParallelWorker.

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

GetCurrentFullTransactionId()

FullTransactionId GetCurrentFullTransactionId

(

void

)

Definition at line 503 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 521 of file xact.c.

{
    return CurrentTransactionState->fullTransactionId;
}

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp

(

void

)

Definition at line 864 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 780 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 445 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 462 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 914 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::nestingLevel.

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

GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp

(

void

)

Definition at line 855 of file xact.c.

{
    return xactStartTimestamp;
}

References xactStartTimestamp.

Referenced by current_timestamp(), GetCurrentTimeUsec(), InitializeParallelDSM(), now(), pg_timezone_abbrevs(), sql_localtimestamp(), and timetz_zone().

GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp

(

void

)

Definition at line 876 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 598 of file xact.c.

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

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

Referenced by xid_age().

GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId

(

void

)

Definition at line 474 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 490 of file xact.c.

{
    return XactTopFullTransactionId;
}

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

GetTopTransactionId()

TransactionId GetTopTransactionId

(

void

)

Definition at line 417 of file xact.c.

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

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

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

GetTopTransactionIdIfAny()

TransactionId GetTopTransactionIdIfAny

(

void

)

Definition at line 432 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 398 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 RecoveryConflictInterrupt().

IsInParallelMode()

bool IsInParallelMode

(

void

)

Definition at line 1069 of file xact.c.

{
    return CurrentTransactionState->parallelModeLevel != 0;
}

References CurrentTransactionState, and TransactionStateData::parallelModeLevel.

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

IsInTransactionBlock()

bool IsInTransactionBlock

(

bool

isTopLevel

)

Definition at line 3613 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 4890 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 RecoveryConflictInterrupt().

IsSubxactTopXidLogPending()

bool IsSubxactTopXidLogPending

(

void

)

Definition at line 550 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 4817 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 4835 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(), RecoveryConflictInterrupt(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), SnapBuildExportSnapshot(), StartupDecodingContext(), and WalSndErrorCleanup().

IsTransactionState()

bool IsTransactionState

(

void

)

Definition at line 378 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(), 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(), RelationIdGetRelation(), RelationInitPhysicalAddr(), RelationReloadNailed(), replorigin_create(), replorigin_drop_by_name(), SearchCatCacheInternal(), SetMultiXactIdLimit(), SetTransactionIdLimit(), SnapBuildClearExportedSnapshot(), SocketBackend(), and stream_stop_internal().

MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny

(

void

)

Definition at line 532 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 582 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 5311 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 2412 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;
 
    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();
}

References AfterTriggerEndXact(), AfterTriggerFireDeferred(), Assert(), AtCommit_Memory(), AtEOXact_ApplyLauncher(), AtEOXact_Buffers(), AtEOXact_ComboCid(), AtEOXact_Enum(), AtEOXact_Files(), AtEOXact_GUC(), AtEOXact_HashTables(), AtEOXact_LargeObject(), AtEOXact_LogicalRepWorkers(), AtEOXact_Namespace(), AtEOXact_on_commit_actions(), AtEOXact_RelationCache(), AtEOXact_SMgr(), AtEOXact_Snapshot(), AtEOXact_SPI(), AtPrepare_Locks(), AtPrepare_MultiXact(), AtPrepare_Notify(), AtPrepare_PgStat(), AtPrepare_PredicateLocks(), AtPrepare_RelationMap(), CallXactCallbacks(), TransactionStateData::childXids, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog(), EndPrepare(), ereport, errcode(), errmsg(), ERROR, TransactionStateData::fullTransactionId, GetCurrentTimestamp(), GetCurrentTransactionId(), GetUserId(), TransactionStateData::gucNestLevel, HOLD_INTERRUPTS, InvalidFullTransactionId, InvalidSubTransactionId, IsInParallelMode(), MarkAsPreparing(), TransactionStateData::maxChildXids, MyDatabaseId, MyProc, MyXactFlags, TransactionStateData::nChildXids, TransactionStateData::nestingLevel, nParallelCurrentXids, TransactionStateData::parent, pgstat_report_xact_timestamp(), PostPrepare_Inval(), PostPrepare_Locks(), PostPrepare_MultiXact(), PostPrepare_PgStat(), PostPrepare_PredicateLocks(), PostPrepare_smgr(), PostPrepare_Twophase(), PreCommit_CheckForSerializationFailure(), PreCommit_on_commit_actions(), PreCommit_Portals(), prepareGID, ProcArrayClearTransaction(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerDelete(), ResourceOwnerRelease(), RESUME_INTERRUPTS, ShowTransactionState(), smgrDoPendingSyncs(), StartPrepare(), TransactionStateData::state, TransactionStateData::subTransactionId, TopTransactionResourceOwner, TRANS_DEFAULT, TRANS_INPROGRESS, TRANS_PREPARE, TransStateAsString(), WARNING, XACT_EVENT_PRE_PREPARE, XACT_EVENT_PREPARE, XACT_FLAGS_ACCESSEDTEMPNAMESPACE, XactHasExportedSnapshots(), XactLastRecEnd, and XactTopFullTransactionId.

Referenced by CommitTransactionCommand().

PrepareTransactionBlock()

bool PrepareTransactionBlock

(

const char *

gid

)

Definition at line 3839 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 3482 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(), cluster(), CreateSubscription(), DiscardAll(), DropSubscription(), exec_replication_command(), ExecDropStmt(), ExecReindex(), ProcessUtilitySlow(), ReindexPartitions(), standard_ProcessUtility(), and vacuum().

PushTransaction()

static void PushTransaction ( void  )

static

Definition at line 5251 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->parallelModeLevel = 0;
    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.
     */
}

References TransactionStateData::blockState, currentSubTransactionId, CurrentTransactionState, ereport, errcode(), errmsg(), ERROR, TransactionStateData::fullTransactionId, GetUserIdAndSecContext(), TransactionStateData::gucNestLevel, InvalidFullTransactionId, InvalidSubTransactionId, MemoryContextAllocZero(), TransactionStateData::nestingLevel, NewGUCNestLevel(), TransactionStateData::parallelModeLevel, TransactionStateData::parent, pfree(), TransactionStateData::prevSecContext, TransactionStateData::prevUser, TransactionStateData::prevXactReadOnly, TransactionStateData::savepointLevel, TransactionStateData::state, TransactionStateData::subTransactionId, TBLOCK_SUBBEGIN, TopTransactionContext, TransactionStateData::topXidLogged, TRANS_DEFAULT, and XactReadOnly.

Referenced by BeginInternalSubTransaction(), and DefineSavepoint().

RecordTransactionAbort()

static TransactionId RecordTransactionAbort ( bool  isSubXact )

static

Definition at line 1702 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 1283 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