PostgreSQL Source Code  git master
xact.h File Reference
#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
 

Enumerations

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

Functions

bool IsTransactionState (void)
 
bool IsAbortedTransactionBlockState (void)
 
TransactionId GetTopTransactionId (void)
 
TransactionId GetTopTransactionIdIfAny (void)
 
TransactionId GetCurrentTransactionId (void)
 
TransactionId GetCurrentTransactionIdIfAny (void)
 
TransactionId GetStableLatestTransactionId (void)
 
SubTransactionId GetCurrentSubTransactionId (void)
 
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)
 
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)
 

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
 

Macro Definition Documentation

◆ GIDSIZE

#define GIDSIZE   200

Definition at line 31 of file xact.h.

◆ IsolationIsSerializable

#define IsolationIsSerializable ( )    (XactIsoLevel == XACT_SERIALIZABLE)

Definition at line 52 of file xact.h.

◆ IsolationUsesXactSnapshot

#define IsolationUsesXactSnapshot ( )    (XactIsoLevel >= XACT_REPEATABLE_READ)

Definition at line 51 of file xact.h.

◆ MinSizeOfXactAbort

#define MinSizeOfXactAbort   sizeof(xl_xact_abort)

Definition at line 344 of file xact.h.

◆ MinSizeOfXactAssignment

#define MinSizeOfXactAssignment   offsetof(xl_xact_assignment, xsub)

Definition at line 225 of file xact.h.

◆ MinSizeOfXactCommit

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

Definition at line 328 of file xact.h.

◆ MinSizeOfXactInvals

#define MinSizeOfXactInvals   offsetof(xl_xact_invals, msgs)

Definition at line 301 of file xact.h.

◆ MinSizeOfXactRelfileLocators

#define MinSizeOfXactRelfileLocators   offsetof(xl_xact_relfilelocators, xlocators)

Definition at line 273 of file xact.h.

◆ MinSizeOfXactStatsItems

#define MinSizeOfXactStatsItems   offsetof(xl_xact_stats_items, items)

Definition at line 294 of file xact.h.

◆ MinSizeOfXactSubxacts

#define MinSizeOfXactSubxacts   offsetof(xl_xact_subxacts, subxacts)

Definition at line 266 of file xact.h.

◆ SYNCHRONOUS_COMMIT_ON

#define SYNCHRONOUS_COMMIT_ON   SYNCHRONOUS_COMMIT_REMOTE_FLUSH

Definition at line 80 of file xact.h.

◆ XACT_COMPLETION_APPLY_FEEDBACK

#define XACT_COMPLETION_APPLY_FEEDBACK   (1U << 29)

Definition at line 206 of file xact.h.

◆ XACT_COMPLETION_FORCE_SYNC_COMMIT

#define XACT_COMPLETION_FORCE_SYNC_COMMIT   (1U << 31)

Definition at line 208 of file xact.h.

◆ XACT_COMPLETION_UPDATE_RELCACHE_FILE

#define XACT_COMPLETION_UPDATE_RELCACHE_FILE   (1U << 30)

Definition at line 207 of file xact.h.

◆ XACT_FLAGS_ACCESSEDTEMPNAMESPACE

#define XACT_FLAGS_ACCESSEDTEMPNAMESPACE   (1U << 0)

Definition at line 102 of file xact.h.

◆ XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK

#define XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK   (1U << 1)

Definition at line 108 of file xact.h.

◆ XACT_FLAGS_NEEDIMMEDIATECOMMIT

#define XACT_FLAGS_NEEDIMMEDIATECOMMIT   (1U << 2)

Definition at line 114 of file xact.h.

◆ XACT_FLAGS_PIPELINING

#define XACT_FLAGS_PIPELINING   (1U << 3)

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

◆ XACT_XINFO_HAS_DBINFO

#define XACT_XINFO_HAS_DBINFO   (1U << 0)

Definition at line 188 of file xact.h.

◆ XACT_XINFO_HAS_DROPPED_STATS

#define XACT_XINFO_HAS_DROPPED_STATS   (1U << 8)

Definition at line 196 of file xact.h.

◆ XACT_XINFO_HAS_GID

#define XACT_XINFO_HAS_GID   (1U << 7)

Definition at line 195 of file xact.h.

◆ XACT_XINFO_HAS_INVALS

#define XACT_XINFO_HAS_INVALS   (1U << 3)

Definition at line 191 of file xact.h.

◆ XACT_XINFO_HAS_ORIGIN

#define XACT_XINFO_HAS_ORIGIN   (1U << 5)

Definition at line 193 of file xact.h.

◆ XACT_XINFO_HAS_RELFILELOCATORS

#define XACT_XINFO_HAS_RELFILELOCATORS   (1U << 2)

Definition at line 190 of file xact.h.

◆ XACT_XINFO_HAS_SUBXACTS

#define XACT_XINFO_HAS_SUBXACTS   (1U << 1)

Definition at line 189 of file xact.h.

◆ XACT_XINFO_HAS_TWOPHASE

#define XACT_XINFO_HAS_TWOPHASE   (1U << 4)

Definition at line 192 of file xact.h.

◆ XactCompletionApplyFeedback

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

Definition at line 211 of file xact.h.

◆ XactCompletionForceSyncCommit

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

Definition at line 215 of file xact.h.

◆ XactCompletionRelcacheInitFileInval

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

Definition at line 213 of file xact.h.

◆ XLOG_XACT_ABORT

#define XLOG_XACT_ABORT   0x20

Definition at line 171 of file xact.h.

◆ XLOG_XACT_ABORT_PREPARED

#define XLOG_XACT_ABORT_PREPARED   0x40

Definition at line 173 of file xact.h.

◆ XLOG_XACT_ASSIGNMENT

#define XLOG_XACT_ASSIGNMENT   0x50

Definition at line 174 of file xact.h.

◆ XLOG_XACT_COMMIT

#define XLOG_XACT_COMMIT   0x00

Definition at line 169 of file xact.h.

◆ XLOG_XACT_COMMIT_PREPARED

#define XLOG_XACT_COMMIT_PREPARED   0x30

Definition at line 172 of file xact.h.

◆ XLOG_XACT_HAS_INFO

#define XLOG_XACT_HAS_INFO   0x80

Definition at line 182 of file xact.h.

◆ XLOG_XACT_INVALIDATIONS

#define XLOG_XACT_INVALIDATIONS   0x60

Definition at line 175 of file xact.h.

◆ XLOG_XACT_OPMASK

#define XLOG_XACT_OPMASK   0x70

Definition at line 179 of file xact.h.

◆ XLOG_XACT_PREPARE

#define XLOG_XACT_PREPARE   0x10

Definition at line 170 of file xact.h.

Typedef Documentation

◆ SavedTransactionCharacteristics

◆ SubXactCallback

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

Definition at line 148 of file xact.h.

◆ XactCallback

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

Definition at line 138 of file xact.h.

◆ xl_xact_abort

typedef struct xl_xact_abort 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

Definition at line 402 of file xact.h.

◆ xl_xact_prepare

◆ xl_xact_relfilelocators

◆ xl_xact_stats_item

◆ xl_xact_stats_items

◆ xl_xact_subxacts

◆ xl_xact_twophase

◆ xl_xact_xinfo

typedef struct xl_xact_xinfo xl_xact_xinfo

Enumeration Type Documentation

◆ SubXactEvent

Enumerator
SUBXACT_EVENT_START_SUB 
SUBXACT_EVENT_COMMIT_SUB 
SUBXACT_EVENT_ABORT_SUB 
SUBXACT_EVENT_PRE_COMMIT_SUB 

Definition at line 140 of file xact.h.

141 {
146 } SubXactEvent;
SubXactEvent
Definition: xact.h:141
@ SUBXACT_EVENT_PRE_COMMIT_SUB
Definition: xact.h:145
@ SUBXACT_EVENT_START_SUB
Definition: xact.h:142
@ SUBXACT_EVENT_ABORT_SUB
Definition: xact.h:144
@ SUBXACT_EVENT_COMMIT_SUB
Definition: xact.h:143

◆ SyncCommitLevel

Enumerator
SYNCHRONOUS_COMMIT_OFF 
SYNCHRONOUS_COMMIT_LOCAL_FLUSH 
SYNCHRONOUS_COMMIT_REMOTE_WRITE 
SYNCHRONOUS_COMMIT_REMOTE_FLUSH 
SYNCHRONOUS_COMMIT_REMOTE_APPLY 

Definition at line 68 of file xact.h.

69 {
70  SYNCHRONOUS_COMMIT_OFF, /* asynchronous commit */
71  SYNCHRONOUS_COMMIT_LOCAL_FLUSH, /* wait for local flush only */
72  SYNCHRONOUS_COMMIT_REMOTE_WRITE, /* wait for local flush and remote
73  * write */
74  SYNCHRONOUS_COMMIT_REMOTE_FLUSH, /* wait for local and remote flush */
75  SYNCHRONOUS_COMMIT_REMOTE_APPLY /* wait for local and remote flush and
76  * remote apply */
SyncCommitLevel
Definition: xact.h:69
@ SYNCHRONOUS_COMMIT_LOCAL_FLUSH
Definition: xact.h:71
@ SYNCHRONOUS_COMMIT_REMOTE_WRITE
Definition: xact.h:72
@ SYNCHRONOUS_COMMIT_REMOTE_APPLY
Definition: xact.h:75
@ SYNCHRONOUS_COMMIT_REMOTE_FLUSH
Definition: xact.h:74
@ SYNCHRONOUS_COMMIT_OFF
Definition: xact.h:70

◆ 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 126 of file xact.h.

127 {
136 } XactEvent;
XactEvent
Definition: xact.h:127
@ XACT_EVENT_PRE_PREPARE
Definition: xact.h:135
@ XACT_EVENT_COMMIT
Definition: xact.h:128
@ XACT_EVENT_PARALLEL_PRE_COMMIT
Definition: xact.h:134
@ XACT_EVENT_PARALLEL_COMMIT
Definition: xact.h:129
@ XACT_EVENT_ABORT
Definition: xact.h:130
@ XACT_EVENT_PRE_COMMIT
Definition: xact.h:133
@ XACT_EVENT_PARALLEL_ABORT
Definition: xact.h:131
@ XACT_EVENT_PREPARE
Definition: xact.h:132

Function Documentation

◆ AbortCurrentTransaction()

void AbortCurrentTransaction ( void  )

Definition at line 3312 of file xact.c.

3313 {
3315 
3316  switch (s->blockState)
3317  {
3318  case TBLOCK_DEFAULT:
3319  if (s->state == TRANS_DEFAULT)
3320  {
3321  /* we are idle, so nothing to do */
3322  }
3323  else
3324  {
3325  /*
3326  * We can get here after an error during transaction start
3327  * (state will be TRANS_START). Need to clean up the
3328  * incompletely started transaction. First, adjust the
3329  * low-level state to suppress warning message from
3330  * AbortTransaction.
3331  */
3332  if (s->state == TRANS_START)
3333  s->state = TRANS_INPROGRESS;
3334  AbortTransaction();
3336  }
3337  break;
3338 
3339  /*
3340  * If we aren't in a transaction block, we just do the basic abort
3341  * & cleanup transaction. For this purpose, we treat an implicit
3342  * transaction block as if it were a simple statement.
3343  */
3344  case TBLOCK_STARTED:
3346  AbortTransaction();
3349  break;
3350 
3351  /*
3352  * If we are in TBLOCK_BEGIN it means something screwed up right
3353  * after reading "BEGIN TRANSACTION". We assume that the user
3354  * will interpret the error as meaning the BEGIN failed to get him
3355  * into a transaction block, so we should abort and return to idle
3356  * state.
3357  */
3358  case TBLOCK_BEGIN:
3359  AbortTransaction();
3362  break;
3363 
3364  /*
3365  * We are somewhere in a transaction block and we've gotten a
3366  * failure, so we abort the transaction and set up the persistent
3367  * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3368  */
3369  case TBLOCK_INPROGRESS:
3371  AbortTransaction();
3372  s->blockState = TBLOCK_ABORT;
3373  /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3374  break;
3375 
3376  /*
3377  * Here, we failed while trying to COMMIT. Clean up the
3378  * transaction and return to idle state (we do not want to stay in
3379  * the transaction).
3380  */
3381  case TBLOCK_END:
3382  AbortTransaction();
3385  break;
3386 
3387  /*
3388  * Here, we are already in an aborted transaction state and are
3389  * waiting for a ROLLBACK, but for some reason we failed again! So
3390  * we just remain in the abort state.
3391  */
3392  case TBLOCK_ABORT:
3393  case TBLOCK_SUBABORT:
3394  break;
3395 
3396  /*
3397  * We are in a failed transaction and we got the ROLLBACK command.
3398  * We have already aborted, we just need to cleanup and go to idle
3399  * state.
3400  */
3401  case TBLOCK_ABORT_END:
3404  break;
3405 
3406  /*
3407  * We are in a live transaction and we got a ROLLBACK command.
3408  * Abort, cleanup, go to idle state.
3409  */
3410  case TBLOCK_ABORT_PENDING:
3411  AbortTransaction();
3414  break;
3415 
3416  /*
3417  * Here, we failed while trying to PREPARE. Clean up the
3418  * transaction and return to idle state (we do not want to stay in
3419  * the transaction).
3420  */
3421  case TBLOCK_PREPARE:
3422  AbortTransaction();
3425  break;
3426 
3427  /*
3428  * We got an error inside a subtransaction. Abort just the
3429  * subtransaction, and go to the persistent SUBABORT state until
3430  * we get ROLLBACK.
3431  */
3432  case TBLOCK_SUBINPROGRESS:
3435  break;
3436 
3437  /*
3438  * If we failed while trying to create a subtransaction, clean up
3439  * the broken subtransaction and abort the parent. The same
3440  * applies if we get a failure while ending a subtransaction.
3441  */
3442  case TBLOCK_SUBBEGIN:
3443  case TBLOCK_SUBRELEASE:
3444  case TBLOCK_SUBCOMMIT:
3446  case TBLOCK_SUBRESTART:
3450  break;
3451 
3452  /*
3453  * Same as above, except the Abort() was already done.
3454  */
3455  case TBLOCK_SUBABORT_END:
3459  break;
3460  }
3461 }
TransState state
Definition: xact.c:195
TBlockState blockState
Definition: xact.c:196
static void CleanupSubTransaction(void)
Definition: xact.c:5224
static void CleanupTransaction(void)
Definition: xact.c:2895
@ TRANS_INPROGRESS
Definition: xact.c:145
@ TRANS_START
Definition: xact.c:144
@ TRANS_DEFAULT
Definition: xact.c:143
static void AbortSubTransaction(void)
Definition: xact.c:5065
@ TBLOCK_DEFAULT
Definition: xact.c:160
@ TBLOCK_SUBABORT_END
Definition: xact.c:180
@ TBLOCK_STARTED
Definition: xact.c:161
@ TBLOCK_SUBCOMMIT
Definition: xact.c:178
@ TBLOCK_IMPLICIT_INPROGRESS
Definition: xact.c:166
@ TBLOCK_ABORT_END
Definition: xact.c:170
@ TBLOCK_PREPARE
Definition: xact.c:172
@ TBLOCK_ABORT_PENDING
Definition: xact.c:171
@ TBLOCK_ABORT
Definition: xact.c:169
@ TBLOCK_SUBRELEASE
Definition: xact.c:177
@ TBLOCK_SUBBEGIN
Definition: xact.c:175
@ TBLOCK_SUBABORT
Definition: xact.c:179
@ TBLOCK_SUBRESTART
Definition: xact.c:182
@ TBLOCK_INPROGRESS
Definition: xact.c:165
@ TBLOCK_END
Definition: xact.c:168
@ TBLOCK_PARALLEL_INPROGRESS
Definition: xact.c:167
@ TBLOCK_SUBABORT_RESTART
Definition: xact.c:183
@ TBLOCK_SUBABORT_PENDING
Definition: xact.c:181
@ TBLOCK_BEGIN
Definition: xact.c:164
@ TBLOCK_SUBINPROGRESS
Definition: xact.c:176
static void AbortTransaction(void)
Definition: xact.c:2703
static TransactionState CurrentTransactionState
Definition: xact.c:254
void AbortCurrentTransaction(void)
Definition: xact.c:3312

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

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

◆ AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction ( void  )

Definition at line 4719 of file xact.c.

4720 {
4722 
4723  /* Ensure we're not running in a doomed memory context */
4724  AtAbort_Memory();
4725 
4726  /*
4727  * Get out of any transaction or nested transaction
4728  */
4729  do
4730  {
4731  switch (s->blockState)
4732  {
4733  case TBLOCK_DEFAULT:
4734  if (s->state == TRANS_DEFAULT)
4735  {
4736  /* Not in a transaction, do nothing */
4737  }
4738  else
4739  {
4740  /*
4741  * We can get here after an error during transaction start
4742  * (state will be TRANS_START). Need to clean up the
4743  * incompletely started transaction. First, adjust the
4744  * low-level state to suppress warning message from
4745  * AbortTransaction.
4746  */
4747  if (s->state == TRANS_START)
4748  s->state = TRANS_INPROGRESS;
4749  AbortTransaction();
4751  }
4752  break;
4753  case TBLOCK_STARTED:
4754  case TBLOCK_BEGIN:
4755  case TBLOCK_INPROGRESS:
4758  case TBLOCK_END:
4759  case TBLOCK_ABORT_PENDING:
4760  case TBLOCK_PREPARE:
4761  /* In a transaction, so clean up */
4762  AbortTransaction();
4765  break;
4766  case TBLOCK_ABORT:
4767  case TBLOCK_ABORT_END:
4768 
4769  /*
4770  * AbortTransaction is already done, still need Cleanup.
4771  * However, if we failed partway through running ROLLBACK,
4772  * there will be an active portal running that command, which
4773  * we need to shut down before doing CleanupTransaction.
4774  */
4775  AtAbort_Portals();
4778  break;
4779 
4780  /*
4781  * In a subtransaction, so clean it up and abort parent too
4782  */
4783  case TBLOCK_SUBBEGIN:
4784  case TBLOCK_SUBINPROGRESS:
4785  case TBLOCK_SUBRELEASE:
4786  case TBLOCK_SUBCOMMIT:
4788  case TBLOCK_SUBRESTART:
4791  s = CurrentTransactionState; /* changed by pop */
4792  break;
4793 
4794  case TBLOCK_SUBABORT:
4795  case TBLOCK_SUBABORT_END:
4797  /* As above, but AbortSubTransaction already done */
4798  if (s->curTransactionOwner)
4799  {
4800  /* As in TBLOCK_ABORT, might have a live portal to zap */
4805  }
4807  s = CurrentTransactionState; /* changed by pop */
4808  break;
4809  }
4810  } while (s->blockState != TBLOCK_DEFAULT);
4811 
4812  /* Should be out of all subxacts now */
4813  Assert(s->parent == NULL);
4814 
4815  /* If we didn't actually have anything to do, revert to TopMemoryContext */
4816  AtCleanup_Memory();
4817 }
Assert(fmt[strlen(fmt) - 1] !='\n')
void AtAbort_Portals(void)
Definition: portalmem.c:782
void AtSubAbort_Portals(SubTransactionId mySubid, SubTransactionId parentSubid, ResourceOwner myXactOwner, ResourceOwner parentXactOwner)
Definition: portalmem.c:980
SubTransactionId subTransactionId
Definition: xact.c:192
struct TransactionStateData * parent
Definition: xact.c:212
ResourceOwner curTransactionOwner
Definition: xact.c:200
static void AtCleanup_Memory(void)
Definition: xact.c:1925
static void AtAbort_Memory(void)
Definition: xact.c:1835

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

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

◆ BeginImplicitTransactionBlock()

void BeginImplicitTransactionBlock ( void  )

Definition at line 4179 of file xact.c.

4180 {
4182 
4183  /*
4184  * If we are in STARTED state (that is, no transaction block is open),
4185  * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4186  * block.
4187  *
4188  * For caller convenience, we consider all other transaction states as
4189  * legal here; otherwise the caller would need its own state check, which
4190  * seems rather pointless.
4191  */
4192  if (s->blockState == TBLOCK_STARTED)
4194 }

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

Referenced by exec_simple_query().

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char *  name)

Definition at line 4547 of file xact.c.

4548 {
4550 
4551  /*
4552  * Workers synchronize transaction state at the beginning of each parallel
4553  * operation, so we can't account for new subtransactions after that
4554  * point. We might be able to make an exception for the type of
4555  * subtransaction established by this function, which is typically used in
4556  * contexts where we're going to release or roll back the subtransaction
4557  * before proceeding further, so that no enduring change to the
4558  * transaction state occurs. For now, however, we prohibit this case along
4559  * with all the others.
4560  */
4561  if (IsInParallelMode())
4562  ereport(ERROR,
4563  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4564  errmsg("cannot start subtransactions during a parallel operation")));
4565 
4566  switch (s->blockState)
4567  {
4568  case TBLOCK_STARTED:
4569  case TBLOCK_INPROGRESS:
4571  case TBLOCK_END:
4572  case TBLOCK_PREPARE:
4573  case TBLOCK_SUBINPROGRESS:
4574  /* Normal subtransaction start */
4575  PushTransaction();
4576  s = CurrentTransactionState; /* changed by push */
4577 
4578  /*
4579  * Savepoint names, like the TransactionState block itself, live
4580  * in TopTransactionContext.
4581  */
4582  if (name)
4584  break;
4585 
4586  /* These cases are invalid. */
4587  case TBLOCK_DEFAULT:
4588  case TBLOCK_BEGIN:
4590  case TBLOCK_SUBBEGIN:
4591  case TBLOCK_SUBRELEASE:
4592  case TBLOCK_SUBCOMMIT:
4593  case TBLOCK_ABORT:
4594  case TBLOCK_SUBABORT:
4595  case TBLOCK_ABORT_END:
4596  case TBLOCK_SUBABORT_END:
4597  case TBLOCK_ABORT_PENDING:
4599  case TBLOCK_SUBRESTART:
4601  elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
4603  break;
4604  }
4605 
4608 }
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define FATAL
Definition: elog.h:41
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
const char * name
Definition: encode.c:571
MemoryContext TopTransactionContext
Definition: mcxt.c:146
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1611
static void PushTransaction(void)
Definition: xact.c:5257
void StartTransactionCommand(void)
Definition: xact.c:2944
bool IsInParallelMode(void)
Definition: xact.c:1069
static const char * BlockStateAsString(TBlockState blockState)
Definition: xact.c:5537
void CommitTransactionCommand(void)
Definition: xact.c:3041

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

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

◆ BeginTransactionBlock()

void BeginTransactionBlock ( void  )

Definition at line 3777 of file xact.c.

3778 {
3780 
3781  switch (s->blockState)
3782  {
3783  /*
3784  * We are not inside a transaction block, so allow one to begin.
3785  */
3786  case TBLOCK_STARTED:
3787  s->blockState = TBLOCK_BEGIN;
3788  break;
3789 
3790  /*
3791  * BEGIN converts an implicit transaction block to a regular one.
3792  * (Note that we allow this even if we've already done some
3793  * commands, which is a bit odd but matches historical practice.)
3794  */
3796  s->blockState = TBLOCK_BEGIN;
3797  break;
3798 
3799  /*
3800  * Already a transaction block in progress.
3801  */
3802  case TBLOCK_INPROGRESS:
3804  case TBLOCK_SUBINPROGRESS:
3805  case TBLOCK_ABORT:
3806  case TBLOCK_SUBABORT:
3807  ereport(WARNING,
3808  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3809  errmsg("there is already a transaction in progress")));
3810  break;
3811 
3812  /* These cases are invalid. */
3813  case TBLOCK_DEFAULT:
3814  case TBLOCK_BEGIN:
3815  case TBLOCK_SUBBEGIN:
3816  case TBLOCK_END:
3817  case TBLOCK_SUBRELEASE:
3818  case TBLOCK_SUBCOMMIT:
3819  case TBLOCK_ABORT_END:
3820  case TBLOCK_SUBABORT_END:
3821  case TBLOCK_ABORT_PENDING:
3823  case TBLOCK_SUBRESTART:
3825  case TBLOCK_PREPARE:
3826  elog(FATAL, "BeginTransactionBlock: unexpected state %s",
3828  break;
3829  }
3830 }
#define WARNING
Definition: elog.h:36

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

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

◆ CommandCounterIncrement()

void CommandCounterIncrement ( void  )

Definition at line 1078 of file xact.c.

1079 {
1080  /*
1081  * If the current value of the command counter hasn't been "used" to mark
1082  * tuples, we need not increment it, since there's no need to distinguish
1083  * a read-only command from others. This helps postpone command counter
1084  * overflow, and keeps no-op CommandCounterIncrement operations cheap.
1085  */
1087  {
1088  /*
1089  * Workers synchronize transaction state at the beginning of each
1090  * parallel operation, so we can't account for new commands after that
1091  * point.
1092  */
1094  elog(ERROR, "cannot start commands during a parallel operation");
1095 
1096  currentCommandId += 1;
1098  {
1099  currentCommandId -= 1;
1100  ereport(ERROR,
1101  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1102  errmsg("cannot have more than 2^32-2 commands in a transaction")));
1103  }
1104  currentCommandIdUsed = false;
1105 
1106  /* Propagate new command ID into static snapshots */
1108 
1109  /*
1110  * Make any catalog changes done by the just-completed command visible
1111  * in the local syscache. We obviously don't need to do this after a
1112  * read-only command. (But see hacks in inval.c to make real sure we
1113  * don't think a command that queued inval messages was read-only.)
1114  */
1115  AtCCI_LocalCache();
1116  }
1117 }
#define InvalidCommandId
Definition: c.h:653
#define IsParallelWorker()
Definition: parallel.h:61
void SnapshotSetCommandId(CommandId curcid)
Definition: snapmgr.c:491
static bool currentCommandIdUsed
Definition: xact.c:262
static CommandId currentCommandId
Definition: xact.c:261
static void AtCCI_LocalCache(void)
Definition: xact.c:1540

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

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

◆ CommitTransactionCommand()

void CommitTransactionCommand ( void  )

Definition at line 3041 of file xact.c.

3042 {
3045 
3047 
3048  switch (s->blockState)
3049  {
3050  /*
3051  * These shouldn't happen. TBLOCK_DEFAULT means the previous
3052  * StartTransactionCommand didn't set the STARTED state
3053  * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
3054  * by EndParallelWorkerTransaction(), not this function.
3055  */
3056  case TBLOCK_DEFAULT:
3058  elog(FATAL, "CommitTransactionCommand: unexpected state %s",
3060  break;
3061 
3062  /*
3063  * If we aren't in a transaction block, just do our usual
3064  * transaction commit, and return to the idle state.
3065  */
3066  case TBLOCK_STARTED:
3069  break;
3070 
3071  /*
3072  * We are completing a "BEGIN TRANSACTION" command, so we change
3073  * to the "transaction block in progress" state and return. (We
3074  * assume the BEGIN did nothing to the database, so we need no
3075  * CommandCounterIncrement.)
3076  */
3077  case TBLOCK_BEGIN:
3079  break;
3080 
3081  /*
3082  * This is the case when we have finished executing a command
3083  * someplace within a transaction block. We increment the command
3084  * counter and return.
3085  */
3086  case TBLOCK_INPROGRESS:
3088  case TBLOCK_SUBINPROGRESS:
3090  break;
3091 
3092  /*
3093  * We are completing a "COMMIT" command. Do it and return to the
3094  * idle state.
3095  */
3096  case TBLOCK_END:
3099  if (s->chain)
3100  {
3101  StartTransaction();
3103  s->chain = false;
3105  }
3106  break;
3107 
3108  /*
3109  * Here we are in the middle of a transaction block but one of the
3110  * commands caused an abort so we do nothing but remain in the
3111  * abort state. Eventually we will get a ROLLBACK command.
3112  */
3113  case TBLOCK_ABORT:
3114  case TBLOCK_SUBABORT:
3115  break;
3116 
3117  /*
3118  * Here we were in an aborted transaction block and we just got
3119  * the ROLLBACK command from the user, so clean up the
3120  * already-aborted transaction and return to the idle state.
3121  */
3122  case TBLOCK_ABORT_END:
3125  if (s->chain)
3126  {
3127  StartTransaction();
3129  s->chain = false;
3131  }
3132  break;
3133 
3134  /*
3135  * Here we were in a perfectly good transaction block but the user
3136  * told us to ROLLBACK anyway. We have to abort the transaction
3137  * and then clean up.
3138  */
3139  case TBLOCK_ABORT_PENDING:
3140  AbortTransaction();
3143  if (s->chain)
3144  {
3145  StartTransaction();
3147  s->chain = false;
3149  }
3150  break;
3151 
3152  /*
3153  * We are completing a "PREPARE TRANSACTION" command. Do it and
3154  * return to the idle state.
3155  */
3156  case TBLOCK_PREPARE:
3159  break;
3160 
3161  /*
3162  * The user issued a SAVEPOINT inside a transaction block.
3163  * Start a subtransaction. (DefineSavepoint already did
3164  * PushTransaction, so as to have someplace to put the SUBBEGIN
3165  * state.)
3166  */
3167  case TBLOCK_SUBBEGIN:
3170  break;
3171 
3172  /*
3173  * The user issued a RELEASE command, so we end the current
3174  * subtransaction and return to the parent transaction. The parent
3175  * might be ended too, so repeat till we find an INPROGRESS
3176  * transaction or subtransaction.
3177  */
3178  case TBLOCK_SUBRELEASE:
3179  do
3180  {
3182  s = CurrentTransactionState; /* changed by pop */
3183  } while (s->blockState == TBLOCK_SUBRELEASE);
3184 
3187  break;
3188 
3189  /*
3190  * The user issued a COMMIT, so we end the current subtransaction
3191  * hierarchy and perform final commit. We do this by rolling up
3192  * any subtransactions into their parent, which leads to O(N^2)
3193  * operations with respect to resource owners - this isn't that
3194  * bad until we approach a thousands of savepoints but is
3195  * necessary for correctness should after triggers create new
3196  * resource owners.
3197  */
3198  case TBLOCK_SUBCOMMIT:
3199  do
3200  {
3202  s = CurrentTransactionState; /* changed by pop */
3203  } while (s->blockState == TBLOCK_SUBCOMMIT);
3204  /* If we had a COMMIT command, finish off the main xact too */
3205  if (s->blockState == TBLOCK_END)
3206  {
3207  Assert(s->parent == NULL);
3210  if (s->chain)
3211  {
3212  StartTransaction();
3214  s->chain = false;
3216  }
3217  }
3218  else if (s->blockState == TBLOCK_PREPARE)
3219  {
3220  Assert(s->parent == NULL);
3223  }
3224  else
3225  elog(ERROR, "CommitTransactionCommand: unexpected state %s",
3227  break;
3228 
3229  /*
3230  * The current already-failed subtransaction is ending due to a
3231  * ROLLBACK or ROLLBACK TO command, so pop it and recursively
3232  * examine the parent (which could be in any of several states).
3233  */
3234  case TBLOCK_SUBABORT_END:
3237  break;
3238 
3239  /*
3240  * As above, but it's not dead yet, so abort first.
3241  */
3246  break;
3247 
3248  /*
3249  * The current subtransaction is the target of a ROLLBACK TO
3250  * command. Abort and pop it, then start a new subtransaction
3251  * with the same name.
3252  */
3253  case TBLOCK_SUBRESTART:
3254  {
3255  char *name;
3256  int savepointLevel;
3257 
3258  /* save name and keep Cleanup from freeing it */
3259  name = s->name;
3260  s->name = NULL;
3261  savepointLevel = s->savepointLevel;
3262 
3265 
3266  DefineSavepoint(NULL);
3267  s = CurrentTransactionState; /* changed by push */
3268  s->name = name;
3269  s->savepointLevel = savepointLevel;
3270 
3271  /* This is the same as TBLOCK_SUBBEGIN case */
3275  }
3276  break;
3277 
3278  /*
3279  * Same as above, but the subtransaction had already failed, so we
3280  * don't need AbortSubTransaction.
3281  */
3283  {
3284  char *name;
3285  int savepointLevel;
3286 
3287  /* save name and keep Cleanup from freeing it */
3288  name = s->name;
3289  s->name = NULL;
3290  savepointLevel = s->savepointLevel;
3291 
3293 
3294  DefineSavepoint(NULL);
3295  s = CurrentTransactionState; /* changed by push */
3296  s->name = name;
3297  s->savepointLevel = savepointLevel;
3298 
3299  /* This is the same as TBLOCK_SUBBEGIN case */
3303  }
3304  break;
3305  }
3306 }
void SaveTransactionCharacteristics(SavedTransactionCharacteristics *s)
Definition: xact.c:3021
void RestoreTransactionCharacteristics(const SavedTransactionCharacteristics *s)
Definition: xact.c:3029
static void StartTransaction(void)
Definition: xact.c:1996
void DefineSavepoint(const char *name)
Definition: xact.c:4226
static void CommitSubTransaction(void)
Definition: xact.c:4956
void CommandCounterIncrement(void)
Definition: xact.c:1078
static void CommitTransaction(void)
Definition: xact.c:2155
static void PrepareTransaction(void)
Definition: xact.c:2415
static void StartSubTransaction(void)
Definition: xact.c:4919

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

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

◆ DefineSavepoint()

void DefineSavepoint ( const char *  name)

Definition at line 4226 of file xact.c.

4227 {
4229 
4230  /*
4231  * Workers synchronize transaction state at the beginning of each parallel
4232  * operation, so we can't account for new subtransactions after that
4233  * point. (Note that this check will certainly error out if s->blockState
4234  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4235  * below.)
4236  */
4237  if (IsInParallelMode())
4238  ereport(ERROR,
4239  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4240  errmsg("cannot define savepoints during a parallel operation")));
4241 
4242  switch (s->blockState)
4243  {
4244  case TBLOCK_INPROGRESS:
4245  case TBLOCK_SUBINPROGRESS:
4246  /* Normal subtransaction start */
4247  PushTransaction();
4248  s = CurrentTransactionState; /* changed by push */
4249 
4250  /*
4251  * Savepoint names, like the TransactionState block itself, live
4252  * in TopTransactionContext.
4253  */
4254  if (name)
4256  break;
4257 
4258  /*
4259  * We disallow savepoint commands in implicit transaction blocks.
4260  * There would be no great difficulty in allowing them so far as
4261  * this module is concerned, but a savepoint seems inconsistent
4262  * with exec_simple_query's behavior of abandoning the whole query
4263  * string upon error. Also, the point of an implicit transaction
4264  * block (as opposed to a regular one) is to automatically close
4265  * after an error, so it's hard to see how a savepoint would fit
4266  * into that.
4267  *
4268  * The error messages for this are phrased as if there were no
4269  * active transaction block at all, which is historical but
4270  * perhaps could be improved.
4271  */
4273  ereport(ERROR,
4274  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4275  /* translator: %s represents an SQL statement name */
4276  errmsg("%s can only be used in transaction blocks",
4277  "SAVEPOINT")));
4278  break;
4279 
4280  /* These cases are invalid. */
4281  case TBLOCK_DEFAULT:
4282  case TBLOCK_STARTED:
4283  case TBLOCK_BEGIN:
4285  case TBLOCK_SUBBEGIN:
4286  case TBLOCK_END:
4287  case TBLOCK_SUBRELEASE:
4288  case TBLOCK_SUBCOMMIT:
4289  case TBLOCK_ABORT:
4290  case TBLOCK_SUBABORT:
4291  case TBLOCK_ABORT_END:
4292  case TBLOCK_SUBABORT_END:
4293  case TBLOCK_ABORT_PENDING:
4295  case TBLOCK_SUBRESTART:
4297  case TBLOCK_PREPARE:
4298  elog(FATAL, "DefineSavepoint: unexpected state %s",
4300  break;
4301  }
4302 }

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

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

◆ EndImplicitTransactionBlock()

void EndImplicitTransactionBlock ( void  )

Definition at line 4204 of file xact.c.

4205 {
4207 
4208  /*
4209  * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4210  * allowing CommitTransactionCommand to commit whatever happened during
4211  * the implicit transaction block as though it were a single statement.
4212  *
4213  * For caller convenience, we consider all other transaction states as
4214  * legal here; otherwise the caller would need its own state check, which
4215  * seems rather pointless.
4216  */
4219 }

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

Referenced by exec_simple_query().

◆ EndParallelWorkerTransaction()

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool  chain)

Definition at line 3897 of file xact.c.

3898 {
3900  bool result = false;
3901 
3902  switch (s->blockState)
3903  {
3904  /*
3905  * We are in a transaction block, so tell CommitTransactionCommand
3906  * to COMMIT.
3907  */
3908  case TBLOCK_INPROGRESS:
3909  s->blockState = TBLOCK_END;
3910  result = true;
3911  break;
3912 
3913  /*
3914  * We are in an implicit transaction block. If AND CHAIN was
3915  * specified, error. Otherwise commit, but issue a warning
3916  * because there was no explicit BEGIN before this.
3917  */
3919  if (chain)
3920  ereport(ERROR,
3921  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
3922  /* translator: %s represents an SQL statement name */
3923  errmsg("%s can only be used in transaction blocks",
3924  "COMMIT AND CHAIN")));
3925  else
3926  ereport(WARNING,
3927  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
3928  errmsg("there is no transaction in progress")));
3929  s->blockState = TBLOCK_END;
3930  result = true;
3931  break;
3932 
3933  /*
3934  * We are in a failed transaction block. Tell
3935  * CommitTransactionCommand it's time to exit the block.
3936  */
3937  case TBLOCK_ABORT:
3939  break;
3940 
3941  /*
3942  * We are in a live subtransaction block. Set up to subcommit all
3943  * open subtransactions and then commit the main transaction.
3944  */
3945  case TBLOCK_SUBINPROGRESS:
3946  while (s->parent != NULL)
3947  {
3948  if (s->blockState == TBLOCK_SUBINPROGRESS)
3950  else
3951  elog(FATAL, "EndTransactionBlock: unexpected state %s",
3953  s = s->parent;
3954  }
3955  if (s->blockState == TBLOCK_INPROGRESS)
3956  s->blockState = TBLOCK_END;
3957  else
3958  elog(FATAL, "EndTransactionBlock: unexpected state %s",
3960  result = true;
3961  break;
3962 
3963  /*
3964  * Here we are inside an aborted subtransaction. Treat the COMMIT
3965  * as ROLLBACK: set up to abort everything and exit the main
3966  * transaction.
3967  */
3968  case TBLOCK_SUBABORT:
3969  while (s->parent != NULL)
3970  {
3971  if (s->blockState == TBLOCK_SUBINPROGRESS)
3973  else if (s->blockState == TBLOCK_SUBABORT)
3975  else
3976  elog(FATAL, "EndTransactionBlock: unexpected state %s",
3978  s = s->parent;
3979  }
3980  if (s->blockState == TBLOCK_INPROGRESS)
3982  else if (s->blockState == TBLOCK_ABORT)
3984  else
3985  elog(FATAL, "EndTransactionBlock: unexpected state %s",
3987  break;
3988 
3989  /*
3990  * The user issued COMMIT when not inside a transaction. For
3991  * COMMIT without CHAIN, issue a WARNING, staying in
3992  * TBLOCK_STARTED state. The upcoming call to
3993  * CommitTransactionCommand() will then close the transaction and
3994  * put us back into the default state. For COMMIT AND CHAIN,
3995  * error.
3996  */
3997  case TBLOCK_STARTED:
3998  if (chain)
3999  ereport(ERROR,
4000  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4001  /* translator: %s represents an SQL statement name */
4002  errmsg("%s can only be used in transaction blocks",
4003  "COMMIT AND CHAIN")));
4004  else
4005  ereport(WARNING,
4006  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4007  errmsg("there is no transaction in progress")));
4008  result = true;
4009  break;
4010 
4011  /*
4012  * The user issued a COMMIT that somehow ran inside a parallel
4013  * worker. We can't cope with that.
4014  */
4016  ereport(FATAL,
4017  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4018  errmsg("cannot commit during a parallel operation")));
4019  break;
4020 
4021  /* These cases are invalid. */
4022  case TBLOCK_DEFAULT:
4023  case TBLOCK_BEGIN:
4024  case TBLOCK_SUBBEGIN:
4025  case TBLOCK_END:
4026  case TBLOCK_SUBRELEASE:
4027  case TBLOCK_SUBCOMMIT:
4028  case TBLOCK_ABORT_END:
4029  case TBLOCK_SUBABORT_END:
4030  case TBLOCK_ABORT_PENDING:
4032  case TBLOCK_SUBRESTART:
4034  case TBLOCK_PREPARE:
4035  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4037  break;
4038  }
4039 
4041  s->blockState == TBLOCK_END ||
4042  s->blockState == TBLOCK_ABORT_END ||
4044 
4045  s->chain = chain;
4046 
4047  return result;
4048 }

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

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

◆ EnterParallelMode()

void EnterParallelMode ( void  )

◆ EstimateTransactionStateSpace()

Size EstimateTransactionStateSpace ( void  )

Definition at line 5351 of file xact.c.

5352 {
5353  TransactionState s;
5354  Size nxids = 0;
5356 
5357  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5358  {
5360  nxids = add_size(nxids, 1);
5361  nxids = add_size(nxids, s->nChildXids);
5362  }
5363 
5364  return add_size(size, mul_size(sizeof(TransactionId), nxids));
5365 }
uint32 TransactionId
Definition: c.h:636
size_t Size
Definition: c.h:589
Size add_size(Size s1, Size s2)
Definition: shmem.c:502
Size mul_size(Size s1, Size s2)
Definition: shmem.c:519
FullTransactionId fullTransactionId
Definition: xact.c:191
#define FullTransactionIdIsValid(x)
Definition: transam.h:55
#define SerializedTransactionStateHeaderSize
Definition: xact.c:233

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

Referenced by InitializeParallelDSM().

◆ ExitParallelMode()

void ExitParallelMode ( void  )

◆ ForceSyncCommit()

void ForceSyncCommit ( void  )

Definition at line 1128 of file xact.c.

1129 {
1130  forceSyncCommit = true;
1131 }
static bool forceSyncCommit
Definition: xact.c:287

References forceSyncCommit.

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

◆ GetCurrentCommandId()

CommandId GetCurrentCommandId ( bool  used)

Definition at line 818 of file xact.c.

819 {
820  /* this is global to a transaction, not subtransaction-local */
821  if (used)
822  {
823  /*
824  * Forbid setting currentCommandIdUsed in a parallel worker, because
825  * we have no provision for communicating this back to the leader. We
826  * could relax this restriction when currentCommandIdUsed was already
827  * true at the start of the parallel operation.
828  */
830  currentCommandIdUsed = true;
831  }
832  return currentCommandId;
833 }

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

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

◆ GetCurrentFullTransactionId()

FullTransactionId GetCurrentFullTransactionId ( void  )

Definition at line 503 of file xact.c.

504 {
506 
509  return s->fullTransactionId;
510 }
static void AssignTransactionId(TransactionState s)
Definition: xact.c:626

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

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void  )

Definition at line 521 of file xact.c.

522 {
524 }

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void  )

Definition at line 864 of file xact.c.

865 {
866  return stmtStartTimestamp;
867 }
static TimestampTz stmtStartTimestamp
Definition: xact.c:275

References stmtStartTimestamp.

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

◆ GetCurrentSubTransactionId()

◆ GetCurrentTransactionId()

◆ GetCurrentTransactionIdIfAny()

◆ GetCurrentTransactionNestLevel()

◆ GetCurrentTransactionStartTimestamp()

TimestampTz GetCurrentTransactionStartTimestamp ( void  )

Definition at line 855 of file xact.c.

856 {
857  return xactStartTimestamp;
858 }
static TimestampTz xactStartTimestamp
Definition: xact.c:274

References xactStartTimestamp.

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

◆ GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp ( void  )

Definition at line 876 of file xact.c.

877 {
879 
880  /* should only be called after commit / abort processing */
881  Assert(s->state == TRANS_DEFAULT ||
882  s->state == TRANS_COMMIT ||
883  s->state == TRANS_ABORT ||
884  s->state == TRANS_PREPARE);
885 
886  if (xactStopTimestamp == 0)
888 
889  return xactStopTimestamp;
890 }
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1582
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:166
static TimestampTz xactStopTimestamp
Definition: xact.c:276
@ TRANS_COMMIT
Definition: xact.c:146
@ TRANS_ABORT
Definition: xact.c:147
@ TRANS_PREPARE
Definition: xact.c:148

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

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

◆ GetStableLatestTransactionId()

TransactionId GetStableLatestTransactionId ( void  )

Definition at line 598 of file xact.c.

599 {
601  static TransactionId stablexid = InvalidTransactionId;
602 
603  if (lxid != MyProc->lxid)
604  {
605  lxid = MyProc->lxid;
606  stablexid = GetTopTransactionIdIfAny();
607  if (!TransactionIdIsValid(stablexid))
608  stablexid = ReadNextTransactionId();
609  }
610 
611  Assert(TransactionIdIsValid(stablexid));
612 
613  return stablexid;
614 }
uint32 LocalTransactionId
Definition: c.h:638
#define InvalidLocalTransactionId
Definition: lock.h:65
PGPROC * MyProc
Definition: proc.c:66
LocalTransactionId lxid
Definition: proc.h:183
static TransactionId ReadNextTransactionId(void)
Definition: transam.h:315
#define InvalidTransactionId
Definition: transam.h:31
#define TransactionIdIsValid(xid)
Definition: transam.h:41
TransactionId GetTopTransactionIdIfAny(void)
Definition: xact.c:432

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

Referenced by xid_age().

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void  )

Definition at line 474 of file xact.c.

475 {
479 }
static TransactionStateData TopTransactionStateData
Definition: xact.c:241
static FullTransactionId XactTopFullTransactionId
Definition: xact.c:125

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

Referenced by pg_current_xact_id().

◆ GetTopFullTransactionIdIfAny()

FullTransactionId GetTopFullTransactionIdIfAny ( void  )

Definition at line 490 of file xact.c.

491 {
493 }

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

◆ GetTopTransactionId()

◆ GetTopTransactionIdIfAny()

◆ IsAbortedTransactionBlockState()

◆ IsInParallelMode()

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool  isTopLevel)

Definition at line 3619 of file xact.c.

3620 {
3621  /*
3622  * Return true on same conditions that would make
3623  * PreventInTransactionBlock error out
3624  */
3625  if (IsTransactionBlock())
3626  return true;
3627 
3628  if (IsSubTransaction())
3629  return true;
3630 
3632  return true;
3633 
3634  if (!isTopLevel)
3635  return true;
3636 
3639  return true;
3640 
3641  return false;
3642 }
bool IsSubTransaction(void)
Definition: xact.c:4896
bool IsTransactionBlock(void)
Definition: xact.c:4823
int MyXactFlags
Definition: xact.c:136
#define XACT_FLAGS_PIPELINING
Definition: xact.h:121

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

Referenced by vacuum().

◆ IsSubTransaction()

◆ IsSubxactTopXidLogPending()

bool IsSubxactTopXidLogPending ( void  )

Definition at line 550 of file xact.c.

551 {
552  /* check whether it is already logged */
554  return false;
555 
556  /* wal_level has to be logical */
557  if (!XLogLogicalInfoActive())
558  return false;
559 
560  /* we need to be in a transaction state */
561  if (!IsTransactionState())
562  return false;
563 
564  /* it has to be a subtransaction */
565  if (!IsSubTransaction())
566  return false;
567 
568  /* the subtransaction has to have a XID assigned */
570  return false;
571 
572  return true;
573 }
bool IsTransactionState(void)
Definition: xact.c:378
TransactionId GetCurrentTransactionIdIfAny(void)
Definition: xact.c:462
#define XLogLogicalInfoActive()
Definition: xlog.h:121

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

Referenced by MarkSubxactTopXidLogged(), and XLogRecordAssemble().

◆ IsTransactionBlock()

◆ IsTransactionOrTransactionBlock()

◆ IsTransactionState()

bool IsTransactionState ( void  )

Definition at line 378 of file xact.c.

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

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

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

◆ MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny ( void  )

◆ MarkSubxactTopXidLogged()

void MarkSubxactTopXidLogged ( void  )

Definition at line 582 of file xact.c.

583 {
585 
587 }
bool IsSubxactTopXidLogPending(void)
Definition: xact.c:550

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

Referenced by XLogInsertRecord().

◆ ParseAbortRecord()

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

Definition at line 141 of file xactdesc.c.

142 {
143  char *data = ((char *) xlrec) + MinSizeOfXactAbort;
144 
145  memset(parsed, 0, sizeof(*parsed));
146 
147  parsed->xinfo = 0; /* default, if no XLOG_XACT_HAS_INFO is
148  * present */
149 
150  parsed->xact_time = xlrec->xact_time;
151 
152  if (info & XLOG_XACT_HAS_INFO)
153  {
154  xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;
155 
156  parsed->xinfo = xl_xinfo->xinfo;
157 
158  data += sizeof(xl_xact_xinfo);
159  }
160 
161  if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
162  {
163  xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;
164 
165  parsed->dbId = xl_dbinfo->dbId;
166  parsed->tsId = xl_dbinfo->tsId;
167 
168  data += sizeof(xl_xact_dbinfo);
169  }
170 
171  if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
172  {
173  xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;
174 
175  parsed->nsubxacts = xl_subxacts->nsubxacts;
176  parsed->subxacts = xl_subxacts->subxacts;
177 
179  data += parsed->nsubxacts * sizeof(TransactionId);
180  }
181 
183  {
185 
186  parsed->nrels = xl_rellocator->nrels;
187  parsed->xlocators = xl_rellocator->xlocators;
188 
190  data += xl_rellocator->nrels * sizeof(RelFileLocator);
191  }
192 
193  if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
194  {
196 
197  parsed->nstats = xl_drops->nitems;
198  parsed->stats = xl_drops->items;
199 
201  data += xl_drops->nitems * sizeof(xl_xact_stats_item);
202  }
203 
204  if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
205  {
206  xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
207 
208  parsed->twophase_xid = xl_twophase->xid;
209 
210  data += sizeof(xl_xact_twophase);
211 
212  if (parsed->xinfo & XACT_XINFO_HAS_GID)
213  {
214  strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
215  data += strlen(data) + 1;
216  }
217  }
218 
219  /* Note: no alignment is guaranteed after this point */
220 
221  if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
222  {
223  xl_xact_origin xl_origin;
224 
225  /* no alignment is guaranteed, so copy onto stack */
226  memcpy(&xl_origin, data, sizeof(xl_origin));
227 
228  parsed->origin_lsn = xl_origin.origin_lsn;
229  parsed->origin_timestamp = xl_origin.origin_timestamp;
230 
231  data += sizeof(xl_xact_origin);
232  }
233 }
const void * data
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
struct RelFileLocator RelFileLocator
TimestampTz xact_time
Definition: xact.h:332
Oid tsId
Definition: xact.h:258
Oid dbId
Definition: xact.h:257
TimestampTz origin_timestamp
Definition: xact.h:311
XLogRecPtr origin_lsn
Definition: xact.h:310
xl_xact_stats_item * stats
Definition: xact.h:419
RelFileLocator * xlocators
Definition: xact.h:416
TransactionId twophase_xid
Definition: xact.h:421
TimestampTz xact_time
Definition: xact.h:406
TransactionId * subxacts
Definition: xact.h:413
XLogRecPtr origin_lsn
Definition: xact.h:424
char twophase_gid[GIDSIZE]
Definition: xact.h:422
TimestampTz origin_timestamp
Definition: xact.h:425
RelFileLocator xlocators[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.h:271
xl_xact_stats_item items[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.h:292
TransactionId subxacts[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.h:264
int nsubxacts
Definition: xact.h:263
TransactionId xid
Definition: xact.h:305
uint32 xinfo
Definition: xact.h:252
struct xl_xact_stats_item xl_xact_stats_item
#define MinSizeOfXactSubxacts
Definition: xact.h:266
struct xl_xact_dbinfo xl_xact_dbinfo
#define XACT_XINFO_HAS_GID
Definition: xact.h:195
struct xl_xact_origin xl_xact_origin
#define XACT_XINFO_HAS_ORIGIN
Definition: xact.h:193
#define XACT_XINFO_HAS_TWOPHASE
Definition: xact.h:192
#define MinSizeOfXactRelfileLocators
Definition: xact.h:273
#define MinSizeOfXactStatsItems
Definition: xact.h:294
#define XACT_XINFO_HAS_RELFILELOCATORS
Definition: xact.h:190
#define MinSizeOfXactAbort
Definition: xact.h:344
struct xl_xact_xinfo xl_xact_xinfo
#define XACT_XINFO_HAS_DBINFO
Definition: xact.h:188
struct xl_xact_twophase xl_xact_twophase
#define XLOG_XACT_HAS_INFO
Definition: xact.h:182
#define XACT_XINFO_HAS_SUBXACTS
Definition: xact.h:189
#define XACT_XINFO_HAS_DROPPED_STATS
Definition: xact.h:196

References data, xl_xact_dbinfo::dbId, xl_xact_parsed_abort::dbId, xl_xact_stats_items::items, MinSizeOfXactAbort, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, xl_xact_stats_items::nitems, xl_xact_relfilelocators::nrels, xl_xact_parsed_abort::nrels, xl_xact_parsed_abort::nstats, xl_xact_subxacts::nsubxacts, xl_xact_parsed_abort::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_parsed_abort::origin_lsn, xl_xact_origin::origin_timestamp, xl_xact_parsed_abort::origin_timestamp, xl_xact_parsed_abort::stats, strlcpy(), xl_xact_subxacts::subxacts, xl_xact_parsed_abort::subxacts, xl_xact_dbinfo::tsId, xl_xact_parsed_abort::tsId, xl_xact_parsed_abort::twophase_gid, xl_xact_parsed_abort::twophase_xid, xl_xact_abort::xact_time, xl_xact_parsed_abort::xact_time, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_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, xl_xact_parsed_abort::xinfo, xl_xact_relfilelocators::xlocators, xl_xact_parsed_abort::xlocators, and XLOG_XACT_HAS_INFO.

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

◆ ParseCommitRecord()

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

Definition at line 35 of file xactdesc.c.

36 {
37  char *data = ((char *) xlrec) + MinSizeOfXactCommit;
38 
39  memset(parsed, 0, sizeof(*parsed));
40 
41  parsed->xinfo = 0; /* default, if no XLOG_XACT_HAS_INFO is
42  * present */
43 
44  parsed->xact_time = xlrec->xact_time;
45 
46  if (info & XLOG_XACT_HAS_INFO)
47  {
48  xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;
49 
50  parsed->xinfo = xl_xinfo->xinfo;
51 
52  data += sizeof(xl_xact_xinfo);
53  }
54 
55  if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
56  {
57  xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;
58 
59  parsed->dbId = xl_dbinfo->dbId;
60  parsed->tsId = xl_dbinfo->tsId;
61 
62  data += sizeof(xl_xact_dbinfo);
63  }
64 
65  if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
66  {
67  xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;
68 
69  parsed->nsubxacts = xl_subxacts->nsubxacts;
70  parsed->subxacts = xl_subxacts->subxacts;
71 
73  data += parsed->nsubxacts * sizeof(TransactionId);
74  }
75 
77  {
79 
80  parsed->nrels = xl_rellocators->nrels;
81  parsed->xlocators = xl_rellocators->xlocators;
82 
84  data += xl_rellocators->nrels * sizeof(RelFileLocator);
85  }
86 
87  if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
88  {
90 
91  parsed->nstats = xl_drops->nitems;
92  parsed->stats = xl_drops->items;
93 
95  data += xl_drops->nitems * sizeof(xl_xact_stats_item);
96  }
97 
98  if (parsed->xinfo & XACT_XINFO_HAS_INVALS)
99  {
100  xl_xact_invals *xl_invals = (xl_xact_invals *) data;
101 
102  parsed->nmsgs = xl_invals->nmsgs;
103  parsed->msgs = xl_invals->msgs;
104 
106  data += xl_invals->nmsgs * sizeof(SharedInvalidationMessage);
107  }
108 
109  if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
110  {
111  xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
112 
113  parsed->twophase_xid = xl_twophase->xid;
114 
115  data += sizeof(xl_xact_twophase);
116 
117  if (parsed->xinfo & XACT_XINFO_HAS_GID)
118  {
119  strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
120  data += strlen(data) + 1;
121  }
122  }
123 
124  /* Note: no alignment is guaranteed after this point */
125 
126  if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
127  {
128  xl_xact_origin xl_origin;
129 
130  /* no alignment is guaranteed, so copy onto stack */
131  memcpy(&xl_origin, data, sizeof(xl_origin));
132 
133  parsed->origin_lsn = xl_origin.origin_lsn;
134  parsed->origin_timestamp = xl_origin.origin_timestamp;
135 
136  data += sizeof(xl_xact_origin);
137  }
138 }
TimestampTz xact_time
Definition: xact.h:316
SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.h:299
int nmsgs
Definition: xact.h:298
xl_xact_stats_item * stats
Definition: xact.h:386
TimestampTz xact_time
Definition: xact.h:373
TransactionId twophase_xid
Definition: xact.h:391
RelFileLocator * xlocators
Definition: xact.h:383
TimestampTz origin_timestamp
Definition: xact.h:399
TransactionId * subxacts
Definition: xact.h:380
char twophase_gid[GIDSIZE]
Definition: xact.h:392
XLogRecPtr origin_lsn
Definition: xact.h:398
SharedInvalidationMessage * msgs
Definition: xact.h:389
#define MinSizeOfXactInvals
Definition: xact.h:301
#define MinSizeOfXactCommit
Definition: xact.h:328
#define XACT_XINFO_HAS_INVALS
Definition: xact.h:191

References data, xl_xact_dbinfo::dbId, xl_xact_parsed_commit::dbId, xl_xact_stats_items::items, MinSizeOfXactCommit, MinSizeOfXactInvals, MinSizeOfXactRelfileLocators, MinSizeOfXactStatsItems, MinSizeOfXactSubxacts, xl_xact_invals::msgs, xl_xact_parsed_commit::msgs, xl_xact_stats_items::nitems, xl_xact_invals::nmsgs, xl_xact_parsed_commit::nmsgs, xl_xact_relfilelocators::nrels, xl_xact_parsed_commit::nrels, xl_xact_parsed_commit::nstats, xl_xact_subxacts::nsubxacts, xl_xact_parsed_commit::nsubxacts, xl_xact_origin::origin_lsn, xl_xact_parsed_commit::origin_lsn, xl_xact_origin::origin_timestamp, xl_xact_parsed_commit::origin_timestamp, xl_xact_parsed_commit::stats, strlcpy(), xl_xact_subxacts::subxacts, xl_xact_parsed_commit::subxacts, xl_xact_dbinfo::tsId, xl_xact_parsed_commit::tsId, xl_xact_parsed_commit::twophase_gid, xl_xact_parsed_commit::twophase_xid, xl_xact_commit::xact_time, xl_xact_parsed_commit::xact_time, XACT_XINFO_HAS_DBINFO, XACT_XINFO_HAS_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, xl_xact_parsed_commit::xinfo, xl_xact_relfilelocators::xlocators, xl_xact_parsed_commit::xlocators, and XLOG_XACT_HAS_INFO.

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

◆ ParsePrepareRecord()

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

Definition at line 239 of file xactdesc.c.

240 {
241  char *bufptr;
242 
243  bufptr = ((char *) xlrec) + MAXALIGN(sizeof(xl_xact_prepare));
244 
245  memset(parsed, 0, sizeof(*parsed));
246 
247  parsed->xact_time = xlrec->prepared_at;
248  parsed->origin_lsn = xlrec->origin_lsn;
249  parsed->origin_timestamp = xlrec->origin_timestamp;
250  parsed->twophase_xid = xlrec->xid;
251  parsed->dbId = xlrec->database;
252  parsed->nsubxacts = xlrec->nsubxacts;
253  parsed->nrels = xlrec->ncommitrels;
254  parsed->nabortrels = xlrec->nabortrels;
255  parsed->nmsgs = xlrec->ninvalmsgs;
256 
257  strncpy(parsed->twophase_gid, bufptr, xlrec->gidlen);
258  bufptr += MAXALIGN(xlrec->gidlen);
259 
260  parsed->subxacts = (TransactionId *) bufptr;
261  bufptr += MAXALIGN(xlrec->nsubxacts * sizeof(TransactionId));
262 
263  parsed->xlocators = (RelFileLocator *) bufptr;
264  bufptr += MAXALIGN(xlrec->ncommitrels * sizeof(RelFileLocator));
265 
266  parsed->abortlocators = (RelFileLocator *) bufptr;
267  bufptr += MAXALIGN(xlrec->nabortrels * sizeof(RelFileLocator));
268 
269  parsed->stats = (xl_xact_stats_item *) bufptr;
270  bufptr += MAXALIGN(xlrec->ncommitstats * sizeof(xl_xact_stats_item));
271 
272  parsed->abortstats = (xl_xact_stats_item *) bufptr;
273  bufptr += MAXALIGN(xlrec->nabortstats * sizeof(xl_xact_stats_item));
274 
275  parsed->msgs = (SharedInvalidationMessage *) bufptr;
276  bufptr += MAXALIGN(xlrec->ninvalmsgs * sizeof(SharedInvalidationMessage));
277 }
#define MAXALIGN(LEN)
Definition: c.h:795
RelFileLocator * abortlocators
Definition: xact.h:394
xl_xact_stats_item * abortstats
Definition: xact.h:396
TimestampTz prepared_at
Definition: xact.h:352
int32 nabortrels
Definition: xact.h:356
int32 ninvalmsgs
Definition: xact.h:359
int32 ncommitstats
Definition: xact.h:357
TimestampTz origin_timestamp
Definition: xact.h:363
uint16 gidlen
Definition: xact.h:361
int32 nabortstats
Definition: xact.h:358
Oid database
Definition: xact.h:351
XLogRecPtr origin_lsn
Definition: xact.h:362
int32 ncommitrels
Definition: xact.h:355
TransactionId xid
Definition: xact.h:350
int32 nsubxacts
Definition: xact.h:354

References xl_xact_parsed_commit::abortlocators, xl_xact_parsed_commit::abortstats, xl_xact_prepare::database, xl_xact_parsed_commit::dbId, xl_xact_prepare::gidlen, MAXALIGN, xl_xact_parsed_commit::msgs, xl_xact_prepare::nabortrels, xl_xact_parsed_commit::nabortrels, xl_xact_prepare::nabortstats, xl_xact_prepare::ncommitrels, xl_xact_prepare::ncommitstats, xl_xact_prepare::ninvalmsgs, xl_xact_parsed_commit::nmsgs, xl_xact_parsed_commit::nrels, xl_xact_prepare::nsubxacts, xl_xact_parsed_commit::nsubxacts, xl_xact_prepare::origin_lsn, xl_xact_parsed_commit::origin_lsn, xl_xact_prepare::origin_timestamp, xl_xact_parsed_commit::origin_timestamp, xl_xact_prepare::prepared_at, xl_xact_parsed_commit::stats, xl_xact_parsed_commit::subxacts, xl_xact_parsed_commit::twophase_gid, xl_xact_parsed_commit::twophase_xid, xl_xact_parsed_commit::xact_time, xl_xact_prepare::xid, and xl_xact_parsed_commit::xlocators.

Referenced by xact_decode(), and xact_desc_prepare().

◆ PrepareTransactionBlock()

bool PrepareTransactionBlock ( const char *  gid)

Definition at line 3845 of file xact.c.

3846 {
3847  TransactionState s;
3848  bool result;
3849 
3850  /* Set up to commit the current transaction */
3851  result = EndTransactionBlock(false);
3852 
3853  /* If successful, change outer tblock state to PREPARE */
3854  if (result)
3855  {
3857 
3858  while (s->parent != NULL)
3859  s = s->parent;
3860 
3861  if (s->blockState == TBLOCK_END)
3862  {
3863  /* Save GID where PrepareTransaction can find it again */
3865 
3867  }
3868  else
3869  {
3870  /*
3871  * ignore case where we are not in a transaction;
3872  * EndTransactionBlock already issued a warning.
3873  */
3876  /* Don't send back a PREPARE result tag... */
3877  result = false;
3878  }
3879  }
3880 
3881  return result;
3882 }
static char * prepareGID
Definition: xact.c:282
bool EndTransactionBlock(bool chain)
Definition: xact.c:3897

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

Referenced by apply_handle_prepare_internal(), and standard_ProcessUtility().

◆ PreventInTransactionBlock()

void PreventInTransactionBlock ( bool  isTopLevel,
const char *  stmtType 
)

Definition at line 3488 of file xact.c.

3489 {
3490  /*
3491  * xact block already started?
3492  */
3493  if (IsTransactionBlock())
3494  ereport(ERROR,
3495  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3496  /* translator: %s represents an SQL statement name */
3497  errmsg("%s cannot run inside a transaction block",
3498  stmtType)));
3499 
3500  /*
3501  * subtransaction?
3502  */
3503  if (IsSubTransaction())
3504  ereport(ERROR,
3505  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3506  /* translator: %s represents an SQL statement name */
3507  errmsg("%s cannot run inside a subtransaction",
3508  stmtType)));
3509 
3510  /*
3511  * inside a pipeline that has started an implicit transaction?
3512  */
3514  ereport(ERROR,
3515  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3516  /* translator: %s represents an SQL statement name */
3517  errmsg("%s cannot be executed within a pipeline",
3518  stmtType)));
3519 
3520  /*
3521  * inside a function call?
3522  */
3523  if (!isTopLevel)
3524  ereport(ERROR,
3525  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3526  /* translator: %s represents an SQL statement name */
3527  errmsg("%s cannot be executed from a function", stmtType)));
3528 
3529  /* If we got past IsTransactionBlock test, should be in default state */
3532  elog(FATAL, "cannot prevent transaction chain");
3533 
3534  /* All okay. Set the flag to make sure the right thing happens later. */
3536 }
#define XACT_FLAGS_NEEDIMMEDIATECOMMIT
Definition: xact.h:114

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

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

◆ RegisterSubXactCallback()

void RegisterSubXactCallback ( SubXactCallback  callback,
void *  arg 
)

Definition at line 3717 of file xact.c.

3718 {
3719  SubXactCallbackItem *item;
3720 
3721  item = (SubXactCallbackItem *)
3723  item->callback = callback;
3724  item->arg = arg;
3725  item->next = SubXact_callbacks;
3726  SubXact_callbacks = item;
3727 }
MemoryContext TopMemoryContext
Definition: mcxt.c:141
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1005
void * arg
struct SubXactCallbackItem * next
Definition: xact.c:316
SubXactCallback callback
Definition: xact.c:317
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46
static SubXactCallbackItem * SubXact_callbacks
Definition: xact.c:321

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

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

◆ RegisterXactCallback()

void RegisterXactCallback ( XactCallback  callback,
void *  arg 
)

Definition at line 3657 of file xact.c.

3658 {
3659  XactCallbackItem *item;
3660 
3661  item = (XactCallbackItem *)
3663  item->callback = callback;
3664  item->arg = arg;
3665  item->next = Xact_callbacks;
3666  Xact_callbacks = item;
3667 }
struct XactCallbackItem * next
Definition: xact.c:304
void * arg
Definition: xact.c:306
XactCallback callback
Definition: xact.c:305
static XactCallbackItem * Xact_callbacks
Definition: xact.c:309

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

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

◆ ReleaseCurrentSubTransaction()

void ReleaseCurrentSubTransaction ( void  )

Definition at line 4618 of file xact.c.

4619 {
4621 
4622  /*
4623  * Workers synchronize transaction state at the beginning of each parallel
4624  * operation, so we can't account for commit of subtransactions after that
4625  * point. This should not happen anyway. Code calling this would
4626  * typically have called BeginInternalSubTransaction() first, failing
4627  * there.
4628  */
4629  if (IsInParallelMode())
4630  ereport(ERROR,
4631  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4632  errmsg("cannot commit subtransactions during a parallel operation")));
4633 
4634  if (s->blockState != TBLOCK_SUBINPROGRESS)
4635  elog(ERROR, "ReleaseCurrentSubTransaction: unexpected state %s",
4637  Assert(s->state == TRANS_INPROGRESS);
4640  s = CurrentTransactionState; /* changed by pop */
4641  Assert(s->state == TRANS_INPROGRESS);
4642 }
MemoryContext CurTransactionContext
Definition: mcxt.c:147
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:138

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

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

◆ ReleaseSavepoint()

void ReleaseSavepoint ( const char *  name)

Definition at line 4311 of file xact.c.

4312 {
4314  TransactionState target,
4315  xact;
4316 
4317  /*
4318  * Workers synchronize transaction state at the beginning of each parallel
4319  * operation, so we can't account for transaction state change after that
4320  * point. (Note that this check will certainly error out if s->blockState
4321  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4322  * below.)
4323  */
4324  if (IsInParallelMode())
4325  ereport(ERROR,
4326  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4327  errmsg("cannot release savepoints during a parallel operation")));
4328 
4329  switch (s->blockState)
4330  {
4331  /*
4332  * We can't release a savepoint if there is no savepoint defined.
4333  */
4334  case TBLOCK_INPROGRESS:
4335  ereport(ERROR,
4336  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4337  errmsg("savepoint \"%s\" does not exist", name)));
4338  break;
4339 
4341  /* See comment about implicit transactions in DefineSavepoint */
4342  ereport(ERROR,
4343  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4344  /* translator: %s represents an SQL statement name */
4345  errmsg("%s can only be used in transaction blocks",
4346  "RELEASE SAVEPOINT")));
4347  break;
4348 
4349  /*
4350  * We are in a non-aborted subtransaction. This is the only valid
4351  * case.
4352  */
4353  case TBLOCK_SUBINPROGRESS:
4354  break;
4355 
4356  /* These cases are invalid. */
4357  case TBLOCK_DEFAULT:
4358  case TBLOCK_STARTED:
4359  case TBLOCK_BEGIN:
4361  case TBLOCK_SUBBEGIN:
4362  case TBLOCK_END:
4363  case TBLOCK_SUBRELEASE:
4364  case TBLOCK_SUBCOMMIT:
4365  case TBLOCK_ABORT:
4366  case TBLOCK_SUBABORT:
4367  case TBLOCK_ABORT_END:
4368  case TBLOCK_SUBABORT_END:
4369  case TBLOCK_ABORT_PENDING:
4371  case TBLOCK_SUBRESTART:
4373  case TBLOCK_PREPARE:
4374  elog(FATAL, "ReleaseSavepoint: unexpected state %s",
4376  break;
4377  }
4378 
4379  for (target = s; PointerIsValid(target); target = target->parent)
4380  {
4381  if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4382  break;
4383  }
4384 
4385  if (!PointerIsValid(target))
4386  ereport(ERROR,
4387  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4388  errmsg("savepoint \"%s\" does not exist", name)));
4389 
4390  /* disallow crossing savepoint level boundaries */
4391  if (target->savepointLevel != s->savepointLevel)
4392  ereport(ERROR,
4393  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4394  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4395 
4396  /*
4397  * Mark "commit pending" all subtransactions up to the target
4398  * subtransaction. The actual commits will happen when control gets to
4399  * CommitTransactionCommand.
4400  */
4401  xact = CurrentTransactionState;
4402  for (;;)
4403  {
4405  xact->blockState = TBLOCK_SUBRELEASE;
4406  if (xact == target)
4407  break;
4408  xact = xact->parent;
4409  Assert(PointerIsValid(xact));
4410  }
4411 }
#define PointerIsValid(pointer)
Definition: c.h:747

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

Referenced by standard_ProcessUtility().

◆ RequireTransactionBlock()

void RequireTransactionBlock ( bool  isTopLevel,
const char *  stmtType 
)

Definition at line 3566 of file xact.c.

3567 {
3568  CheckTransactionBlock(isTopLevel, true, stmtType);
3569 }
static void CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType)
Definition: xact.c:3575

References CheckTransactionBlock().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

◆ RestoreTransactionCharacteristics()

◆ RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction ( void  )

Definition at line 4652 of file xact.c.

4653 {
4655 
4656  /*
4657  * Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
4658  * during parallel operations. That's because we may be in the leader,
4659  * recovering from an error thrown while we were in parallel mode. We
4660  * won't reach here in a worker, because BeginInternalSubTransaction()
4661  * will have failed.
4662  */
4663 
4664  switch (s->blockState)
4665  {
4666  /* Must be in a subtransaction */
4667  case TBLOCK_SUBINPROGRESS:
4668  case TBLOCK_SUBABORT:
4669  break;
4670 
4671  /* These cases are invalid. */
4672  case TBLOCK_DEFAULT:
4673  case TBLOCK_STARTED:
4674  case TBLOCK_BEGIN:
4677  case TBLOCK_SUBBEGIN:
4678  case TBLOCK_INPROGRESS:
4679  case TBLOCK_END:
4680  case TBLOCK_SUBRELEASE:
4681  case TBLOCK_SUBCOMMIT:
4682  case TBLOCK_ABORT:
4683  case TBLOCK_ABORT_END:
4684  case TBLOCK_SUBABORT_END:
4685  case TBLOCK_ABORT_PENDING:
4687  case TBLOCK_SUBRESTART:
4689  case TBLOCK_PREPARE:
4690  elog(FATAL, "RollbackAndReleaseCurrentSubTransaction: unexpected state %s",
4692  break;
4693  }
4694 
4695  /*
4696  * Abort the current subtransaction, if needed.
4697  */
4698  if (s->blockState == TBLOCK_SUBINPROGRESS)
4700 
4701  /* And clean it up, too */
4703 
4704  s = CurrentTransactionState; /* changed by pop */
4706  s->blockState == TBLOCK_INPROGRESS ||
4708  s->blockState == TBLOCK_STARTED);
4709 }

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

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

◆ RollbackToSavepoint()

void RollbackToSavepoint ( const char *  name)

Definition at line 4420 of file xact.c.

4421 {
4423  TransactionState target,
4424  xact;
4425 
4426  /*
4427  * Workers synchronize transaction state at the beginning of each parallel
4428  * operation, so we can't account for transaction state change after that
4429  * point. (Note that this check will certainly error out if s->blockState
4430  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4431  * below.)
4432  */
4433  if (IsInParallelMode())
4434  ereport(ERROR,
4435  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4436  errmsg("cannot rollback to savepoints during a parallel operation")));
4437 
4438  switch (s->blockState)
4439  {
4440  /*
4441  * We can't rollback to a savepoint if there is no savepoint
4442  * defined.
4443  */
4444  case TBLOCK_INPROGRESS:
4445  case TBLOCK_ABORT:
4446  ereport(ERROR,
4447  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4448  errmsg("savepoint \"%s\" does not exist", name)));
4449  break;
4450 
4452  /* See comment about implicit transactions in DefineSavepoint */
4453  ereport(ERROR,
4454  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4455  /* translator: %s represents an SQL statement name */
4456  errmsg("%s can only be used in transaction blocks",
4457  "ROLLBACK TO SAVEPOINT")));
4458  break;
4459 
4460  /*
4461  * There is at least one savepoint, so proceed.
4462  */
4463  case TBLOCK_SUBINPROGRESS:
4464  case TBLOCK_SUBABORT:
4465  break;
4466 
4467  /* These cases are invalid. */
4468  case TBLOCK_DEFAULT:
4469  case TBLOCK_STARTED:
4470  case TBLOCK_BEGIN:
4472  case TBLOCK_SUBBEGIN:
4473  case TBLOCK_END:
4474  case TBLOCK_SUBRELEASE:
4475  case TBLOCK_SUBCOMMIT:
4476  case TBLOCK_ABORT_END:
4477  case TBLOCK_SUBABORT_END:
4478  case TBLOCK_ABORT_PENDING:
4480  case TBLOCK_SUBRESTART:
4482  case TBLOCK_PREPARE:
4483  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4485  break;
4486  }
4487 
4488  for (target = s; PointerIsValid(target); target = target->parent)
4489  {
4490  if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4491  break;
4492  }
4493 
4494  if (!PointerIsValid(target))
4495  ereport(ERROR,
4496  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4497  errmsg("savepoint \"%s\" does not exist", name)));
4498 
4499  /* disallow crossing savepoint level boundaries */
4500  if (target->savepointLevel != s->savepointLevel)
4501  ereport(ERROR,
4502  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4503  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4504 
4505  /*
4506  * Mark "abort pending" all subtransactions up to the target
4507  * subtransaction. The actual aborts will happen when control gets to
4508  * CommitTransactionCommand.
4509  */
4510  xact = CurrentTransactionState;
4511  for (;;)
4512  {
4513  if (xact == target)
4514  break;
4515  if (xact->blockState == TBLOCK_SUBINPROGRESS)
4517  else if (xact->blockState == TBLOCK_SUBABORT)
4519  else
4520  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4522  xact = xact->parent;
4523  Assert(PointerIsValid(xact));
4524  }
4525 
4526  /* And mark the target as "restart pending" */
4527  if (xact->blockState == TBLOCK_SUBINPROGRESS)
4528  xact->blockState = TBLOCK_SUBRESTART;
4529  else if (xact->blockState == TBLOCK_SUBABORT)
4531  else
4532  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4534 }

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

Referenced by pa_stream_abort(), and standard_ProcessUtility().

◆ SaveTransactionCharacteristics()

◆ SerializeTransactionState()

void SerializeTransactionState ( Size  maxsize,
char *  start_address 
)

Definition at line 5379 of file xact.c.

5380 {
5381  TransactionState s;
5382  Size nxids = 0;
5383  Size i = 0;
5384  TransactionId *workspace;
5386 
5387  result = (SerializedTransactionState *) start_address;
5388 
5389  result->xactIsoLevel = XactIsoLevel;
5390  result->xactDeferrable = XactDeferrable;
5392  result->currentFullTransactionId =
5395 
5396  /*
5397  * If we're running in a parallel worker and launching a parallel worker
5398  * of our own, we can just pass along the information that was passed to
5399  * us.
5400  */
5401  if (nParallelCurrentXids > 0)
5402  {
5404  memcpy(&result->parallelCurrentXids[0], ParallelCurrentXids,
5406  return;
5407  }
5408 
5409  /*
5410  * OK, we need to generate a sorted list of XIDs that our workers should
5411  * view as current. First, figure out how many there are.
5412  */
5413  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5414  {
5416  nxids = add_size(nxids, 1);
5417  nxids = add_size(nxids, s->nChildXids);
5418  }
5420  <= maxsize);
5421 
5422  /* Copy them to our scratch space. */
5423  workspace = palloc(nxids * sizeof(TransactionId));
5424  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5425  {
5427  workspace[i++] = XidFromFullTransactionId(s->fullTransactionId);
5428  if (s->nChildXids > 0)
5429  memcpy(&workspace[i], s->childXids,
5430  s->nChildXids * sizeof(TransactionId));
5431  i += s->nChildXids;
5432  }
5433  Assert(i == nxids);
5434 
5435  /* Sort them. */
5436  qsort(workspace, nxids, sizeof(TransactionId), xidComparator);
5437 
5438  /* Copy data into output area. */
5439  result->nParallelCurrentXids = nxids;
5440  memcpy(&result->parallelCurrentXids[0], workspace,
5441  nxids * sizeof(TransactionId));
5442 }
int i
Definition: isn.c:73
void * palloc(Size size)
Definition: mcxt.c:1210
#define qsort(a, b, c, d)
Definition: port.h:445
FullTransactionId currentFullTransactionId
Definition: xact.c:226
FullTransactionId topFullTransactionId
Definition: xact.c:225
CommandId currentCommandId
Definition: xact.c:227
TransactionId parallelCurrentXids[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.c:229
TransactionId * childXids
Definition: xact.c:201
static int nParallelCurrentXids
Definition: xact.c:126
static TransactionId * ParallelCurrentXids
Definition: xact.c:127
int xidComparator(const void *arg1, const void *arg2)
Definition: xid.c:138

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

Referenced by InitializeParallelDSM().

◆ SetCurrentStatementStartTimestamp()

void SetCurrentStatementStartTimestamp ( void  )

◆ SetParallelStartTimestamps()

void SetParallelStartTimestamps ( TimestampTz  xact_ts,
TimestampTz  stmt_ts 
)

Definition at line 844 of file xact.c.

845 {
847  xactStartTimestamp = xact_ts;
848  stmtStartTimestamp = stmt_ts;
849 }

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

Referenced by ParallelWorkerMain().

◆ StartParallelWorkerTransaction()

void StartParallelWorkerTransaction ( char *  tstatespace)

◆ StartTransactionCommand()

void StartTransactionCommand ( void  )

Definition at line 2944 of file xact.c.

2945 {
2947 
2948  switch (s->blockState)
2949  {
2950  /*
2951  * if we aren't in a transaction block, we just do our usual start
2952  * transaction.
2953  */
2954  case TBLOCK_DEFAULT:
2955  StartTransaction();
2957  break;
2958 
2959  /*
2960  * We are somewhere in a transaction block or subtransaction and
2961  * about to start a new command. For now we do nothing, but
2962  * someday we may do command-local resource initialization. (Note
2963  * that any needed CommandCounterIncrement was done by the
2964  * previous CommitTransactionCommand.)
2965  */
2966  case TBLOCK_INPROGRESS:
2968  case TBLOCK_SUBINPROGRESS:
2969  break;
2970 
2971  /*
2972  * Here we are in a failed transaction block (one of the commands
2973  * caused an abort) so we do nothing but remain in the abort
2974  * state. Eventually we will get a ROLLBACK command which will
2975  * get us out of this state. (It is up to other code to ensure
2976  * that no commands other than ROLLBACK will be processed in these
2977  * states.)
2978  */
2979  case TBLOCK_ABORT:
2980  case TBLOCK_SUBABORT:
2981  break;
2982 
2983  /* These cases are invalid. */
2984  case TBLOCK_STARTED:
2985  case TBLOCK_BEGIN:
2987  case TBLOCK_SUBBEGIN:
2988  case TBLOCK_END:
2989  case TBLOCK_SUBRELEASE:
2990  case TBLOCK_SUBCOMMIT:
2991  case TBLOCK_ABORT_END:
2992  case TBLOCK_SUBABORT_END:
2993  case TBLOCK_ABORT_PENDING:
2995  case TBLOCK_SUBRESTART:
2997  case TBLOCK_PREPARE:
2998  elog(ERROR, "StartTransactionCommand: unexpected state %s",
3000  break;
3001  }
3002 
3003  /*
3004  * We must switch to CurTransactionContext before returning. This is
3005  * already done if we called StartTransaction, otherwise not.
3006  */
3007  Assert(CurTransactionContext != NULL);
3009 }

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

Referenced by _SPI_commit(), _SPI_rollback(), apply_handle_commit_internal(), ApplyWorkerMain(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), begin_replication_step(), BeginInternalSubTransaction(), BootstrapModeMain(), clear_subscription_skip_lsn(), cluster(), cluster_multiple_rels(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), exec_replication_command(), FetchTableStates(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeApplyWorker(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), ParallelApplyWorkerMain(), ParallelWorkerMain(), perform_work_item(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), ReorderBufferProcessTXN(), shell_check_detail(), SnapBuildExportSnapshot(), start_xact_command(), vacuum(), and vacuum_rel().

◆ SubTransactionIsActive()

bool SubTransactionIsActive ( SubTransactionId  subxid)

Definition at line 794 of file xact.c.

795 {
797 
798  for (s = CurrentTransactionState; s != NULL; s = s->parent)
799  {
800  if (s->state == TRANS_ABORT)
801  continue;
802  if (s->subTransactionId == subxid)
803  return true;
804  }
805  return false;
806 }

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

Referenced by fmgr_sql().

◆ TransactionBlockStatusCode()

char TransactionBlockStatusCode ( void  )

Definition at line 4855 of file xact.c.

4856 {
4858 
4859  switch (s->blockState)
4860  {
4861  case TBLOCK_DEFAULT:
4862  case TBLOCK_STARTED:
4863  return 'I'; /* idle --- not in transaction */
4864  case TBLOCK_BEGIN:
4865  case TBLOCK_SUBBEGIN:
4866  case TBLOCK_INPROGRESS:
4869  case TBLOCK_SUBINPROGRESS:
4870  case TBLOCK_END:
4871  case TBLOCK_SUBRELEASE:
4872  case TBLOCK_SUBCOMMIT:
4873  case TBLOCK_PREPARE:
4874  return 'T'; /* in transaction */
4875  case TBLOCK_ABORT:
4876  case TBLOCK_SUBABORT:
4877  case TBLOCK_ABORT_END:
4878  case TBLOCK_SUBABORT_END:
4879  case TBLOCK_ABORT_PENDING:
4881  case TBLOCK_SUBRESTART:
4883  return 'E'; /* in failed transaction */
4884  }
4885 
4886  /* should never get here */
4887  elog(FATAL, "invalid transaction block state: %s",
4889  return 0; /* keep compiler quiet */
4890 }

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

Referenced by ReadyForQuery().

◆ TransactionIdIsCurrentTransactionId()

bool TransactionIdIsCurrentTransactionId ( TransactionId  xid)

Definition at line 926 of file xact.c.

927 {
929 
930  /*
931  * We always say that BootstrapTransactionId is "not my transaction ID"
932  * even when it is (ie, during bootstrap). Along with the fact that
933  * transam.c always treats BootstrapTransactionId as already committed,
934  * this causes the heapam_visibility.c routines to see all tuples as
935  * committed, which is what we need during bootstrap. (Bootstrap mode
936  * only inserts tuples, it never updates or deletes them, so all tuples
937  * can be presumed good immediately.)
938  *
939  * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
940  * not my transaction ID, so we can just return "false" immediately for
941  * any non-normal XID.
942  */
943  if (!TransactionIdIsNormal(xid))
944  return false;
945 
947  return true;
948 
949  /*
950  * In parallel workers, the XIDs we must consider as current are stored in
951  * ParallelCurrentXids rather than the transaction-state stack. Note that
952  * the XIDs in this array are sorted numerically rather than according to
953  * transactionIdPrecedes order.
954  */
955  if (nParallelCurrentXids > 0)
956  {
957  int low,
958  high;
959 
960  low = 0;
961  high = nParallelCurrentXids - 1;
962  while (low <= high)
963  {
964  int middle;
965  TransactionId probe;
966 
967  middle = low + (high - low) / 2;
968  probe = ParallelCurrentXids[middle];
969  if (probe == xid)
970  return true;
971  else if (probe < xid)
972  low = middle + 1;
973  else
974  high = middle - 1;
975  }
976  return false;
977  }
978 
979  /*
980  * We will return true for the Xid of the current subtransaction, any of
981  * its subcommitted children, any of its parents, or any of their
982  * previously subcommitted children. However, a transaction being aborted
983  * is no longer "current", even though it may still have an entry on the
984  * state stack.
985  */
986  for (s = CurrentTransactionState; s != NULL; s = s->parent)
987  {
988  int low,
989  high;
990 
991  if (s->state == TRANS_ABORT)
992  continue;
994  continue; /* it can't have any child XIDs either */
996  return true;
997  /* As the childXids array is ordered, we can use binary search */
998  low = 0;
999  high = s->nChildXids - 1;
1000  while (low <= high)
1001  {
1002  int middle;
1003  TransactionId probe;
1004 
1005  middle = low + (high - low) / 2;
1006  probe = s->childXids[middle];
1007  if (TransactionIdEquals(probe, xid))
1008  return true;
1009  else if (TransactionIdPrecedes(probe, xid))
1010  low = middle + 1;
1011  else
1012  high = middle - 1;
1013  }
1014  }
1015 
1016  return false;
1017 }
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

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

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

◆ UnregisterSubXactCallback()

void UnregisterSubXactCallback ( SubXactCallback  callback,
void *  arg 
)

Definition at line 3730 of file xact.c.

3731 {
3732  SubXactCallbackItem *item;
3733  SubXactCallbackItem *prev;
3734 
3735  prev = NULL;
3736  for (item = SubXact_callbacks; item; prev = item, item = item->next)
3737  {
3738  if (item->callback == callback && item->arg == arg)
3739  {
3740  if (prev)
3741  prev->next = item->next;
3742  else
3743  SubXact_callbacks = item->next;
3744  pfree(item);
3745  break;
3746  }
3747  }
3748 }
void pfree(void *pointer)
Definition: mcxt.c:1436

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

◆ UnregisterXactCallback()

void UnregisterXactCallback ( XactCallback  callback,
void *  arg 
)

Definition at line 3670 of file xact.c.

3671 {
3672  XactCallbackItem *item;
3673  XactCallbackItem *prev;
3674 
3675  prev = NULL;
3676  for (item = Xact_callbacks; item; prev = item, item = item->next)
3677  {
3678  if (item->callback == callback && item->arg == arg)
3679  {
3680  if (prev)
3681  prev->next = item->next;
3682  else
3683  Xact_callbacks = item->next;
3684  pfree(item);
3685  break;
3686  }
3687  }
3688 }

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

◆ UserAbortTransactionBlock()

void UserAbortTransactionBlock ( bool  chain)

Definition at line 4057 of file xact.c.

4058 {
4060 
4061  switch (s->blockState)
4062  {
4063  /*
4064  * We are inside a transaction block and we got a ROLLBACK command
4065  * from the user, so tell CommitTransactionCommand to abort and
4066  * exit the transaction block.
4067  */
4068  case TBLOCK_INPROGRESS:
4070  break;
4071 
4072  /*
4073  * We are inside a failed transaction block and we got a ROLLBACK
4074  * command from the user. Abort processing is already done, so
4075  * CommitTransactionCommand just has to cleanup and go back to
4076  * idle state.
4077  */
4078  case TBLOCK_ABORT:
4080  break;
4081 
4082  /*
4083  * We are inside a subtransaction. Mark everything up to top
4084  * level as exitable.
4085  */
4086  case TBLOCK_SUBINPROGRESS:
4087  case TBLOCK_SUBABORT:
4088  while (s->parent != NULL)
4089  {
4090  if (s->blockState == TBLOCK_SUBINPROGRESS)
4092  else if (s->blockState == TBLOCK_SUBABORT)
4094  else
4095  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4097  s = s->parent;
4098  }
4099  if (s->blockState == TBLOCK_INPROGRESS)
4101  else if (s->blockState == TBLOCK_ABORT)
4103  else
4104  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4106  break;
4107 
4108  /*
4109  * The user issued ABORT when not inside a transaction. For
4110  * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4111  * The upcoming call to CommitTransactionCommand() will then put
4112  * us back into the default state. For ROLLBACK AND CHAIN, error.
4113  *
4114  * We do the same thing with ABORT inside an implicit transaction,
4115  * although in this case we might be rolling back actual database
4116  * state changes. (It's debatable whether we should issue a
4117  * WARNING in this case, but we have done so historically.)
4118  */
4119  case TBLOCK_STARTED:
4121  if (chain)
4122  ereport(ERROR,
4123  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4124  /* translator: %s represents an SQL statement name */
4125  errmsg("%s can only be used in transaction blocks",
4126  "ROLLBACK AND CHAIN")));
4127  else
4128  ereport(WARNING,
4129  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4130  errmsg("there is no transaction in progress")));
4132  break;
4133 
4134  /*
4135  * The user issued an ABORT that somehow ran inside a parallel
4136  * worker. We can't cope with that.
4137  */
4139  ereport(FATAL,
4140  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4141  errmsg("cannot abort during a parallel operation")));
4142  break;
4143 
4144  /* These cases are invalid. */
4145  case TBLOCK_DEFAULT:
4146  case TBLOCK_BEGIN:
4147  case TBLOCK_SUBBEGIN:
4148  case TBLOCK_END:
4149  case TBLOCK_SUBRELEASE:
4150  case TBLOCK_SUBCOMMIT:
4151  case TBLOCK_ABORT_END:
4152  case TBLOCK_SUBABORT_END:
4153  case TBLOCK_ABORT_PENDING:
4155  case TBLOCK_SUBRESTART:
4157  case TBLOCK_PREPARE:
4158  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4160  break;
4161  }
4162 
4165 
4166  s->chain = chain;
4167 }

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

Referenced by standard_ProcessUtility().

◆ WarnNoTransactionBlock()

void WarnNoTransactionBlock ( bool  isTopLevel,
const char *  stmtType 
)

Definition at line 3560 of file xact.c.

3561 {
3562  CheckTransactionBlock(isTopLevel, false, stmtType);
3563 }

References CheckTransactionBlock().

Referenced by ExecSetVariableStmt(), and standard_ProcessUtility().

◆ xact_desc()

void xact_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 436 of file xactdesc.c.

437 {
438  char *rec = XLogRecGetData(record);
439  uint8 info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
440 
441  if (info == XLOG_XACT_COMMIT || info == XLOG_XACT_COMMIT_PREPARED)
442  {
443  xl_xact_commit *xlrec = (xl_xact_commit *) rec;
444 
445  xact_desc_commit(buf, XLogRecGetInfo(record), xlrec,
446  XLogRecGetOrigin(record));
447  }
448  else if (info == XLOG_XACT_ABORT || info == XLOG_XACT_ABORT_PREPARED)
449  {
450  xl_xact_abort *xlrec = (xl_xact_abort *) rec;
451 
452  xact_desc_abort(buf, XLogRecGetInfo(record), xlrec,
453  XLogRecGetOrigin(record));
454  }
455  else if (info == XLOG_XACT_PREPARE)
456  {
457  xl_xact_prepare *xlrec = (xl_xact_prepare *) rec;
458 
459  xact_desc_prepare(buf, XLogRecGetInfo(record), xlrec,
460  XLogRecGetOrigin(record));
461  }
462  else if (info == XLOG_XACT_ASSIGNMENT)
463  {
464  xl_xact_assignment *xlrec = (xl_xact_assignment *) rec;
465 
466  /*
467  * Note that we ignore the WAL record's xid, since we're more
468  * interested in the top-level xid that issued the record and which
469  * xids are being reported here.
470  */
471  appendStringInfo(buf, "xtop %u: ", xlrec->xtop);
472  xact_desc_assignment(buf, xlrec);
473  }
474  else if (info == XLOG_XACT_INVALIDATIONS)
475  {
476  xl_xact_invals *xlrec = (xl_xact_invals *) rec;
477 
479  InvalidOid, false);
480  }
481 }
unsigned char uint8
Definition: c.h:488
static char * buf
Definition: pg_test_fsync.c:67
#define InvalidOid
Definition: postgres_ext.h:36
void standby_desc_invalidations(StringInfo buf, int nmsgs, SharedInvalidationMessage *msgs, Oid dbId, Oid tsId, bool relcacheInitFileInval)
Definition: standbydesc.c:105
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
TransactionId xtop
Definition: xact.h:220
#define XLOG_XACT_COMMIT_PREPARED
Definition: xact.h:172
#define XLOG_XACT_INVALIDATIONS
Definition: xact.h:175
#define XLOG_XACT_PREPARE
Definition: xact.h:170
#define XLOG_XACT_COMMIT
Definition: xact.h:169
#define XLOG_XACT_OPMASK
Definition: xact.h:179
#define XLOG_XACT_ABORT
Definition: xact.h:171
#define XLOG_XACT_ASSIGNMENT
Definition: xact.h:174
#define XLOG_XACT_ABORT_PREPARED
Definition: xact.h:173
static void xact_desc_commit(StringInfo buf, uint8 info, xl_xact_commit *xlrec, RepOriginId origin_id)
Definition: xactdesc.c:331
static void xact_desc_abort(StringInfo buf, uint8 info, xl_xact_abort *xlrec, RepOriginId origin_id)
Definition: xactdesc.c:367
static void xact_desc_assignment(StringInfo buf, xl_xact_assignment *xlrec)
Definition: xactdesc.c:425
static void xact_desc_prepare(StringInfo buf, uint8 info, xl_xact_prepare *xlrec, RepOriginId origin_id)
Definition: xactdesc.c:394
#define XLogRecGetOrigin(decoder)
Definition: xlogreader.h:412
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:409
#define XLogRecGetData(decoder)
Definition: xlogreader.h:414

References appendStringInfo(), buf, InvalidOid, xl_xact_invals::msgs, xl_xact_invals::nmsgs, 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, XLogRecGetOrigin, and xl_xact_assignment::xtop.

◆ xact_identify()

const char* xact_identify ( uint8  info)

Definition at line 484 of file xactdesc.c.

485 {
486  const char *id = NULL;
487 
488  switch (info & XLOG_XACT_OPMASK)
489  {
490  case XLOG_XACT_COMMIT:
491  id = "COMMIT";
492  break;
493  case XLOG_XACT_PREPARE:
494  id = "PREPARE";
495  break;
496  case XLOG_XACT_ABORT:
497  id = "ABORT";
498  break;
500  id = "COMMIT_PREPARED";
501  break;
503  id = "ABORT_PREPARED";
504  break;
506  id = "ASSIGNMENT";
507  break;
509  id = "INVALIDATION";
510  break;
511  }
512 
513  return id;
514 }

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

Definition at line 6193 of file xact.c.

6194 {
6195  uint8 info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
6196 
6197  /* Backup blocks are not used in xact records */
6198  Assert(!XLogRecHasAnyBlockRefs(record));
6199 
6200  if (info == XLOG_XACT_COMMIT)
6201  {
6202  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6203  xl_xact_parsed_commit parsed;
6204 
6205  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6206  xact_redo_commit(&parsed, XLogRecGetXid(record),
6207  record->EndRecPtr, XLogRecGetOrigin(record));
6208  }
6209  else if (info == XLOG_XACT_COMMIT_PREPARED)
6210  {
6211  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6212  xl_xact_parsed_commit parsed;
6213 
6214  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6215  xact_redo_commit(&parsed, parsed.twophase_xid,
6216  record->EndRecPtr, XLogRecGetOrigin(record));
6217 
6218  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6219  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6220  PrepareRedoRemove(parsed.twophase_xid, false);
6221  LWLockRelease(TwoPhaseStateLock);
6222  }
6223  else if (info == XLOG_XACT_ABORT)
6224  {
6225  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6226  xl_xact_parsed_abort parsed;
6227 
6228  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6229  xact_redo_abort(&parsed, XLogRecGetXid(record),
6230  record->EndRecPtr, XLogRecGetOrigin(record));
6231  }
6232  else if (info == XLOG_XACT_ABORT_PREPARED)
6233  {
6234  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6235  xl_xact_parsed_abort parsed;
6236 
6237  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6238  xact_redo_abort(&parsed, parsed.twophase_xid,
6239  record->EndRecPtr, XLogRecGetOrigin(record));
6240 
6241  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6242  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6243  PrepareRedoRemove(parsed.twophase_xid, false);
6244  LWLockRelease(TwoPhaseStateLock);
6245  }
6246  else if (info == XLOG_XACT_PREPARE)
6247  {
6248  /*
6249  * Store xid and start/end pointers of the WAL record in TwoPhaseState
6250  * gxact entry.
6251  */
6252  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6254  record->ReadRecPtr,
6255  record->EndRecPtr,
6256  XLogRecGetOrigin(record));
6257  LWLockRelease(TwoPhaseStateLock);
6258  }
6259  else if (info == XLOG_XACT_ASSIGNMENT)
6260  {
6262 
6265  xlrec->nsubxacts, xlrec->xsub);
6266  }
6267  else if (info == XLOG_XACT_INVALIDATIONS)
6268  {
6269  /*
6270  * XXX we do ignore this for now, what matters are invalidations
6271  * written into the commit record.
6272  */
6273  }
6274  else
6275  elog(PANIC, "xact_redo: unknown op code %u", info);
6276 }
#define PANIC
Definition: elog.h:42
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1195
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1803
@ LW_EXCLUSIVE
Definition: lwlock.h:115
void ProcArrayApplyXidAssignment(TransactionId topxid, int nsubxids, TransactionId *subxids)
Definition: procarray.c:1305
XLogRecPtr EndRecPtr
Definition: xlogreader.h:207
XLogRecPtr ReadRecPtr
Definition: xlogreader.h:206
TransactionId xsub[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.h:222
void PrepareRedoRemove(TransactionId xid, bool giveWarning)
Definition: twophase.c:2525
void PrepareRedoAdd(char *buf, XLogRecPtr start_lsn, XLogRecPtr end_lsn, RepOriginId origin_id)
Definition: twophase.c:2455
static void xact_redo_commit(xl_xact_parsed_commit *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)
Definition: xact.c:5960
static void xact_redo_abort(xl_xact_parsed_abort *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)
Definition: xact.c:6114
void ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *parsed)
Definition: xactdesc.c:35
void ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
Definition: xactdesc.c:141
#define XLogRecGetXid(decoder)
Definition: xlogreader.h:411
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:416
HotStandbyState standbyState
Definition: xlogutils.c:56
@ STANDBY_INITIALIZED
Definition: xlogutils.h:50

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

◆ xactGetCommittedChildren()

int xactGetCommittedChildren ( TransactionId **  ptr)

Definition at line 5620 of file xact.c.

5621 {
5623 
5624  if (s->nChildXids == 0)
5625  *ptr = NULL;
5626  else
5627  *ptr = s->childXids;
5628 
5629  return s->nChildXids;
5630 }

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

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

◆ XactLogAbortRecord()

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

Definition at line 5816 of file xact.c.

5822 {
5823  xl_xact_abort xlrec;
5824  xl_xact_xinfo xl_xinfo;
5825  xl_xact_subxacts xl_subxacts;
5826  xl_xact_relfilelocators xl_relfilelocators;
5827  xl_xact_stats_items xl_dropped_stats;
5828  xl_xact_twophase xl_twophase;
5829  xl_xact_dbinfo xl_dbinfo;
5830  xl_xact_origin xl_origin;
5831 
5832  uint8 info;
5833 
5834  Assert(CritSectionCount > 0);
5835 
5836  xl_xinfo.xinfo = 0;
5837 
5838  /* decide between a plain and 2pc abort */
5839  if (!TransactionIdIsValid(twophase_xid))
5840  info = XLOG_XACT_ABORT;
5841  else
5842  info = XLOG_XACT_ABORT_PREPARED;
5843 
5844 
5845  /* First figure out and collect all the information needed */
5846 
5847  xlrec.xact_time = abort_time;
5848 
5849  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5850  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5851 
5852  if (nsubxacts > 0)
5853  {
5854  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5855  xl_subxacts.nsubxacts = nsubxacts;
5856  }
5857 
5858  if (nrels > 0)
5859  {
5861  xl_relfilelocators.nrels = nrels;
5862  info |= XLR_SPECIAL_REL_UPDATE;
5863  }
5864 
5865  if (ndroppedstats > 0)
5866  {
5867  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5868  xl_dropped_stats.nitems = ndroppedstats;
5869  }
5870 
5871  if (TransactionIdIsValid(twophase_xid))
5872  {
5873  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5874  xl_twophase.xid = twophase_xid;
5875  Assert(twophase_gid != NULL);
5876 
5877  if (XLogLogicalInfoActive())
5878  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5879  }
5880 
5881  if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
5882  {
5883  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5884  xl_dbinfo.dbId = MyDatabaseId;
5885  xl_dbinfo.tsId = MyDatabaseTableSpace;
5886  }
5887 
5888  /*
5889  * Dump transaction origin information. We need this during recovery to
5890  * update the replication origin progress.
5891  */
5893  {
5894  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5895 
5898  }
5899 
5900  if (xl_xinfo.xinfo != 0)
5901  info |= XLOG_XACT_HAS_INFO;
5902 
5903  /* Then include all the collected data into the abort record. */
5904 
5905  XLogBeginInsert();
5906 
5907  XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);
5908 
5909  if (xl_xinfo.xinfo != 0)
5910  XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));
5911 
5912  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5913  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
5914 
5915  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5916  {
5917  XLogRegisterData((char *) (&xl_subxacts),
5919  XLogRegisterData((char *) subxacts,
5920  nsubxacts * sizeof(TransactionId));
5921  }
5922 
5923  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5924  {
5925  XLogRegisterData((char *) (&xl_relfilelocators),
5927  XLogRegisterData((char *) rels,
5928  nrels * sizeof(RelFileLocator));
5929  }
5930 
5931  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5932  {
5933  XLogRegisterData((char *) (&xl_dropped_stats),
5935  XLogRegisterData((char *) droppedstats,
5936  ndroppedstats * sizeof(xl_xact_stats_item));
5937  }
5938 
5939  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5940  {
5941  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
5942  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5943  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
5944  }
5945 
5946  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5947  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
5948 
5949  /* Include the replication origin */
5951 
5952  return XLogInsert(RM_XACT_ID, info);
5953 }
#define unconstify(underlying_type, expr)
Definition: c.h:1232
Oid MyDatabaseTableSpace
Definition: globals.c:91
volatile uint32 CritSectionCount
Definition: globals.c:42
Oid MyDatabaseId
Definition: globals.c:89
TimestampTz replorigin_session_origin_timestamp
Definition: origin.c:158
RepOriginId replorigin_session_origin
Definition: origin.c:156
XLogRecPtr replorigin_session_origin_lsn
Definition: origin.c:157
#define InvalidRepOriginId
Definition: origin.h:33
#define XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK
Definition: xact.h:108
#define XACT_XINFO_HAS_AE_LOCKS
Definition: xact.h:194
#define XLOG_INCLUDE_ORIGIN
Definition: xlog.h:149
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:351
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:451
void XLogSetRecordFlags(uint8 flags)
Definition: xloginsert.c:433
void XLogBeginInsert(void)
Definition: xloginsert.c:150
#define XLR_SPECIAL_REL_UPDATE
Definition: xlogrecord.h:71

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

Referenced by RecordTransactionAbort(), and RecordTransactionAbortPrepared().

◆ XactLogCommitRecord()

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

Definition at line 5644 of file xact.c.

5652 {
5653  xl_xact_commit xlrec;
5654  xl_xact_xinfo xl_xinfo;
5655  xl_xact_dbinfo xl_dbinfo;
5656  xl_xact_subxacts xl_subxacts;
5657  xl_xact_relfilelocators xl_relfilelocators;
5658  xl_xact_stats_items xl_dropped_stats;
5659  xl_xact_invals xl_invals;
5660  xl_xact_twophase xl_twophase;
5661  xl_xact_origin xl_origin;
5662  uint8 info;
5663 
5664  Assert(CritSectionCount > 0);
5665 
5666  xl_xinfo.xinfo = 0;
5667 
5668  /* decide between a plain and 2pc commit */
5669  if (!TransactionIdIsValid(twophase_xid))
5670  info = XLOG_XACT_COMMIT;
5671  else
5673 
5674  /* First figure out and collect all the information needed */
5675 
5676  xlrec.xact_time = commit_time;
5677 
5678  if (relcacheInval)
5680  if (forceSyncCommit)
5682  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5683  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5684 
5685  /*
5686  * Check if the caller would like to ask standbys for immediate feedback
5687  * once this commit is applied.
5688  */
5691 
5692  /*
5693  * Relcache invalidations requires information about the current database
5694  * and so does logical decoding.
5695  */
5696  if (nmsgs > 0 || XLogLogicalInfoActive())
5697  {
5698  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5699  xl_dbinfo.dbId = MyDatabaseId;
5700  xl_dbinfo.tsId = MyDatabaseTableSpace;
5701  }
5702 
5703  if (nsubxacts > 0)
5704  {
5705  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5706  xl_subxacts.nsubxacts = nsubxacts;
5707  }
5708 
5709  if (nrels > 0)
5710  {
5712  xl_relfilelocators.nrels = nrels;
5713  info |= XLR_SPECIAL_REL_UPDATE;
5714  }
5715 
5716  if (ndroppedstats > 0)
5717  {
5718  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5719  xl_dropped_stats.nitems = ndroppedstats;
5720  }
5721 
5722  if (nmsgs > 0)
5723  {
5724  xl_xinfo.xinfo |= XACT_XINFO_HAS_INVALS;
5725  xl_invals.nmsgs = nmsgs;
5726  }
5727 
5728  if (TransactionIdIsValid(twophase_xid))
5729  {
5730  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5731  xl_twophase.xid = twophase_xid;
5732  Assert(twophase_gid != NULL);
5733 
5734  if (XLogLogicalInfoActive())
5735  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5736  }
5737 
5738  /* dump transaction origin information */
5740  {
5741  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5742 
5745  }
5746 
5747  if (xl_xinfo.xinfo != 0)
5748  info |= XLOG_XACT_HAS_INFO;
5749 
5750  /* Then include all the collected data into the commit record. */
5751 
5752  XLogBeginInsert();
5753 
5754  XLogRegisterData((char *) (&xlrec), sizeof(xl_xact_commit));
5755 
5756  if (xl_xinfo.xinfo != 0)
5757  XLogRegisterData((char *) (&xl_xinfo.xinfo), sizeof(xl_xinfo.xinfo));
5758 
5759  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5760  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
5761 
5762  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5763  {
5764  XLogRegisterData((char *) (&xl_subxacts),
5766  XLogRegisterData((char *) subxacts,
5767  nsubxacts * sizeof(TransactionId));
5768  }
5769 
5770  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5771  {
5772  XLogRegisterData((char *) (&xl_relfilelocators),
5774  XLogRegisterData((char *) rels,
5775  nrels * sizeof(RelFileLocator));
5776  }
5777 
5778  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5779  {
5780  XLogRegisterData((char *) (&xl_dropped_stats),
5782  XLogRegisterData((char *) droppedstats,
5783  ndroppedstats * sizeof(xl_xact_stats_item));
5784  }
5785 
5786  if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
5787  {
5788  XLogRegisterData((char *) (&xl_invals), MinSizeOfXactInvals);
5789  XLogRegisterData((char *) msgs,
5790  nmsgs * sizeof(SharedInvalidationMessage));
5791  }
5792 
5793  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5794  {
5795  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
5796  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5797  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
5798  }
5799 
5800  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5801  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
5802 
5803  /* we allow filtering by xacts */
5805 
5806  return XLogInsert(RM_XACT_ID, info);
5807 }
int synchronous_commit
Definition: xact.c:87
#define XACT_COMPLETION_UPDATE_RELCACHE_FILE
Definition: xact.h:207
#define XACT_COMPLETION_FORCE_SYNC_COMMIT
Definition: xact.h:208
#define XACT_COMPLETION_APPLY_FEEDBACK
Definition: xact.h:206

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

Referenced by RecordTransactionCommit(), and RecordTransactionCommitPrepared().

Variable Documentation

◆ bsysscan

◆ CheckXidAlive

◆ DefaultXactDeferrable

PGDLLIMPORT bool DefaultXactDeferrable
extern

Definition at line 84 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactIsoLevel

PGDLLIMPORT int DefaultXactIsoLevel
extern

Definition at line 78 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactReadOnly

PGDLLIMPORT bool DefaultXactReadOnly
extern

Definition at line 81 of file xact.c.

Referenced by StartTransaction().

◆ MyXactFlags

◆ synchronous_commit

PGDLLIMPORT int synchronous_commit
extern

Definition at line 87 of file xact.c.

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

◆ xact_is_sampled

PGDLLIMPORT bool xact_is_sampled
extern

Definition at line 290 of file xact.c.

Referenced by check_log_duration(), and StartTransaction().

◆ XactDeferrable

◆ XactIsoLevel

◆ XactReadOnly