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 3320 of file xact.c.

3321 {
3323 
3324  switch (s->blockState)
3325  {
3326  case TBLOCK_DEFAULT:
3327  if (s->state == TRANS_DEFAULT)
3328  {
3329  /* we are idle, so nothing to do */
3330  }
3331  else
3332  {
3333  /*
3334  * We can get here after an error during transaction start
3335  * (state will be TRANS_START). Need to clean up the
3336  * incompletely started transaction. First, adjust the
3337  * low-level state to suppress warning message from
3338  * AbortTransaction.
3339  */
3340  if (s->state == TRANS_START)
3341  s->state = TRANS_INPROGRESS;
3342  AbortTransaction();
3344  }
3345  break;
3346 
3347  /*
3348  * If we aren't in a transaction block, we just do the basic abort
3349  * & cleanup transaction. For this purpose, we treat an implicit
3350  * transaction block as if it were a simple statement.
3351  */
3352  case TBLOCK_STARTED:
3354  AbortTransaction();
3357  break;
3358 
3359  /*
3360  * If we are in TBLOCK_BEGIN it means something screwed up right
3361  * after reading "BEGIN TRANSACTION". We assume that the user
3362  * will interpret the error as meaning the BEGIN failed to get him
3363  * into a transaction block, so we should abort and return to idle
3364  * state.
3365  */
3366  case TBLOCK_BEGIN:
3367  AbortTransaction();
3370  break;
3371 
3372  /*
3373  * We are somewhere in a transaction block and we've gotten a
3374  * failure, so we abort the transaction and set up the persistent
3375  * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3376  */
3377  case TBLOCK_INPROGRESS:
3379  AbortTransaction();
3380  s->blockState = TBLOCK_ABORT;
3381  /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3382  break;
3383 
3384  /*
3385  * Here, we failed while trying to COMMIT. Clean up the
3386  * transaction and return to idle state (we do not want to stay in
3387  * the transaction).
3388  */
3389  case TBLOCK_END:
3390  AbortTransaction();
3393  break;
3394 
3395  /*
3396  * Here, we are already in an aborted transaction state and are
3397  * waiting for a ROLLBACK, but for some reason we failed again! So
3398  * we just remain in the abort state.
3399  */
3400  case TBLOCK_ABORT:
3401  case TBLOCK_SUBABORT:
3402  break;
3403 
3404  /*
3405  * We are in a failed transaction and we got the ROLLBACK command.
3406  * We have already aborted, we just need to cleanup and go to idle
3407  * state.
3408  */
3409  case TBLOCK_ABORT_END:
3412  break;
3413 
3414  /*
3415  * We are in a live transaction and we got a ROLLBACK command.
3416  * Abort, cleanup, go to idle state.
3417  */
3418  case TBLOCK_ABORT_PENDING:
3419  AbortTransaction();
3422  break;
3423 
3424  /*
3425  * Here, we failed while trying to PREPARE. Clean up the
3426  * transaction and return to idle state (we do not want to stay in
3427  * the transaction).
3428  */
3429  case TBLOCK_PREPARE:
3430  AbortTransaction();
3433  break;
3434 
3435  /*
3436  * We got an error inside a subtransaction. Abort just the
3437  * subtransaction, and go to the persistent SUBABORT state until
3438  * we get ROLLBACK.
3439  */
3440  case TBLOCK_SUBINPROGRESS:
3443  break;
3444 
3445  /*
3446  * If we failed while trying to create a subtransaction, clean up
3447  * the broken subtransaction and abort the parent. The same
3448  * applies if we get a failure while ending a subtransaction.
3449  */
3450  case TBLOCK_SUBBEGIN:
3451  case TBLOCK_SUBRELEASE:
3452  case TBLOCK_SUBCOMMIT:
3454  case TBLOCK_SUBRESTART:
3458  break;
3459 
3460  /*
3461  * Same as above, except the Abort() was already done.
3462  */
3463  case TBLOCK_SUBABORT_END:
3467  break;
3468  }
3469 }
TransState state
Definition: xact.c:193
TBlockState blockState
Definition: xact.c:194
static void CleanupSubTransaction(void)
Definition: xact.c:5245
static void CleanupTransaction(void)
Definition: xact.c:2903
@ TRANS_INPROGRESS
Definition: xact.c:143
@ TRANS_START
Definition: xact.c:142
@ TRANS_DEFAULT
Definition: xact.c:141
static void AbortSubTransaction(void)
Definition: xact.c:5073
@ TBLOCK_DEFAULT
Definition: xact.c:158
@ TBLOCK_SUBABORT_END
Definition: xact.c:178
@ TBLOCK_STARTED
Definition: xact.c:159
@ TBLOCK_SUBCOMMIT
Definition: xact.c:176
@ TBLOCK_IMPLICIT_INPROGRESS
Definition: xact.c:164
@ TBLOCK_ABORT_END
Definition: xact.c:168
@ TBLOCK_PREPARE
Definition: xact.c:170
@ TBLOCK_ABORT_PENDING
Definition: xact.c:169
@ TBLOCK_ABORT
Definition: xact.c:167
@ TBLOCK_SUBRELEASE
Definition: xact.c:175
@ TBLOCK_SUBBEGIN
Definition: xact.c:173
@ TBLOCK_SUBABORT
Definition: xact.c:177
@ TBLOCK_SUBRESTART
Definition: xact.c:180
@ TBLOCK_INPROGRESS
Definition: xact.c:163
@ TBLOCK_END
Definition: xact.c:166
@ TBLOCK_PARALLEL_INPROGRESS
Definition: xact.c:165
@ TBLOCK_SUBABORT_RESTART
Definition: xact.c:181
@ TBLOCK_SUBABORT_PENDING
Definition: xact.c:179
@ TBLOCK_BEGIN
Definition: xact.c:162
@ TBLOCK_SUBINPROGRESS
Definition: xact.c:174
static void AbortTransaction(void)
Definition: xact.c:2708
static TransactionState CurrentTransactionState
Definition: xact.c:252
void AbortCurrentTransaction(void)
Definition: xact.c:3320

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 4727 of file xact.c.

4728 {
4730 
4731  /* Ensure we're not running in a doomed memory context */
4732  AtAbort_Memory();
4733 
4734  /*
4735  * Get out of any transaction or nested transaction
4736  */
4737  do
4738  {
4739  switch (s->blockState)
4740  {
4741  case TBLOCK_DEFAULT:
4742  if (s->state == TRANS_DEFAULT)
4743  {
4744  /* Not in a transaction, do nothing */
4745  }
4746  else
4747  {
4748  /*
4749  * We can get here after an error during transaction start
4750  * (state will be TRANS_START). Need to clean up the
4751  * incompletely started transaction. First, adjust the
4752  * low-level state to suppress warning message from
4753  * AbortTransaction.
4754  */
4755  if (s->state == TRANS_START)
4756  s->state = TRANS_INPROGRESS;
4757  AbortTransaction();
4759  }
4760  break;
4761  case TBLOCK_STARTED:
4762  case TBLOCK_BEGIN:
4763  case TBLOCK_INPROGRESS:
4766  case TBLOCK_END:
4767  case TBLOCK_ABORT_PENDING:
4768  case TBLOCK_PREPARE:
4769  /* In a transaction, so clean up */
4770  AbortTransaction();
4773  break;
4774  case TBLOCK_ABORT:
4775  case TBLOCK_ABORT_END:
4776 
4777  /*
4778  * AbortTransaction is already done, still need Cleanup.
4779  * However, if we failed partway through running ROLLBACK,
4780  * there will be an active portal running that command, which
4781  * we need to shut down before doing CleanupTransaction.
4782  */
4783  AtAbort_Portals();
4786  break;
4787 
4788  /*
4789  * In a subtransaction, so clean it up and abort parent too
4790  */
4791  case TBLOCK_SUBBEGIN:
4792  case TBLOCK_SUBINPROGRESS:
4793  case TBLOCK_SUBRELEASE:
4794  case TBLOCK_SUBCOMMIT:
4796  case TBLOCK_SUBRESTART:
4799  s = CurrentTransactionState; /* changed by pop */
4800  break;
4801 
4802  case TBLOCK_SUBABORT:
4803  case TBLOCK_SUBABORT_END:
4805  /* As above, but AbortSubTransaction already done */
4806  if (s->curTransactionOwner)
4807  {
4808  /* As in TBLOCK_ABORT, might have a live portal to zap */
4813  }
4815  s = CurrentTransactionState; /* changed by pop */
4816  break;
4817  }
4818  } while (s->blockState != TBLOCK_DEFAULT);
4819 
4820  /* Should be out of all subxacts now */
4821  Assert(s->parent == NULL);
4822 
4823  /* If we didn't actually have anything to do, revert to TopMemoryContext */
4824  AtCleanup_Memory();
4825 }
Assert(fmt[strlen(fmt) - 1] !='\n')
void AtAbort_Portals(void)
Definition: portalmem.c:781
void AtSubAbort_Portals(SubTransactionId mySubid, SubTransactionId parentSubid, ResourceOwner myXactOwner, ResourceOwner parentXactOwner)
Definition: portalmem.c:979
SubTransactionId subTransactionId
Definition: xact.c:190
struct TransactionStateData * parent
Definition: xact.c:210
ResourceOwner curTransactionOwner
Definition: xact.c:198
static void AtCleanup_Memory(void)
Definition: xact.c:1920
static void AtAbort_Memory(void)
Definition: xact.c:1830

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 4187 of file xact.c.

4188 {
4190 
4191  /*
4192  * If we are in STARTED state (that is, no transaction block is open),
4193  * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4194  * block.
4195  *
4196  * For caller convenience, we consider all other transaction states as
4197  * legal here; otherwise the caller would need its own state check, which
4198  * seems rather pointless.
4199  */
4200  if (s->blockState == TBLOCK_STARTED)
4202 }

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

Referenced by exec_simple_query().

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char *  name)

Definition at line 4555 of file xact.c.

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

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 3785 of file xact.c.

3786 {
3788 
3789  switch (s->blockState)
3790  {
3791  /*
3792  * We are not inside a transaction block, so allow one to begin.
3793  */
3794  case TBLOCK_STARTED:
3795  s->blockState = TBLOCK_BEGIN;
3796  break;
3797 
3798  /*
3799  * BEGIN converts an implicit transaction block to a regular one.
3800  * (Note that we allow this even if we've already done some
3801  * commands, which is a bit odd but matches historical practice.)
3802  */
3804  s->blockState = TBLOCK_BEGIN;
3805  break;
3806 
3807  /*
3808  * Already a transaction block in progress.
3809  */
3810  case TBLOCK_INPROGRESS:
3812  case TBLOCK_SUBINPROGRESS:
3813  case TBLOCK_ABORT:
3814  case TBLOCK_SUBABORT:
3815  ereport(WARNING,
3816  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3817  errmsg("there is already a transaction in progress")));
3818  break;
3819 
3820  /* These cases are invalid. */
3821  case TBLOCK_DEFAULT:
3822  case TBLOCK_BEGIN:
3823  case TBLOCK_SUBBEGIN:
3824  case TBLOCK_END:
3825  case TBLOCK_SUBRELEASE:
3826  case TBLOCK_SUBCOMMIT:
3827  case TBLOCK_ABORT_END:
3828  case TBLOCK_SUBABORT_END:
3829  case TBLOCK_ABORT_PENDING:
3831  case TBLOCK_SUBRESTART:
3833  case TBLOCK_PREPARE:
3834  elog(FATAL, "BeginTransactionBlock: unexpected state %s",
3836  break;
3837  }
3838 }
#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 1076 of file xact.c.

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

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(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAlterColumnType(), ATExecCmd(), ATExecDropColumn(), ATExecDropExpression(), ATExecDropIdentity(), ATExecSetCompression(), ATExecSetExpression(), ATExecSetTableSpace(), ATExecSetTableSpaceNoStorage(), ATInheritAdjustNotNulls(), 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(), DefineIndex(), DefineRelation(), DefineVirtualRelation(), deleteOneObject(), DetachPartitionFinalize(), DropClonedTriggersFromPartition(), dropconstraint_internal(), 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(), SetDatatabaseHasLoginEventTriggers(), SetDefaultACL(), SetMatViewPopulatedState(), shdepReassignOwned(), SPI_cursor_open_internal(), standard_ProcessUtility(), StoreConstraints(), StorePartitionBound(), tryAttachPartitionForeignKey(), vacuum(), and validatePartitionedIndex().

◆ CommitTransactionCommand()

void CommitTransactionCommand ( void  )

Definition at line 3049 of file xact.c.

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

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(), ATExecDetachPartition(), autoprewarm_database_main(), bbsink_server_new(), BeginInternalSubTransaction(), BootstrapModeMain(), clear_subscription_skip_lsn(), cluster_multiple_rels(), DefineIndex(), DisableSubscriptionAndExit(), do_autovacuum(), EventTriggerOnLogin(), exec_replication_command(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitializeLogRepWorker(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), pa_start_subtrans(), pa_stream_abort(), ParallelApplyWorkerMain(), ParallelWorkerMain(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessCatchupInterrupt(), ProcessIncomingNotify(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), run_apply_worker(), shell_check_detail(), stream_abort_internal(), stream_stop_internal(), synchronize_slots(), vacuum(), vacuum_rel(), validate_remote_info(), and worker_spi_main().

◆ DefineSavepoint()

void DefineSavepoint ( const char *  name)

Definition at line 4234 of file xact.c.

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

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 4212 of file xact.c.

4213 {
4215 
4216  /*
4217  * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4218  * allowing CommitTransactionCommand to commit whatever happened during
4219  * the implicit transaction block as though it were a single statement.
4220  *
4221  * For caller convenience, we consider all other transaction states as
4222  * legal here; otherwise the caller would need its own state check, which
4223  * seems rather pointless.
4224  */
4227 }

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

Referenced by exec_simple_query().

◆ EndParallelWorkerTransaction()

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool  chain)

Definition at line 3905 of file xact.c.

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

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 5373 of file xact.c.

5374 {
5375  TransactionState s;
5376  Size nxids = 0;
5378 
5379  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5380  {
5382  nxids = add_size(nxids, 1);
5383  nxids = add_size(nxids, s->nChildXids);
5384  }
5385 
5386  return add_size(size, mul_size(sizeof(TransactionId), nxids));
5387 }
uint32 TransactionId
Definition: c.h:639
size_t Size
Definition: c.h:592
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
Size mul_size(Size s1, Size s2)
Definition: shmem.c:510
static pg_noinline void Size size
Definition: slab.c:607
FullTransactionId fullTransactionId
Definition: xact.c:189
#define FullTransactionIdIsValid(x)
Definition: transam.h:55
#define SerializedTransactionStateHeaderSize
Definition: xact.c:231

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

Referenced by InitializeParallelDSM().

◆ ExitParallelMode()

void ExitParallelMode ( void  )

◆ ForceSyncCommit()

void ForceSyncCommit ( void  )

Definition at line 1126 of file xact.c.

1127 {
1128  forceSyncCommit = true;
1129 }
static bool forceSyncCommit
Definition: xact.c:285

References forceSyncCommit.

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

◆ GetCurrentCommandId()

CommandId GetCurrentCommandId ( bool  used)

Definition at line 816 of file xact.c.

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

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 501 of file xact.c.

502 {
504 
507  return s->fullTransactionId;
508 }
static void AssignTransactionId(TransactionState s)
Definition: xact.c:624

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

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void  )

Definition at line 519 of file xact.c.

520 {
522 }

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void  )

Definition at line 862 of file xact.c.

863 {
864  return stmtStartTimestamp;
865 }
static TimestampTz stmtStartTimestamp
Definition: xact.c:273

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 853 of file xact.c.

854 {
855  return xactStartTimestamp;
856 }
static TimestampTz xactStartTimestamp
Definition: xact.c:272

References xactStartTimestamp.

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

◆ GetCurrentTransactionStopTimestamp()

TimestampTz GetCurrentTransactionStopTimestamp ( void  )

Definition at line 874 of file xact.c.

875 {
877 
878  /* should only be called after commit / abort processing */
879  Assert(s->state == TRANS_DEFAULT ||
880  s->state == TRANS_COMMIT ||
881  s->state == TRANS_ABORT ||
882  s->state == TRANS_PREPARE);
883 
884  if (xactStopTimestamp == 0)
886 
887  return xactStopTimestamp;
888 }
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1654
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:169
static TimestampTz xactStopTimestamp
Definition: xact.c:274
@ TRANS_COMMIT
Definition: xact.c:144
@ TRANS_ABORT
Definition: xact.c:145
@ TRANS_PREPARE
Definition: xact.c:146

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 596 of file xact.c.

597 {
599  static TransactionId stablexid = InvalidTransactionId;
600 
601  if (lxid != MyProc->vxid.lxid)
602  {
603  lxid = MyProc->vxid.lxid;
604  stablexid = GetTopTransactionIdIfAny();
605  if (!TransactionIdIsValid(stablexid))
606  stablexid = ReadNextTransactionId();
607  }
608 
609  Assert(TransactionIdIsValid(stablexid));
610 
611  return stablexid;
612 }
uint32 LocalTransactionId
Definition: c.h:641
#define InvalidLocalTransactionId
Definition: lock.h:65
PGPROC * MyProc
Definition: proc.c:66
LocalTransactionId lxid
Definition: proc.h:196
struct PGPROC::@112 vxid
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:430

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

Referenced by xid_age().

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void  )

Definition at line 472 of file xact.c.

473 {
477 }
static TransactionStateData TopTransactionStateData
Definition: xact.c:239
static FullTransactionId XactTopFullTransactionId
Definition: xact.c:123

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

Referenced by pg_current_xact_id().

◆ GetTopFullTransactionIdIfAny()

FullTransactionId GetTopFullTransactionIdIfAny ( void  )

Definition at line 488 of file xact.c.

489 {
491 }

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

◆ GetTopTransactionId()

◆ GetTopTransactionIdIfAny()

◆ IsAbortedTransactionBlockState()

◆ IsInParallelMode()

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool  isTopLevel)

Definition at line 3627 of file xact.c.

3628 {
3629  /*
3630  * Return true on same conditions that would make
3631  * PreventInTransactionBlock error out
3632  */
3633  if (IsTransactionBlock())
3634  return true;
3635 
3636  if (IsSubTransaction())
3637  return true;
3638 
3640  return true;
3641 
3642  if (!isTopLevel)
3643  return true;
3644 
3647  return true;
3648 
3649  return false;
3650 }
bool IsSubTransaction(void)
Definition: xact.c:4904
bool IsTransactionBlock(void)
Definition: xact.c:4831
int MyXactFlags
Definition: xact.c:134
#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 548 of file xact.c.

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

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

Referenced by MarkSubxactTopXidLogged(), and XLogRecordAssemble().

◆ IsTransactionBlock()

◆ IsTransactionOrTransactionBlock()

◆ IsTransactionState()

bool IsTransactionState ( void  )

Definition at line 376 of file xact.c.

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

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

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

◆ MarkCurrentTransactionIdLoggedIfAny()

void MarkCurrentTransactionIdLoggedIfAny ( void  )

◆ MarkSubxactTopXidLogged()

void MarkSubxactTopXidLogged ( void  )

Definition at line 580 of file xact.c.

581 {
583 
585 }
bool IsSubxactTopXidLogPending(void)
Definition: xact.c:548

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(), SummarizeXactRecord(), 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(), SummarizeXactRecord(), 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:798
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 3853 of file xact.c.

3854 {
3855  TransactionState s;
3856  bool result;
3857 
3858  /* Set up to commit the current transaction */
3859  result = EndTransactionBlock(false);
3860 
3861  /* If successful, change outer tblock state to PREPARE */
3862  if (result)
3863  {
3865 
3866  while (s->parent != NULL)
3867  s = s->parent;
3868 
3869  if (s->blockState == TBLOCK_END)
3870  {
3871  /* Save GID where PrepareTransaction can find it again */
3873 
3875  }
3876  else
3877  {
3878  /*
3879  * ignore case where we are not in a transaction;
3880  * EndTransactionBlock already issued a warning.
3881  */
3884  /* Don't send back a PREPARE result tag... */
3885  result = false;
3886  }
3887  }
3888 
3889  return result;
3890 }
static char * prepareGID
Definition: xact.c:280
bool EndTransactionBlock(bool chain)
Definition: xact.c:3905

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 3496 of file xact.c.

3497 {
3498  /*
3499  * xact block already started?
3500  */
3501  if (IsTransactionBlock())
3502  ereport(ERROR,
3503  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3504  /* translator: %s represents an SQL statement name */
3505  errmsg("%s cannot run inside a transaction block",
3506  stmtType)));
3507 
3508  /*
3509  * subtransaction?
3510  */
3511  if (IsSubTransaction())
3512  ereport(ERROR,
3513  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3514  /* translator: %s represents an SQL statement name */
3515  errmsg("%s cannot run inside a subtransaction",
3516  stmtType)));
3517 
3518  /*
3519  * inside a pipeline that has started an implicit transaction?
3520  */
3522  ereport(ERROR,
3523  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3524  /* translator: %s represents an SQL statement name */
3525  errmsg("%s cannot be executed within a pipeline",
3526  stmtType)));
3527 
3528  /*
3529  * inside a function call?
3530  */
3531  if (!isTopLevel)
3532  ereport(ERROR,
3533  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3534  /* translator: %s represents an SQL statement name */
3535  errmsg("%s cannot be executed from a function", stmtType)));
3536 
3537  /* If we got past IsTransactionBlock test, should be in default state */
3540  elog(FATAL, "cannot prevent transaction chain");
3541 
3542  /* All okay. Set the flag to make sure the right thing happens later. */
3544 }
#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 3725 of file xact.c.

3726 {
3727  SubXactCallbackItem *item;
3728 
3729  item = (SubXactCallbackItem *)
3731  item->callback = callback;
3732  item->arg = arg;
3733  item->next = SubXact_callbacks;
3734  SubXact_callbacks = item;
3735 }
MemoryContext TopMemoryContext
Definition: mcxt.c:137
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1062
void * arg
struct SubXactCallbackItem * next
Definition: xact.c:314
SubXactCallback callback
Definition: xact.c:315
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46
static SubXactCallbackItem * SubXact_callbacks
Definition: xact.c:319

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 3665 of file xact.c.

3666 {
3667  XactCallbackItem *item;
3668 
3669  item = (XactCallbackItem *)
3671  item->callback = callback;
3672  item->arg = arg;
3673  item->next = Xact_callbacks;
3674  Xact_callbacks = item;
3675 }
struct XactCallbackItem * next
Definition: xact.c:302
void * arg
Definition: xact.c:304
XactCallback callback
Definition: xact.c:303
static XactCallbackItem * Xact_callbacks
Definition: xact.c:307

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 4626 of file xact.c.

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

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 4319 of file xact.c.

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

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 3574 of file xact.c.

3575 {
3576  CheckTransactionBlock(isTopLevel, true, stmtType);
3577 }
static void CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType)
Definition: xact.c:3583

References CheckTransactionBlock().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

◆ RestoreTransactionCharacteristics()

◆ RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction ( void  )

Definition at line 4660 of file xact.c.

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

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 4428 of file xact.c.

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

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 5401 of file xact.c.

5402 {
5403  TransactionState s;
5404  Size nxids = 0;
5405  Size i = 0;
5406  TransactionId *workspace;
5408 
5409  result = (SerializedTransactionState *) start_address;
5410 
5411  result->xactIsoLevel = XactIsoLevel;
5412  result->xactDeferrable = XactDeferrable;
5414  result->currentFullTransactionId =
5417 
5418  /*
5419  * If we're running in a parallel worker and launching a parallel worker
5420  * of our own, we can just pass along the information that was passed to
5421  * us.
5422  */
5423  if (nParallelCurrentXids > 0)
5424  {
5426  memcpy(&result->parallelCurrentXids[0], ParallelCurrentXids,
5428  return;
5429  }
5430 
5431  /*
5432  * OK, we need to generate a sorted list of XIDs that our workers should
5433  * view as current. First, figure out how many there are.
5434  */
5435  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5436  {
5438  nxids = add_size(nxids, 1);
5439  nxids = add_size(nxids, s->nChildXids);
5440  }
5442  <= maxsize);
5443 
5444  /* Copy them to our scratch space. */
5445  workspace = palloc(nxids * sizeof(TransactionId));
5446  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5447  {
5449  workspace[i++] = XidFromFullTransactionId(s->fullTransactionId);
5450  if (s->nChildXids > 0)
5451  memcpy(&workspace[i], s->childXids,
5452  s->nChildXids * sizeof(TransactionId));
5453  i += s->nChildXids;
5454  }
5455  Assert(i == nxids);
5456 
5457  /* Sort them. */
5458  qsort(workspace, nxids, sizeof(TransactionId), xidComparator);
5459 
5460  /* Copy data into output area. */
5461  result->nParallelCurrentXids = nxids;
5462  memcpy(&result->parallelCurrentXids[0], workspace,
5463  nxids * sizeof(TransactionId));
5464 }
int i
Definition: isn.c:73
void * palloc(Size size)
Definition: mcxt.c:1197
#define qsort(a, b, c, d)
Definition: port.h:449
FullTransactionId currentFullTransactionId
Definition: xact.c:224
FullTransactionId topFullTransactionId
Definition: xact.c:223
CommandId currentCommandId
Definition: xact.c:225
TransactionId parallelCurrentXids[FLEXIBLE_ARRAY_MEMBER]
Definition: xact.c:227
TransactionId * childXids
Definition: xact.c:199
static int nParallelCurrentXids
Definition: xact.c:124
static TransactionId * ParallelCurrentXids
Definition: xact.c:125
int xidComparator(const void *arg1, const void *arg2)
Definition: xid.c:139

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 842 of file xact.c.

843 {
845  xactStartTimestamp = xact_ts;
846  stmtStartTimestamp = stmt_ts;
847 }

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

Referenced by ParallelWorkerMain().

◆ StartParallelWorkerTransaction()

void StartParallelWorkerTransaction ( char *  tstatespace)

◆ StartTransactionCommand()

void StartTransactionCommand ( void  )

Definition at line 2952 of file xact.c.

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

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

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

◆ SubTransactionIsActive()

bool SubTransactionIsActive ( SubTransactionId  subxid)

Definition at line 792 of file xact.c.

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

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

Referenced by fmgr_sql().

◆ TransactionBlockStatusCode()

char TransactionBlockStatusCode ( void  )

Definition at line 4863 of file xact.c.

4864 {
4866 
4867  switch (s->blockState)
4868  {
4869  case TBLOCK_DEFAULT:
4870  case TBLOCK_STARTED:
4871  return 'I'; /* idle --- not in transaction */
4872  case TBLOCK_BEGIN:
4873  case TBLOCK_SUBBEGIN:
4874  case TBLOCK_INPROGRESS:
4877  case TBLOCK_SUBINPROGRESS:
4878  case TBLOCK_END:
4879  case TBLOCK_SUBRELEASE:
4880  case TBLOCK_SUBCOMMIT:
4881  case TBLOCK_PREPARE:
4882  return 'T'; /* in transaction */
4883  case TBLOCK_ABORT:
4884  case TBLOCK_SUBABORT:
4885  case TBLOCK_ABORT_END:
4886  case TBLOCK_SUBABORT_END:
4887  case TBLOCK_ABORT_PENDING:
4889  case TBLOCK_SUBRESTART:
4891  return 'E'; /* in failed transaction */
4892  }
4893 
4894  /* should never get here */
4895  elog(FATAL, "invalid transaction block state: %s",
4897  return 0; /* keep compiler quiet */
4898 }

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 924 of file xact.c.

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

3739 {
3740  SubXactCallbackItem *item;
3741  SubXactCallbackItem *prev;
3742 
3743  prev = NULL;
3744  for (item = SubXact_callbacks; item; prev = item, item = item->next)
3745  {
3746  if (item->callback == callback && item->arg == arg)
3747  {
3748  if (prev)
3749  prev->next = item->next;
3750  else
3751  SubXact_callbacks = item->next;
3752  pfree(item);
3753  break;
3754  }
3755  }
3756 }
void pfree(void *pointer)
Definition: mcxt.c:1401

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

◆ UnregisterXactCallback()

void UnregisterXactCallback ( XactCallback  callback,
void *  arg 
)

Definition at line 3678 of file xact.c.

3679 {
3680  XactCallbackItem *item;
3681  XactCallbackItem *prev;
3682 
3683  prev = NULL;
3684  for (item = Xact_callbacks; item; prev = item, item = item->next)
3685  {
3686  if (item->callback == callback && item->arg == arg)
3687  {
3688  if (prev)
3689  prev->next = item->next;
3690  else
3691  Xact_callbacks = item->next;
3692  pfree(item);
3693  break;
3694  }
3695  }
3696 }

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

◆ UserAbortTransactionBlock()

void UserAbortTransactionBlock ( bool  chain)

Definition at line 4065 of file xact.c.

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

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 3568 of file xact.c.

3569 {
3570  CheckTransactionBlock(isTopLevel, false, stmtType);
3571 }

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:491
static char * buf
Definition: pg_test_fsync.c:73
#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:97
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:413
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415

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 6215 of file xact.c.

6216 {
6217  uint8 info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
6218 
6219  /* Backup blocks are not used in xact records */
6220  Assert(!XLogRecHasAnyBlockRefs(record));
6221 
6222  if (info == XLOG_XACT_COMMIT)
6223  {
6224  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6225  xl_xact_parsed_commit parsed;
6226 
6227  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6228  xact_redo_commit(&parsed, XLogRecGetXid(record),
6229  record->EndRecPtr, XLogRecGetOrigin(record));
6230  }
6231  else if (info == XLOG_XACT_COMMIT_PREPARED)
6232  {
6233  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6234  xl_xact_parsed_commit parsed;
6235 
6236  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6237  xact_redo_commit(&parsed, parsed.twophase_xid,
6238  record->EndRecPtr, XLogRecGetOrigin(record));
6239 
6240  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6241  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6242  PrepareRedoRemove(parsed.twophase_xid, false);
6243  LWLockRelease(TwoPhaseStateLock);
6244  }
6245  else if (info == XLOG_XACT_ABORT)
6246  {
6247  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6248  xl_xact_parsed_abort parsed;
6249 
6250  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6251  xact_redo_abort(&parsed, XLogRecGetXid(record),
6252  record->EndRecPtr, XLogRecGetOrigin(record));
6253  }
6254  else if (info == XLOG_XACT_ABORT_PREPARED)
6255  {
6256  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6257  xl_xact_parsed_abort parsed;
6258 
6259  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6260  xact_redo_abort(&parsed, parsed.twophase_xid,
6261  record->EndRecPtr, XLogRecGetOrigin(record));
6262 
6263  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6264  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6265  PrepareRedoRemove(parsed.twophase_xid, false);
6266  LWLockRelease(TwoPhaseStateLock);
6267  }
6268  else if (info == XLOG_XACT_PREPARE)
6269  {
6270  /*
6271  * Store xid and start/end pointers of the WAL record in TwoPhaseState
6272  * gxact entry.
6273  */
6274  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6276  record->ReadRecPtr,
6277  record->EndRecPtr,
6278  XLogRecGetOrigin(record));
6279  LWLockRelease(TwoPhaseStateLock);
6280  }
6281  else if (info == XLOG_XACT_ASSIGNMENT)
6282  {
6284 
6287  xlrec->nsubxacts, xlrec->xsub);
6288  }
6289  else if (info == XLOG_XACT_INVALIDATIONS)
6290  {
6291  /*
6292  * XXX we do ignore this for now, what matters are invalidations
6293  * written into the commit record.
6294  */
6295  }
6296  else
6297  elog(PANIC, "xact_redo: unknown op code %u", info);
6298 }
#define PANIC
Definition: elog.h:42
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1172
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1785
@ LW_EXCLUSIVE
Definition: lwlock.h:116
void ProcArrayApplyXidAssignment(TransactionId topxid, int nsubxids, TransactionId *subxids)
Definition: procarray.c:1306
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:2582
void PrepareRedoAdd(char *buf, XLogRecPtr start_lsn, XLogRecPtr end_lsn, RepOriginId origin_id)
Definition: twophase.c:2480
static void xact_redo_commit(xl_xact_parsed_commit *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)
Definition: xact.c:5982
static void xact_redo_abort(xl_xact_parsed_abort *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)
Definition: xact.c:6136
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:412
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417
HotStandbyState standbyState
Definition: xlogutils.c:53
@ 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 5642 of file xact.c.

5643 {
5645 
5646  if (s->nChildXids == 0)
5647  *ptr = NULL;
5648  else
5649  *ptr = s->childXids;
5650 
5651  return s->nChildXids;
5652 }

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 5838 of file xact.c.

5844 {
5845  xl_xact_abort xlrec;
5846  xl_xact_xinfo xl_xinfo;
5847  xl_xact_subxacts xl_subxacts;
5848  xl_xact_relfilelocators xl_relfilelocators;
5849  xl_xact_stats_items xl_dropped_stats;
5850  xl_xact_twophase xl_twophase;
5851  xl_xact_dbinfo xl_dbinfo;
5852  xl_xact_origin xl_origin;
5853 
5854  uint8 info;
5855 
5856  Assert(CritSectionCount > 0);
5857 
5858  xl_xinfo.xinfo = 0;
5859 
5860  /* decide between a plain and 2pc abort */
5861  if (!TransactionIdIsValid(twophase_xid))
5862  info = XLOG_XACT_ABORT;
5863  else
5864  info = XLOG_XACT_ABORT_PREPARED;
5865 
5866 
5867  /* First figure out and collect all the information needed */
5868 
5869  xlrec.xact_time = abort_time;
5870 
5871  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5872  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5873 
5874  if (nsubxacts > 0)
5875  {
5876  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5877  xl_subxacts.nsubxacts = nsubxacts;
5878  }
5879 
5880  if (nrels > 0)
5881  {
5883  xl_relfilelocators.nrels = nrels;
5884  info |= XLR_SPECIAL_REL_UPDATE;
5885  }
5886 
5887  if (ndroppedstats > 0)
5888  {
5889  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5890  xl_dropped_stats.nitems = ndroppedstats;
5891  }
5892 
5893  if (TransactionIdIsValid(twophase_xid))
5894  {
5895  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5896  xl_twophase.xid = twophase_xid;
5897  Assert(twophase_gid != NULL);
5898 
5899  if (XLogLogicalInfoActive())
5900  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5901  }
5902 
5903  if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
5904  {
5905  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5906  xl_dbinfo.dbId = MyDatabaseId;
5907  xl_dbinfo.tsId = MyDatabaseTableSpace;
5908  }
5909 
5910  /*
5911  * Dump transaction origin information. We need this during recovery to
5912  * update the replication origin progress.
5913  */
5915  {
5916  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5917 
5920  }
5921 
5922  if (xl_xinfo.xinfo != 0)
5923  info |= XLOG_XACT_HAS_INFO;
5924 
5925  /* Then include all the collected data into the abort record. */
5926 
5927  XLogBeginInsert();
5928 
5929  XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);
5930 
5931  if (xl_xinfo.xinfo != 0)
5932  XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));
5933 
5934  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5935  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
5936 
5937  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5938  {
5939  XLogRegisterData((char *) (&xl_subxacts),
5941  XLogRegisterData((char *) subxacts,
5942  nsubxacts * sizeof(TransactionId));
5943  }
5944 
5945  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5946  {
5947  XLogRegisterData((char *) (&xl_relfilelocators),
5949  XLogRegisterData((char *) rels,
5950  nrels * sizeof(RelFileLocator));
5951  }
5952 
5953  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5954  {
5955  XLogRegisterData((char *) (&xl_dropped_stats),
5957  XLogRegisterData((char *) droppedstats,
5958  ndroppedstats * sizeof(xl_xact_stats_item));
5959  }
5960 
5961  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5962  {
5963  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
5964  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5965  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
5966  }
5967 
5968  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5969  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
5970 
5971  /* Include the replication origin */
5973 
5974  return XLogInsert(RM_XACT_ID, info);
5975 }
#define unconstify(underlying_type, expr)
Definition: c.h:1232
Oid MyDatabaseTableSpace
Definition: globals.c:92
volatile uint32 CritSectionCount
Definition: globals.c:43
Oid MyDatabaseId
Definition: globals.c:90
TimestampTz replorigin_session_origin_timestamp
Definition: origin.c:157
RepOriginId replorigin_session_origin
Definition: origin.c:155
XLogRecPtr replorigin_session_origin_lsn
Definition: origin.c:156
#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:152
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogSetRecordFlags(uint8 flags)
Definition: xloginsert.c:456
void XLogBeginInsert(void)
Definition: xloginsert.c:149
#define XLR_SPECIAL_REL_UPDATE
Definition: xlogrecord.h:82

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 5666 of file xact.c.

5674 {
5675  xl_xact_commit xlrec;
5676  xl_xact_xinfo xl_xinfo;
5677  xl_xact_dbinfo xl_dbinfo;
5678  xl_xact_subxacts xl_subxacts;
5679  xl_xact_relfilelocators xl_relfilelocators;
5680  xl_xact_stats_items xl_dropped_stats;
5681  xl_xact_invals xl_invals;
5682  xl_xact_twophase xl_twophase;
5683  xl_xact_origin xl_origin;
5684  uint8 info;
5685 
5686  Assert(CritSectionCount > 0);
5687 
5688  xl_xinfo.xinfo = 0;
5689 
5690  /* decide between a plain and 2pc commit */
5691  if (!TransactionIdIsValid(twophase_xid))
5692  info = XLOG_XACT_COMMIT;
5693  else
5695 
5696  /* First figure out and collect all the information needed */
5697 
5698  xlrec.xact_time = commit_time;
5699 
5700  if (relcacheInval)
5702  if (forceSyncCommit)
5704  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5705  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5706 
5707  /*
5708  * Check if the caller would like to ask standbys for immediate feedback
5709  * once this commit is applied.
5710  */
5713 
5714  /*
5715  * Relcache invalidations requires information about the current database
5716  * and so does logical decoding.
5717  */
5718  if (nmsgs > 0 || XLogLogicalInfoActive())
5719  {
5720  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5721  xl_dbinfo.dbId = MyDatabaseId;
5722  xl_dbinfo.tsId = MyDatabaseTableSpace;
5723  }
5724 
5725  if (nsubxacts > 0)
5726  {
5727  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5728  xl_subxacts.nsubxacts = nsubxacts;
5729  }
5730 
5731  if (nrels > 0)
5732  {
5734  xl_relfilelocators.nrels = nrels;
5735  info |= XLR_SPECIAL_REL_UPDATE;
5736  }
5737 
5738  if (ndroppedstats > 0)
5739  {
5740  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5741  xl_dropped_stats.nitems = ndroppedstats;
5742  }
5743 
5744  if (nmsgs > 0)
5745  {
5746  xl_xinfo.xinfo |= XACT_XINFO_HAS_INVALS;
5747  xl_invals.nmsgs = nmsgs;
5748  }
5749 
5750  if (TransactionIdIsValid(twophase_xid))
5751  {
5752  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5753  xl_twophase.xid = twophase_xid;
5754  Assert(twophase_gid != NULL);
5755 
5756  if (XLogLogicalInfoActive())
5757  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5758  }
5759 
5760  /* dump transaction origin information */
5762  {
5763  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5764 
5767  }
5768 
5769  if (xl_xinfo.xinfo != 0)
5770  info |= XLOG_XACT_HAS_INFO;
5771 
5772  /* Then include all the collected data into the commit record. */
5773 
5774  XLogBeginInsert();
5775 
5776  XLogRegisterData((char *) (&xlrec), sizeof(xl_xact_commit));
5777 
5778  if (xl_xinfo.xinfo != 0)
5779  XLogRegisterData((char *) (&xl_xinfo.xinfo), sizeof(xl_xinfo.xinfo));
5780 
5781  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5782  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
5783 
5784  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5785  {
5786  XLogRegisterData((char *) (&xl_subxacts),
5788  XLogRegisterData((char *) subxacts,
5789  nsubxacts * sizeof(TransactionId));
5790  }
5791 
5792  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5793  {
5794  XLogRegisterData((char *) (&xl_relfilelocators),
5796  XLogRegisterData((char *) rels,
5797  nrels * sizeof(RelFileLocator));
5798  }
5799 
5800  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5801  {
5802  XLogRegisterData((char *) (&xl_dropped_stats),
5804  XLogRegisterData((char *) droppedstats,
5805  ndroppedstats * sizeof(xl_xact_stats_item));
5806  }
5807 
5808  if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
5809  {
5810  XLogRegisterData((char *) (&xl_invals), MinSizeOfXactInvals);
5811  XLogRegisterData((char *) msgs,
5812  nmsgs * sizeof(SharedInvalidationMessage));
5813  }
5814 
5815  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5816  {
5817  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
5818  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5819  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
5820  }
5821 
5822  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5823  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
5824 
5825  /* we allow filtering by xacts */
5827 
5828  return XLogInsert(RM_XACT_ID, info);
5829 }
int synchronous_commit
Definition: xact.c:85
#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 82 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactIsoLevel

PGDLLIMPORT int DefaultXactIsoLevel
extern

Definition at line 76 of file xact.c.

Referenced by StartTransaction().

◆ DefaultXactReadOnly

PGDLLIMPORT bool DefaultXactReadOnly
extern

Definition at line 79 of file xact.c.

Referenced by StartTransaction().

◆ MyXactFlags

◆ synchronous_commit

PGDLLIMPORT int synchronous_commit
extern

Definition at line 85 of file xact.c.

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

◆ xact_is_sampled

PGDLLIMPORT bool xact_is_sampled
extern

Definition at line 288 of file xact.c.

Referenced by check_log_duration(), and StartTransaction().

◆ XactDeferrable

◆ XactIsoLevel

◆ XactReadOnly