xact.h File Reference

#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "nodes/pg_list.h"
#include "storage/relfilenode.h"
#include "storage/sinval.h"
#include "utils/datetime.h"

Include dependency graph for xact.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	xl_xact_assignment
struct	xl_xact_xinfo
struct	xl_xact_dbinfo
struct	xl_xact_subxacts
struct	xl_xact_relfilenodes
struct	xl_xact_invals
struct	xl_xact_twophase
struct	xl_xact_origin
struct	xl_xact_commit
struct	xl_xact_abort
struct	xl_xact_parsed_commit
struct	xl_xact_parsed_abort

Macros
#define	GIDSIZE   200
#define	XACT_READ_UNCOMMITTED   0
#define	XACT_READ_COMMITTED   1
#define	XACT_REPEATABLE_READ   2
#define	XACT_SERIALIZABLE   3
#define	IsolationUsesXactSnapshot()   (XactIsoLevel >= XACT_REPEATABLE_READ)
#define	IsolationIsSerializable()   (XactIsoLevel == XACT_SERIALIZABLE)
#define	SYNCHRONOUS_COMMIT_ON   SYNCHRONOUS_COMMIT_REMOTE_FLUSH
#define	XACT_FLAGS_ACCESSEDTEMPREL   (1U << 0)
#define	XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK   (1U << 1)
#define	XLOG_XACT_COMMIT   0x00
#define	XLOG_XACT_PREPARE   0x10
#define	XLOG_XACT_ABORT   0x20
#define	XLOG_XACT_COMMIT_PREPARED   0x30
#define	XLOG_XACT_ABORT_PREPARED   0x40
#define	XLOG_XACT_ASSIGNMENT   0x50
#define	XLOG_XACT_OPMASK   0x70
#define	XLOG_XACT_HAS_INFO   0x80
#define	XACT_XINFO_HAS_DBINFO   (1U << 0)
#define	XACT_XINFO_HAS_SUBXACTS   (1U << 1)
#define	XACT_XINFO_HAS_RELFILENODES   (1U << 2)
#define	XACT_XINFO_HAS_INVALS   (1U << 3)
#define	XACT_XINFO_HAS_TWOPHASE   (1U << 4)
#define	XACT_XINFO_HAS_ORIGIN   (1U << 5)
#define	XACT_XINFO_HAS_AE_LOCKS   (1U << 6)
#define	XACT_XINFO_HAS_GID   (1U << 7)
#define	XACT_COMPLETION_APPLY_FEEDBACK   (1U << 29)
#define	XACT_COMPLETION_UPDATE_RELCACHE_FILE   (1U << 30)
#define	XACT_COMPLETION_FORCE_SYNC_COMMIT   (1U << 31)
#define	XactCompletionApplyFeedback(xinfo)   ((xinfo & XACT_COMPLETION_APPLY_FEEDBACK) != 0)
#define	XactCompletionRelcacheInitFileInval(xinfo)   ((xinfo & XACT_COMPLETION_UPDATE_RELCACHE_FILE) != 0)
#define	XactCompletionForceSyncCommit(xinfo)   ((xinfo & XACT_COMPLETION_FORCE_SYNC_COMMIT) != 0)
#define	MinSizeOfXactAssignment   offsetof(xl_xact_assignment, xsub)
#define	MinSizeOfXactSubxacts   offsetof(xl_xact_subxacts, subxacts)
#define	MinSizeOfXactRelfilenodes   offsetof(xl_xact_relfilenodes, xnodes)
#define	MinSizeOfXactInvals   offsetof(xl_xact_invals, msgs)
#define	MinSizeOfXactCommit   (offsetof(xl_xact_commit, xact_time) + sizeof(TimestampTz))
#define	MinSizeOfXactAbort   sizeof(xl_xact_abort)

Typedefs
typedef void(*	XactCallback) (XactEvent event, void *arg)
typedef void(*	SubXactCallback) (SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg)
typedef struct xl_xact_assignment	xl_xact_assignment
typedef struct xl_xact_xinfo	xl_xact_xinfo
typedef struct xl_xact_dbinfo	xl_xact_dbinfo
typedef struct xl_xact_subxacts	xl_xact_subxacts
typedef struct xl_xact_relfilenodes	xl_xact_relfilenodes
typedef struct xl_xact_invals	xl_xact_invals
typedef struct xl_xact_twophase	xl_xact_twophase
typedef struct xl_xact_origin	xl_xact_origin
typedef struct xl_xact_commit	xl_xact_commit
typedef struct xl_xact_abort	xl_xact_abort
typedef struct xl_xact_parsed_commit	xl_xact_parsed_commit
typedef xl_xact_parsed_commit	xl_xact_parsed_prepare
typedef struct xl_xact_parsed_abort	xl_xact_parsed_abort

Enumerations
enum	SyncCommitLevel {   SYNCHRONOUS_COMMIT_OFF, SYNCHRONOUS_COMMIT_LOCAL_FLUSH, SYNCHRONOUS_COMMIT_REMOTE_WRITE, SYNCHRONOUS_COMMIT_REMOTE_FLUSH,   SYNCHRONOUS_COMMIT_REMOTE_APPLY }
enum	XactEvent {   XACT_EVENT_COMMIT, XACT_EVENT_PARALLEL_COMMIT, XACT_EVENT_ABORT, XACT_EVENT_PARALLEL_ABORT,   XACT_EVENT_PREPARE, XACT_EVENT_PRE_COMMIT, XACT_EVENT_PARALLEL_PRE_COMMIT, XACT_EVENT_PRE_PREPARE }
enum	SubXactEvent { SUBXACT_EVENT_START_SUB, SUBXACT_EVENT_COMMIT_SUB, SUBXACT_EVENT_ABORT_SUB, SUBXACT_EVENT_PRE_COMMIT_SUB }

Functions
bool	IsTransactionState (void)
bool	IsAbortedTransactionBlockState (void)
TransactionId	GetTopTransactionId (void)
TransactionId	GetTopTransactionIdIfAny (void)
TransactionId	GetCurrentTransactionId (void)
TransactionId	GetCurrentTransactionIdIfAny (void)
TransactionId	GetStableLatestTransactionId (void)
SubTransactionId	GetCurrentSubTransactionId (void)
void	MarkCurrentTransactionIdLoggedIfAny (void)
bool	SubTransactionIsActive (SubTransactionId subxid)
CommandId	GetCurrentCommandId (bool used)
TimestampTz	GetCurrentTransactionStartTimestamp (void)
TimestampTz	GetCurrentStatementStartTimestamp (void)
TimestampTz	GetCurrentTransactionStopTimestamp (void)
void	SetCurrentStatementStartTimestamp (void)
int	GetCurrentTransactionNestLevel (void)
bool	TransactionIdIsCurrentTransactionId (TransactionId xid)
void	CommandCounterIncrement (void)
void	ForceSyncCommit (void)
void	StartTransactionCommand (void)
void	CommitTransactionCommand (void)
void	AbortCurrentTransaction (void)
void	BeginTransactionBlock (void)
bool	EndTransactionBlock (void)
bool	PrepareTransactionBlock (const char *gid)
void	UserAbortTransactionBlock (void)
void	BeginImplicitTransactionBlock (void)
void	EndImplicitTransactionBlock (void)
void	ReleaseSavepoint (const char *name)
void	DefineSavepoint (const char *name)
void	RollbackToSavepoint (const char *name)
void	BeginInternalSubTransaction (const char *name)
void	ReleaseCurrentSubTransaction (void)
void	RollbackAndReleaseCurrentSubTransaction (void)
bool	IsSubTransaction (void)
Size	EstimateTransactionStateSpace (void)
void	SerializeTransactionState (Size maxsize, char *start_address)
void	StartParallelWorkerTransaction (char *tstatespace)
void	EndParallelWorkerTransaction (void)
bool	IsTransactionBlock (void)
bool	IsTransactionOrTransactionBlock (void)
char	TransactionBlockStatusCode (void)
void	AbortOutOfAnyTransaction (void)
void	PreventInTransactionBlock (bool isTopLevel, const char *stmtType)
void	RequireTransactionBlock (bool isTopLevel, const char *stmtType)
void	WarnNoTransactionBlock (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)
int	xactGetCommittedChildren (TransactionId **ptr)
XLogRecPtr	XactLogCommitRecord (TimestampTz commit_time, int nsubxacts, TransactionId *subxacts, int nrels, RelFileNode *rels, int nmsgs, SharedInvalidationMessage *msgs, bool relcacheInval, bool forceSync, int xactflags, TransactionId twophase_xid, const char *twophase_gid)
XLogRecPtr	XactLogAbortRecord (TimestampTz abort_time, int nsubxacts, TransactionId *subxacts, int nrels, RelFileNode *rels, int xactflags, TransactionId twophase_xid, const char *twophase_gid)
void	xact_redo (XLogReaderState *record)
void	xact_desc (StringInfo buf, XLogReaderState *record)
const char *	xact_identify (uint8 info)
void	ParseCommitRecord (uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *parsed)
void	ParseAbortRecord (uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
void	EnterParallelMode (void)
void	ExitParallelMode (void)
bool	IsInParallelMode (void)

Variables
int	DefaultXactIsoLevel
PGDLLIMPORT int	XactIsoLevel
bool	DefaultXactReadOnly
bool	XactReadOnly
bool	DefaultXactDeferrable
bool	XactDeferrable
int	synchronous_commit
int	MyXactFlags

Macro Definition Documentation

GIDSIZE

#define GIDSIZE   200

Definition at line 30 of file xact.h.

Referenced by MarkAsPreparing().

IsolationIsSerializable

#define IsolationIsSerializable

(

)

(XactIsoLevel == XACT_SERIALIZABLE)

Definition at line 51 of file xact.h.

Referenced by begin_remote_xact(), CreateParallelContext(), GetSerializableTransactionSnapshot(), GetTransactionSnapshot(), ImportSnapshot(), PreCommit_CheckForSerializationFailure(), ReleasePredicateLocks(), SetSerializableTransactionSnapshot(), SetTransactionSnapshot(), and standard_planner().

IsolationUsesXactSnapshot

#define IsolationUsesXactSnapshot

(

)

(XactIsoLevel >= XACT_REPEATABLE_READ)

Definition at line 50 of file xact.h.

Referenced by bt_check_every_level(), EvalPlanQualFetch(), ExecCheckHeapTupleVisible(), ExecCheckTIDVisible(), ExecDelete(), ExecLockRows(), ExecOnConflictUpdate(), ExecUpdate(), GetTransactionSnapshot(), GetTupleForTrigger(), ImportSnapshot(), ri_PerformCheck(), and SetTransactionSnapshot().

MinSizeOfXactAbort

#define MinSizeOfXactAbort   sizeof(xl_xact_abort)

Definition at line 290 of file xact.h.

Referenced by ParseAbortRecord(), and XactLogAbortRecord().

MinSizeOfXactAssignment

#define MinSizeOfXactAssignment   offsetof(xl_xact_assignment, xsub)

Definition at line 195 of file xact.h.

Referenced by AssignTransactionId().

MinSizeOfXactCommit

#define MinSizeOfXactCommit   (offsetof(xl_xact_commit, xact_time) + sizeof(TimestampTz))

Definition at line 275 of file xact.h.

Referenced by ParseCommitRecord().

MinSizeOfXactInvals

#define MinSizeOfXactInvals   offsetof(xl_xact_invals, msgs)

Definition at line 249 of file xact.h.

Referenced by ParseCommitRecord(), and XactLogCommitRecord().

MinSizeOfXactRelfilenodes

#define MinSizeOfXactRelfilenodes   offsetof(xl_xact_relfilenodes, xnodes)

Definition at line 242 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

MinSizeOfXactSubxacts

#define MinSizeOfXactSubxacts   offsetof(xl_xact_subxacts, subxacts)

Definition at line 235 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

SYNCHRONOUS_COMMIT_ON

#define SYNCHRONOUS_COMMIT_ON   SYNCHRONOUS_COMMIT_REMOTE_FLUSH

Definition at line 75 of file xact.h.

XACT_COMPLETION_APPLY_FEEDBACK

#define XACT_COMPLETION_APPLY_FEEDBACK   (1U << 29)

Definition at line 176 of file xact.h.

Referenced by XactLogCommitRecord().

XACT_COMPLETION_FORCE_SYNC_COMMIT

#define XACT_COMPLETION_FORCE_SYNC_COMMIT   (1U << 31)

Definition at line 178 of file xact.h.

Referenced by XactLogCommitRecord().

XACT_COMPLETION_UPDATE_RELCACHE_FILE

#define XACT_COMPLETION_UPDATE_RELCACHE_FILE   (1U << 30)

Definition at line 177 of file xact.h.

Referenced by XactLogCommitRecord().

XACT_FLAGS_ACCESSEDTEMPREL

#define XACT_FLAGS_ACCESSEDTEMPREL   (1U << 0)

Definition at line 93 of file xact.h.

Referenced by PreCommit_on_commit_actions(), PrepareTransaction(), relation_open(), and try_relation_open().

XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK

#define XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK   (1U << 1)

Definition at line 99 of file xact.h.

Referenced by LogAccessExclusiveLock(), RecordTransactionAbortPrepared(), RecordTransactionCommitPrepared(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_READ_COMMITTED

#define XACT_READ_COMMITTED   1

Definition at line 36 of file xact.h.

Referenced by check_XactIsoLevel(), InitPostgres(), and show_XactIsoLevel().

XACT_READ_UNCOMMITTED

#define XACT_READ_UNCOMMITTED   0

Definition at line 35 of file xact.h.

Referenced by check_XactIsoLevel(), and show_XactIsoLevel().

XACT_REPEATABLE_READ

#define XACT_REPEATABLE_READ   2

Definition at line 37 of file xact.h.

Referenced by check_XactIsoLevel(), CreateReplicationSlot(), show_XactIsoLevel(), SnapBuildExportSnapshot(), and SnapBuildInitialSnapshot().

XACT_SERIALIZABLE

#define XACT_SERIALIZABLE   3

Definition at line 38 of file xact.h.

Referenced by check_XactIsoLevel(), ImportSnapshot(), and show_XactIsoLevel().

XACT_XINFO_HAS_AE_LOCKS

#define XACT_XINFO_HAS_AE_LOCKS   (1U << 6)

Definition at line 165 of file xact.h.

Referenced by xact_redo_abort(), xact_redo_commit(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_DBINFO

#define XACT_XINFO_HAS_DBINFO   (1U << 0)

Definition at line 159 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_GID

#define XACT_XINFO_HAS_GID   (1U << 7)

Definition at line 166 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_INVALS

#define XACT_XINFO_HAS_INVALS   (1U << 3)

Definition at line 162 of file xact.h.

Referenced by ParseCommitRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_ORIGIN

#define XACT_XINFO_HAS_ORIGIN   (1U << 5)

Definition at line 164 of file xact.h.

Referenced by DecodeCommit(), ParseAbortRecord(), ParseCommitRecord(), xact_desc_commit(), xact_redo_commit(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_RELFILENODES

#define XACT_XINFO_HAS_RELFILENODES   (1U << 2)

Definition at line 161 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_SUBXACTS

#define XACT_XINFO_HAS_SUBXACTS   (1U << 1)

Definition at line 160 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XACT_XINFO_HAS_TWOPHASE

#define XACT_XINFO_HAS_TWOPHASE   (1U << 4)

Definition at line 163 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XactCompletionApplyFeedback

#define XactCompletionApplyFeedback

(

xinfo

)

((xinfo & XACT_COMPLETION_APPLY_FEEDBACK) != 0)

Definition at line 181 of file xact.h.

Referenced by xact_redo_commit().

XactCompletionForceSyncCommit

#define XactCompletionForceSyncCommit

(

xinfo

)

((xinfo & XACT_COMPLETION_FORCE_SYNC_COMMIT) != 0)

Definition at line 185 of file xact.h.

Referenced by xact_desc_commit(), and xact_redo_commit().

XactCompletionRelcacheInitFileInval

#define XactCompletionRelcacheInitFileInval

(

xinfo

)

((xinfo & XACT_COMPLETION_UPDATE_RELCACHE_FILE) != 0)

Definition at line 183 of file xact.h.

Referenced by xact_desc_commit(), and xact_redo_commit().

XLOG_XACT_ABORT

#define XLOG_XACT_ABORT   0x20

Definition at line 142 of file xact.h.

Referenced by DecodeXactOp(), getRecordTimestamp(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc(), xact_identify(), xact_redo(), and XactLogAbortRecord().

XLOG_XACT_ABORT_PREPARED

#define XLOG_XACT_ABORT_PREPARED   0x40

Definition at line 144 of file xact.h.

Referenced by DecodeXactOp(), getRecordTimestamp(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc(), xact_identify(), xact_redo(), and XactLogAbortRecord().

XLOG_XACT_ASSIGNMENT

#define XLOG_XACT_ASSIGNMENT   0x50

Definition at line 145 of file xact.h.

Referenced by AssignTransactionId(), DecodeXactOp(), xact_desc(), xact_identify(), and xact_redo().

XLOG_XACT_COMMIT

#define XLOG_XACT_COMMIT   0x00

Definition at line 140 of file xact.h.

Referenced by DecodeXactOp(), getRecordTimestamp(), recoveryApplyDelay(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc(), xact_identify(), xact_redo(), and XactLogCommitRecord().

XLOG_XACT_COMMIT_PREPARED

#define XLOG_XACT_COMMIT_PREPARED   0x30

Definition at line 143 of file xact.h.

Referenced by DecodeXactOp(), getRecordTimestamp(), recoveryApplyDelay(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc(), xact_identify(), xact_redo(), and XactLogCommitRecord().

XLOG_XACT_HAS_INFO

#define XLOG_XACT_HAS_INFO   0x80

Definition at line 153 of file xact.h.

Referenced by ParseAbortRecord(), ParseCommitRecord(), XactLogAbortRecord(), and XactLogCommitRecord().

XLOG_XACT_OPMASK

#define XLOG_XACT_OPMASK   0x70

Definition at line 150 of file xact.h.

Referenced by DecodeXactOp(), getRecordTimestamp(), recoveryApplyDelay(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc(), xact_identify(), xact_redo(), and XlogReadTwoPhaseData().

XLOG_XACT_PREPARE

#define XLOG_XACT_PREPARE   0x10

Definition at line 141 of file xact.h.

Referenced by DecodeXactOp(), EndPrepare(), xact_identify(), xact_redo(), and XlogReadTwoPhaseData().

Typedef Documentation

SubXactCallback

typedef void(* SubXactCallback) (SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg)

Definition at line 127 of file xact.h.

XactCallback

typedef void(* XactCallback) (XactEvent event, void *arg)

Definition at line 117 of file xact.h.

xl_xact_abort

typedef struct xl_xact_abort xl_xact_abort

xl_xact_assignment

typedef struct xl_xact_assignment xl_xact_assignment

xl_xact_commit

typedef struct xl_xact_commit xl_xact_commit

xl_xact_dbinfo

typedef struct xl_xact_dbinfo xl_xact_dbinfo

xl_xact_invals

typedef struct xl_xact_invals xl_xact_invals

xl_xact_origin

typedef struct xl_xact_origin xl_xact_origin

xl_xact_parsed_abort

typedef struct xl_xact_parsed_abort xl_xact_parsed_abort

xl_xact_parsed_commit

typedef struct xl_xact_parsed_commit xl_xact_parsed_commit

xl_xact_parsed_prepare

typedef xl_xact_parsed_commit xl_xact_parsed_prepare

Definition at line 323 of file xact.h.

xl_xact_relfilenodes

typedef struct xl_xact_relfilenodes xl_xact_relfilenodes

xl_xact_subxacts

typedef struct xl_xact_subxacts xl_xact_subxacts

xl_xact_twophase

typedef struct xl_xact_twophase xl_xact_twophase

xl_xact_xinfo

typedef struct xl_xact_xinfo xl_xact_xinfo

Enumeration Type Documentation

SubXactEvent

enum SubXactEvent

Enumerator
SUBXACT_EVENT_START_SUB
SUBXACT_EVENT_COMMIT_SUB
SUBXACT_EVENT_ABORT_SUB
SUBXACT_EVENT_PRE_COMMIT_SUB

Definition at line 119 of file xact.h.

{
    SUBXACT_EVENT_START_SUB,
    SUBXACT_EVENT_COMMIT_SUB,
    SUBXACT_EVENT_ABORT_SUB,
    SUBXACT_EVENT_PRE_COMMIT_SUB
} SubXactEvent;

SyncCommitLevel

enum SyncCommitLevel

Enumerator
SYNCHRONOUS_COMMIT_OFF
SYNCHRONOUS_COMMIT_LOCAL_FLUSH
SYNCHRONOUS_COMMIT_REMOTE_WRITE
SYNCHRONOUS_COMMIT_REMOTE_FLUSH
SYNCHRONOUS_COMMIT_REMOTE_APPLY

Definition at line 64 of file xact.h.

{
    SYNCHRONOUS_COMMIT_OFF,     /* asynchronous commit */
    SYNCHRONOUS_COMMIT_LOCAL_FLUSH, /* wait for local flush only */
    SYNCHRONOUS_COMMIT_REMOTE_WRITE,    /* wait for local flush and remote
                                         * write */
    SYNCHRONOUS_COMMIT_REMOTE_FLUSH,    /* wait for local and remote flush */
    SYNCHRONOUS_COMMIT_REMOTE_APPLY /* wait for local flush and remote apply */
}           SyncCommitLevel;

XactEvent

enum XactEvent

Enumerator
XACT_EVENT_COMMIT
XACT_EVENT_PARALLEL_COMMIT
XACT_EVENT_ABORT
XACT_EVENT_PARALLEL_ABORT
XACT_EVENT_PREPARE
XACT_EVENT_PRE_COMMIT
XACT_EVENT_PARALLEL_PRE_COMMIT
XACT_EVENT_PRE_PREPARE

Definition at line 105 of file xact.h.

{
    XACT_EVENT_COMMIT,
    XACT_EVENT_PARALLEL_COMMIT,
    XACT_EVENT_ABORT,
    XACT_EVENT_PARALLEL_ABORT,
    XACT_EVENT_PREPARE,
    XACT_EVENT_PRE_COMMIT,
    XACT_EVENT_PARALLEL_PRE_COMMIT,
    XACT_EVENT_PRE_PREPARE
} XactEvent;

Function Documentation

AbortCurrentTransaction()

void AbortCurrentTransaction

(

void

)

Definition at line 2984 of file xact.c.

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

Referenced by AbortCurrentTransaction(), AutoVacLauncherMain(), PostgresMain(), ReorderBufferCommit(), ReorderBufferImmediateInvalidation(), SnapBuildClearExportedSnapshot(), and SPI_rollback().

{
    TransactionState s = CurrentTransactionState;

    switch (s->blockState)
    {
        case TBLOCK_DEFAULT:
            if (s->state == TRANS_DEFAULT)
            {
                /* we are idle, so nothing to do */
            }
            else
            {
                /*
                 * We can get here after an error during transaction start
                 * (state will be TRANS_START).  Need to clean up the
                 * incompletely started transaction.  First, adjust the
                 * low-level state to suppress warning message from
                 * AbortTransaction.
                 */
                if (s->state == TRANS_START)
                    s->state = TRANS_INPROGRESS;
                AbortTransaction();
                CleanupTransaction();
            }
            break;

            /*
             * If we aren't in a transaction block, we just do the basic abort
             * & cleanup transaction.  For this purpose, we treat an implicit
             * transaction block as if it were a simple statement.
             */
        case TBLOCK_STARTED:
        case TBLOCK_IMPLICIT_INPROGRESS:
            AbortTransaction();
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * If we are in TBLOCK_BEGIN it means something screwed up right
             * after reading "BEGIN TRANSACTION".  We assume that the user
             * will interpret the error as meaning the BEGIN failed to get him
             * into a transaction block, so we should abort and return to idle
             * state.
             */
        case TBLOCK_BEGIN:
            AbortTransaction();
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * We are somewhere in a transaction block and we've gotten a
             * failure, so we abort the transaction and set up the persistent
             * ABORT state.  We will stay in ABORT until we get a ROLLBACK.
             */
        case TBLOCK_INPROGRESS:
        case TBLOCK_PARALLEL_INPROGRESS:
            AbortTransaction();
            s->blockState = TBLOCK_ABORT;
            /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
            break;

            /*
             * Here, we failed while trying to COMMIT.  Clean up the
             * transaction and return to idle state (we do not want to stay in
             * the transaction).
             */
        case TBLOCK_END:
            AbortTransaction();
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * Here, we are already in an aborted transaction state and are
             * waiting for a ROLLBACK, but for some reason we failed again! So
             * we just remain in the abort state.
             */
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
            break;

            /*
             * We are in a failed transaction and we got the ROLLBACK command.
             * We have already aborted, we just need to cleanup and go to idle
             * state.
             */
        case TBLOCK_ABORT_END:
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * We are in a live transaction and we got a ROLLBACK command.
             * Abort, cleanup, go to idle state.
             */
        case TBLOCK_ABORT_PENDING:
            AbortTransaction();
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * Here, we failed while trying to PREPARE.  Clean up the
             * transaction and return to idle state (we do not want to stay in
             * the transaction).
             */
        case TBLOCK_PREPARE:
            AbortTransaction();
            CleanupTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * We got an error inside a subtransaction.  Abort just the
             * subtransaction, and go to the persistent SUBABORT state until
             * we get ROLLBACK.
             */
        case TBLOCK_SUBINPROGRESS:
            AbortSubTransaction();
            s->blockState = TBLOCK_SUBABORT;
            break;

            /*
             * If we failed while trying to create a subtransaction, clean up
             * the broken subtransaction and abort the parent.  The same
             * applies if we get a failure while ending a subtransaction.
             */
        case TBLOCK_SUBBEGIN:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
            AbortSubTransaction();
            CleanupSubTransaction();
            AbortCurrentTransaction();
            break;

            /*
             * Same as above, except the Abort() was already done.
             */
        case TBLOCK_SUBABORT_END:
        case TBLOCK_SUBABORT_RESTART:
            CleanupSubTransaction();
            AbortCurrentTransaction();
            break;
    }
}

AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction

(

void

)

Definition at line 4318 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    /* Ensure we're not running in a doomed memory context */
    AtAbort_Memory();

    /*
     * Get out of any transaction or nested transaction
     */
    do
    {
        switch (s->blockState)
        {
            case TBLOCK_DEFAULT:
                if (s->state == TRANS_DEFAULT)
                {
                    /* Not in a transaction, do nothing */
                }
                else
                {
                    /*
                     * We can get here after an error during transaction start
                     * (state will be TRANS_START).  Need to clean up the
                     * incompletely started transaction.  First, adjust the
                     * low-level state to suppress warning message from
                     * AbortTransaction.
                     */
                    if (s->state == TRANS_START)
                        s->state = TRANS_INPROGRESS;
                    AbortTransaction();
                    CleanupTransaction();
                }
                break;
            case TBLOCK_STARTED:
            case TBLOCK_BEGIN:
            case TBLOCK_INPROGRESS:
            case TBLOCK_IMPLICIT_INPROGRESS:
            case TBLOCK_PARALLEL_INPROGRESS:
            case TBLOCK_END:
            case TBLOCK_ABORT_PENDING:
            case TBLOCK_PREPARE:
                /* In a transaction, so clean up */
                AbortTransaction();
                CleanupTransaction();
                s->blockState = TBLOCK_DEFAULT;
                break;
            case TBLOCK_ABORT:
            case TBLOCK_ABORT_END:

                /*
                 * AbortTransaction is already done, still need Cleanup.
                 * However, if we failed partway through running ROLLBACK,
                 * there will be an active portal running that command, which
                 * we need to shut down before doing CleanupTransaction.
                 */
                AtAbort_Portals();
                CleanupTransaction();
                s->blockState = TBLOCK_DEFAULT;
                break;

                /*
                 * In a subtransaction, so clean it up and abort parent too
                 */
            case TBLOCK_SUBBEGIN:
            case TBLOCK_SUBINPROGRESS:
            case TBLOCK_SUBRELEASE:
            case TBLOCK_SUBCOMMIT:
            case TBLOCK_SUBABORT_PENDING:
            case TBLOCK_SUBRESTART:
                AbortSubTransaction();
                CleanupSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
                break;

            case TBLOCK_SUBABORT:
            case TBLOCK_SUBABORT_END:
            case TBLOCK_SUBABORT_RESTART:
                /* As above, but AbortSubTransaction already done */
                if (s->curTransactionOwner)
                {
                    /* As in TBLOCK_ABORT, might have a live portal to zap */
                    AtSubAbort_Portals(s->subTransactionId,
                                       s->parent->subTransactionId,
                                       s->curTransactionOwner,
                                       s->parent->curTransactionOwner);
                }
                CleanupSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
                break;
        }
    } while (s->blockState != TBLOCK_DEFAULT);

    /* Should be out of all subxacts now */
    Assert(s->parent == NULL);

    /* If we didn't actually have anything to do, revert to TopMemoryContext */
    AtCleanup_Memory();
}

BeginImplicitTransactionBlock()

void BeginImplicitTransactionBlock

(

void

)

Definition at line 3778 of file xact.c.

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

Referenced by exec_simple_query().

{
    TransactionState s = CurrentTransactionState;

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

BeginInternalSubTransaction()

void BeginInternalSubTransaction

(

const char *

name

)

Definition at line 4146 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for new subtransactions after that
     * point. We might be able to make an exception for the type of
     * subtransaction established by this function, which is typically used in
     * contexts where we're going to release or roll back the subtransaction
     * before proceeding further, so that no enduring change to the
     * transaction state occurs. For now, however, we prohibit this case along
     * with all the others.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot start subtransactions during a parallel operation")));

    switch (s->blockState)
    {
        case TBLOCK_STARTED:
        case TBLOCK_INPROGRESS:
        case TBLOCK_IMPLICIT_INPROGRESS:
        case TBLOCK_END:
        case TBLOCK_PREPARE:
        case TBLOCK_SUBINPROGRESS:
            /* Normal subtransaction start */
            PushTransaction();
            s = CurrentTransactionState;    /* changed by push */

            /*
             * Savepoint names, like the TransactionState block itself, live
             * in TopTransactionContext.
             */
            if (name)
                s->name = MemoryContextStrdup(TopTransactionContext, name);
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
            elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }

    CommitTransactionCommand();
    StartTransactionCommand();
}

BeginTransactionBlock()

void BeginTransactionBlock

(

void

)

Definition at line 3412 of file xact.c.

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

Referenced by standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;

    switch (s->blockState)
    {
            /*
             * We are not inside a transaction block, so allow one to begin.
             */
        case TBLOCK_STARTED:
            s->blockState = TBLOCK_BEGIN;
            break;

            /*
             * BEGIN converts an implicit transaction block to a regular one.
             * (Note that we allow this even if we've already done some
             * commands, which is a bit odd but matches historical practice.)
             */
        case TBLOCK_IMPLICIT_INPROGRESS:
            s->blockState = TBLOCK_BEGIN;
            break;

            /*
             * Already a transaction block in progress.
             */
        case TBLOCK_INPROGRESS:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
            ereport(WARNING,
                    (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                     errmsg("there is already a transaction in progress")));
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_BEGIN:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "BeginTransactionBlock: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
}

CommandCounterIncrement()

void CommandCounterIncrement

(

void

)

Definition at line 914 of file xact.c.

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

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

{
    /*
     * If the current value of the command counter hasn't been "used" to mark
     * tuples, we need not increment it, since there's no need to distinguish
     * a read-only command from others.  This helps postpone command counter
     * overflow, and keeps no-op CommandCounterIncrement operations cheap.
     */
    if (currentCommandIdUsed)
    {
        /*
         * Workers synchronize transaction state at the beginning of each
         * parallel operation, so we can't account for new commands after that
         * point.
         */
        if (IsInParallelMode() || IsParallelWorker())
            elog(ERROR, "cannot start commands during a parallel operation");

        currentCommandId += 1;
        if (currentCommandId == InvalidCommandId)
        {
            currentCommandId -= 1;
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("cannot have more than 2^32-2 commands in a transaction")));
        }
        currentCommandIdUsed = false;

        /* Propagate new command ID into static snapshots */
        SnapshotSetCommandId(currentCommandId);

        /*
         * Make any catalog changes done by the just-completed command visible
         * in the local syscache.  We obviously don't need to do this after a
         * read-only command.  (But see hacks in inval.c to make real sure we
         * don't think a command that queued inval messages was read-only.)
         */
        AtCCI_LocalCache();
    }
}

CommitTransactionCommand()

void CommitTransactionCommand

(

void

)

Definition at line 2744 of file xact.c.

References AbortSubTransaction(), AbortTransaction(), Assert, AssertState, TransactionStateData::blockState, BlockStateAsString(), CleanupSubTransaction(), CleanupTransaction(), CommandCounterIncrement(), CommitSubTransaction(), CommitTransaction(), CommitTransactionCommand(), CurrentTransactionState, DefineSavepoint(), elog, ERROR, FATAL, TransactionStateData::name, TransactionStateData::parent, PrepareTransaction(), TransactionStateData::savepointLevel, StartSubTransaction(), 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 apply_handle_commit(), ApplyWorkerMain(), autoprewarm_database_main(), BeginInternalSubTransaction(), BootstrapModeMain(), cluster(), CommitTransactionCommand(), DefineIndex(), do_autovacuum(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), ParallelWorkerMain(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), ProcessCatchupInterrupt(), ProcessCompletedNotifies(), ProcessIncomingNotify(), ReindexMultipleTables(), RemoveTempRelationsCallback(), SPI_commit(), vacuum(), and vacuum_rel().

{
    TransactionState s = CurrentTransactionState;

    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;
            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;
            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;
            break;

            /*
             * We are completing a "PREPARE TRANSACTION" command.  Do it and
             * return to the idle state.
             */
        case TBLOCK_PREPARE:
            PrepareTransaction();
            s->blockState = TBLOCK_DEFAULT;
            break;

            /*
             * We were just issued a SAVEPOINT inside a transaction block.
             * Start a subtransaction.  (DefineSavepoint already did
             * PushTransaction, so as to have someplace to put the SUBBEGIN
             * state.)
             */
        case TBLOCK_SUBBEGIN:
            StartSubTransaction();
            s->blockState = TBLOCK_SUBINPROGRESS;
            break;

            /*
             * We were issued a RELEASE command, so we end the current
             * subtransaction and return to the parent transaction. The parent
             * might be ended too, so repeat till we find an INPROGRESS
             * transaction or subtransaction.
             */
        case TBLOCK_SUBRELEASE:
            do
            {
                CommitSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
            } while (s->blockState == TBLOCK_SUBRELEASE);

            Assert(s->blockState == TBLOCK_INPROGRESS ||
                   s->blockState == TBLOCK_SUBINPROGRESS);
            break;

            /*
             * We were issued a COMMIT, so we end the current subtransaction
             * hierarchy and perform final commit. We do this by rolling up
             * any subtransactions into their parent, which leads to O(N^2)
             * operations with respect to resource owners - this isn't that
             * bad until we approach a thousands of savepoints but is
             * necessary for correctness should after triggers create new
             * resource owners.
             */
        case TBLOCK_SUBCOMMIT:
            do
            {
                CommitSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
            } while (s->blockState == TBLOCK_SUBCOMMIT);
            /* If we had a COMMIT command, finish off the main xact too */
            if (s->blockState == TBLOCK_END)
            {
                Assert(s->parent == NULL);
                CommitTransaction();
                s->blockState = TBLOCK_DEFAULT;
            }
            else if (s->blockState == TBLOCK_PREPARE)
            {
                Assert(s->parent == NULL);
                PrepareTransaction();
                s->blockState = TBLOCK_DEFAULT;
            }
            else
                elog(ERROR, "CommitTransactionCommand: unexpected state %s",
                     BlockStateAsString(s->blockState));
            break;

            /*
             * The current already-failed subtransaction is ending due to a
             * ROLLBACK or ROLLBACK TO command, so pop it and recursively
             * examine the parent (which could be in any of several states).
             */
        case TBLOCK_SUBABORT_END:
            CleanupSubTransaction();
            CommitTransactionCommand();
            break;

            /*
             * As above, but it's not dead yet, so abort first.
             */
        case TBLOCK_SUBABORT_PENDING:
            AbortSubTransaction();
            CleanupSubTransaction();
            CommitTransactionCommand();
            break;

            /*
             * The current subtransaction is the target of a ROLLBACK TO
             * command.  Abort and pop it, then start a new subtransaction
             * with the same name.
             */
        case TBLOCK_SUBRESTART:
            {
                char       *name;
                int         savepointLevel;

                /* save name and keep Cleanup from freeing it */
                name = s->name;
                s->name = NULL;
                savepointLevel = s->savepointLevel;

                AbortSubTransaction();
                CleanupSubTransaction();

                DefineSavepoint(NULL);
                s = CurrentTransactionState;    /* changed by push */
                s->name = name;
                s->savepointLevel = savepointLevel;

                /* This is the same as TBLOCK_SUBBEGIN case */
                AssertState(s->blockState == TBLOCK_SUBBEGIN);
                StartSubTransaction();
                s->blockState = TBLOCK_SUBINPROGRESS;
            }
            break;

            /*
             * Same as above, but the subtransaction had already failed, so we
             * don't need AbortSubTransaction.
             */
        case TBLOCK_SUBABORT_RESTART:
            {
                char       *name;
                int         savepointLevel;

                /* save name and keep Cleanup from freeing it */
                name = s->name;
                s->name = NULL;
                savepointLevel = s->savepointLevel;

                CleanupSubTransaction();

                DefineSavepoint(NULL);
                s = CurrentTransactionState;    /* changed by push */
                s->name = name;
                s->savepointLevel = savepointLevel;

                /* This is the same as TBLOCK_SUBBEGIN case */
                AssertState(s->blockState == TBLOCK_SUBBEGIN);
                StartSubTransaction();
                s->blockState = TBLOCK_SUBINPROGRESS;
            }
            break;
    }
}

DefineSavepoint()

void DefineSavepoint

(

const char *

name

)

Definition at line 3825 of file xact.c.

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

Referenced by CommitTransactionCommand(), and standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;

    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for new subtransactions after that
     * point.  (Note that this check will certainly error out if s->blockState
     * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
     * below.)
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot define savepoints during a parallel operation")));

    switch (s->blockState)
    {
        case TBLOCK_INPROGRESS:
        case TBLOCK_SUBINPROGRESS:
            /* Normal subtransaction start */
            PushTransaction();
            s = CurrentTransactionState;    /* changed by push */

            /*
             * Savepoint names, like the TransactionState block itself, live
             * in TopTransactionContext.
             */
            if (name)
                s->name = MemoryContextStrdup(TopTransactionContext, name);
            break;

            /*
             * We disallow savepoint commands in implicit transaction blocks.
             * There would be no great difficulty in allowing them so far as
             * this module is concerned, but a savepoint seems inconsistent
             * with exec_simple_query's behavior of abandoning the whole query
             * string upon error.  Also, the point of an implicit transaction
             * block (as opposed to a regular one) is to automatically close
             * after an error, so it's hard to see how a savepoint would fit
             * into that.
             *
             * The error messages for this are phrased as if there were no
             * active transaction block at all, which is historical but
             * perhaps could be improved.
             */
        case TBLOCK_IMPLICIT_INPROGRESS:
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                            "SAVEPOINT")));
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "DefineSavepoint: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
}

EndImplicitTransactionBlock()

void EndImplicitTransactionBlock

(

void

)

Definition at line 3803 of file xact.c.

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

Referenced by exec_simple_query().

{
    TransactionState s = CurrentTransactionState;

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

EndParallelWorkerTransaction()

void EndParallelWorkerTransaction

(

void

)

Definition at line 5062 of file xact.c.

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

Referenced by ParallelWorkerMain().

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

EndTransactionBlock()

bool EndTransactionBlock

(

void

)

Definition at line 3532 of file xact.c.

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

Referenced by PrepareTransactionBlock(), and standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;
    bool        result = false;

    switch (s->blockState)
    {
            /*
             * We are in a transaction block, so tell CommitTransactionCommand
             * to COMMIT.
             */
        case TBLOCK_INPROGRESS:
            s->blockState = TBLOCK_END;
            result = true;
            break;

            /*
             * In an implicit transaction block, commit, but issue a warning
             * because there was no explicit BEGIN before this.
             */
        case TBLOCK_IMPLICIT_INPROGRESS:
            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.  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.
             */
        case TBLOCK_STARTED:
            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;
    }

    return result;
}

EnterParallelMode()

void EnterParallelMode

(

void

)

Definition at line 872 of file xact.c.

References Assert, CurrentTransactionState, and TransactionStateData::parallelModeLevel.

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

{
    TransactionState s = CurrentTransactionState;

    Assert(s->parallelModeLevel >= 0);

    ++s->parallelModeLevel;
}

EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace

(

void

)

Definition at line 4938 of file xact.c.

References add_size(), mul_size(), TransactionStateData::nChildXids, nParallelCurrentXids, TransactionStateData::parent, TransactionStateData::transactionId, and TransactionIdIsValid.

Referenced by InitializeParallelDSM().

{
    TransactionState s;
    Size        nxids = 6;      /* iso level, deferrable, top & current XID,
                                 * command counter, XID count */

    for (s = CurrentTransactionState; s != NULL; s = s->parent)
    {
        if (TransactionIdIsValid(s->transactionId))
            nxids = add_size(nxids, 1);
        nxids = add_size(nxids, s->nChildXids);
    }

    nxids = add_size(nxids, nParallelCurrentXids);
    return mul_size(nxids, sizeof(TransactionId));
}

ExitParallelMode()

void ExitParallelMode

(

void

)

Definition at line 885 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    Assert(s->parallelModeLevel > 0);
    Assert(s->parallelModeLevel > 1 || !ParallelContextActive());

    --s->parallelModeLevel;
}

ForceSyncCommit()

void ForceSyncCommit

(

void

)

Definition at line 962 of file xact.c.

References forceSyncCommit.

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

{
    forceSyncCommit = true;
}

GetCurrentCommandId()

CommandId GetCurrentCommandId

(

bool

used

)

Definition at line 679 of file xact.c.

References Assert, currentCommandId, currentCommandIdUsed, and IsParallelWorker.

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

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

GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp

(

void

)

Definition at line 709 of file xact.c.

References stmtStartTimestamp.

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

{
    return stmtStartTimestamp;
}

GetCurrentSubTransactionId()

SubTransactionId GetCurrentSubTransactionId

(

void

)

Definition at line 641 of file xact.c.

References CurrentTransactionState, and TransactionStateData::subTransactionId.

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

{
    TransactionState s = CurrentTransactionState;

    return s->subTransactionId;
}

GetCurrentTransactionId()

TransactionId GetCurrentTransactionId

(

void

)

Definition at line 417 of file xact.c.

References AssignTransactionId(), CurrentTransactionState, TransactionStateData::transactionId, and TransactionIdIsValid.

Referenced by AlterEnum(), 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(), and ReorderBufferCommit().

{
    TransactionState s = CurrentTransactionState;

    if (!TransactionIdIsValid(s->transactionId))
        AssignTransactionId(s);
    return s->transactionId;
}

GetCurrentTransactionIdIfAny()

TransactionId GetCurrentTransactionIdIfAny

(

void

)

Definition at line 434 of file xact.c.

References TransactionStateData::transactionId.

Referenced by RecordTransactionAbort(), ReorderBufferCommit(), and XLogRecordAssemble().

{
    return CurrentTransactionState->transactionId;
}

GetCurrentTransactionNestLevel()

int GetCurrentTransactionNestLevel

(

void

)

Definition at line 753 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by AfterTriggerBeginSubXact(), AfterTriggerEndSubXact(), AfterTriggerSetState(), AtEOSubXact_Inval(), AtEOSubXact_Namespace(), AtSubAbort_Notify(), AtSubCommit_Notify(), AtSubCommit_smgr(), AtSubStart_Notify(), begin_remote_xact(), pgfdw_subxact_callback(), pgstat_count_heap_delete(), pgstat_count_heap_insert(), pgstat_count_heap_update(), pgstat_count_truncate(), PopOverrideSearchPath(), PrepareInvalidationState(), PushActiveSnapshot(), PushOverrideSearchPath(), register_seq_scan(), RelationCreateStorage(), RelationDropStorage(), RelationMapUpdateMap(), smgrDoPendingDeletes(), and smgrGetPendingDeletes().

{
    TransactionState s = CurrentTransactionState;

    return s->nestingLevel;
}

GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp

(

void

)

Definition at line 700 of file xact.c.

References xactStartTimestamp.

Referenced by GetCurrentDateTime(), GetCurrentTimeUsec(), GetSQLCurrentDate(), GetSQLCurrentTime(), GetSQLCurrentTimestamp(), GetSQLLocalTime(), GetSQLLocalTimestamp(), now(), pg_timezone_abbrevs(), and pg_timezone_names().

{
    return xactStartTimestamp;
}

GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp

(

void

)

Definition at line 721 of file xact.c.

References GetCurrentTimestamp(), and xactStopTimestamp.

Referenced by pgstat_report_stat().

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

GetStableLatestTransactionId()

TransactionId GetStableLatestTransactionId

(

void

)

Definition at line 461 of file xact.c.

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

Referenced by xid_age().

{
    static LocalTransactionId lxid = InvalidLocalTransactionId;
    static TransactionId stablexid = InvalidTransactionId;

    if (lxid != MyProc->lxid)
    {
        lxid = MyProc->lxid;
        stablexid = GetTopTransactionIdIfAny();
        if (!TransactionIdIsValid(stablexid))
            stablexid = ReadNewTransactionId();
    }

    Assert(TransactionIdIsValid(stablexid));

    return stablexid;
}

GetTopTransactionId()

TransactionId GetTopTransactionId

(

void

)

Definition at line 389 of file xact.c.

References AssignTransactionId(), TransactionIdIsValid, and XactTopTransactionId.

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

{
    if (!TransactionIdIsValid(XactTopTransactionId))
        AssignTransactionId(&TopTransactionStateData);
    return XactTopTransactionId;
}

GetTopTransactionIdIfAny()

TransactionId GetTopTransactionIdIfAny

(

void

)

Definition at line 404 of file xact.c.

References XactTopTransactionId.

Referenced by CheckForSerializableConflictOut(), ConditionalXactLockTableWait(), CreateInitDecodingContext(), ExportSnapshot(), GetSerializableTransactionSnapshotInt(), GetStableLatestTransactionId(), ImportSnapshot(), index_drop(), index_set_state_flags(), initSpGistState(), log_line_prefix(), PredicateLockTuple(), RecordTransactionCommit(), txid_current_if_assigned(), write_csvlog(), XactLockTableWait(), and XidIsConcurrent().

{
    return XactTopTransactionId;
}

IsAbortedTransactionBlockState()

bool IsAbortedTransactionBlockState

(

void

)

Definition at line 370 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    if (s->blockState == TBLOCK_ABORT ||
        s->blockState == TBLOCK_SUBABORT)
        return true;

    return false;
}

IsInParallelMode()

bool IsInParallelMode

(

void

)

Definition at line 905 of file xact.c.

References TransactionStateData::parallelModeLevel.

Referenced by _SPI_execute_plan(), AbortSubTransaction(), AbortTransaction(), AssignTransactionId(), BeginInternalSubTransaction(), check_xact_readonly(), CommandCounterIncrement(), CommitSubTransaction(), CommitTransaction(), CreateParallelContext(), DefineSavepoint(), ExecSetVariableStmt(), GetLatestSnapshot(), GetNewTransactionId(), GetSerializableTransactionSnapshotInt(), GetTransactionSnapshot(), heap_delete(), heap_inplace_update(), heap_update(), init_execution_state(), PrepareTransaction(), PreventAdvisoryLocksInParallelMode(), PreventCommandIfParallelMode(), ReleaseCurrentSubTransaction(), ReleaseSavepoint(), RemoveReindexPending(), RollbackToSavepoint(), set_config_option(), SetReindexPending(), SPI_cursor_open_internal(), standard_ExecutorStart(), and UpdateActiveSnapshotCommandId().

{
    return CurrentTransactionState->parallelModeLevel != 0;
}

IsInTransactionBlock()

bool IsInTransactionBlock

(

bool

isTopLevel

)

Definition at line 3267 of file xact.c.

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

Referenced by vacuum().

{
    /*
     * Return true on same conditions that would make
     * PreventInTransactionBlock error out
     */
    if (IsTransactionBlock())
        return true;

    if (IsSubTransaction())
        return true;

    if (!isTopLevel)
        return true;

    if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
        CurrentTransactionState->blockState != TBLOCK_STARTED)
        return true;

    return false;
}

IsSubTransaction()

bool IsSubTransaction

(

void

)

Definition at line 4495 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by AfterTriggerSetState(), check_transaction_deferrable(), check_transaction_read_only(), check_XactIsoLevel(), CheckTargetForConflictsIn(), CheckTransactionBlock(), CreateReplicationSlot(), ExportSnapshot(), ImportSnapshot(), IsInTransactionBlock(), PreventInTransactionBlock(), RecoveryConflictInterrupt(), SPI_commit(), and SPI_rollback().

{
    TransactionState s = CurrentTransactionState;

    if (s->nestingLevel >= 2)
        return true;

    return false;
}

IsTransactionBlock()

bool IsTransactionBlock

(

void

)

Definition at line 4422 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    if (s->blockState == TBLOCK_DEFAULT || s->blockState == TBLOCK_STARTED)
        return false;

    return true;
}

IsTransactionOrTransactionBlock()

bool IsTransactionOrTransactionBlock

(

void

)

Definition at line 4440 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, and TBLOCK_DEFAULT.

Referenced by PostgresMain(), ProcessCatchupInterrupt(), ProcessNotifyInterrupt(), RecoveryConflictInterrupt(), ReorderBufferCommit(), ReorderBufferImmediateInvalidation(), SnapBuildExportSnapshot(), and StartupDecodingContext().

{
    TransactionState s = CurrentTransactionState;

    if (s->blockState == TBLOCK_DEFAULT)
        return false;

    return true;
}

IsTransactionState()

bool IsTransactionState

(

void

)

Definition at line 350 of file xact.c.

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

Referenced by apply_handle_commit(), apply_handle_origin(), check_client_encoding(), check_default_tablespace(), check_role(), check_session_authorization(), check_temp_tablespaces(), check_transaction_read_only(), check_TSCurrentConfig(), check_XactIsoLevel(), CreateInitDecodingContext(), ensure_transaction(), GetMessageEncoding(), LogLogicalMessage(), maybe_reread_subscription(), 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(), SearchCatCacheInternal(), SetMultiXactIdLimit(), SetTransactionIdLimit(), SnapBuildClearExportedSnapshot(), and SocketBackend().

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

MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny

(

void

)

Definition at line 445 of file xact.c.

References TransactionStateData::didLogXid, TransactionStateData::transactionId, and TransactionIdIsValid.

Referenced by XLogInsertRecord().

{
    if (TransactionIdIsValid(CurrentTransactionState->transactionId))
        CurrentTransactionState->didLogXid = true;
}

ParseAbortRecord()

void ParseAbortRecord	(	uint8	info,
		xl_xact_abort *	xlrec,
		xl_xact_parsed_abort *	parsed
	)

Definition at line 129 of file xactdesc.c.

References xl_xact_dbinfo::dbId, xl_xact_parsed_abort::dbId, MinSizeOfXactAbort, MinSizeOfXactRelfilenodes, MinSizeOfXactSubxacts, xl_xact_relfilenodes::nrels, xl_xact_parsed_abort::nrels, xl_xact_subxacts::nsubxacts, xl_xact_parsed_abort::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_parsed_abort::origin_lsn, xl_xact_origin::origin_timestamp, xl_xact_parsed_abort::origin_timestamp, strlcpy(), xl_xact_subxacts::subxacts, xl_xact_parsed_abort::subxacts, xl_xact_dbinfo::tsId, xl_xact_parsed_abort::tsId, xl_xact_parsed_abort::twophase_gid, xl_xact_parsed_abort::twophase_xid, xl_xact_abort::xact_time, xl_xact_parsed_abort::xact_time, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILENODES, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, xl_xact_parsed_abort::xinfo, XLOG_XACT_HAS_INFO, xl_xact_relfilenodes::xnodes, and xl_xact_parsed_abort::xnodes.

Referenced by DecodeXactOp(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc_abort(), and xact_redo().

{
    char       *data = ((char *) xlrec) + MinSizeOfXactAbort;

    memset(parsed, 0, sizeof(*parsed));

    parsed->xinfo = 0;          /* default, if no XLOG_XACT_HAS_INFO is
                                 * present */

    parsed->xact_time = xlrec->xact_time;

    if (info & XLOG_XACT_HAS_INFO)
    {
        xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;

        parsed->xinfo = xl_xinfo->xinfo;

        data += sizeof(xl_xact_xinfo);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
    {
        xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;

        parsed->dbId = xl_dbinfo->dbId;
        parsed->tsId = xl_dbinfo->tsId;

        data += sizeof(xl_xact_dbinfo);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
    {
        xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;

        parsed->nsubxacts = xl_subxacts->nsubxacts;
        parsed->subxacts = xl_subxacts->subxacts;

        data += MinSizeOfXactSubxacts;
        data += parsed->nsubxacts * sizeof(TransactionId);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_RELFILENODES)
    {
        xl_xact_relfilenodes *xl_relfilenodes = (xl_xact_relfilenodes *) data;

        parsed->nrels = xl_relfilenodes->nrels;
        parsed->xnodes = xl_relfilenodes->xnodes;

        data += MinSizeOfXactRelfilenodes;
        data += xl_relfilenodes->nrels * sizeof(RelFileNode);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
    {
        xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;

        parsed->twophase_xid = xl_twophase->xid;

        data += sizeof(xl_xact_twophase);

        if (parsed->xinfo & XACT_XINFO_HAS_GID)
        {
            strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
            data += strlen(data) + 1;
        }
    }

    /* Note: no alignment is guaranteed after this point */

    if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
    {
        xl_xact_origin xl_origin;

        /* no alignment is guaranteed, so copy onto stack */
        memcpy(&xl_origin, data, sizeof(xl_origin));

        parsed->origin_lsn = xl_origin.origin_lsn;
        parsed->origin_timestamp = xl_origin.origin_timestamp;

        data += sizeof(xl_xact_origin);
    }
}

ParseCommitRecord()

void ParseCommitRecord	(	uint8	info,
		xl_xact_commit *	xlrec,
		xl_xact_parsed_commit *	parsed
	)

Definition at line 34 of file xactdesc.c.

References xl_xact_dbinfo::dbId, xl_xact_parsed_commit::dbId, MinSizeOfXactCommit, MinSizeOfXactInvals, MinSizeOfXactRelfilenodes, MinSizeOfXactSubxacts, xl_xact_invals::msgs, xl_xact_parsed_commit::msgs, xl_xact_invals::nmsgs, xl_xact_parsed_commit::nmsgs, xl_xact_relfilenodes::nrels, xl_xact_parsed_commit::nrels, xl_xact_subxacts::nsubxacts, xl_xact_parsed_commit::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_parsed_commit::origin_lsn, xl_xact_origin::origin_timestamp, xl_xact_parsed_commit::origin_timestamp, strlcpy(), xl_xact_subxacts::subxacts, xl_xact_parsed_commit::subxacts, xl_xact_dbinfo::tsId, xl_xact_parsed_commit::tsId, xl_xact_parsed_commit::twophase_gid, xl_xact_parsed_commit::twophase_xid, xl_xact_commit::xact_time, xl_xact_parsed_commit::xact_time, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_INVALS, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILENODES, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, xl_xact_parsed_commit::xinfo, XLOG_XACT_HAS_INFO, xl_xact_relfilenodes::xnodes, and xl_xact_parsed_commit::xnodes.

Referenced by DecodeXactOp(), recoveryStopsAfter(), recoveryStopsBefore(), xact_desc_commit(), and xact_redo().

{
    char       *data = ((char *) xlrec) + MinSizeOfXactCommit;

    memset(parsed, 0, sizeof(*parsed));

    parsed->xinfo = 0;          /* default, if no XLOG_XACT_HAS_INFO is
                                 * present */

    parsed->xact_time = xlrec->xact_time;

    if (info & XLOG_XACT_HAS_INFO)
    {
        xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;

        parsed->xinfo = xl_xinfo->xinfo;

        data += sizeof(xl_xact_xinfo);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
    {
        xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;

        parsed->dbId = xl_dbinfo->dbId;
        parsed->tsId = xl_dbinfo->tsId;

        data += sizeof(xl_xact_dbinfo);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
    {
        xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;

        parsed->nsubxacts = xl_subxacts->nsubxacts;
        parsed->subxacts = xl_subxacts->subxacts;

        data += MinSizeOfXactSubxacts;
        data += parsed->nsubxacts * sizeof(TransactionId);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_RELFILENODES)
    {
        xl_xact_relfilenodes *xl_relfilenodes = (xl_xact_relfilenodes *) data;

        parsed->nrels = xl_relfilenodes->nrels;
        parsed->xnodes = xl_relfilenodes->xnodes;

        data += MinSizeOfXactRelfilenodes;
        data += xl_relfilenodes->nrels * sizeof(RelFileNode);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_INVALS)
    {
        xl_xact_invals *xl_invals = (xl_xact_invals *) data;

        parsed->nmsgs = xl_invals->nmsgs;
        parsed->msgs = xl_invals->msgs;

        data += MinSizeOfXactInvals;
        data += xl_invals->nmsgs * sizeof(SharedInvalidationMessage);
    }

    if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
    {
        xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;

        parsed->twophase_xid = xl_twophase->xid;

        data += sizeof(xl_xact_twophase);

        if (parsed->xinfo & XACT_XINFO_HAS_GID)
        {
            strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
            data += strlen(data) + 1;
        }
    }

    /* Note: no alignment is guaranteed after this point */

    if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
    {
        xl_xact_origin xl_origin;

        /* no alignment is guaranteed, so copy onto stack */
        memcpy(&xl_origin, data, sizeof(xl_origin));

        parsed->origin_lsn = xl_origin.origin_lsn;
        parsed->origin_timestamp = xl_origin.origin_timestamp;

        data += sizeof(xl_xact_origin);
    }
}

PrepareTransactionBlock()

bool PrepareTransactionBlock

(

const char *

gid

)

Definition at line 3480 of file xact.c.

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

Referenced by standard_ProcessUtility().

{
    TransactionState s;
    bool        result;

    /* Set up to commit the current transaction */
    result = EndTransactionBlock();

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

PreventInTransactionBlock()

void PreventInTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3153 of file xact.c.

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

Referenced by AlterDatabase(), AlterEnum(), cluster(), CreateSubscription(), DiscardAll(), DropSubscription(), exec_replication_command(), ExecDropStmt(), ProcessUtilitySlow(), standard_ProcessUtility(), and vacuum().

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

RegisterSubXactCallback()

void RegisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

Definition at line 3357 of file xact.c.

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

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

{
    SubXactCallbackItem *item;

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

RegisterXactCallback()

void RegisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

Definition at line 3302 of file xact.c.

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

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

{
    XactCallbackItem *item;

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

ReleaseCurrentSubTransaction()

void ReleaseCurrentSubTransaction

(

void

)

Definition at line 4217 of file xact.c.

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

Referenced by exec_stmt_block(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), pltcl_subtrans_commit(), pltcl_subtransaction(), PLy_spi_subtransaction_commit(), and PLy_subtransaction_exit().

{
    TransactionState s = CurrentTransactionState;

    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for commit of subtransactions after that
     * point.  This should not happen anyway.  Code calling this would
     * typically have called BeginInternalSubTransaction() first, failing
     * there.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot commit subtransactions during a parallel operation")));

    if (s->blockState != TBLOCK_SUBINPROGRESS)
        elog(ERROR, "ReleaseCurrentSubTransaction: unexpected state %s",
             BlockStateAsString(s->blockState));
    Assert(s->state == TRANS_INPROGRESS);
    MemoryContextSwitchTo(CurTransactionContext);
    CommitSubTransaction();
    s = CurrentTransactionState;    /* changed by pop */
    Assert(s->state == TRANS_INPROGRESS);
}

ReleaseSavepoint()

void ReleaseSavepoint

(

const char *

name

)

Definition at line 3910 of file xact.c.

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

Referenced by standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;
    TransactionState target,
                xact;

    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for transaction state change after that
     * point.  (Note that this check will certainly error out if s->blockState
     * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
     * below.)
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot release savepoints during a parallel operation")));

    switch (s->blockState)
    {
            /*
             * We can't release a savepoint if there is no savepoint defined.
             */
        case TBLOCK_INPROGRESS:
            ereport(ERROR,
                    (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                     errmsg("savepoint \"%s\" does not exist", name)));
            break;

        case TBLOCK_IMPLICIT_INPROGRESS:
            /* See comment about implicit transactions in DefineSavepoint */
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                            "RELEASE SAVEPOINT")));
            break;

            /*
             * We are in a non-aborted subtransaction.  This is the only valid
             * case.
             */
        case TBLOCK_SUBINPROGRESS:
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "ReleaseSavepoint: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }

    for (target = s; PointerIsValid(target); target = target->parent)
    {
        if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
            break;
    }

    if (!PointerIsValid(target))
        ereport(ERROR,
                (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                 errmsg("savepoint \"%s\" does not exist", name)));

    /* disallow crossing savepoint level boundaries */
    if (target->savepointLevel != s->savepointLevel)
        ereport(ERROR,
                (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                 errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));

    /*
     * Mark "commit pending" all subtransactions up to the target
     * subtransaction.  The actual commits will happen when control gets to
     * CommitTransactionCommand.
     */
    xact = CurrentTransactionState;
    for (;;)
    {
        Assert(xact->blockState == TBLOCK_SUBINPROGRESS);
        xact->blockState = TBLOCK_SUBRELEASE;
        if (xact == target)
            break;
        xact = xact->parent;
        Assert(PointerIsValid(xact));
    }
}

RequireTransactionBlock()

void RequireTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3219 of file xact.c.

References CheckTransactionBlock().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

{
    CheckTransactionBlock(isTopLevel, true, stmtType);
}

RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction

(

void

)

Definition at line 4251 of file xact.c.

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

Referenced by exec_stmt_block(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), pltcl_subtrans_abort(), pltcl_subtransaction(), PLy_abort_open_subtransactions(), PLy_spi_subtransaction_abort(), PLy_subtransaction_exit(), ReorderBufferCommit(), and ReorderBufferImmediateInvalidation().

{
    TransactionState s = CurrentTransactionState;

    /*
     * Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
     * during parallel operations.  That's because we may be in the master,
     * recovering from an error thrown while we were in parallel mode.  We
     * won't reach here in a worker, because BeginInternalSubTransaction()
     * will have failed.
     */

    switch (s->blockState)
    {
            /* Must be in a subtransaction */
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_SUBABORT:
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_IMPLICIT_INPROGRESS:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_INPROGRESS:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "RollbackAndReleaseCurrentSubTransaction: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }

    /*
     * Abort the current subtransaction, if needed.
     */
    if (s->blockState == TBLOCK_SUBINPROGRESS)
        AbortSubTransaction();

    /* And clean it up, too */
    CleanupSubTransaction();

    s = CurrentTransactionState;    /* changed by pop */
    AssertState(s->blockState == TBLOCK_SUBINPROGRESS ||
                s->blockState == TBLOCK_INPROGRESS ||
                s->blockState == TBLOCK_IMPLICIT_INPROGRESS ||
                s->blockState == TBLOCK_STARTED);
}

RollbackToSavepoint()

void RollbackToSavepoint

(

const char *

name

)

Definition at line 4019 of file xact.c.

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

Referenced by standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;
    TransactionState target,
                xact;

    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for transaction state change after that
     * point.  (Note that this check will certainly error out if s->blockState
     * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
     * below.)
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot rollback to savepoints during a parallel operation")));

    switch (s->blockState)
    {
            /*
             * We can't rollback to a savepoint if there is no savepoint
             * defined.
             */
        case TBLOCK_INPROGRESS:
        case TBLOCK_ABORT:
            ereport(ERROR,
                    (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                     errmsg("savepoint \"%s\" does not exist", name)));
            break;

        case TBLOCK_IMPLICIT_INPROGRESS:
            /* See comment about implicit transactions in DefineSavepoint */
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                            "ROLLBACK TO SAVEPOINT")));
            break;

            /*
             * There is at least one savepoint, so proceed.
             */
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_SUBABORT:
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "RollbackToSavepoint: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }

    for (target = s; PointerIsValid(target); target = target->parent)
    {
        if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
            break;
    }

    if (!PointerIsValid(target))
        ereport(ERROR,
                (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                 errmsg("savepoint \"%s\" does not exist", name)));

    /* disallow crossing savepoint level boundaries */
    if (target->savepointLevel != s->savepointLevel)
        ereport(ERROR,
                (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                 errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));

    /*
     * Mark "abort pending" all subtransactions up to the target
     * subtransaction.  The actual aborts will happen when control gets to
     * CommitTransactionCommand.
     */
    xact = CurrentTransactionState;
    for (;;)
    {
        if (xact == target)
            break;
        if (xact->blockState == TBLOCK_SUBINPROGRESS)
            xact->blockState = TBLOCK_SUBABORT_PENDING;
        else if (xact->blockState == TBLOCK_SUBABORT)
            xact->blockState = TBLOCK_SUBABORT_END;
        else
            elog(FATAL, "RollbackToSavepoint: unexpected state %s",
                 BlockStateAsString(xact->blockState));
        xact = xact->parent;
        Assert(PointerIsValid(xact));
    }

    /* And mark the target as "restart pending" */
    if (xact->blockState == TBLOCK_SUBINPROGRESS)
        xact->blockState = TBLOCK_SUBRESTART;
    else if (xact->blockState == TBLOCK_SUBABORT)
        xact->blockState = TBLOCK_SUBABORT_RESTART;
    else
        elog(FATAL, "RollbackToSavepoint: unexpected state %s",
             BlockStateAsString(xact->blockState));
}

SerializeTransactionState()

void SerializeTransactionState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 4971 of file xact.c.

References add_size(), Assert, TransactionStateData::childXids, currentCommandId, i, TransactionStateData::nChildXids, nParallelCurrentXids, palloc(), ParallelCurrentXids, TransactionStateData::parent, qsort, TransactionStateData::transactionId, TransactionIdIsValid, XactDeferrable, XactIsoLevel, XactTopTransactionId, and xidComparator().

Referenced by InitializeParallelDSM().

{
    TransactionState s;
    Size        nxids = 0;
    Size        i = 0;
    Size        c = 0;
    TransactionId *workspace;
    TransactionId *result = (TransactionId *) start_address;

    result[c++] = (TransactionId) XactIsoLevel;
    result[c++] = (TransactionId) XactDeferrable;
    result[c++] = XactTopTransactionId;
    result[c++] = CurrentTransactionState->transactionId;
    result[c++] = (TransactionId) currentCommandId;
    Assert(maxsize >= c * sizeof(TransactionId));

    /*
     * If we're running in a parallel worker and launching a parallel worker
     * of our own, we can just pass along the information that was passed to
     * us.
     */
    if (nParallelCurrentXids > 0)
    {
        result[c++] = nParallelCurrentXids;
        Assert(maxsize >= (nParallelCurrentXids + c) * sizeof(TransactionId));
        memcpy(&result[c], ParallelCurrentXids,
               nParallelCurrentXids * sizeof(TransactionId));
        return;
    }

    /*
     * OK, we need to generate a sorted list of XIDs that our workers should
     * view as current.  First, figure out how many there are.
     */
    for (s = CurrentTransactionState; s != NULL; s = s->parent)
    {
        if (TransactionIdIsValid(s->transactionId))
            nxids = add_size(nxids, 1);
        nxids = add_size(nxids, s->nChildXids);
    }
    Assert((c + 1 + nxids) * sizeof(TransactionId) <= maxsize);

    /* Copy them to our scratch space. */
    workspace = palloc(nxids * sizeof(TransactionId));
    for (s = CurrentTransactionState; s != NULL; s = s->parent)
    {
        if (TransactionIdIsValid(s->transactionId))
            workspace[i++] = s->transactionId;
        memcpy(&workspace[i], s->childXids,
               s->nChildXids * sizeof(TransactionId));
        i += s->nChildXids;
    }
    Assert(i == nxids);

    /* Sort them. */
    qsort(workspace, nxids, sizeof(TransactionId), xidComparator);

    /* Copy data into output area. */
    result[c++] = (TransactionId) nxids;
    memcpy(&result[c], workspace, nxids * sizeof(TransactionId));
}

SetCurrentStatementStartTimestamp()

void SetCurrentStatementStartTimestamp

(

void

)

Definition at line 732 of file xact.c.

References GetCurrentTimestamp(), and stmtStartTimestamp.

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

{
    stmtStartTimestamp = GetCurrentTimestamp();
}

StartParallelWorkerTransaction()

void StartParallelWorkerTransaction

(

char *

tstatespace

)

Definition at line 5039 of file xact.c.

References Assert, TransactionStateData::blockState, currentCommandId, nParallelCurrentXids, ParallelCurrentXids, StartTransaction(), TBLOCK_DEFAULT, TBLOCK_PARALLEL_INPROGRESS, TransactionStateData::transactionId, XactDeferrable, XactIsoLevel, and XactTopTransactionId.

Referenced by ParallelWorkerMain().

{
    TransactionId *tstate = (TransactionId *) tstatespace;

    Assert(CurrentTransactionState->blockState == TBLOCK_DEFAULT);
    StartTransaction();

    XactIsoLevel = (int) tstate[0];
    XactDeferrable = (bool) tstate[1];
    XactTopTransactionId = tstate[2];
    CurrentTransactionState->transactionId = tstate[3];
    currentCommandId = tstate[4];
    nParallelCurrentXids = (int) tstate[5];
    ParallelCurrentXids = &tstate[6];

    CurrentTransactionState->blockState = TBLOCK_PARALLEL_INPROGRESS;
}

StartTransactionCommand()

void StartTransactionCommand

(

void

)

Definition at line 2673 of file xact.c.

References Assert, TransactionStateData::blockState, BlockStateAsString(), CurrentTransactionState, CurTransactionContext, elog, ERROR, MemoryContextSwitchTo(), StartTransaction(), TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_BEGIN, TBLOCK_DEFAULT, TBLOCK_END, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_PREPARE, TBLOCK_STARTED, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, and TBLOCK_SUBRESTART.

Referenced by ApplyWorkerMain(), autoprewarm_database_main(), BeginInternalSubTransaction(), BootstrapModeMain(), cluster(), DefineIndex(), do_autovacuum(), ensure_transaction(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), ParallelWorkerMain(), perform_work_item(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), ProcessCatchupInterrupt(), ProcessCompletedNotifies(), ProcessIncomingNotify(), ReindexMultipleTables(), RemoveTempRelationsCallback(), ReorderBufferCommit(), SnapBuildExportSnapshot(), SPI_start_transaction(), start_xact_command(), vacuum(), and vacuum_rel().

{
    TransactionState s = CurrentTransactionState;

    switch (s->blockState)
    {
            /*
             * if we aren't in a transaction block, we just do our usual start
             * transaction.
             */
        case TBLOCK_DEFAULT:
            StartTransaction();
            s->blockState = TBLOCK_STARTED;
            break;

            /*
             * We are somewhere in a transaction block or subtransaction and
             * about to start a new command.  For now we do nothing, but
             * someday we may do command-local resource initialization. (Note
             * that any needed CommandCounterIncrement was done by the
             * previous CommitTransactionCommand.)
             */
        case TBLOCK_INPROGRESS:
        case TBLOCK_IMPLICIT_INPROGRESS:
        case TBLOCK_SUBINPROGRESS:
            break;

            /*
             * Here we are in a failed transaction block (one of the commands
             * caused an abort) so we do nothing but remain in the abort
             * state.  Eventually we will get a ROLLBACK command which will
             * get us out of this state.  (It is up to other code to ensure
             * that no commands other than ROLLBACK will be processed in these
             * states.)
             */
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
            break;

            /* These cases are invalid. */
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(ERROR, "StartTransactionCommand: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }

    /*
     * We must switch to CurTransactionContext before returning. This is
     * already done if we called StartTransaction, otherwise not.
     */
    Assert(CurTransactionContext != NULL);
    MemoryContextSwitchTo(CurTransactionContext);
}

SubTransactionIsActive()

bool SubTransactionIsActive

(

SubTransactionId

subxid

)

Definition at line 655 of file xact.c.

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

Referenced by fmgr_sql().

{
    TransactionState s;

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

TransactionBlockStatusCode()

char TransactionBlockStatusCode

(

void

)

Definition at line 4454 of file xact.c.

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

Referenced by ReadyForQuery().

{
    TransactionState s = CurrentTransactionState;

    switch (s->blockState)
    {
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
            return 'I';         /* idle --- not in transaction */
        case TBLOCK_BEGIN:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_INPROGRESS:
        case TBLOCK_IMPLICIT_INPROGRESS:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_PREPARE:
            return 'T';         /* in transaction */
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
            return 'E';         /* in failed transaction */
    }

    /* should never get here */
    elog(FATAL, "invalid transaction block state: %s",
         BlockStateAsString(s->blockState));
    return 0;                   /* keep compiler quiet */
}

TransactionIdIsCurrentTransactionId()

bool TransactionIdIsCurrentTransactionId

(

TransactionId

xid

)

Definition at line 765 of file xact.c.

References TransactionStateData::childXids, TransactionStateData::nChildXids, nParallelCurrentXids, ParallelCurrentXids, TransactionStateData::parent, TransactionStateData::state, TRANS_ABORT, TransactionStateData::transactionId, TransactionIdEquals, TransactionIdIsNormal, TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by acquire_sample_rows(), compute_new_xmax_infomask(), copy_heap_data(), Do_MultiXactIdWait(), DoesMultiXactIdConflict(), EvalPlanQualFetch(), ExecCheckHeapTupleVisible(), ExecOnConflictUpdate(), FreezeMultiXactId(), heap_delete(), heap_lock_tuple(), heap_update(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuum(), IndexBuildHeapRangeScan(), MultiXactIdIsRunning(), RI_FKey_fk_upd_check_required(), SnapBuildWaitSnapshot(), test_lockmode_for_conflict(), TransactionIdIsInProgress(), and txid_status().

{
    TransactionState s;

    /*
     * We always say that BootstrapTransactionId is "not my transaction ID"
     * even when it is (ie, during bootstrap).  Along with the fact that
     * transam.c always treats BootstrapTransactionId as already committed,
     * this causes the tqual.c routines to see all tuples as committed, which
     * is what we need during bootstrap.  (Bootstrap mode only inserts tuples,
     * it never updates or deletes them, so all tuples can be presumed good
     * immediately.)
     *
     * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
     * not my transaction ID, so we can just return "false" immediately for
     * any non-normal XID.
     */
    if (!TransactionIdIsNormal(xid))
        return false;

    /*
     * In parallel workers, the XIDs we must consider as current are stored in
     * ParallelCurrentXids rather than the transaction-state stack.  Note that
     * the XIDs in this array are sorted numerically rather than according to
     * transactionIdPrecedes order.
     */
    if (nParallelCurrentXids > 0)
    {
        int         low,
                    high;

        low = 0;
        high = nParallelCurrentXids - 1;
        while (low <= high)
        {
            int         middle;
            TransactionId probe;

            middle = low + (high - low) / 2;
            probe = ParallelCurrentXids[middle];
            if (probe == xid)
                return true;
            else if (probe < xid)
                low = middle + 1;
            else
                high = middle - 1;
        }
        return false;
    }

    /*
     * We will return true for the Xid of the current subtransaction, any of
     * its subcommitted children, any of its parents, or any of their
     * previously subcommitted children.  However, a transaction being aborted
     * is no longer "current", even though it may still have an entry on the
     * state stack.
     */
    for (s = CurrentTransactionState; s != NULL; s = s->parent)
    {
        int         low,
                    high;

        if (s->state == TRANS_ABORT)
            continue;
        if (!TransactionIdIsValid(s->transactionId))
            continue;           /* it can't have any child XIDs either */
        if (TransactionIdEquals(xid, s->transactionId))
            return true;
        /* As the childXids array is ordered, we can use binary search */
        low = 0;
        high = s->nChildXids - 1;
        while (low <= high)
        {
            int         middle;
            TransactionId probe;

            middle = low + (high - low) / 2;
            probe = s->childXids[middle];
            if (TransactionIdEquals(probe, xid))
                return true;
            else if (TransactionIdPrecedes(probe, xid))
                low = middle + 1;
            else
                high = middle - 1;
        }
    }

    return false;
}

UnregisterSubXactCallback()

void UnregisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

Definition at line 3370 of file xact.c.

References SubXactCallbackItem::next, and pfree().

{
    SubXactCallbackItem *item;
    SubXactCallbackItem *prev;

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

UnregisterXactCallback()

void UnregisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

Definition at line 3315 of file xact.c.

References XactCallbackItem::next, and pfree().

{
    XactCallbackItem *item;
    XactCallbackItem *prev;

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

UserAbortTransactionBlock()

void UserAbortTransactionBlock

(

void

)

Definition at line 3668 of file xact.c.

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

Referenced by standard_ProcessUtility().

{
    TransactionState s = CurrentTransactionState;

    switch (s->blockState)
    {
            /*
             * We are inside a transaction block and we got a ROLLBACK command
             * from the user, so tell CommitTransactionCommand to abort and
             * exit the transaction block.
             */
        case TBLOCK_INPROGRESS:
            s->blockState = TBLOCK_ABORT_PENDING;
            break;

            /*
             * We are inside a failed transaction block and we got a ROLLBACK
             * command from the user.  Abort processing is already done, so
             * CommitTransactionCommand just has to cleanup and go back to
             * idle state.
             */
        case TBLOCK_ABORT:
            s->blockState = TBLOCK_ABORT_END;
            break;

            /*
             * We are inside a subtransaction.  Mark everything up to top
             * level as exitable.
             */
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_SUBABORT:
            while (s->parent != NULL)
            {
                if (s->blockState == TBLOCK_SUBINPROGRESS)
                    s->blockState = TBLOCK_SUBABORT_PENDING;
                else if (s->blockState == TBLOCK_SUBABORT)
                    s->blockState = TBLOCK_SUBABORT_END;
                else
                    elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                         BlockStateAsString(s->blockState));
                s = s->parent;
            }
            if (s->blockState == TBLOCK_INPROGRESS)
                s->blockState = TBLOCK_ABORT_PENDING;
            else if (s->blockState == TBLOCK_ABORT)
                s->blockState = TBLOCK_ABORT_END;
            else
                elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                     BlockStateAsString(s->blockState));
            break;

            /*
             * The user issued ABORT when not inside a transaction. Issue a
             * WARNING and go to abort state.  The upcoming call to
             * CommitTransactionCommand() will then put us back into the
             * default state.
             *
             * We do the same thing with ABORT inside an implicit transaction,
             * although in this case we might be rolling back actual database
             * state changes.  (It's debatable whether we should issue a
             * WARNING in this case, but we have done so historically.)
             */
        case TBLOCK_STARTED:
        case TBLOCK_IMPLICIT_INPROGRESS:
            ereport(WARNING,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                     errmsg("there is no transaction in progress")));
            s->blockState = TBLOCK_ABORT_PENDING;
            break;

            /*
             * The user issued an ABORT that somehow ran inside a parallel
             * worker.  We can't cope with that.
             */
        case TBLOCK_PARALLEL_INPROGRESS:
            ereport(FATAL,
                    (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                     errmsg("cannot abort during a parallel operation")));
            break;

            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_BEGIN:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
}

WarnNoTransactionBlock()

void WarnNoTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

Definition at line 3213 of file xact.c.

References CheckTransactionBlock().

Referenced by ExecSetVariableStmt(), and standard_ProcessUtility().

{
    CheckTransactionBlock(isTopLevel, false, stmtType);
}

xact_desc()

void xact_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 308 of file xactdesc.c.

References appendStringInfo(), xact_desc_abort(), xact_desc_assignment(), xact_desc_commit(), XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_ASSIGNMENT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, XLogRecGetData, XLogRecGetInfo, XLogRecGetOrigin, and xl_xact_assignment::xtop.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;

    if (info == XLOG_XACT_COMMIT || info == XLOG_XACT_COMMIT_PREPARED)
    {
        xl_xact_commit *xlrec = (xl_xact_commit *) rec;

        xact_desc_commit(buf, XLogRecGetInfo(record), xlrec,
                         XLogRecGetOrigin(record));
    }
    else if (info == XLOG_XACT_ABORT || info == XLOG_XACT_ABORT_PREPARED)
    {
        xl_xact_abort *xlrec = (xl_xact_abort *) rec;

        xact_desc_abort(buf, XLogRecGetInfo(record), xlrec);
    }
    else if (info == XLOG_XACT_ASSIGNMENT)
    {
        xl_xact_assignment *xlrec = (xl_xact_assignment *) rec;

        /*
         * Note that we ignore the WAL record's xid, since we're more
         * interested in the top-level xid that issued the record and which
         * xids are being reported here.
         */
        appendStringInfo(buf, "xtop %u: ", xlrec->xtop);
        xact_desc_assignment(buf, xlrec);
    }
}

xact_identify()

const char* xact_identify

(

uint8

info

)

Definition at line 341 of file xactdesc.c.

References XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_ASSIGNMENT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, and XLOG_XACT_PREPARE.

{
    const char *id = NULL;

    switch (info & XLOG_XACT_OPMASK)
    {
        case XLOG_XACT_COMMIT:
            id = "COMMIT";
            break;
        case XLOG_XACT_PREPARE:
            id = "PREPARE";
            break;
        case XLOG_XACT_ABORT:
            id = "ABORT";
            break;
        case XLOG_XACT_COMMIT_PREPARED:
            id = "COMMIT_PREPARED";
            break;
        case XLOG_XACT_ABORT_PREPARED:
            id = "ABORT_PREPARED";
            break;
        case XLOG_XACT_ASSIGNMENT:
            id = "ASSIGNMENT";
            break;
    }

    return id;
}

xact_redo()

void xact_redo

(

XLogReaderState *

record

)

Definition at line 5764 of file xact.c.

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

{
    uint8       info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;

    /* Backup blocks are not used in xact records */
    Assert(!XLogRecHasAnyBlockRefs(record));

    if (info == XLOG_XACT_COMMIT)
    {
        xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
        xl_xact_parsed_commit parsed;

        ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
        xact_redo_commit(&parsed, XLogRecGetXid(record),
                         record->EndRecPtr, XLogRecGetOrigin(record));
    }
    else if (info == XLOG_XACT_COMMIT_PREPARED)
    {
        xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
        xl_xact_parsed_commit parsed;

        ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
        xact_redo_commit(&parsed, parsed.twophase_xid,
                         record->EndRecPtr, XLogRecGetOrigin(record));

        /* Delete TwoPhaseState gxact entry and/or 2PC file. */
        LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
        PrepareRedoRemove(parsed.twophase_xid, false);
        LWLockRelease(TwoPhaseStateLock);
    }
    else if (info == XLOG_XACT_ABORT)
    {
        xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
        xl_xact_parsed_abort parsed;

        ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
        xact_redo_abort(&parsed, XLogRecGetXid(record));
    }
    else if (info == XLOG_XACT_ABORT_PREPARED)
    {
        xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
        xl_xact_parsed_abort parsed;

        ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
        xact_redo_abort(&parsed, parsed.twophase_xid);

        /* Delete TwoPhaseState gxact entry and/or 2PC file. */
        LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
        PrepareRedoRemove(parsed.twophase_xid, false);
        LWLockRelease(TwoPhaseStateLock);
    }
    else if (info == XLOG_XACT_PREPARE)
    {
        /*
         * Store xid and start/end pointers of the WAL record in TwoPhaseState
         * gxact entry.
         */
        LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
        PrepareRedoAdd(XLogRecGetData(record),
                       record->ReadRecPtr,
                       record->EndRecPtr,
                       XLogRecGetOrigin(record));
        LWLockRelease(TwoPhaseStateLock);
    }
    else if (info == XLOG_XACT_ASSIGNMENT)
    {
        xl_xact_assignment *xlrec = (xl_xact_assignment *) XLogRecGetData(record);

        if (standbyState >= STANDBY_INITIALIZED)
            ProcArrayApplyXidAssignment(xlrec->xtop,
                                        xlrec->nsubxacts, xlrec->xsub);
    }
    else
        elog(PANIC, "xact_redo: unknown op code %u", info);
}

xactGetCommittedChildren()

int xactGetCommittedChildren

(

TransactionId **

ptr

)

Definition at line 5208 of file xact.c.

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

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

{
    TransactionState s = CurrentTransactionState;

    if (s->nChildXids == 0)
        *ptr = NULL;
    else
        *ptr = s->childXids;

    return s->nChildXids;
}

XactLogAbortRecord()

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

Definition at line 5387 of file xact.c.

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

Referenced by RecordTransactionAbort(), and RecordTransactionAbortPrepared().

{
    xl_xact_abort xlrec;
    xl_xact_xinfo xl_xinfo;
    xl_xact_subxacts xl_subxacts;
    xl_xact_relfilenodes xl_relfilenodes;
    xl_xact_twophase xl_twophase;
    xl_xact_dbinfo xl_dbinfo;
    xl_xact_origin xl_origin;

    uint8       info;

    Assert(CritSectionCount > 0);

    xl_xinfo.xinfo = 0;

    /* decide between a plain and 2pc abort */
    if (!TransactionIdIsValid(twophase_xid))
        info = XLOG_XACT_ABORT;
    else
        info = XLOG_XACT_ABORT_PREPARED;


    /* First figure out and collect all the information needed */

    xlrec.xact_time = abort_time;

    if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
        xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;

    if (nsubxacts > 0)
    {
        xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
        xl_subxacts.nsubxacts = nsubxacts;
    }

    if (nrels > 0)
    {
        xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILENODES;
        xl_relfilenodes.nrels = nrels;
    }

    if (TransactionIdIsValid(twophase_xid))
    {
        xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
        xl_twophase.xid = twophase_xid;
        Assert(twophase_gid != NULL);

        if (XLogLogicalInfoActive())
            xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
    }

    if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
    {
        xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
        xl_dbinfo.dbId = MyDatabaseId;
        xl_dbinfo.tsId = MyDatabaseTableSpace;
    }

    /* dump transaction origin information only for abort prepared */
    if ((replorigin_session_origin != InvalidRepOriginId) &&
        TransactionIdIsValid(twophase_xid) &&
        XLogLogicalInfoActive())
    {
        xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;

        xl_origin.origin_lsn = replorigin_session_origin_lsn;
        xl_origin.origin_timestamp = replorigin_session_origin_timestamp;
    }

    if (xl_xinfo.xinfo != 0)
        info |= XLOG_XACT_HAS_INFO;

    /* Then include all the collected data into the abort record. */

    XLogBeginInsert();

    XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);

    if (xl_xinfo.xinfo != 0)
        XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));

    if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
        XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));

    if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
    {
        XLogRegisterData((char *) (&xl_subxacts),
                         MinSizeOfXactSubxacts);
        XLogRegisterData((char *) subxacts,
                         nsubxacts * sizeof(TransactionId));
    }

    if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILENODES)
    {
        XLogRegisterData((char *) (&xl_relfilenodes),
                         MinSizeOfXactRelfilenodes);
        XLogRegisterData((char *) rels,
                         nrels * sizeof(RelFileNode));
    }

    if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
    {
        XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
        if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
            XLogRegisterData((char *) twophase_gid, strlen(twophase_gid) + 1);
    }

    if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
        XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));

    if (TransactionIdIsValid(twophase_xid))
        XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);

    return XLogInsert(RM_XACT_ID, info);
}