#include "access/transam.h"
#include "access/xlogreader.h"
#include "datatype/timestamp.h"
#include "lib/stringinfo.h"
#include "nodes/pg_list.h"
#include "storage/relfilelocator.h"
#include "storage/sinval.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	SavedTransactionCharacteristics

struct	xl_xact_assignment

struct	xl_xact_xinfo

struct	xl_xact_dbinfo

struct	xl_xact_subxacts

struct	xl_xact_relfilelocators

struct	xl_xact_stats_item

struct	xl_xact_stats_items

struct	xl_xact_invals

struct	xl_xact_twophase

struct	xl_xact_origin

struct	xl_xact_commit

struct	xl_xact_abort

struct	xl_xact_prepare

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_ACCESSEDTEMPNAMESPACE (1U << 0)

#define	XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK (1U << 1)

#define	XACT_FLAGS_NEEDIMMEDIATECOMMIT (1U << 2)

#define	XACT_FLAGS_PIPELINING (1U << 3)

#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_INVALIDATIONS 0x60

#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_RELFILELOCATORS (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_XINFO_HAS_DROPPED_STATS (1U << 8)

#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	MinSizeOfXactRelfileLocators offsetof(xl_xact_relfilelocators, xlocators)

#define	MinSizeOfXactStatsItems offsetof(xl_xact_stats_items, items)

#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 SavedTransactionCharacteristics	SavedTransactionCharacteristics

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_relfilelocators	xl_xact_relfilelocators

typedef struct xl_xact_stats_item	xl_xact_stats_item

typedef struct xl_xact_stats_items	xl_xact_stats_items

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_prepare	xl_xact_prepare

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

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)

FullTransactionId	GetTopFullTransactionId (void)

FullTransactionId	GetTopFullTransactionIdIfAny (void)

FullTransactionId	GetCurrentFullTransactionId (void)

FullTransactionId	GetCurrentFullTransactionIdIfAny (void)

void	MarkCurrentTransactionIdLoggedIfAny (void)

bool	SubTransactionIsActive (SubTransactionId subxid)

CommandId	GetCurrentCommandId (bool used)

void	SetParallelStartTimestamps (TimestampTz xact_ts, TimestampTz stmt_ts)

TimestampTz	GetCurrentTransactionStartTimestamp (void)

TimestampTz	GetCurrentStatementStartTimestamp (void)

TimestampTz	GetCurrentTransactionStopTimestamp (void)

void	SetCurrentStatementStartTimestamp (void)

int	GetCurrentTransactionNestLevel (void)

bool	TransactionIdIsCurrentTransactionId (TransactionId xid)

int	GetTopReadOnlyTransactionNestLevel (void)

void	CommandCounterIncrement (void)

void	ForceSyncCommit (void)

void	StartTransactionCommand (void)

void	SaveTransactionCharacteristics (SavedTransactionCharacteristics *s)

void	RestoreTransactionCharacteristics (const SavedTransactionCharacteristics *s)

void	CommitTransactionCommand (void)

void	AbortCurrentTransaction (void)

void	BeginTransactionBlock (void)

bool	EndTransactionBlock (bool chain)

bool	PrepareTransactionBlock (const char *gid)

void	UserAbortTransactionBlock (bool chain)

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)

bool	IsSubxactTopXidLogPending (void)

void	MarkSubxactTopXidLogged (void)

int	xactGetCommittedChildren (TransactionId **ptr)

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

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

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	ParsePrepareRecord (uint8 info, xl_xact_prepare xlrec, xl_xact_parsed_prepare parsed)

void	EnterParallelMode (void)

void	ExitParallelMode (void)

bool	IsInParallelMode (void)

Macro Definition Documentation

◆ GIDSIZE

#define GIDSIZE 200

Definition at line 31 of file xact.h.

◆ IsolationIsSerializable

#define IsolationIsSerializable ( ) (XactIsoLevel == XACT_SERIALIZABLE)

Definition at line 53 of file xact.h.

◆ IsolationUsesXactSnapshot

#define IsolationUsesXactSnapshot ( ) (XactIsoLevel >= XACT_REPEATABLE_READ)

Definition at line 52 of file xact.h.

◆ MinSizeOfXactAbort

#define MinSizeOfXactAbort sizeof(xl_xact_abort)

Definition at line 351 of file xact.h.

◆ MinSizeOfXactAssignment

#define MinSizeOfXactAssignment offsetof(xl_xact_assignment, xsub)

Definition at line 226 of file xact.h.

◆ MinSizeOfXactCommit

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

Definition at line 335 of file xact.h.

◆ MinSizeOfXactInvals

#define MinSizeOfXactInvals offsetof(xl_xact_invals, msgs)

Definition at line 308 of file xact.h.

◆ MinSizeOfXactRelfileLocators

#define MinSizeOfXactRelfileLocators offsetof(xl_xact_relfilelocators, xlocators)

Definition at line 274 of file xact.h.

◆ MinSizeOfXactStatsItems

#define MinSizeOfXactStatsItems offsetof(xl_xact_stats_items, items)

Definition at line 301 of file xact.h.

◆ MinSizeOfXactSubxacts

#define MinSizeOfXactSubxacts offsetof(xl_xact_subxacts, subxacts)

Definition at line 267 of file xact.h.

◆ SYNCHRONOUS_COMMIT_ON

#define SYNCHRONOUS_COMMIT_ON SYNCHRONOUS_COMMIT_REMOTE_FLUSH

Definition at line 81 of file xact.h.

◆ XACT_COMPLETION_APPLY_FEEDBACK

#define XACT_COMPLETION_APPLY_FEEDBACK (1U << 29)

Definition at line 207 of file xact.h.

◆ XACT_COMPLETION_FORCE_SYNC_COMMIT

#define XACT_COMPLETION_FORCE_SYNC_COMMIT (1U << 31)

Definition at line 209 of file xact.h.

◆ XACT_COMPLETION_UPDATE_RELCACHE_FILE

#define XACT_COMPLETION_UPDATE_RELCACHE_FILE (1U << 30)

Definition at line 208 of file xact.h.

◆ XACT_FLAGS_ACCESSEDTEMPNAMESPACE

#define XACT_FLAGS_ACCESSEDTEMPNAMESPACE (1U << 0)

Definition at line 103 of file xact.h.

◆ XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK

#define XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK (1U << 1)

Definition at line 109 of file xact.h.

◆ XACT_FLAGS_NEEDIMMEDIATECOMMIT

#define XACT_FLAGS_NEEDIMMEDIATECOMMIT (1U << 2)

Definition at line 115 of file xact.h.

◆ XACT_FLAGS_PIPELINING

#define XACT_FLAGS_PIPELINING (1U << 3)

Definition at line 122 of file xact.h.

◆ XACT_READ_COMMITTED

#define XACT_READ_COMMITTED 1

Definition at line 37 of file xact.h.

◆ XACT_READ_UNCOMMITTED

#define XACT_READ_UNCOMMITTED 0

Definition at line 36 of file xact.h.

◆ XACT_REPEATABLE_READ

#define XACT_REPEATABLE_READ 2

Definition at line 38 of file xact.h.

◆ XACT_SERIALIZABLE

#define XACT_SERIALIZABLE 3

Definition at line 39 of file xact.h.

◆ XACT_XINFO_HAS_AE_LOCKS

#define XACT_XINFO_HAS_AE_LOCKS (1U << 6)

Definition at line 195 of file xact.h.

◆ XACT_XINFO_HAS_DBINFO

#define XACT_XINFO_HAS_DBINFO (1U << 0)

Definition at line 189 of file xact.h.

◆ XACT_XINFO_HAS_DROPPED_STATS

#define XACT_XINFO_HAS_DROPPED_STATS (1U << 8)

Definition at line 197 of file xact.h.

◆ XACT_XINFO_HAS_GID

#define XACT_XINFO_HAS_GID (1U << 7)

Definition at line 196 of file xact.h.

◆ XACT_XINFO_HAS_INVALS

#define XACT_XINFO_HAS_INVALS (1U << 3)

Definition at line 192 of file xact.h.

◆ XACT_XINFO_HAS_ORIGIN

#define XACT_XINFO_HAS_ORIGIN (1U << 5)

Definition at line 194 of file xact.h.

◆ XACT_XINFO_HAS_RELFILELOCATORS

#define XACT_XINFO_HAS_RELFILELOCATORS (1U << 2)

Definition at line 191 of file xact.h.

◆ XACT_XINFO_HAS_SUBXACTS

#define XACT_XINFO_HAS_SUBXACTS (1U << 1)

Definition at line 190 of file xact.h.

◆ XACT_XINFO_HAS_TWOPHASE

#define XACT_XINFO_HAS_TWOPHASE (1U << 4)

Definition at line 193 of file xact.h.

◆ XactCompletionApplyFeedback

#define XactCompletionApplyFeedback ( xinfo ) ((xinfo & XACT_COMPLETION_APPLY_FEEDBACK) != 0)

Definition at line 212 of file xact.h.

{
    TransactionId xtop;         /* assigned XID's top-level XID */
    int         nsubxacts;      /* number of subtransaction XIDs */
    TransactionId xsub[FLEXIBLE_ARRAY_MEMBER];  /* assigned subxids */
} xl_xact_assignment;
 
#define MinSizeOfXactAssignment offsetof(xl_xact_assignment, xsub)
 
/*
 * Commit and abort records can contain a lot of information. But a large
 * portion of the records won't need all possible pieces of information. So we
 * only include what's needed.
 *
 * A minimal commit/abort record only consists of a xl_xact_commit/abort
 * struct. The presence of additional information is indicated by bits set in
 * 'xl_xact_xinfo->xinfo'. The presence of the xinfo field itself is signaled
 * by a set XLOG_XACT_HAS_INFO bit in the xl_info field.
 *
 * NB: All the individual data chunks should be sized to multiples of
 * sizeof(int) and only require int32 alignment. If they require bigger
 * alignment, they need to be copied upon reading.
 */
 
/* sub-records for commit/abort */
 
typedef struct xl_xact_xinfo
{
    /*
     * Even though we right now only require two bytes of space in xinfo we
     * use four so following records don't have to care about alignment.
     * Commit records can be large, so copying large portions isn't
     * attractive.
     */
    uint32      xinfo;
} xl_xact_xinfo;
 
typedef struct xl_xact_dbinfo
{
    Oid         dbId;           /* MyDatabaseId */
    Oid         tsId;           /* MyDatabaseTableSpace */
} xl_xact_dbinfo;
 
typedef struct xl_xact_subxacts
{
    int         nsubxacts;      /* number of subtransaction XIDs */
    TransactionId subxacts[FLEXIBLE_ARRAY_MEMBER];
} xl_xact_subxacts;
#define MinSizeOfXactSubxacts offsetof(xl_xact_subxacts, subxacts)
 
typedef struct xl_xact_relfilelocators
{
    int         nrels;          /* number of relations */
    RelFileLocator xlocators[FLEXIBLE_ARRAY_MEMBER];
} xl_xact_relfilelocators;
#define MinSizeOfXactRelfileLocators offsetof(xl_xact_relfilelocators, xlocators)
 
/*
 * A transactionally dropped statistics entry.
 *
 * Declared here rather than pgstat.h because pgstat.h can't be included from
 * frontend code, but the WAL format needs to be readable by frontend
 * programs.
 */
typedef struct xl_xact_stats_item
{
    int         kind;
    Oid         dboid;
 
    /*
     * This stores the value of PgStat_HashKey.objid as two uint32 as all the
     * fields of xl_xact_xinfo should be multiples of size(int).
     */
    uint32      objid_lo;
    uint32      objid_hi;
} xl_xact_stats_item;
 
typedef struct xl_xact_stats_items
{
    int         nitems;
    xl_xact_stats_item items[FLEXIBLE_ARRAY_MEMBER];
} xl_xact_stats_items;
#define MinSizeOfXactStatsItems offsetof(xl_xact_stats_items, items)
 
typedef struct xl_xact_invals
{
    int         nmsgs;          /* number of shared inval msgs */
    SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER];
} xl_xact_invals;
#define MinSizeOfXactInvals offsetof(xl_xact_invals, msgs)
 
typedef struct xl_xact_twophase
{
    TransactionId xid;
} xl_xact_twophase;
 
typedef struct xl_xact_origin
{
    XLogRecPtr  origin_lsn;
    TimestampTz origin_timestamp;
} xl_xact_origin;
 
typedef struct xl_xact_commit
{
    TimestampTz xact_time;      /* time of commit */
 
    /* xl_xact_xinfo follows if XLOG_XACT_HAS_INFO */
    /* xl_xact_dbinfo follows if XINFO_HAS_DBINFO */
    /* xl_xact_subxacts follows if XINFO_HAS_SUBXACT */
    /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
    /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
    /* xl_xact_invals follows if XINFO_HAS_INVALS */
    /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
    /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
    /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
} xl_xact_commit;
#define MinSizeOfXactCommit (offsetof(xl_xact_commit, xact_time) + sizeof(TimestampTz))
 
typedef struct xl_xact_abort
{
    TimestampTz xact_time;      /* time of abort */
 
    /* xl_xact_xinfo follows if XLOG_XACT_HAS_INFO */
    /* xl_xact_dbinfo follows if XINFO_HAS_DBINFO */
    /* xl_xact_subxacts follows if XINFO_HAS_SUBXACT */
    /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
    /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
    /* No invalidation messages needed. */
    /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
    /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
    /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
} xl_xact_abort;
#define MinSizeOfXactAbort sizeof(xl_xact_abort)
 
typedef struct xl_xact_prepare
{
    uint32      magic;          /* format identifier */
    uint32      total_len;      /* actual file length */
    TransactionId xid;          /* original transaction XID */
    Oid         database;       /* OID of database it was in */
    TimestampTz prepared_at;    /* time of preparation */
    Oid         owner;          /* user running the transaction */
    int32       nsubxacts;      /* number of following subxact XIDs */
    int32       ncommitrels;    /* number of delete-on-commit rels */
    int32       nabortrels;     /* number of delete-on-abort rels */
    int32       ncommitstats;   /* number of stats to drop on commit */
    int32       nabortstats;    /* number of stats to drop on abort */
    int32       ninvalmsgs;     /* number of cache invalidation messages */
    bool        initfileinval;  /* does relcache init file need invalidation? */
    uint16      gidlen;         /* length of the GID - GID follows the header */
    XLogRecPtr  origin_lsn;     /* lsn of this record at origin node */
    TimestampTz origin_timestamp;   /* time of prepare at origin node */
} xl_xact_prepare;
 
/*
 * Commit/Abort records in the above form are a bit verbose to parse, so
 * there's a deconstructed versions generated by ParseCommit/AbortRecord() for
 * easier consumption.
 */
typedef struct xl_xact_parsed_commit
{
    TimestampTz xact_time;
    uint32      xinfo;
 
    Oid         dbId;           /* MyDatabaseId */
    Oid         tsId;           /* MyDatabaseTableSpace */
 
    int         nsubxacts;
    TransactionId *subxacts;
 
    int         nrels;
    RelFileLocator *xlocators;
 
    int         nstats;
    xl_xact_stats_item *stats;
 
    int         nmsgs;
    SharedInvalidationMessage *msgs;
 
    TransactionId twophase_xid; /* only for 2PC */
    char        twophase_gid[GIDSIZE];  /* only for 2PC */
    int         nabortrels;     /* only for 2PC */
    RelFileLocator *abortlocators;  /* only for 2PC */
    int         nabortstats;    /* only for 2PC */
    xl_xact_stats_item *abortstats; /* only for 2PC */
 
    XLogRecPtr  origin_lsn;
    TimestampTz origin_timestamp;
} xl_xact_parsed_commit;
 
typedef xl_xact_parsed_commit xl_xact_parsed_prepare;
 
typedef struct xl_xact_parsed_abort
{
    TimestampTz xact_time;
    uint32      xinfo;
 
    Oid         dbId;           /* MyDatabaseId */
    Oid         tsId;           /* MyDatabaseTableSpace */
 
    int         nsubxacts;
    TransactionId *subxacts;
 
    int         nrels;
    RelFileLocator *xlocators;
 
    int         nstats;
    xl_xact_stats_item *stats;
 
    TransactionId twophase_xid; /* only for 2PC */
    char        twophase_gid[GIDSIZE];  /* only for 2PC */
 
    XLogRecPtr  origin_lsn;
    TimestampTz origin_timestamp;
} xl_xact_parsed_abort;
 
 
/* ----------------
 *      extern definitions
 * ----------------
 */
extern bool IsTransactionState(void);
extern bool IsAbortedTransactionBlockState(void);
extern TransactionId GetTopTransactionId(void);
extern TransactionId GetTopTransactionIdIfAny(void);
extern TransactionId GetCurrentTransactionId(void);
extern TransactionId GetCurrentTransactionIdIfAny(void);
extern TransactionId GetStableLatestTransactionId(void);
extern SubTransactionId GetCurrentSubTransactionId(void);
extern FullTransactionId GetTopFullTransactionId(void);
extern FullTransactionId GetTopFullTransactionIdIfAny(void);
extern FullTransactionId GetCurrentFullTransactionId(void);
extern FullTransactionId GetCurrentFullTransactionIdIfAny(void);
extern void MarkCurrentTransactionIdLoggedIfAny(void);
extern bool SubTransactionIsActive(SubTransactionId subxid);
extern CommandId GetCurrentCommandId(bool used);
extern void SetParallelStartTimestamps(TimestampTz xact_ts, TimestampTz stmt_ts);
extern TimestampTz GetCurrentTransactionStartTimestamp(void);
extern TimestampTz GetCurrentStatementStartTimestamp(void);
extern TimestampTz GetCurrentTransactionStopTimestamp(void);
extern void SetCurrentStatementStartTimestamp(void);
extern int  GetCurrentTransactionNestLevel(void);
extern bool TransactionIdIsCurrentTransactionId(TransactionId xid);
extern int  GetTopReadOnlyTransactionNestLevel(void);
extern void CommandCounterIncrement(void);
extern void ForceSyncCommit(void);
extern void StartTransactionCommand(void);
extern void SaveTransactionCharacteristics(SavedTransactionCharacteristics *s);
extern void RestoreTransactionCharacteristics(const SavedTransactionCharacteristics *s);
extern void CommitTransactionCommand(void);
extern void AbortCurrentTransaction(void);
extern void BeginTransactionBlock(void);
extern bool EndTransactionBlock(bool chain);
extern bool PrepareTransactionBlock(const char *gid);
extern void UserAbortTransactionBlock(bool chain);
extern void BeginImplicitTransactionBlock(void);
extern void EndImplicitTransactionBlock(void);
extern void ReleaseSavepoint(const char *name);
extern void DefineSavepoint(const char *name);
extern void RollbackToSavepoint(const char *name);
extern void BeginInternalSubTransaction(const char *name);
extern void ReleaseCurrentSubTransaction(void);
extern void RollbackAndReleaseCurrentSubTransaction(void);
extern bool IsSubTransaction(void);
extern Size EstimateTransactionStateSpace(void);
extern void SerializeTransactionState(Size maxsize, char *start_address);
extern void StartParallelWorkerTransaction(char *tstatespace);
extern void EndParallelWorkerTransaction(void);
extern bool IsTransactionBlock(void);
extern bool IsTransactionOrTransactionBlock(void);
extern char TransactionBlockStatusCode(void);
extern void AbortOutOfAnyTransaction(void);
extern void PreventInTransactionBlock(bool isTopLevel, const char *stmtType);
extern void RequireTransactionBlock(bool isTopLevel, const char *stmtType);
extern void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType);
extern bool IsInTransactionBlock(bool isTopLevel);
extern void RegisterXactCallback(XactCallback callback, void *arg);
extern void UnregisterXactCallback(XactCallback callback, void *arg);
extern void RegisterSubXactCallback(SubXactCallback callback, void *arg);
extern void UnregisterSubXactCallback(SubXactCallback callback, void *arg);
 
extern bool IsSubxactTopXidLogPending(void);
extern void MarkSubxactTopXidLogged(void);
 
extern int  xactGetCommittedChildren(TransactionId **ptr);
 
extern XLogRecPtr XactLogCommitRecord(TimestampTz commit_time,
                                      int nsubxacts, TransactionId *subxacts,
                                      int nrels, RelFileLocator *rels,
                                      int ndroppedstats,
                                      xl_xact_stats_item *droppedstats,
                                      int nmsgs, SharedInvalidationMessage *msgs,
                                      bool relcacheInval,
                                      int xactflags,
                                      TransactionId twophase_xid,
                                      const char *twophase_gid);
 
extern XLogRecPtr XactLogAbortRecord(TimestampTz abort_time,
                                     int nsubxacts, TransactionId *subxacts,
                                     int nrels, RelFileLocator *rels,
                                     int ndroppedstats,
                                     xl_xact_stats_item *droppedstats,
                                     int xactflags, TransactionId twophase_xid,
                                     const char *twophase_gid);
extern void xact_redo(XLogReaderState *record);
 
/* xactdesc.c */
extern void xact_desc(StringInfo buf, XLogReaderState *record);
extern const char *xact_identify(uint8 info);
 
/* also in xactdesc.c, so they can be shared between front/backend code */
extern void ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *parsed);
extern void ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed);
extern void ParsePrepareRecord(uint8 info, xl_xact_prepare *xlrec, xl_xact_parsed_prepare *parsed);
 
extern void EnterParallelMode(void);
extern void ExitParallelMode(void);
extern bool IsInParallelMode(void);
 
#endif                          /* XACT_H */

◆ XactCompletionForceSyncCommit

#define XactCompletionForceSyncCommit ( xinfo ) ((xinfo & XACT_COMPLETION_FORCE_SYNC_COMMIT) != 0)

Definition at line 216 of file xact.h.

◆ XactCompletionRelcacheInitFileInval

#define XactCompletionRelcacheInitFileInval ( xinfo ) ((xinfo & XACT_COMPLETION_UPDATE_RELCACHE_FILE) != 0)

Definition at line 214 of file xact.h.

◆ XLOG_XACT_ABORT

#define XLOG_XACT_ABORT 0x20

Definition at line 172 of file xact.h.

◆ XLOG_XACT_ABORT_PREPARED

#define XLOG_XACT_ABORT_PREPARED 0x40

Definition at line 174 of file xact.h.

◆ XLOG_XACT_ASSIGNMENT

#define XLOG_XACT_ASSIGNMENT 0x50

Definition at line 175 of file xact.h.

◆ XLOG_XACT_COMMIT

#define XLOG_XACT_COMMIT 0x00

Definition at line 170 of file xact.h.

◆ XLOG_XACT_COMMIT_PREPARED

#define XLOG_XACT_COMMIT_PREPARED 0x30

Definition at line 173 of file xact.h.

◆ XLOG_XACT_HAS_INFO

#define XLOG_XACT_HAS_INFO 0x80

Definition at line 183 of file xact.h.

◆ XLOG_XACT_INVALIDATIONS

#define XLOG_XACT_INVALIDATIONS 0x60

Definition at line 176 of file xact.h.

◆ XLOG_XACT_OPMASK

#define XLOG_XACT_OPMASK 0x70

Definition at line 180 of file xact.h.

◆ XLOG_XACT_PREPARE

#define XLOG_XACT_PREPARE 0x10

Definition at line 171 of file xact.h.

Typedef Documentation

◆ SavedTransactionCharacteristics

typedef struct SavedTransactionCharacteristics SavedTransactionCharacteristics

◆ SubXactCallback

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

Definition at line 149 of file xact.h.

◆ XactCallback

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

Definition at line 139 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 409 of file xact.h.

◆ xl_xact_prepare

typedef struct xl_xact_prepare xl_xact_prepare

◆ xl_xact_relfilelocators

typedef struct xl_xact_relfilelocators xl_xact_relfilelocators

◆ xl_xact_stats_item

typedef struct xl_xact_stats_item xl_xact_stats_item

◆ xl_xact_stats_items

typedef struct xl_xact_stats_items xl_xact_stats_items

◆ 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 141 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 69 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 and remote 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 127 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 )

extern

Definition at line 3501 of file xact.c.

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

References AbortCurrentTransactionInternal().

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

◆ AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction ( void )

extern

Definition at line 4913 of file xact.c.

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

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

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

◆ BeginImplicitTransactionBlock()

void BeginImplicitTransactionBlock ( void )

extern

Definition at line 4377 of file xact.c.

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

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

Referenced by exec_simple_query(), and start_xact_command().

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char * name )

extern

Definition at line 4745 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
    bool        save_ExitOnAnyError = ExitOnAnyError;
 
    /*
     * Errors within this function are improbable, but if one does happen we
     * force a FATAL exit.  Callers generally aren't prepared to handle losing
     * control, and moreover our transaction state is probably corrupted if we
     * fail partway through; so an ordinary ERROR longjmp isn't okay.
     */
    ExitOnAnyError = true;
 
    /*
     * We do not check for parallel mode here.  It's permissible to start and
     * end "internal" subtransactions while in parallel mode, so long as no
     * new XIDs or command IDs are assigned.  Enforcement of that occurs in
     * AssignTransactionId() and CommandCounterIncrement().
     */
 
    switch (s->blockState)
    {
        case TBLOCK_STARTED:
        case TBLOCK_INPROGRESS:
        case TBLOCK_IMPLICIT_INPROGRESS:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_END:
        case TBLOCK_PREPARE:
        case TBLOCK_SUBINPROGRESS:
            /* Normal subtransaction start */
            PushTransaction();
            s = CurrentTransactionState;    /* changed by push */
 
            /*
             * Savepoint names, like the TransactionState block itself, live
             * in TopTransactionContext.
             */
            if (name)
                s->name = MemoryContextStrdup(TopTransactionContext, name);
            break;
 
            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_BEGIN:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
            elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
 
    CommitTransactionCommand();
    StartTransactionCommand();
 
    ExitOnAnyError = save_ExitOnAnyError;
}

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

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

◆ BeginTransactionBlock()

void BeginTransactionBlock ( void )

extern

Definition at line 3975 of file xact.c.

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

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

Referenced by apply_handle_prepare_internal(), pa_start_subtrans(), and standard_ProcessUtility().

◆ CommandCounterIncrement()

void CommandCounterIncrement ( void )

extern

Definition at line 1130 of file xact.c.

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

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

Referenced by _SPI_execute_plan(), acquire_inherited_sample_rows(), addFkConstraint(), AddRoleMems(), AlterPropGraph(), AlterPublicationAllFlags(), AlterPublicationOptions(), AlterRole(), apply_concurrent_changes(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAlterColumnType(), ATExecAlterConstrInheritability(), ATExecCmd(), ATExecDropColumn(), ATExecDropExpression(), ATExecDropIdentity(), ATExecMergePartitions(), ATExecSetAccessMethodNoStorage(), ATExecSetCompression(), ATExecSetExpression(), ATExecSetNotNull(), ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), ATExecSplitPartition(), ATParseTransformCmd(), ATRewriteTables(), AttachPartitionEnsureIndexes(), AttachPartitionForeignKey(), btadjustmembers(), CommitSubTransaction(), CommitTransactionCommandInternal(), compute_return_type(), copy_index_constraints(), copy_table_data(), create_ctas_internal(), create_toast_table(), CreateFKCheckTrigger(), createForeignKeyActionTriggers(), CreateForeignTable(), createPartitionTable(), CreatePropGraph(), CreatePublication(), CreateRole(), CreateSchemaCommand(), createTableConstraints(), CreateTriggerFiringOn(), DefineCollation(), DefineDomain(), DefineIndex(), DefineRange(), DefineRelation(), DefineVirtualRelation(), delete_pg_statistic(), delete_pg_statistic_ext_data(), deleteOneObject(), DetachPartitionFinalize(), do_analyze_rel(), DropClonedTriggersFromPartition(), dropconstraint_internal(), DropForeignKeyConstraintTriggers(), DropRole(), end_replication_step(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerInvoke(), EventTriggerSQLDrop(), EventTriggerTableRewrite(), exec_eval_simple_expr(), exec_execute_message(), exec_parse_message(), exec_simple_query(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), execute_sql_string(), ExplainOnePlan(), finish_heap_swap(), fmgr_sql(), hashadjustmembers(), ImportForeignSchema(), index_build(), index_create(), IndexSetParentIndex(), InitTempTableNamespace(), insert_element_record(), inv_create(), inv_drop(), inv_truncate(), inv_write(), LogicalRepSyncTableStart(), make_new_heap(), makeConfigurationDependencies(), moveArrayTypeName(), objectNamesToOids(), OperatorShellMake(), OperatorUpd(), pg_import_system_collations(), PortalRunMulti(), ProcedureCreate(), process_single_relation(), ProcessSyncingTablesForApply(), ProcessUtilitySlow(), rebuild_relation_finish_concurrent(), recordExtensionInitPrivWorker(), reindex_index(), reindex_relation(), ReindexRelationConcurrently(), relation_statistics_update(), RelationSetNewRelfilenumber(), RemoveInheritedConstraint(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectPolicy(), RenumberEnumType(), ReplaceRoleInInitPriv(), replorigin_create(), replorigin_drop_by_name(), ri_FastPathBatchFlush(), ri_FastPathCheck(), ri_PerformCheck(), set_attnotnull(), SetDatabaseHasLoginEventTriggers(), SetDefaultACL(), SetMatViewPopulatedState(), shdepReassignOwned(), SPI_cursor_open_internal(), standard_ProcessUtility(), StoreConstraints(), StorePartitionBound(), upsert_pg_statistic(), upsert_pg_statistic_ext_data(), vacuum(), and validatePartitionedIndex().

◆ CommitTransactionCommand()

void CommitTransactionCommand ( void )

extern

Definition at line 3207 of file xact.c.

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

References CommitTransactionCommandInternal().

Referenced by _SPI_commit(), AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_prepare_internal(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), BeginInternalSubTransaction(), BootstrapModeMain(), BuildDatabaseList(), BuildRelationList(), clear_subscription_skip_lsn(), copy_sequences(), DatabaseExists(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), EventTriggerOnLogin(), exec_replication_command(), ExecRepack(), finish_xact_command(), FinishSyncWorker(), get_database_list(), get_subscription_list(), HasSubscriptionTablesCached(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeLogRepWorker(), InitPostgres(), LogicalRepSyncSequences(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), pa_stream_abort(), ParallelApplyWorkerMain(), ParallelWorkerMain(), process_single_relation(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ProcessSequencesForSync(), ProcessSingleRelationByOid(), ProcessSyncingTablesForApply(), ProcessSyncingTablesForSync(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), RepackWorkerMain(), ReplSlotSyncWorkerMain(), run_apply_worker(), shell_check_detail(), stream_abort_internal(), stream_stop_internal(), update_retention_status(), vacuum(), vacuum_rel(), validate_remote_info(), and worker_spi_main().

◆ DefineSavepoint()

void DefineSavepoint ( const char * name )

extern

Definition at line 4424 of file xact.c.

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

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

Referenced by CommitTransactionCommandInternal(), pa_start_subtrans(), and standard_ProcessUtility().

◆ EndImplicitTransactionBlock()

void EndImplicitTransactionBlock ( void )

extern

Definition at line 4402 of file xact.c.

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

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

Referenced by exec_simple_query(), and PostgresMain().

◆ EndParallelWorkerTransaction()

void EndParallelWorkerTransaction ( void )

extern

Definition at line 5687 of file xact.c.

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

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

Referenced by ParallelWorkerMain().

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool chain )

extern

Definition at line 4095 of file xact.c.

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

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

Referenced by apply_handle_commit_internal(), pa_stream_abort(), PrepareTransactionBlock(), and standard_ProcessUtility().

◆ EnterParallelMode()

void EnterParallelMode ( void )

extern

Definition at line 1081 of file xact.c.

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

References Assert, CurrentTransactionState, and TransactionStateData::parallelModeLevel.

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

◆ EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace ( void )

extern

Definition at line 5563 of file xact.c.

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

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

Referenced by InitializeParallelDSM().

◆ ExitParallelMode()

void ExitParallelMode ( void )

extern

Definition at line 1094 of file xact.c.

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

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

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

◆ ForceSyncCommit()

void ForceSyncCommit ( void )

extern

Definition at line 1182 of file xact.c.

{
    forceSyncCommit = true;
}

References forceSyncCommit.

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

◆ GetCurrentCommandId()

CommandId GetCurrentCommandId ( bool used )

extern

Definition at line 831 of file xact.c.

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

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

Referenced by apply_concurrent_delete(), apply_concurrent_insert(), apply_concurrent_update(), ATRewriteTable(), CatalogTuplesMultiInsertWithInfo(), CopyFrom(), create_edata_for_relation(), create_estate_for_relation(), FindConflictTuple(), GetSnapshotData(), GetSnapshotDataReuse(), heap_inplace_lock(), heap_insert_for_repack(), intorel_startup(), MergePartitionsMoveRows(), pgrowlocks(), RegisterRelcacheInvalidation(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), ri_LockPKTuple(), simple_heap_delete(), simple_heap_insert(), simple_heap_update(), simple_table_tuple_delete(), simple_table_tuple_insert(), simple_table_tuple_update(), SplitPartitionMoveRows(), standard_ExecutorStart(), toast_save_datum(), transientrel_startup(), and UpdateActiveSnapshotCommandId().

◆ GetCurrentFullTransactionId()

FullTransactionId GetCurrentFullTransactionId ( void )

extern

Definition at line 514 of file xact.c.

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

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

Referenced by PrepareTransaction().

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void )

extern

Definition at line 532 of file xact.c.

{
    return CurrentTransactionState->fullTransactionId;
}

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void )

extern

Definition at line 881 of file xact.c.

{
    return stmtStartTimestamp;
}

References stmtStartTimestamp.

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

◆ GetCurrentSubTransactionId()

SubTransactionId GetCurrentSubTransactionId ( void )

extern

Definition at line 793 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::subTransactionId.

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

◆ GetCurrentTransactionId()

TransactionId GetCurrentTransactionId ( void )

extern

Definition at line 456 of file xact.c.

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

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

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

◆ GetCurrentTransactionIdIfAny()

TransactionId GetCurrentTransactionIdIfAny ( void )

extern

Definition at line 473 of file xact.c.

{
    return XidFromFullTransactionId(CurrentTransactionState->fullTransactionId);
}

References CurrentTransactionState, TransactionStateData::fullTransactionId, and XidFromFullTransactionId.

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

◆ GetCurrentTransactionNestLevel()

int GetCurrentTransactionNestLevel ( void )

extern

Definition at line 931 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::nestingLevel.

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

◆ GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp ( void )

extern

Definition at line 872 of file xact.c.

{
    return xactStartTimestamp;
}

References xactStartTimestamp.

Referenced by GetCurrentTimeUsec(), GetSQLCurrentTimestamp(), GetSQLLocalTimestamp(), InitializeParallelDSM(), now(), pg_timezone_abbrevs_abbrevs(), pg_timezone_abbrevs_zone(), pg_timezone_names(), and timetz_zone().

◆ GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp ( void )

extern

Definition at line 893 of file xact.c.

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

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

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

◆ GetStableLatestTransactionId()

TransactionId GetStableLatestTransactionId ( void )

extern

Definition at line 609 of file xact.c.

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

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

Referenced by xid_age().

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void )

extern

Definition at line 485 of file xact.c.

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

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

Referenced by pg_current_xact_id().

◆ GetTopFullTransactionIdIfAny()

FullTransactionId GetTopFullTransactionIdIfAny ( void )

extern

Definition at line 501 of file xact.c.

{
    return XactTopFullTransactionId;
}

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

◆ GetTopReadOnlyTransactionNestLevel()

int GetTopReadOnlyTransactionNestLevel ( void )

extern

Definition at line 1062 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
 
    if (!XactReadOnly)
        return 0;
    while (s->nestingLevel > 1)
    {
        if (!s->prevXactReadOnly)
            return s->nestingLevel;
        s = s->parent;
    }
    return s->nestingLevel;
}

References CurrentTransactionState, TransactionStateData::nestingLevel, TransactionStateData::parent, TransactionStateData::prevXactReadOnly, and XactReadOnly.

Referenced by begin_remote_xact().

◆ GetTopTransactionId()

TransactionId GetTopTransactionId ( void )

extern

Definition at line 428 of file xact.c.

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

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

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

◆ GetTopTransactionIdIfAny()

TransactionId GetTopTransactionIdIfAny ( void )

extern

◆ IsAbortedTransactionBlockState()

bool IsAbortedTransactionBlockState ( void )

extern

Definition at line 409 of file xact.c.

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

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

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

◆ IsInParallelMode()

bool IsInParallelMode ( void )

extern

Definition at line 1119 of file xact.c.

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

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

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

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool isTopLevel )

extern

Definition at line 3820 of file xact.c.

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

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

Referenced by vacuum().

◆ IsSubTransaction()

bool IsSubTransaction ( void )

extern

Definition at line 5095 of file xact.c.

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

References CurrentTransactionState, and TransactionStateData::nestingLevel.

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

◆ IsSubxactTopXidLogPending()

bool IsSubxactTopXidLogPending ( void )

extern

Definition at line 561 of file xact.c.

{
    /* check whether it is already logged */
    if (CurrentTransactionState->topXidLogged)
        return false;
 
    /* effective_wal_level has to be logical */
    if (!XLogLogicalInfoActive())
        return false;
 
    /* we need to be in a transaction state */
    if (!IsTransactionState())
        return false;
 
    /* it has to be a subtransaction */
    if (!IsSubTransaction())
        return false;
 
    /* the subtransaction has to have a XID assigned */
    if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny()))
        return false;
 
    return true;
}

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

Referenced by MarkSubxactTopXidLogged(), and XLogRecordAssemble().

◆ IsTransactionBlock()

bool IsTransactionBlock ( void )

extern

Definition at line 5022 of file xact.c.

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

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

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

◆ IsTransactionOrTransactionBlock()

bool IsTransactionOrTransactionBlock ( void )

extern

Definition at line 5040 of file xact.c.

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

References TransactionStateData::blockState, CurrentTransactionState, and TBLOCK_DEFAULT.

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

◆ IsTransactionState()

bool IsTransactionState ( void )

extern

Definition at line 389 of file xact.c.

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

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

Referenced by AcceptInvalidationMessages(), apply_handle_commit_internal(), apply_handle_origin(), assign_transaction_timeout(), begin_replication_step(), check_client_encoding(), check_default_table_access_method(), check_default_tablespace(), check_default_text_search_config(), check_role(), check_session_authorization(), check_temp_tablespaces(), check_transaction_isolation(), check_transaction_read_only(), clear_subscription_skip_lsn(), ConditionalCatalogCacheInitializeCache(), CreateInitDecodingContext(), ensure_last_message(), FetchRelationStates(), FinishSyncWorker(), IsSubxactTopXidLogPending(), LogicalParallelApplyLoop(), LogicalRepApplyLoop(), LogLogicalMessage(), maybe_reread_subscription(), pa_send_data(), pa_start_subtrans(), pg_do_encoding_conversion(), PrepareClientEncoding(), PrepareTempTablespaces(), ProcessSyncingTablesForApply(), ProcessSyncingTablesForSync(), RelationCacheInvalidate(), RelationFlushRelation(), RelationInitPhysicalAddr(), replorigin_create(), replorigin_drop_by_name(), ReplSlotSyncWorkerMain(), SetMultiXactIdLimit(), SetTransactionIdLimit(), SnapBuildClearExportedSnapshot(), SocketBackend(), stream_stop_internal(), SyncReplicationSlots(), update_retention_status(), and validate_remote_info().

◆ MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny ( void )

extern

Definition at line 543 of file xact.c.

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

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

Referenced by XLogInsertRecord().

◆ MarkSubxactTopXidLogged()

void MarkSubxactTopXidLogged ( void )

extern

Definition at line 593 of file xact.c.

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

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

Referenced by XLogInsertRecord().

◆ ParseAbortRecord()

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

extern

Definition at line 141 of file xactdesc.c.

{
    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_RELFILELOCATORS)
    {
        xl_xact_relfilelocators *xl_rellocator = (xl_xact_relfilelocators *) data;
 
        parsed->nrels = xl_rellocator->nrels;
        parsed->xlocators = xl_rellocator->xlocators;
 
        data += MinSizeOfXactRelfileLocators;
        data += xl_rellocator->nrels * sizeof(RelFileLocator);
    }
 
    if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
    {
        xl_xact_stats_items *xl_drops = (xl_xact_stats_items *) data;
 
        parsed->nstats = xl_drops->nitems;
        parsed->stats = xl_drops->items;
 
        data += MinSizeOfXactStatsItems;
        data += xl_drops->nitems * sizeof(xl_xact_stats_item);
    }
 
    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);
    }
}

References data, xl_xact_dbinfo::dbId, fb(), memcpy(), MinSizeOfXactAbort, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, xl_xact_stats_items::nitems, xl_xact_relfilelocators::nrels, xl_xact_subxacts::nsubxacts, strlcpy(), XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, and XLOG_XACT_HAS_INFO.

Referenced by recoveryStopsAfter(), recoveryStopsBefore(), SummarizeXactRecord(), xact_decode(), xact_desc_abort(), and xact_redo().

◆ ParseCommitRecord()

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

extern

Definition at line 35 of file xactdesc.c.

{
    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_RELFILELOCATORS)
    {
        xl_xact_relfilelocators *xl_rellocators = (xl_xact_relfilelocators *) data;
 
        parsed->nrels = xl_rellocators->nrels;
        parsed->xlocators = xl_rellocators->xlocators;
 
        data += MinSizeOfXactRelfileLocators;
        data += xl_rellocators->nrels * sizeof(RelFileLocator);
    }
 
    if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
    {
        xl_xact_stats_items *xl_drops = (xl_xact_stats_items *) data;
 
        parsed->nstats = xl_drops->nitems;
        parsed->stats = xl_drops->items;
 
        data += MinSizeOfXactStatsItems;
        data += xl_drops->nitems * sizeof(xl_xact_stats_item);
    }
 
    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);
    }
}

References data, xl_xact_dbinfo::dbId, fb(), memcpy(), MinSizeOfXactCommit, MinSizeOfXactInvals, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, xl_xact_stats_items::nitems, xl_xact_invals::nmsgs, xl_xact_relfilelocators::nrels, xl_xact_subxacts::nsubxacts, strlcpy(), XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_INVALS, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, xl_xact_twophase::xid, xl_xact_xinfo::xinfo, and XLOG_XACT_HAS_INFO.

Referenced by recoveryStopsAfter(), recoveryStopsBefore(), SummarizeXactRecord(), xact_decode(), xact_desc_commit(), and xact_redo().

◆ ParsePrepareRecord()

void ParsePrepareRecord	(	uint8	info,
		xl_xact_prepare *	xlrec,
		xl_xact_parsed_prepare *	parsed
	)

extern

Definition at line 239 of file xactdesc.c.

{
    char       *bufptr;
 
    bufptr = ((char *) xlrec) + MAXALIGN(sizeof(xl_xact_prepare));
 
    memset(parsed, 0, sizeof(*parsed));
 
    parsed->xact_time = xlrec->prepared_at;
    parsed->origin_lsn = xlrec->origin_lsn;
    parsed->origin_timestamp = xlrec->origin_timestamp;
    parsed->twophase_xid = xlrec->xid;
    parsed->dbId = xlrec->database;
    parsed->nsubxacts = xlrec->nsubxacts;
    parsed->nrels = xlrec->ncommitrels;
    parsed->nabortrels = xlrec->nabortrels;
    parsed->nstats = xlrec->ncommitstats;
    parsed->nabortstats = xlrec->nabortstats;
    parsed->nmsgs = xlrec->ninvalmsgs;
 
    strncpy(parsed->twophase_gid, bufptr, xlrec->gidlen);
    bufptr += MAXALIGN(xlrec->gidlen);
 
    parsed->subxacts = (TransactionId *) bufptr;
    bufptr += MAXALIGN(xlrec->nsubxacts * sizeof(TransactionId));
 
    parsed->xlocators = (RelFileLocator *) bufptr;
    bufptr += MAXALIGN(xlrec->ncommitrels * sizeof(RelFileLocator));
 
    parsed->abortlocators = (RelFileLocator *) bufptr;
    bufptr += MAXALIGN(xlrec->nabortrels * sizeof(RelFileLocator));
 
    parsed->stats = (xl_xact_stats_item *) bufptr;
    bufptr += MAXALIGN(xlrec->ncommitstats * sizeof(xl_xact_stats_item));
 
    parsed->abortstats = (xl_xact_stats_item *) bufptr;
    bufptr += MAXALIGN(xlrec->nabortstats * sizeof(xl_xact_stats_item));
 
    parsed->msgs = (SharedInvalidationMessage *) bufptr;
    bufptr += MAXALIGN(xlrec->ninvalmsgs * sizeof(SharedInvalidationMessage));
}

References fb(), and MAXALIGN.

Referenced by xact_decode(), and xact_desc_prepare().

◆ PrepareTransactionBlock()

bool PrepareTransactionBlock ( const char * gid )

extern

Definition at line 4043 of file xact.c.

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

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

Referenced by apply_handle_prepare_internal(), and standard_ProcessUtility().

◆ PreventInTransactionBlock()

void PreventInTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

extern

Definition at line 3698 of file xact.c.

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

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

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

◆ RegisterSubXactCallback()

void RegisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

extern

Definition at line 3915 of file xact.c.

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

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

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

◆ RegisterXactCallback()

void RegisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

extern

Definition at line 3855 of file xact.c.

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

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

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

◆ ReleaseCurrentSubTransaction()

void ReleaseCurrentSubTransaction ( void )

extern

Definition at line 4819 of file xact.c.

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

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

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

◆ ReleaseSavepoint()

void ReleaseSavepoint ( const char * name )

extern

Definition at line 4509 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
    TransactionState target,
                xact;
 
    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for transaction state change after that
     * point.  (Note that this check will certainly error out if s->blockState
     * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
     * below.)
     */
    if (IsInParallelMode() || IsParallelWorker())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot release savepoints during a parallel operation")));
 
    switch (s->blockState)
    {
            /*
             * We can't release a savepoint if there is no savepoint defined.
             */
        case TBLOCK_INPROGRESS:
            ereport(ERROR,
                    (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                     errmsg("savepoint \"%s\" does not exist", name)));
            break;
 
        case TBLOCK_IMPLICIT_INPROGRESS:
            /* See comment about implicit transactions in DefineSavepoint */
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                            "RELEASE SAVEPOINT")));
            break;
 
            /*
             * We are in a non-aborted subtransaction.  This is the only valid
             * case.
             */
        case TBLOCK_SUBINPROGRESS:
            break;
 
            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT:
        case TBLOCK_SUBABORT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "ReleaseSavepoint: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
 
    for (target = s; target; target = target->parent)
    {
        if (target->name && strcmp(target->name, name) == 0)
            break;
    }
 
    if (!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(xact);
    }
}

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

Referenced by standard_ProcessUtility().

◆ RequireTransactionBlock()

void RequireTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

extern

Definition at line 3767 of file xact.c.

{
    CheckTransactionBlock(isTopLevel, true, stmtType);
}

References CheckTransactionBlock(), and fb().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

◆ RestoreTransactionCharacteristics()

void RestoreTransactionCharacteristics ( const SavedTransactionCharacteristics * s )

extern

Definition at line 3194 of file xact.c.

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

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

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

◆ RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction ( void )

extern

Definition at line 4847 of file xact.c.

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

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

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

◆ RollbackToSavepoint()

void RollbackToSavepoint ( const char * name )

extern

Definition at line 4618 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
    TransactionState target,
                xact;
 
    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for transaction state change after that
     * point.  (Note that this check will certainly error out if s->blockState
     * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
     * below.)
     */
    if (IsInParallelMode() || IsParallelWorker())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot rollback to savepoints during a parallel operation")));
 
    switch (s->blockState)
    {
            /*
             * We can't rollback to a savepoint if there is no savepoint
             * defined.
             */
        case TBLOCK_INPROGRESS:
        case TBLOCK_ABORT:
            ereport(ERROR,
                    (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
                     errmsg("savepoint \"%s\" does not exist", name)));
            break;
 
        case TBLOCK_IMPLICIT_INPROGRESS:
            /* See comment about implicit transactions in DefineSavepoint */
            ereport(ERROR,
                    (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
            /* translator: %s represents an SQL statement name */
                     errmsg("%s can only be used in transaction blocks",
                            "ROLLBACK TO SAVEPOINT")));
            break;
 
            /*
             * There is at least one savepoint, so proceed.
             */
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_SUBABORT:
            break;
 
            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_STARTED:
        case TBLOCK_BEGIN:
        case TBLOCK_PARALLEL_INPROGRESS:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "RollbackToSavepoint: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
 
    for (target = s; target; target = target->parent)
    {
        if (target->name && strcmp(target->name, name) == 0)
            break;
    }
 
    if (!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(xact);
    }
 
    /* And mark the target as "restart pending" */
    if (xact->blockState == TBLOCK_SUBINPROGRESS)
        xact->blockState = TBLOCK_SUBRESTART;
    else if (xact->blockState == TBLOCK_SUBABORT)
        xact->blockState = TBLOCK_SUBABORT_RESTART;
    else
        elog(FATAL, "RollbackToSavepoint: unexpected state %s",
             BlockStateAsString(xact->blockState));
}

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

Referenced by pa_stream_abort(), and standard_ProcessUtility().

◆ SaveTransactionCharacteristics()

void SaveTransactionCharacteristics ( SavedTransactionCharacteristics * s )

extern

Definition at line 3186 of file xact.c.

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

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

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

◆ SerializeTransactionState()

void SerializeTransactionState	(	Size	maxsize,
		char *	start_address
	)

extern

Definition at line 5591 of file xact.c.

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

References add_size(), Assert, TransactionStateData::childXids, currentCommandId, CurrentTransactionState, fb(), TransactionStateData::fullTransactionId, FullTransactionIdIsValid, i, memcpy(), TransactionStateData::nChildXids, nParallelCurrentXids, palloc(), ParallelCurrentXids, TransactionStateData::parent, qsort, result, SerializedTransactionStateHeaderSize, XactDeferrable, XactIsoLevel, SerializedTransactionState::xactIsoLevel, XactTopFullTransactionId, xidComparator(), and XidFromFullTransactionId.

Referenced by InitializeParallelDSM().

◆ SetCurrentStatementStartTimestamp()

void SetCurrentStatementStartTimestamp ( void )

extern

Definition at line 916 of file xact.c.

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

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

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

◆ SetParallelStartTimestamps()

void SetParallelStartTimestamps	(	TimestampTz	xact_ts,
		TimestampTz	stmt_ts
	)

extern

Definition at line 861 of file xact.c.

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

References Assert, IsParallelWorker, stmtStartTimestamp, and xactStartTimestamp.

Referenced by ParallelWorkerMain().

◆ StartParallelWorkerTransaction()

void StartParallelWorkerTransaction ( char * tstatespace )

extern

Definition at line 5662 of file xact.c.

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

References Assert, TransactionStateData::blockState, currentCommandId, CurrentTransactionState, fb(), TransactionStateData::fullTransactionId, nParallelCurrentXids, ParallelCurrentXids, StartTransaction(), TBLOCK_DEFAULT, TBLOCK_PARALLEL_INPROGRESS, XactDeferrable, XactIsoLevel, and XactTopFullTransactionId.

Referenced by ParallelWorkerMain().

◆ StartTransactionCommand()

void StartTransactionCommand ( void )

extern

Definition at line 3109 of file xact.c.

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

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

Referenced by _SPI_commit(), _SPI_rollback(), apply_handle_commit_internal(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), begin_replication_step(), BeginInternalSubTransaction(), BootstrapModeMain(), BuildDatabaseList(), BuildRelationList(), clear_subscription_skip_lsn(), copy_sequences(), DatabaseExists(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), EventTriggerOnLogin(), exec_replication_command(), ExecRepack(), FetchRelationStates(), FinishSyncWorker(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeLogRepWorker(), InitPostgres(), LogicalRepSyncSequences(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), ParallelApplyWorkerMain(), ParallelWorkerMain(), perform_work_item(), process_single_relation(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ProcessSingleRelationByOid(), ProcessSyncingTablesForApply(), ProcessSyncingTablesForSync(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), ReorderBufferProcessTXN(), RepackWorkerMain(), ReplSlotSyncWorkerMain(), run_apply_worker(), shell_check_detail(), SnapBuildExportSnapshot(), start_xact_command(), update_retention_status(), vacuum(), vacuum_rel(), validate_remote_info(), and worker_spi_main().

◆ SubTransactionIsActive()

bool SubTransactionIsActive ( SubTransactionId subxid )

extern

Definition at line 807 of file xact.c.

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

References CurrentTransactionState, fb(), TransactionStateData::parent, TransactionStateData::state, TransactionStateData::subTransactionId, and TRANS_ABORT.

◆ TransactionBlockStatusCode()

char TransactionBlockStatusCode ( void )

extern

Definition at line 5054 of file xact.c.

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

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

Referenced by ReadyForQuery().

◆ TransactionIdIsCurrentTransactionId()

bool TransactionIdIsCurrentTransactionId ( TransactionId xid )

extern

Definition at line 943 of file xact.c.

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

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

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

◆ UnregisterSubXactCallback()

void UnregisterSubXactCallback	(	SubXactCallback	callback,
		void *	arg
	)

extern

Definition at line 3928 of file xact.c.

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

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

◆ UnregisterXactCallback()

void UnregisterXactCallback	(	XactCallback	callback,
		void *	arg
	)

extern

Definition at line 3868 of file xact.c.

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

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

◆ UserAbortTransactionBlock()

void UserAbortTransactionBlock ( bool chain )

extern

Definition at line 4255 of file xact.c.

{
    TransactionState s = CurrentTransactionState;
 
    switch (s->blockState)
    {
            /*
             * We are inside a transaction block and we got a ROLLBACK command
             * from the user, so tell CommitTransactionCommand to abort and
             * exit the transaction block.
             */
        case TBLOCK_INPROGRESS:
            s->blockState = TBLOCK_ABORT_PENDING;
            break;
 
            /*
             * We are inside a failed transaction block and we got a ROLLBACK
             * command from the user.  Abort processing is already done, so
             * CommitTransactionCommand just has to cleanup and go back to
             * idle state.
             */
        case TBLOCK_ABORT:
            s->blockState = TBLOCK_ABORT_END;
            break;
 
            /*
             * We are inside a subtransaction.  Mark everything up to top
             * level as exitable.
             */
        case TBLOCK_SUBINPROGRESS:
        case TBLOCK_SUBABORT:
            while (s->parent != NULL)
            {
                if (s->blockState == TBLOCK_SUBINPROGRESS)
                    s->blockState = TBLOCK_SUBABORT_PENDING;
                else if (s->blockState == TBLOCK_SUBABORT)
                    s->blockState = TBLOCK_SUBABORT_END;
                else
                    elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                         BlockStateAsString(s->blockState));
                s = s->parent;
            }
            if (s->blockState == TBLOCK_INPROGRESS)
                s->blockState = TBLOCK_ABORT_PENDING;
            else if (s->blockState == TBLOCK_ABORT)
                s->blockState = TBLOCK_ABORT_END;
            else
                elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                     BlockStateAsString(s->blockState));
            break;
 
            /*
             * The user issued ABORT when not inside a transaction.  For
             * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
             * The upcoming call to CommitTransactionCommand() will then put
             * us back into the default state.  For ROLLBACK AND CHAIN, error.
             *
             * We do the same thing with ABORT inside an implicit transaction,
             * although in this case we might be rolling back actual database
             * state changes.  (It's debatable whether we should issue a
             * WARNING in this case, but we have done so historically.)
             */
        case TBLOCK_STARTED:
        case TBLOCK_IMPLICIT_INPROGRESS:
            if (chain)
                ereport(ERROR,
                        (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                /* translator: %s represents an SQL statement name */
                         errmsg("%s can only be used in transaction blocks",
                                "ROLLBACK AND CHAIN")));
            else
                ereport(WARNING,
                        (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
                         errmsg("there is no transaction in progress")));
            s->blockState = TBLOCK_ABORT_PENDING;
            break;
 
            /*
             * The user issued an ABORT that somehow ran inside a parallel
             * worker.  We can't cope with that.
             */
        case TBLOCK_PARALLEL_INPROGRESS:
            ereport(FATAL,
                    (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                     errmsg("cannot abort during a parallel operation")));
            break;
 
            /* These cases are invalid. */
        case TBLOCK_DEFAULT:
        case TBLOCK_BEGIN:
        case TBLOCK_SUBBEGIN:
        case TBLOCK_END:
        case TBLOCK_SUBRELEASE:
        case TBLOCK_SUBCOMMIT:
        case TBLOCK_ABORT_END:
        case TBLOCK_SUBABORT_END:
        case TBLOCK_ABORT_PENDING:
        case TBLOCK_SUBABORT_PENDING:
        case TBLOCK_SUBRESTART:
        case TBLOCK_SUBABORT_RESTART:
        case TBLOCK_PREPARE:
            elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
                 BlockStateAsString(s->blockState));
            break;
    }
 
    Assert(s->blockState == TBLOCK_ABORT_END ||
           s->blockState == TBLOCK_ABORT_PENDING);
 
    s->chain = chain;
}

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

Referenced by standard_ProcessUtility().

◆ WarnNoTransactionBlock()

void WarnNoTransactionBlock	(	bool	isTopLevel,
		const char *	stmtType
	)

extern

Definition at line 3761 of file xact.c.

{
    CheckTransactionBlock(isTopLevel, false, stmtType);
}

References CheckTransactionBlock(), and fb().

Referenced by ExecSetVariableStmt(), and standard_ProcessUtility().

◆ xact_desc()

void xact_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

extern

Definition at line 439 of file xactdesc.c.

{
    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,
                        XLogRecGetOrigin(record));
    }
    else if (info == XLOG_XACT_PREPARE)
    {
        xl_xact_prepare *xlrec = (xl_xact_prepare *) rec;
 
        xact_desc_prepare(buf, XLogRecGetInfo(record), xlrec,
                          XLogRecGetOrigin(record));
    }
    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);
    }
    else if (info == XLOG_XACT_INVALIDATIONS)
    {
        xl_xact_invals *xlrec = (xl_xact_invals *) rec;
 
        standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs, InvalidOid,
                                   InvalidOid, false);
    }
}

References appendStringInfo(), buf, fb(), InvalidOid, standby_desc_invalidations(), xact_desc_abort(), xact_desc_assignment(), xact_desc_commit(), xact_desc_prepare(), XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_ASSIGNMENT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_INVALIDATIONS, XLOG_XACT_OPMASK, XLOG_XACT_PREPARE, XLogRecGetData, XLogRecGetInfo, and XLogRecGetOrigin.

◆ xact_identify()

const char * xact_identify ( uint8 info )

extern

Definition at line 487 of file xactdesc.c.

{
    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;
        case XLOG_XACT_INVALIDATIONS:
            id = "INVALIDATION";
            break;
    }
 
    return id;
}

References fb(), XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_ASSIGNMENT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_INVALIDATIONS, XLOG_XACT_OPMASK, and XLOG_XACT_PREPARE.

◆ xact_redo()

void xact_redo ( XLogReaderState * record )

extern

Definition at line 6414 of file xact.c.

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

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

◆ xactGetCommittedChildren()

int xactGetCommittedChildren ( TransactionId ** ptr )

extern

Definition at line 5841 of file xact.c.

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

References TransactionStateData::childXids, CurrentTransactionState, fb(), and TransactionStateData::nChildXids.

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

◆ XactLogAbortRecord()

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

extern

Definition at line 6037 of file xact.c.

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

References Assert, CritSectionCount, fb(), InvalidReplOriginId, MinSizeOfXactAbort, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, MyDatabaseId, MyDatabaseTableSpace, ReplOriginXactState::origin, ReplOriginXactState::origin_lsn, ReplOriginXactState::origin_timestamp, replorigin_xact_state, TransactionIdIsValid, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, XACT_XINFO_HAS_AE_LOCKS, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, XLOG_INCLUDE_ORIGIN, XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_HAS_INFO, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogSetRecordFlags(), and XLR_SPECIAL_REL_UPDATE.

Referenced by RecordTransactionAbort(), and RecordTransactionAbortPrepared().

◆ XactLogCommitRecord()

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

extern

Definition at line 5865 of file xact.c.

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

References Assert, CritSectionCount, fb(), forceSyncCommit, InvalidReplOriginId, MinSizeOfXactInvals, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, MyDatabaseId, MyDatabaseTableSpace, ReplOriginXactState::origin, ReplOriginXactState::origin_lsn, ReplOriginXactState::origin_timestamp, replorigin_xact_state, synchronous_commit, SYNCHRONOUS_COMMIT_REMOTE_APPLY, TransactionIdIsValid, XACT_COMPLETION_APPLY_FEEDBACK, XACT_COMPLETION_FORCE_SYNC_COMMIT, XACT_COMPLETION_UPDATE_RELCACHE_FILE, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, XACT_XINFO_HAS_AE_LOCKS, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_DROPPED_STATS, XACT_XINFO_HAS_GID, XACT_XINFO_HAS_INVALS, XACT_XINFO_HAS_ORIGIN, XACT_XINFO_HAS_RELFILELOCATORS, XACT_XINFO_HAS_SUBXACTS, XACT_XINFO_HAS_TWOPHASE, XLOG_INCLUDE_ORIGIN, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_HAS_INFO, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogSetRecordFlags(), and XLR_SPECIAL_REL_UPDATE.

Referenced by RecordTransactionCommit(), and RecordTransactionCommitPrepared().

Variable Documentation

◆ bsysscan

PGDLLIMPORT bool bsysscan

extern

Definition at line 102 of file xact.c.

Referenced by ResetLogicalStreamingState(), systable_beginscan(), systable_beginscan_ordered(), systable_endscan(), systable_endscan_ordered(), table_beginscan_common(), table_index_fetch_begin(), and table_tuple_fetch_row_version().

◆ CheckXidAlive

PGDLLIMPORT TransactionId CheckXidAlive

extern

Definition at line 101 of file xact.c.

Referenced by HandleConcurrentAbort(), ReorderBufferProcessTXN(), ReorderBufferStreamCommit(), ResetLogicalStreamingState(), SetupCheckXidLive(), systable_beginscan(), systable_beginscan_ordered(), systable_endscan(), systable_endscan_ordered(), table_beginscan_common(), table_index_fetch_begin(), and table_tuple_fetch_row_version().

◆ DefaultXactDeferrable

PGDLLIMPORT bool DefaultXactDeferrable

extern

Definition at line 86 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactIsoLevel

PGDLLIMPORT int DefaultXactIsoLevel

extern

Definition at line 80 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactReadOnly

PGDLLIMPORT bool DefaultXactReadOnly

extern

Definition at line 83 of file xact.c.

Referenced by StartTransaction().

◆ MyXactFlags

◆ synchronous_commit

PGDLLIMPORT int synchronous_commit

extern

Definition at line 89 of file xact.c.

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

◆ xact_is_sampled

PGDLLIMPORT bool xact_is_sampled

extern

Definition at line 298 of file xact.c.

Referenced by check_log_duration(), and StartTransaction().

◆ XactDeferrable

PGDLLIMPORT bool XactDeferrable

extern

Definition at line 87 of file xact.c.

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

◆ XactIsoLevel

PGDLLIMPORT int XactIsoLevel

extern

Definition at line 81 of file xact.c.

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

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 }

Variables
PGDLLIMPORT int	DefaultXactIsoLevel

PGDLLIMPORT int	XactIsoLevel

PGDLLIMPORT bool	DefaultXactReadOnly

PGDLLIMPORT bool	XactReadOnly

PGDLLIMPORT bool	xact_is_sampled

PGDLLIMPORT bool	DefaultXactDeferrable

PGDLLIMPORT bool	XactDeferrable

PGDLLIMPORT int	synchronous_commit

PGDLLIMPORT TransactionId	CheckXidAlive

PGDLLIMPORT bool	bsysscan

PGDLLIMPORT int	MyXactFlags

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ GIDSIZE

◆ IsolationIsSerializable

◆ IsolationUsesXactSnapshot

◆ MinSizeOfXactAbort

◆ MinSizeOfXactAssignment

◆ MinSizeOfXactCommit

◆ MinSizeOfXactInvals

◆ MinSizeOfXactRelfileLocators

◆ MinSizeOfXactStatsItems

◆ MinSizeOfXactSubxacts

◆ SYNCHRONOUS_COMMIT_ON

◆ XACT_COMPLETION_APPLY_FEEDBACK

◆ XACT_COMPLETION_FORCE_SYNC_COMMIT

◆ XACT_COMPLETION_UPDATE_RELCACHE_FILE

◆ XACT_FLAGS_ACCESSEDTEMPNAMESPACE

◆ XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK

◆ XACT_FLAGS_NEEDIMMEDIATECOMMIT

◆ XACT_FLAGS_PIPELINING

◆ XACT_READ_COMMITTED

◆ XACT_READ_UNCOMMITTED

◆ XACT_REPEATABLE_READ

◆ XACT_SERIALIZABLE

◆ XACT_XINFO_HAS_AE_LOCKS

◆ XACT_XINFO_HAS_DBINFO

◆ XACT_XINFO_HAS_DROPPED_STATS

◆ XACT_XINFO_HAS_GID

◆ XACT_XINFO_HAS_INVALS

◆ XACT_XINFO_HAS_ORIGIN

◆ XACT_XINFO_HAS_RELFILELOCATORS

◆ XACT_XINFO_HAS_SUBXACTS

◆ XACT_XINFO_HAS_TWOPHASE

◆ XactCompletionApplyFeedback

◆ XactCompletionForceSyncCommit

◆ XactCompletionRelcacheInitFileInval

◆ XLOG_XACT_ABORT

◆ XLOG_XACT_ABORT_PREPARED

◆ XLOG_XACT_ASSIGNMENT

◆ XLOG_XACT_COMMIT

◆ XLOG_XACT_COMMIT_PREPARED

◆ XLOG_XACT_HAS_INFO

◆ XLOG_XACT_INVALIDATIONS

◆ XLOG_XACT_OPMASK

◆ XLOG_XACT_PREPARE

Typedef Documentation

◆ SavedTransactionCharacteristics

◆ SubXactCallback

◆ XactCallback

◆ xl_xact_abort

◆ xl_xact_assignment

◆ xl_xact_commit

◆ xl_xact_dbinfo

◆ xl_xact_invals

◆ xl_xact_origin

◆ xl_xact_parsed_abort

◆ xl_xact_parsed_commit

◆ xl_xact_parsed_prepare

◆ xl_xact_prepare

◆ xl_xact_relfilelocators

◆ xl_xact_stats_item

◆ xl_xact_stats_items

◆ xl_xact_subxacts

◆ xl_xact_twophase

◆ xl_xact_xinfo

Enumeration Type Documentation

◆ SubXactEvent

◆ SyncCommitLevel

◆ XactEvent

Function Documentation

◆ AbortCurrentTransaction()

◆ AbortOutOfAnyTransaction()

◆ BeginImplicitTransactionBlock()

◆ BeginInternalSubTransaction()

◆ BeginTransactionBlock()